mirror of https://github.com/icedland/iced.git
Misc fixes
This commit is contained in:
wtfsck
parent
25760b62d1
commit
159463ceb1
|
|
@ -78,8 +78,7 @@ namespace Generator.Assembler {
|
|||
toOrigCodeValue.Add(origCode[i], (Code)i);
|
||||
|
||||
discardOpCodes = defs.Where(a => (a.Flags3 & InstructionDefFlags3.AsmIgnore) != 0).Select(a => a.Code).ToHashSet();
|
||||
mapOpCodeToNewName = defs.Where(a => a.AsmMnemonic is not null).
|
||||
Select(a => (code: a.Code, name: a.AsmMnemonic!)).ToDictionary(a => a.code, a => a.name);
|
||||
mapOpCodeToNewName = defs.Where(a => a.AsmMnemonic is not null).ToDictionary(a => a.Code, a => a.AsmMnemonic!);
|
||||
|
||||
var ambigDict = new Dictionary<AmbiguousBcstInstr, List<AmbiguousBcstInstr>>();
|
||||
foreach (var def in defs) {
|
||||
|
|
@ -277,17 +276,18 @@ namespace Generator.Assembler {
|
|||
|
||||
void GenerateOpCodes() {
|
||||
foreach (var def in defs) {
|
||||
var codeValue = def.Code;
|
||||
if (discardOpCodes.Contains(codeValue)) continue;
|
||||
var code = def.Code;
|
||||
if (discardOpCodes.Contains(code))
|
||||
continue;
|
||||
|
||||
string memoName = def.Mnemonic.RawName;
|
||||
var name = mapOpCodeToNewName.TryGetValue(codeValue, out var nameOpt) ? nameOpt : memoName.ToLowerInvariant();
|
||||
var mnemonicName = def.Mnemonic.RawName;
|
||||
var name = mapOpCodeToNewName.TryGetValue(code, out var nameOpt) ? nameOpt : mnemonicName.ToLowerInvariant();
|
||||
|
||||
var signature = new Signature();
|
||||
var regOnlySignature = new Signature();
|
||||
|
||||
var pseudoOpsKind = def.PseudoOp;
|
||||
var opCodeArgFlags = OpCodeArgFlags.Default;
|
||||
var opCodeArgFlags = OpCodeArgFlags.None;
|
||||
|
||||
if (def.Encoding == EncodingKind.VEX) opCodeArgFlags |= OpCodeArgFlags.HasVex;
|
||||
if (def.Encoding == EncodingKind.EVEX) opCodeArgFlags |= OpCodeArgFlags.HasEvex;
|
||||
|
|
@ -302,9 +302,8 @@ namespace Generator.Assembler {
|
|||
|
||||
// For certain instruction, we need to discard them
|
||||
int numberLeadingArgToDiscard = 0;
|
||||
var numberLeadingArgToDiscardOpt = GetSpecialArgEncodingInstruction(def);
|
||||
if (numberLeadingArgToDiscardOpt.HasValue) {
|
||||
numberLeadingArgToDiscard = numberLeadingArgToDiscardOpt.Value;
|
||||
if (GetSpecialArgEncodingInstruction(def) is int argsToDiscard) {
|
||||
numberLeadingArgToDiscard = argsToDiscard;
|
||||
opCodeArgFlags |= OpCodeArgFlags.HasSpecialInstructionEncoding;
|
||||
}
|
||||
|
||||
|
|
@ -349,17 +348,17 @@ namespace Generator.Assembler {
|
|||
break;
|
||||
case (8, 16):
|
||||
case (8, 32):
|
||||
opCodeArgFlags |= OpCodeArgFlags.HasImmediateByteSignedExtended;
|
||||
opCodeArgFlags |= OpCodeArgFlags.HasImmediateByteSignExtended;
|
||||
break;
|
||||
case (8, 64):
|
||||
opCodeArgFlags |= OpCodeArgFlags.HasImmediateByteSignedExtended | OpCodeArgFlags.UnsignedUIntNotSupported;
|
||||
opCodeArgFlags |= OpCodeArgFlags.HasImmediateByteSignExtended | OpCodeArgFlags.UnsignedUIntNotSupported;
|
||||
break;
|
||||
case (32, 64):
|
||||
opCodeArgFlags |= OpCodeArgFlags.UnsignedUIntNotSupported;
|
||||
break;
|
||||
case (16, _):
|
||||
case (16, 16):
|
||||
case (32, 32):
|
||||
case (64, _):
|
||||
case (64, 64):
|
||||
break;
|
||||
default:
|
||||
throw new InvalidOperationException();
|
||||
|
|
@ -413,46 +412,47 @@ namespace Generator.Assembler {
|
|||
if (!ShouldDiscardDuplicatedOpCode(signature, def)) {
|
||||
// discard r16m16
|
||||
bool hasR64M16 = IsR64M16(def);
|
||||
if (!hasR64M16)
|
||||
AddOpCodeToGroup(name, memoName, signature, def, opCodeArgFlags, pseudoOpsKind, numberLeadingArgToDiscard, argSizes, false);
|
||||
if (!hasR64M16) {
|
||||
AddOpCodeToGroup(name, mnemonicName, signature, def, opCodeArgFlags, pseudoOpsKind, numberLeadingArgToDiscard,
|
||||
argSizes, false);
|
||||
}
|
||||
}
|
||||
|
||||
if (signature != regOnlySignature) {
|
||||
opCodeArgFlags &= ~OpCodeArgFlags.HasBroadcast;
|
||||
AddOpCodeToGroup(name, memoName, regOnlySignature, def, opCodeArgFlags | OpCodeArgFlags.HasRegisterMemoryMappedToRegister, pseudoOpsKind, numberLeadingArgToDiscard, argSizes, false);
|
||||
AddOpCodeToGroup(name, mnemonicName, regOnlySignature, def, opCodeArgFlags | OpCodeArgFlags.HasRegisterMemoryMappedToRegister,
|
||||
pseudoOpsKind, numberLeadingArgToDiscard, argSizes, false);
|
||||
}
|
||||
}
|
||||
|
||||
CreatePseudoInstructions();
|
||||
|
||||
var orderedGroups = groups.OrderBy(x => x.Key).Select(x => x.Value).ToList();
|
||||
var orderedGroups = groups.OrderBy(x => x.Key).Select(x => x.Value).ToArray();
|
||||
var signatures = new HashSet<Signature>();
|
||||
var opcodes = new List<InstructionDef>();
|
||||
for (var i = 0; i < orderedGroups.Count; i++) {
|
||||
var @group = orderedGroups[i];
|
||||
|
||||
if (@group.HasRegisterMemoryMappedToRegister) {
|
||||
var inputOpCodes = @group.Items;
|
||||
foreach (var group in orderedGroups) {
|
||||
if (group.HasRegisterMemoryMappedToRegister) {
|
||||
var inputOpCodes = group.Defs;
|
||||
opcodes.Clear();
|
||||
signatures.Clear();
|
||||
// First-pass to select only register versions
|
||||
FilterOpCodesRegister(@group, inputOpCodes, opcodes, signatures, false);
|
||||
FilterOpCodesRegister(group, inputOpCodes, opcodes, signatures, false);
|
||||
|
||||
// Second-pass to populate with RM versions
|
||||
FilterOpCodesRegister(@group, inputOpCodes, opcodes, signatures, true);
|
||||
FilterOpCodesRegister(group, inputOpCodes, opcodes, signatures, true);
|
||||
|
||||
inputOpCodes.Clear();
|
||||
inputOpCodes.AddRange(opcodes);
|
||||
}
|
||||
|
||||
// Update the selector graph for this group of opcodes
|
||||
if (@group.HasSpecialInstructionEncoding)
|
||||
@group.RootOpCodeNode = new OpCodeNode(@group.Items[0]);
|
||||
if (group.HasSpecialInstructionEncoding)
|
||||
group.RootOpCodeNode = new OpCodeNode(group.Defs[0]);
|
||||
else
|
||||
@group.RootOpCodeNode = BuildSelectorGraph(@group);
|
||||
group.RootOpCodeNode = BuildSelectorGraph(group);
|
||||
}
|
||||
|
||||
Generate(groups, orderedGroups.ToArray());
|
||||
Generate(groups, orderedGroups);
|
||||
}
|
||||
|
||||
ArgKind GetArgKind(OpCodeOperandKindDef def, bool isRegMem) {
|
||||
|
|
@ -508,20 +508,22 @@ namespace Generator.Assembler {
|
|||
}
|
||||
|
||||
OpCodeNode BuildSelectorGraph(OpCodeInfoGroup group) {
|
||||
// In case of one opcode, we don't need to perform any disambiguation
|
||||
var opcodes = group.Items;
|
||||
var opcodes = group.Defs;
|
||||
// Sort opcodes by decreasing size
|
||||
opcodes.Sort(group.OrderOpCodesPerOpKindPriority);
|
||||
return BuildSelectorGraph(group, group.Signature, group.Flags, opcodes);
|
||||
}
|
||||
|
||||
OpCodeNode BuildSelectorGraph(OpCodeInfoGroup group, Signature signature, OpCodeArgFlags argFlags, List<InstructionDef> opcodes) {
|
||||
if (opcodes.Count == 0) return default;
|
||||
if (opcodes.Count == 0)
|
||||
return default;
|
||||
|
||||
// In case of one opcode, we don't need to perform any disambiguation
|
||||
if (opcodes.Count == 1)
|
||||
return new OpCodeNode(opcodes[0]);
|
||||
|
||||
Debug.Assert(stackDepth++ < 16, "Potential StackOverflow");
|
||||
if (stackDepth++ >= 16)
|
||||
throw new InvalidOperationException("Potential StackOverflow");
|
||||
try {
|
||||
OrderedSelectorList selectors;
|
||||
|
||||
|
|
@ -530,22 +532,23 @@ namespace Generator.Assembler {
|
|||
var opcodesWithImmediateByteEqual1 = new List<InstructionDef>();
|
||||
var opcodesOthers = new List<InstructionDef>();
|
||||
var indices = CollectByOperandKindPredicate(opcodes, IsImmediateByteEqual1, opcodesWithImmediateByteEqual1, opcodesOthers);
|
||||
Debug.Assert(indices.Count == 1);
|
||||
var newFlags = argFlags ^ OpCodeArgFlags.HasImmediateByteEqual1;
|
||||
if (indices.Count != 1)
|
||||
throw new InvalidOperationException();
|
||||
var newFlags = argFlags & ~OpCodeArgFlags.HasImmediateByteEqual1;
|
||||
return new OpCodeSelector(indices[0], OpCodeSelectorKind.ImmediateByteEqual1) {
|
||||
IfTrue = BuildSelectorGraph(group, group.Signature, newFlags, opcodesWithImmediateByteEqual1),
|
||||
IfFalse = BuildSelectorGraph(group, group.Signature, newFlags, opcodesOthers)
|
||||
IfTrue = BuildSelectorGraph(group, signature, newFlags, opcodesWithImmediateByteEqual1),
|
||||
IfFalse = BuildSelectorGraph(group, signature, newFlags, opcodesOthers)
|
||||
};
|
||||
}
|
||||
else if (group.IsBranch) {
|
||||
var branchShort = new List<InstructionDef>();
|
||||
var branchFar = new List<InstructionDef>();
|
||||
CollectByOperandKindPredicate(opcodes, IsBranchShort, branchShort, branchFar);
|
||||
if (branchShort.Count > 0 && branchFar.Count > 0) {
|
||||
var branchNear = new List<InstructionDef>();
|
||||
CollectByOperandKindPredicate(opcodes, IsBranchShort, branchShort, branchNear);
|
||||
if (branchShort.Count > 0 && branchNear.Count > 0) {
|
||||
var newFlags = argFlags & ~(OpCodeArgFlags.HasBranchShort | OpCodeArgFlags.HasBranchNear);
|
||||
return new OpCodeSelector(OpCodeSelectorKind.BranchShort) {
|
||||
IfTrue = BuildSelectorGraph(group, group.Signature, newFlags, branchShort),
|
||||
IfFalse = BuildSelectorGraph(group, group.Signature, newFlags, branchFar)
|
||||
IfTrue = BuildSelectorGraph(group, signature, newFlags, branchShort),
|
||||
IfFalse = BuildSelectorGraph(group, signature, newFlags, branchNear)
|
||||
};
|
||||
}
|
||||
}
|
||||
|
|
@ -558,7 +561,7 @@ namespace Generator.Assembler {
|
|||
var memOffs64Selector = OpCodeSelectorKind.Invalid;
|
||||
var memOffsSelector = OpCodeSelectorKind.Invalid;
|
||||
|
||||
int argIndex = 0;
|
||||
int argIndex = -1;
|
||||
for (var i = 0; i < opcodes.Count; i++) {
|
||||
var def = opcodes[i];
|
||||
bool handled = false;
|
||||
|
|
@ -570,28 +573,24 @@ namespace Generator.Assembler {
|
|||
memOffs64Selector = OpCodeSelectorKind.MemOffs64_AL;
|
||||
memOffsSelector = OpCodeSelectorKind.MemOffs_AL;
|
||||
argIndex = 0;
|
||||
opCodesRAXMOffs.Add(def);
|
||||
handled = true;
|
||||
break;
|
||||
case Register.AX:
|
||||
memOffs64Selector = OpCodeSelectorKind.MemOffs64_AX;
|
||||
memOffsSelector = OpCodeSelectorKind.MemOffs_AX;
|
||||
argIndex = 0;
|
||||
opCodesRAXMOffs.Add(def);
|
||||
handled = true;
|
||||
break;
|
||||
case Register.EAX:
|
||||
memOffs64Selector = OpCodeSelectorKind.MemOffs64_EAX;
|
||||
memOffsSelector = OpCodeSelectorKind.MemOffs_EAX;
|
||||
argIndex = 0;
|
||||
opCodesRAXMOffs.Add(def);
|
||||
handled = true;
|
||||
break;
|
||||
case Register.RAX:
|
||||
memOffs64Selector = OpCodeSelectorKind.MemOffs64_RAX;
|
||||
memOffsSelector = OpCodeSelectorKind.MemOffs_RAX;
|
||||
argIndex = 0;
|
||||
opCodesRAXMOffs.Add(def);
|
||||
handled = true;
|
||||
break;
|
||||
}
|
||||
|
|
@ -602,44 +601,44 @@ namespace Generator.Assembler {
|
|||
memOffs64Selector = OpCodeSelectorKind.MemOffs64_AL;
|
||||
memOffsSelector = OpCodeSelectorKind.MemOffs_AL;
|
||||
argIndex = 1;
|
||||
opCodesRAXMOffs.Add(def);
|
||||
handled = true;
|
||||
break;
|
||||
case Register.AX:
|
||||
memOffs64Selector = OpCodeSelectorKind.MemOffs64_AX;
|
||||
memOffsSelector = OpCodeSelectorKind.MemOffs_AX;
|
||||
argIndex = 1;
|
||||
opCodesRAXMOffs.Add(def);
|
||||
handled = true;
|
||||
break;
|
||||
case Register.EAX:
|
||||
memOffs64Selector = OpCodeSelectorKind.MemOffs64_EAX;
|
||||
memOffsSelector = OpCodeSelectorKind.MemOffs_EAX;
|
||||
argIndex = 1;
|
||||
opCodesRAXMOffs.Add(def);
|
||||
handled = true;
|
||||
break;
|
||||
case Register.RAX:
|
||||
memOffs64Selector = OpCodeSelectorKind.MemOffs64_RAX;
|
||||
memOffsSelector = OpCodeSelectorKind.MemOffs_RAX;
|
||||
argIndex = 1;
|
||||
opCodesRAXMOffs.Add(def);
|
||||
handled = true;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!handled)
|
||||
if (handled)
|
||||
opCodesRAXMOffs.Add(def);
|
||||
else
|
||||
newOpCodes.Add(def);
|
||||
}
|
||||
|
||||
if (opCodesRAXMOffs.Count > 0) {
|
||||
if (opCodesRAXMOffs.Count != 1)
|
||||
throw new InvalidOperationException();
|
||||
return new OpCodeSelector(argIndex, memOffs64Selector) {
|
||||
IfTrue = BuildSelectorGraph(group, group.Signature, argFlags, opCodesRAXMOffs),
|
||||
IfTrue = BuildSelectorGraph(group, signature, argFlags, opCodesRAXMOffs),
|
||||
IfFalse = new OpCodeSelector(argIndex, memOffsSelector) {
|
||||
IfTrue = BuildSelectorGraph(group, group.Signature, argFlags, opCodesRAXMOffs),
|
||||
IfFalse = BuildSelectorGraph(group, group.Signature, argFlags, newOpCodes)
|
||||
IfTrue = BuildSelectorGraph(group, signature, argFlags, opCodesRAXMOffs),
|
||||
IfFalse = BuildSelectorGraph(group, signature, argFlags, newOpCodes)
|
||||
}
|
||||
};
|
||||
}
|
||||
|
|
@ -649,9 +648,8 @@ namespace Generator.Assembler {
|
|||
if ((argFlags & OpCodeArgFlags.HasBroadcast) != 0) {
|
||||
int memoryIndex = GetBroadcastMemory(argFlags, opcodes, signature, out var broadcastSelectorKind, out var evexBroadcastDef);
|
||||
if (memoryIndex >= 0) {
|
||||
Debug.Assert(evexBroadcastDef is not null);
|
||||
return new OpCodeSelector(memoryIndex, broadcastSelectorKind) {
|
||||
IfTrue = evexBroadcastDef,
|
||||
IfTrue = evexBroadcastDef ?? throw new InvalidOperationException(),
|
||||
IfFalse = BuildSelectorGraph(group, signature, argFlags & ~OpCodeArgFlags.HasBroadcast, opcodes)
|
||||
};
|
||||
}
|
||||
|
|
@ -684,14 +682,14 @@ namespace Generator.Assembler {
|
|||
// - bitness
|
||||
if (selectors.Count <= 1) {
|
||||
// Special case for push imm, select first by bitness and after by imm
|
||||
bool isPushImm = group.Name == "push" && group.Signature.ArgCount == 1 && IsArgKindImmediate(group.Signature.GetArgKind(0));
|
||||
bool isPushImm = group.Name == "push" && signature.ArgCount == 1 && IsArgKindImmediate(signature.GetArgKind(0));
|
||||
if (isPushImm && opcodes.Count > 2) {
|
||||
// bitness
|
||||
selectors = BuildSelectorsPerBitness(@group, argFlags, opcodes);
|
||||
return BuildSelectorGraphFromSelectors(group, group.Signature, argFlags, selectors);
|
||||
selectors = BuildSelectorsPerBitness(group, argFlags, opcodes);
|
||||
return BuildSelectorGraphFromSelectors(group, signature, argFlags, selectors);
|
||||
}
|
||||
|
||||
if ((argFlags & OpCodeArgFlags.HasImmediateByteSignedExtended) != 0) {
|
||||
if ((argFlags & OpCodeArgFlags.HasImmediateByteSignExtended) != 0) {
|
||||
// handle imm >= sbyte.MinValue && imm <= byte.MaxValue
|
||||
var opcodesWithImmediateByteSigned = new List<InstructionDef>();
|
||||
var opcodesOthers = new List<InstructionDef>();
|
||||
|
|
@ -711,11 +709,12 @@ namespace Generator.Assembler {
|
|||
}
|
||||
}
|
||||
|
||||
Debug.Assert(indices.Count == 1);
|
||||
var newFlags = argFlags ^ OpCodeArgFlags.HasImmediateByteSignedExtended;
|
||||
if (indices.Count != 1)
|
||||
throw new InvalidOperationException();
|
||||
var newFlags = argFlags & ~OpCodeArgFlags.HasImmediateByteSignExtended;
|
||||
return new OpCodeSelector(indices[0], selectorKind) {
|
||||
IfTrue = BuildSelectorGraph(group, group.Signature, newFlags, opcodesWithImmediateByteSigned),
|
||||
IfFalse = BuildSelectorGraph(group, group.Signature, newFlags, opcodesOthers)
|
||||
IfTrue = BuildSelectorGraph(group, signature, newFlags, opcodesWithImmediateByteSigned),
|
||||
IfFalse = BuildSelectorGraph(group, signature, newFlags, opcodesOthers)
|
||||
};
|
||||
}
|
||||
|
||||
|
|
@ -730,7 +729,7 @@ namespace Generator.Assembler {
|
|||
}
|
||||
|
||||
// bitness
|
||||
selectors = BuildSelectorsPerBitness(@group, argFlags, opcodes);
|
||||
selectors = BuildSelectorsPerBitness(group, argFlags, opcodes);
|
||||
}
|
||||
|
||||
return BuildSelectorGraphFromSelectors(group, signature, argFlags, selectors);
|
||||
|
|
@ -743,8 +742,8 @@ namespace Generator.Assembler {
|
|||
OpCodeNode BuildSelectorGraphFromSelectors(OpCodeInfoGroup group, Signature signature, OpCodeArgFlags argFlags, OrderedSelectorList selectors) {
|
||||
OpCodeSelector? previousSelector = null;
|
||||
OpCodeNode rootNode = default;
|
||||
int selectorIndex = 0;
|
||||
foreach (var (kind, list) in selectors) {
|
||||
for (int selectorIndex = 0; selectorIndex < selectors.Count; selectorIndex++) {
|
||||
var (kind, list) = selectors[selectorIndex];
|
||||
OpCodeNode node;
|
||||
OpCodeSelector? newSelector = null;
|
||||
|
||||
|
|
@ -762,7 +761,18 @@ namespace Generator.Assembler {
|
|||
case OpCodeSelectorKind.Register32:
|
||||
case OpCodeSelectorKind.Register64:
|
||||
case OpCodeSelectorKind.RegisterST:
|
||||
if (list.Count == 1 || selectorIndex + 1 == selectors.Count)
|
||||
case OpCodeSelectorKind.RegisterBND:
|
||||
case OpCodeSelectorKind.RegisterK:
|
||||
case OpCodeSelectorKind.RegisterSegment:
|
||||
case OpCodeSelectorKind.RegisterCR:
|
||||
case OpCodeSelectorKind.RegisterDR:
|
||||
case OpCodeSelectorKind.RegisterTR:
|
||||
case OpCodeSelectorKind.RegisterMM:
|
||||
case OpCodeSelectorKind.RegisterXMM:
|
||||
case OpCodeSelectorKind.RegisterYMM:
|
||||
case OpCodeSelectorKind.RegisterZMM:
|
||||
case OpCodeSelectorKind.RegisterTMM:
|
||||
if (selectorIndex + 1 == selectors.Count)
|
||||
node = BuildSelectorGraph(group, signature, argFlags, list);
|
||||
else
|
||||
goto default;
|
||||
|
|
@ -779,14 +789,15 @@ namespace Generator.Assembler {
|
|||
|
||||
if (previousSelector is not null)
|
||||
previousSelector.IfFalse = node;
|
||||
else if (selectorIndex != 0)
|
||||
throw new InvalidOperationException();
|
||||
|
||||
previousSelector = newSelector;
|
||||
selectorIndex++;
|
||||
}
|
||||
return rootNode;
|
||||
}
|
||||
|
||||
static OrderedSelectorList BuildSelectorsPerBitness(OpCodeInfoGroup @group, OpCodeArgFlags argFlags, List<InstructionDef> opcodes) {
|
||||
static OrderedSelectorList BuildSelectorsPerBitness(OpCodeInfoGroup group, OpCodeArgFlags argFlags, List<InstructionDef> opcodes) {
|
||||
var selectors = new OrderedSelectorList();
|
||||
foreach (var def in opcodes) {
|
||||
if (def.Encoding == EncodingKind.Legacy) {
|
||||
|
|
@ -794,13 +805,16 @@ namespace Generator.Assembler {
|
|||
var selectorKind = bitness switch {
|
||||
16 => OpCodeSelectorKind.Bitness16,
|
||||
32 => OpCodeSelectorKind.Bitness32,
|
||||
_ => OpCodeSelectorKind.Bitness64,
|
||||
64 => OpCodeSelectorKind.Bitness64,
|
||||
_ => throw new InvalidOperationException(),
|
||||
};
|
||||
selectors.Add(selectorKind, def);
|
||||
}
|
||||
else
|
||||
throw new InvalidOperationException($"Unable to detect bitness for opcode {def.Code.RawName} for group {@group.Name} / {argFlags}");
|
||||
throw new InvalidOperationException($"Unable to detect bitness for opcode {def.Code.RawName} for group {group.Name} / {argFlags}");
|
||||
}
|
||||
if (selectors.Count == opcodes.Count)
|
||||
return selectors;
|
||||
|
||||
// Try to detect bitness differently (for dec_rm16/dec_r16)
|
||||
if (selectors.Count == 1) {
|
||||
|
|
@ -827,7 +841,8 @@ namespace Generator.Assembler {
|
|||
return selectors;
|
||||
}
|
||||
|
||||
static int GetBroadcastMemory(OpCodeArgFlags argFlags, List<InstructionDef> opcodes, Signature signature, out OpCodeSelectorKind selectorKind, out InstructionDef? broadcastDef) {
|
||||
static int GetBroadcastMemory(OpCodeArgFlags argFlags, List<InstructionDef> opcodes, Signature signature,
|
||||
out OpCodeSelectorKind selectorKind, out InstructionDef? broadcastDef) {
|
||||
broadcastDef = null;
|
||||
selectorKind = OpCodeSelectorKind.Invalid;
|
||||
int memoryIndex = -1;
|
||||
|
|
@ -835,7 +850,7 @@ namespace Generator.Assembler {
|
|||
for (int i = 0; i < signature.ArgCount; i++) {
|
||||
if (signature.GetArgKind(i) == ArgKind.Memory) {
|
||||
memoryIndex = i;
|
||||
var evex = @opcodes.First(x => x.Encoding == EncodingKind.EVEX);
|
||||
var evex = opcodes.First(x => x.Encoding == EncodingKind.EVEX);
|
||||
if (evex.OpKindDefs[i].OperandEncoding != OperandEncoding.RegMemModrmRm)
|
||||
throw new InvalidOperationException();
|
||||
broadcastDef = evex;
|
||||
|
|
@ -848,13 +863,14 @@ namespace Generator.Assembler {
|
|||
break;
|
||||
}
|
||||
}
|
||||
Debug.Assert(memoryIndex >= 0);
|
||||
if (memoryIndex < 0)
|
||||
throw new InvalidOperationException();
|
||||
}
|
||||
|
||||
return memoryIndex;
|
||||
}
|
||||
|
||||
bool ShouldDiscardDuplicatedOpCode(Signature signature, InstructionDef def) {
|
||||
static bool ShouldDiscardDuplicatedOpCode(Signature signature, InstructionDef def) {
|
||||
if ((def.Flags3 & InstructionDefFlags3.AsmIgnoreMemory) != 0) {
|
||||
for (int i = 0; i < signature.ArgCount; i++) {
|
||||
var kind = signature.GetArgKind(i);
|
||||
|
|
@ -877,15 +893,15 @@ namespace Generator.Assembler {
|
|||
};
|
||||
}
|
||||
|
||||
static List<int> CollectByOperandKindPredicate(List<InstructionDef> defs, Func<OpCodeOperandKindDef, bool?> predicate, List<InstructionDef> opcodesMatchingPredicate, List<InstructionDef> opcodesNotMatchingPredicate) {
|
||||
static List<int> CollectByOperandKindPredicate(List<InstructionDef> defs, Func<OpCodeOperandKindDef, bool?> predicate,
|
||||
List<InstructionDef> opcodesMatchingPredicate, List<InstructionDef> opcodesNotMatchingPredicate) {
|
||||
var argIndices = new List<int>();
|
||||
foreach (var def in defs) {
|
||||
var selected = opcodesNotMatchingPredicate;
|
||||
for (int i = 0; i < def.OpKindDefs.Length; i++) {
|
||||
var argOpKind = def.OpKindDefs[i];
|
||||
var result = predicate(argOpKind);
|
||||
if (result.HasValue) {
|
||||
if (result.Value) {
|
||||
if (predicate(argOpKind) is bool result) {
|
||||
if (result) {
|
||||
if (!argIndices.Contains(i))
|
||||
argIndices.Add(i);
|
||||
selected = opcodesMatchingPredicate;
|
||||
|
|
@ -929,17 +945,19 @@ namespace Generator.Assembler {
|
|||
return null;
|
||||
}
|
||||
|
||||
OrderedSelectorList BuildSelectorsByRegisterOrMemory(Signature signature, OpCodeArgFlags argFlags, List<InstructionDef> opcodes, bool isRegister) {
|
||||
OrderedSelectorList BuildSelectorsByRegisterOrMemory(Signature signature, OpCodeArgFlags argFlags, List<InstructionDef> opcodes,
|
||||
bool isRegister) {
|
||||
List<OrderedSelectorList>? selectorsList = null;
|
||||
for (int argIndex = 0; argIndex < signature.ArgCount; argIndex++) {
|
||||
var argKind = signature.GetArgKind(argIndex);
|
||||
if (isRegister && !IsRegister(argKind) || !isRegister && (argKind != ArgKind.Memory))
|
||||
if ((isRegister && !IsRegister(argKind)) || (!isRegister && argKind != ArgKind.Memory))
|
||||
continue;
|
||||
|
||||
var selectors = new OrderedSelectorList() { ArgIndex = argIndex };
|
||||
foreach (var def in opcodes) {
|
||||
var argOpKind = def.OpKindDefs[argIndex];
|
||||
var conditionKind = GetSelectorKindForRegisterOrMemory(def, argOpKind, (argFlags & OpCodeArgFlags.HasRegisterMemoryMappedToRegister) != 0);
|
||||
var conditionKind = GetSelectorKindForRegisterOrMemory(def, argOpKind,
|
||||
(argFlags & OpCodeArgFlags.HasRegisterMemoryMappedToRegister) != 0);
|
||||
selectors.Add(conditionKind, def);
|
||||
}
|
||||
|
||||
|
|
@ -951,7 +969,8 @@ namespace Generator.Assembler {
|
|||
selectorsList.Add(selectors);
|
||||
}
|
||||
|
||||
if (selectorsList is null) return new OrderedSelectorList();
|
||||
if (selectorsList is null)
|
||||
return new OrderedSelectorList();
|
||||
|
||||
// Select the largest selector
|
||||
return selectorsList.First(x => x.Count == selectorsList.Max(x => x.Count));
|
||||
|
|
@ -1063,7 +1082,7 @@ namespace Generator.Assembler {
|
|||
case OperandEncoding.MemModrmRm:
|
||||
case OperandEncoding.MemOffset:
|
||||
return memSize switch {
|
||||
80 => 05,
|
||||
80 => 5,
|
||||
64 => 10,
|
||||
48 => 15,
|
||||
32 => 20,
|
||||
|
|
@ -1082,10 +1101,10 @@ namespace Generator.Assembler {
|
|||
|
||||
[Flags]
|
||||
protected enum OpCodeArgFlags {
|
||||
Default = 0,
|
||||
HasImmediateByteEqual1 = 1,
|
||||
None = 0,
|
||||
HasImmediateByteEqual1 = 1 << 0,
|
||||
HasImmediateByteLessThanBits = 1 << 1,
|
||||
HasImmediateByteSignedExtended = 1 << 2,
|
||||
HasImmediateByteSignExtended = 1 << 2,
|
||||
HasLabel = 1 << 3,
|
||||
HasBranchShort = 1 << 4,
|
||||
HasBranchNear = 1 << 5,
|
||||
|
|
@ -1099,17 +1118,17 @@ namespace Generator.Assembler {
|
|||
Pseudo = 1 << 13,
|
||||
SuppressAllExceptions = 1 << 14,
|
||||
RoundingControl = 1 << 15,
|
||||
HasAmbiguousBroadcast = 1 << 16,
|
||||
IsBroadcastXYZ = 1 << 17,
|
||||
HasLabelUlong = 1 << 18,
|
||||
HasImmediateByte = 1 << 19,
|
||||
UnsignedUIntNotSupported = 1 << 20,
|
||||
HasImmediateUnsigned = 1 << 21,
|
||||
IsBroadcastXYZ = 1 << 16,
|
||||
HasLabelUlong = 1 << 17,
|
||||
HasImmediateByte = 1 << 18,
|
||||
UnsignedUIntNotSupported = 1 << 19,
|
||||
HasImmediateUnsigned = 1 << 20,
|
||||
}
|
||||
|
||||
void FilterOpCodesRegister(OpCodeInfoGroup @group, List<InstructionDef> inputOpCodes, List<InstructionDef> opcodes, HashSet<Signature> signatures, bool allowMemory) {
|
||||
void FilterOpCodesRegister(OpCodeInfoGroup group, List<InstructionDef> inputOpCodes, List<InstructionDef> opcodes,
|
||||
HashSet<Signature> signatures, bool allowMemory) {
|
||||
var bitnessFlags = InstructionDefFlags1.None;
|
||||
var vexOrEvexFlags = OpCodeArgFlags.Default;
|
||||
var vexOrEvexFlags = OpCodeArgFlags.None;
|
||||
|
||||
foreach (var code in inputOpCodes) {
|
||||
var registerSignature = new Signature();
|
||||
|
|
@ -1125,12 +1144,16 @@ namespace Generator.Assembler {
|
|||
}
|
||||
|
||||
var codeBitnessFlags = code.Flags1 & BitnessMaskFlags;
|
||||
var codeEvexFlags = code.Encoding == EncodingKind.VEX ? OpCodeArgFlags.HasVex : code.Encoding == EncodingKind.EVEX ? OpCodeArgFlags.HasEvex : OpCodeArgFlags.Default;
|
||||
var codeEvexFlags = code.Encoding switch {
|
||||
EncodingKind.VEX => OpCodeArgFlags.HasVex,
|
||||
EncodingKind.EVEX => OpCodeArgFlags.HasEvex,
|
||||
_ => OpCodeArgFlags.None,
|
||||
};
|
||||
|
||||
if (isValid &&
|
||||
(signatures.Add(registerSignature) ||
|
||||
((bitnessFlags & codeBitnessFlags) != codeBitnessFlags) ||
|
||||
(codeEvexFlags != OpCodeArgFlags.Default && (vexOrEvexFlags & codeEvexFlags) == 0) ||
|
||||
(codeEvexFlags != OpCodeArgFlags.None && (vexOrEvexFlags & codeEvexFlags) == 0) ||
|
||||
(group.Flags & (OpCodeArgFlags.RoundingControl | OpCodeArgFlags.SuppressAllExceptions)) != 0)) {
|
||||
bitnessFlags |= codeBitnessFlags;
|
||||
vexOrEvexFlags |= codeEvexFlags;
|
||||
|
|
@ -1160,8 +1183,6 @@ namespace Generator.Assembler {
|
|||
return ArgKind.Immediate;
|
||||
|
||||
case OperandEncoding.ImpliedConst:
|
||||
if (def.ImpliedConst != 1)
|
||||
throw new InvalidOperationException();
|
||||
return ArgKind.FilterImmediate1;
|
||||
|
||||
case OperandEncoding.ImpliedRegister:
|
||||
|
|
@ -1231,7 +1252,8 @@ namespace Generator.Assembler {
|
|||
return ArgKind.Unknown;
|
||||
}
|
||||
|
||||
protected OpCodeSelectorKind GetSelectorKindForRegisterOrMemory(InstructionDef def, OpCodeOperandKindDef opKindDef, bool returnMemoryAsRegister) {
|
||||
OpCodeSelectorKind GetSelectorKindForRegisterOrMemory(InstructionDef def, OpCodeOperandKindDef opKindDef,
|
||||
bool returnMemoryAsRegister) {
|
||||
switch (opKindDef.OperandEncoding) {
|
||||
case OperandEncoding.ImpliedRegister:
|
||||
return opKindDef.Register switch {
|
||||
|
|
@ -1353,34 +1375,23 @@ namespace Generator.Assembler {
|
|||
};
|
||||
}
|
||||
|
||||
OpCodeInfoGroup AddOpCodeToGroup(string name, string memoName, Signature signature, InstructionDef def, OpCodeArgFlags opCodeArgFlags, PseudoOpsKind? pseudoOpsKind, int numberLeadingArgToDiscard, List<int> argSizes, bool isOtherImmediate) {
|
||||
OpCodeInfoGroup AddOpCodeToGroup(string name, string mnemonicName, Signature signature, InstructionDef def, OpCodeArgFlags opCodeArgFlags,
|
||||
PseudoOpsKind? pseudoOpsKind, int numberLeadingArgsToDiscard, List<int> argSizes, bool isOtherImmediate) {
|
||||
var key = new GroupKey(name, signature);
|
||||
if (!groups.TryGetValue(key, out var group)) {
|
||||
group = new OpCodeInfoGroup(memDefs, defs, name, signature);
|
||||
group.MemoName = memoName;
|
||||
group = new OpCodeInfoGroup(memDefs, defs, name, mnemonicName, signature, numberLeadingArgsToDiscard, pseudoOpsKind, null, 0);
|
||||
groups.Add(key, group);
|
||||
if (pseudoOpsKind is not null)
|
||||
groupsWithPseudo.Add(key, group);
|
||||
}
|
||||
if (group.RootPseudoOpsKind != pseudoOpsKind)
|
||||
throw new InvalidOperationException();
|
||||
|
||||
if (!group.Items.Contains(def))
|
||||
group.Items.Add(def);
|
||||
if (!group.Defs.Contains(def))
|
||||
group.Defs.Add(def);
|
||||
group.Flags |= opCodeArgFlags;
|
||||
group.AllOpCodeFlags |= def.Flags1;
|
||||
|
||||
// Handle pseudo ops
|
||||
if (group.RootPseudoOpsKind is not null) {
|
||||
Debug.Assert(pseudoOpsKind is not null);
|
||||
Debug.Assert(group.RootPseudoOpsKind.Value == pseudoOpsKind.Value);
|
||||
Debug.Assert(groupsWithPseudo.ContainsKey(key));
|
||||
}
|
||||
else {
|
||||
group.RootPseudoOpsKind = pseudoOpsKind;
|
||||
if (pseudoOpsKind.HasValue) {
|
||||
if (!groupsWithPseudo.ContainsKey(key))
|
||||
groupsWithPseudo.Add(key, group);
|
||||
}
|
||||
}
|
||||
|
||||
group.NumberOfLeadingArgToDiscard = numberLeadingArgToDiscard;
|
||||
group.UpdateMaxArgSizes(argSizes);
|
||||
|
||||
// Duplicate immediate signatures with opposite unsigned/signed version
|
||||
|
|
@ -1397,20 +1408,23 @@ namespace Generator.Assembler {
|
|||
signatureWithOtherImmediate.AddArgKind(argKind);
|
||||
}
|
||||
|
||||
if (signature != signatureWithOtherImmediate)
|
||||
AddOpCodeToGroup(name, memoName, signatureWithOtherImmediate, def, opCodeArgFlags | OpCodeArgFlags.HasImmediateUnsigned, null, numberLeadingArgToDiscard, argSizes, true);
|
||||
if (signature != signatureWithOtherImmediate) {
|
||||
AddOpCodeToGroup(name, mnemonicName, signatureWithOtherImmediate, def, opCodeArgFlags | OpCodeArgFlags.HasImmediateUnsigned,
|
||||
null, numberLeadingArgsToDiscard, argSizes, true);
|
||||
}
|
||||
}
|
||||
|
||||
if (!pseudoOpsKind.HasValue && (opCodeArgFlags & OpCodeArgFlags.HasRegisterMemoryMappedToRegister) == 0) {
|
||||
if ((opCodeArgFlags & OpCodeArgFlags.HasRegisterMemoryMappedToRegister) == 0 &&
|
||||
(opCodeArgFlags & OpCodeArgFlags.IsBroadcastXYZ) == 0) {
|
||||
var broadcastName = RenameAmbiguousBroadcasts(name, def);
|
||||
if ((opCodeArgFlags & OpCodeArgFlags.IsBroadcastXYZ) == 0 && broadcastName != name) {
|
||||
group.Flags |= OpCodeArgFlags.HasAmbiguousBroadcast;
|
||||
AddOpCodeToGroup(broadcastName, memoName, signature, def, opCodeArgFlags | OpCodeArgFlags.IsBroadcastXYZ, null, numberLeadingArgToDiscard, argSizes, isOtherImmediate);
|
||||
if (broadcastName != name) {
|
||||
AddOpCodeToGroup(broadcastName, mnemonicName, signature, def, opCodeArgFlags | OpCodeArgFlags.IsBroadcastXYZ,
|
||||
pseudoOpsKind, numberLeadingArgsToDiscard, argSizes, isOtherImmediate);
|
||||
}
|
||||
}
|
||||
|
||||
// Handle label as ulong
|
||||
if (!pseudoOpsKind.HasValue && (opCodeArgFlags & OpCodeArgFlags.HasLabelUlong) == 0 && (opCodeArgFlags & OpCodeArgFlags.HasLabel) != 0) {
|
||||
if ((opCodeArgFlags & OpCodeArgFlags.HasLabelUlong) == 0 && (opCodeArgFlags & OpCodeArgFlags.HasLabel) != 0) {
|
||||
var newLabelULongSignature = new Signature();
|
||||
for (int i = 0; i < signature.ArgCount; i++) {
|
||||
var argKind = signature.GetArgKind(i);
|
||||
|
|
@ -1421,7 +1435,8 @@ namespace Generator.Assembler {
|
|||
}
|
||||
newLabelULongSignature.AddArgKind(argKind);
|
||||
}
|
||||
AddOpCodeToGroup(name, memoName, newLabelULongSignature, def, opCodeArgFlags | OpCodeArgFlags.HasLabelUlong, null, numberLeadingArgToDiscard, argSizes, isOtherImmediate);
|
||||
AddOpCodeToGroup(name, mnemonicName, newLabelULongSignature, def, opCodeArgFlags | OpCodeArgFlags.HasLabelUlong,
|
||||
pseudoOpsKind, numberLeadingArgsToDiscard, argSizes, isOtherImmediate);
|
||||
}
|
||||
|
||||
return group;
|
||||
|
|
@ -1435,14 +1450,17 @@ namespace Generator.Assembler {
|
|||
|
||||
void CreatePseudoInstructions() {
|
||||
foreach (var group in groupsWithPseudo.Values) {
|
||||
if (group.Signature.ArgCount < 1)
|
||||
throw new InvalidOperationException();
|
||||
var pseudo = group.RootPseudoOpsKind ?? throw new InvalidOperationException("Root cannot be null");
|
||||
var pseudoInfo = FormatterConstants.GetPseudoOps(pseudo);
|
||||
|
||||
// Create new signature with last imm argument
|
||||
// Create new signature without last imm argument
|
||||
var signature = new Signature();
|
||||
for (int i = 0; i < group.Signature.ArgCount - 1; i++)
|
||||
signature.AddArgKind(group.Signature.GetArgKind(i));
|
||||
|
||||
var newMaxArgSizes = group.MaxArgSizes.Take(group.MaxArgSizes.Count - 1).ToList();
|
||||
for (int i = 0; i < pseudoInfo.Length; i++) {
|
||||
var (name, imm) = pseudoInfo[i];
|
||||
var key = new GroupKey(name, signature);
|
||||
|
|
@ -1450,14 +1468,11 @@ namespace Generator.Assembler {
|
|||
if (groups.ContainsKey(key))
|
||||
continue;
|
||||
|
||||
var newGroup = new OpCodeInfoGroup(memDefs, defs, name, signature) {
|
||||
var newGroup = new OpCodeInfoGroup(memDefs, defs, name, group.MnemonicName, signature, 0, null, group, imm) {
|
||||
Flags = OpCodeArgFlags.Pseudo,
|
||||
AllOpCodeFlags = group.AllOpCodeFlags,
|
||||
MemoName = group.MemoName,
|
||||
ParentPseudoOpsKind = @group,
|
||||
PseudoOpsKindImmediateValue = imm
|
||||
};
|
||||
newGroup.UpdateMaxArgSizes(group.MaxArgSizes);
|
||||
newGroup.UpdateMaxArgSizes(newMaxArgSizes);
|
||||
groups.Add(key, newGroup);
|
||||
}
|
||||
}
|
||||
|
|
@ -1487,37 +1502,40 @@ namespace Generator.Assembler {
|
|||
}
|
||||
|
||||
protected struct Signature : IEquatable<Signature>, IComparable<Signature> {
|
||||
public int ArgCount;
|
||||
public readonly int ArgCount => argCount;
|
||||
int argCount;
|
||||
ulong argKinds;
|
||||
|
||||
public ArgKind GetArgKind(int argIndex) => (ArgKind)((argKinds >> (8 * argIndex)) & 0xFF);
|
||||
|
||||
public void AddArgKind(ArgKind kind) {
|
||||
var shift = (8 * ArgCount);
|
||||
argKinds = (argKinds & ~((ulong)0xFF << shift)) | ((ulong)kind << shift);
|
||||
ArgCount++;
|
||||
var shift = (8 * argCount);
|
||||
argKinds |= (ulong)kind << shift;
|
||||
argCount++;
|
||||
}
|
||||
|
||||
public override string ToString() {
|
||||
var builder = new StringBuilder();
|
||||
builder.Append('(');
|
||||
for (int i = 0; i < ArgCount; i++) {
|
||||
if (i > 0) builder.Append(", ");
|
||||
for (int i = 0; i < argCount; i++) {
|
||||
if (i > 0)
|
||||
builder.Append(", ");
|
||||
builder.Append(GetArgKind(i));
|
||||
}
|
||||
builder.Append(')');
|
||||
return builder.ToString();
|
||||
}
|
||||
|
||||
public bool Equals(Signature other) => ArgCount == other.ArgCount && argKinds == other.argKinds;
|
||||
public bool Equals(Signature other) => argCount == other.argCount && argKinds == other.argKinds;
|
||||
public override bool Equals(object? obj) => obj is Signature other && Equals(other);
|
||||
public override int GetHashCode() => HashCode.Combine(ArgCount, argKinds);
|
||||
public override int GetHashCode() => HashCode.Combine(argCount, argKinds);
|
||||
public static bool operator ==(Signature left, Signature right) => left.Equals(right);
|
||||
public static bool operator !=(Signature left, Signature right) => !left.Equals(right);
|
||||
|
||||
public int CompareTo(Signature other) {
|
||||
var argCountComparison = ArgCount.CompareTo(other.ArgCount);
|
||||
if (argCountComparison != 0) return argCountComparison;
|
||||
var argCountComparison = argCount.CompareTo(other.argCount);
|
||||
if (argCountComparison != 0)
|
||||
return argCountComparison;
|
||||
return argKinds.CompareTo(other.argKinds);
|
||||
}
|
||||
}
|
||||
|
|
@ -1580,23 +1598,29 @@ namespace Generator.Assembler {
|
|||
readonly MemorySizeDef[] memDefs;
|
||||
readonly InstructionDef[] defs;
|
||||
|
||||
public OpCodeInfoGroup(MemorySizeDef[] memDefs, InstructionDef[] defs, string name, Signature signature) {
|
||||
public OpCodeInfoGroup(MemorySizeDef[] memDefs, InstructionDef[] defs, string name, string mnemonicName, Signature signature,
|
||||
int numberLeadingArgsToDiscard, PseudoOpsKind? rootPseudoOpsKind, OpCodeInfoGroup? parentPseudoOpsKind,
|
||||
int pseudoOpsKindImmediateValue) {
|
||||
this.memDefs = memDefs;
|
||||
this.defs = defs;
|
||||
Name = name;
|
||||
MemoName = name;
|
||||
MnemonicName = mnemonicName;
|
||||
Signature = signature;
|
||||
Items = new List<InstructionDef>();
|
||||
Defs = new List<InstructionDef>();
|
||||
MaxArgSizes = new List<int>();
|
||||
NumberOfLeadingArgsToDiscard = numberLeadingArgsToDiscard;
|
||||
RootPseudoOpsKind = rootPseudoOpsKind;
|
||||
ParentPseudoOpsKind = parentPseudoOpsKind;
|
||||
PseudoOpsKindImmediateValue = pseudoOpsKindImmediateValue;
|
||||
}
|
||||
|
||||
public string MemoName { get; set; }
|
||||
public string MnemonicName { get; }
|
||||
public string Name { get; }
|
||||
public InstructionDefFlags1 AllOpCodeFlags { get; set; }
|
||||
public OpCodeArgFlags Flags { get; set; }
|
||||
public PseudoOpsKind? RootPseudoOpsKind { get; set; }
|
||||
public OpCodeInfoGroup? ParentPseudoOpsKind { get; set; }
|
||||
public int PseudoOpsKindImmediateValue { get; set; }
|
||||
public PseudoOpsKind? RootPseudoOpsKind { get; }
|
||||
public OpCodeInfoGroup? ParentPseudoOpsKind { get; }
|
||||
public int PseudoOpsKindImmediateValue { get; }
|
||||
public bool HasLabel => (Flags & OpCodeArgFlags.HasLabel) != 0;
|
||||
public bool HasSpecialInstructionEncoding => (Flags & OpCodeArgFlags.HasSpecialInstructionEncoding) != 0;
|
||||
public bool IsBranch => (Flags & (OpCodeArgFlags.HasBranchShort | OpCodeArgFlags.HasBranchNear)) != 0;
|
||||
|
|
@ -1605,34 +1629,37 @@ namespace Generator.Assembler {
|
|||
public bool HasImmediateUnsigned => (Flags & OpCodeArgFlags.HasImmediateUnsigned) != 0;
|
||||
public Signature Signature { get; }
|
||||
public OpCodeNode RootOpCodeNode { get; set; }
|
||||
public int MaxImmediateSize { get; set; }
|
||||
public List<InstructionDef> Items { get; }
|
||||
public List<InstructionDef> Defs { get; }
|
||||
public List<int> MaxArgSizes { get; }
|
||||
public int NumberOfLeadingArgToDiscard { get; set; }
|
||||
public int NumberOfLeadingArgsToDiscard { get; }
|
||||
|
||||
public void UpdateMaxArgSizes(List<int> argSizes) {
|
||||
if (MaxArgSizes.Count == 0)
|
||||
MaxArgSizes.AddRange(argSizes);
|
||||
Debug.Assert(MaxArgSizes.Count == argSizes.Count);
|
||||
for (int i = 0; i < MaxArgSizes.Count; i++) {
|
||||
if (MaxArgSizes[i] < argSizes[i])
|
||||
MaxArgSizes[i] = argSizes[i];
|
||||
}
|
||||
Debug.Assert(Signature.ArgCount == argSizes.Count);
|
||||
for (int i = 0; i < MaxArgSizes.Count; i++)
|
||||
MaxArgSizes[i] = Math.Max(MaxArgSizes[i], argSizes[i]);
|
||||
}
|
||||
|
||||
public int OrderOpCodesPerOpKindPriority(InstructionDef x, InstructionDef y) {
|
||||
Debug.Assert(x.OpKindDefs.Length == y.OpKindDefs.Length);
|
||||
int result;
|
||||
for (int i = 0; i < x.OpKindDefs.Length; i++) {
|
||||
if (!IsRegister(Signature.GetArgKind(i))) continue;
|
||||
result = GetPriorityFromKind(x.OpKindDefs[i], GetMemorySizeInBits(memDefs, defs, x)).CompareTo(GetPriorityFromKind(y.OpKindDefs[i], GetMemorySizeInBits(memDefs, defs, y)));
|
||||
if (result != 0) return result;
|
||||
if (!IsRegister(Signature.GetArgKind(i)))
|
||||
continue;
|
||||
result = GetPriorityFromKind(x.OpKindDefs[i], GetMemorySizeInBits(memDefs, defs, x)).
|
||||
CompareTo(GetPriorityFromKind(y.OpKindDefs[i], GetMemorySizeInBits(memDefs, defs, y)));
|
||||
if (result != 0)
|
||||
return result;
|
||||
}
|
||||
|
||||
for (int i = 0; i < x.OpKindDefs.Length; i++) {
|
||||
if (IsRegister(Signature.GetArgKind(i))) continue;
|
||||
result = GetPriorityFromKind(x.OpKindDefs[i], GetMemorySizeInBits(memDefs, defs, x)).CompareTo(GetPriorityFromKind(y.OpKindDefs[i], GetMemorySizeInBits(memDefs, defs, y)));
|
||||
if (result != 0) return result;
|
||||
if (IsRegister(Signature.GetArgKind(i)))
|
||||
continue;
|
||||
result = GetPriorityFromKind(x.OpKindDefs[i], GetMemorySizeInBits(memDefs, defs, x)).
|
||||
CompareTo(GetPriorityFromKind(y.OpKindDefs[i], GetMemorySizeInBits(memDefs, defs, y)));
|
||||
if (result != 0)
|
||||
return result;
|
||||
}
|
||||
|
||||
// Case for ordering by decreasing bitness
|
||||
|
|
@ -1683,9 +1710,9 @@ namespace Generator.Assembler {
|
|||
kind switch {
|
||||
OpCodeSelectorKind.Vex => (OpCodeArgFlags.HasVex, OpCodeArgFlags.HasEvex),
|
||||
OpCodeSelectorKind.EvexBroadcastX or OpCodeSelectorKind.EvexBroadcastY or
|
||||
OpCodeSelectorKind.EvexBroadcastZ => (OpCodeArgFlags.HasEvex | OpCodeArgFlags.HasBroadcast, OpCodeArgFlags.Default),
|
||||
OpCodeSelectorKind.EvexBroadcastZ => (OpCodeArgFlags.HasEvex | OpCodeArgFlags.HasBroadcast, OpCodeArgFlags.None),
|
||||
OpCodeSelectorKind.BranchShort => (OpCodeArgFlags.HasBranchShort, OpCodeArgFlags.HasBranchNear),
|
||||
_ => (OpCodeArgFlags.Default, OpCodeArgFlags.Default),
|
||||
_ => (OpCodeArgFlags.None, OpCodeArgFlags.None),
|
||||
};
|
||||
|
||||
bool IsR64M16(InstructionDef def) {
|
||||
|
|
|
|||
|
|
@ -17,6 +17,7 @@ namespace Generator.Assembler.CSharp {
|
|||
sealed class CSharpAssemblerSyntaxGenerator : AssemblerSyntaxGenerator {
|
||||
readonly IdentifierConverter idConverter;
|
||||
readonly CSharpDocCommentWriter docWriter;
|
||||
readonly EnumType registerType;
|
||||
readonly EnumType memoryOperandSizeType;
|
||||
|
||||
static readonly List<(string, int, string[], string)> declareDataList = new List<(string, int, string[], string)> {
|
||||
|
|
@ -37,6 +38,7 @@ namespace Generator.Assembler.CSharp {
|
|||
: base(generatorContext.Types) {
|
||||
idConverter = CSharpIdentifierConverter.Create();
|
||||
docWriter = new CSharpDocCommentWriter(idConverter);
|
||||
registerType = genTypes[TypeIds.Register];
|
||||
memoryOperandSizeType = genTypes[TypeIds.CodeAsmMemoryOperandSize];
|
||||
}
|
||||
|
||||
|
|
@ -486,9 +488,9 @@ namespace Generator.Assembler.CSharp {
|
|||
if ((groupBitness & bitnessFlags) == 0)
|
||||
continue;
|
||||
|
||||
var renderArgs = GetRenderArgs(@group);
|
||||
var methodName = idConverter.Method(@group.Name);
|
||||
RenderTests(bitness, bitnessFlags, writerTests, methodName, @group, renderArgs);
|
||||
var renderArgs = GetRenderArgs(group);
|
||||
var methodName = idConverter.Method(group.Name);
|
||||
RenderTests(bitness, bitnessFlags, writerTests, methodName, group, renderArgs);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -517,12 +519,14 @@ namespace Generator.Assembler.CSharp {
|
|||
using (writer.Indent()) {
|
||||
writer.Write($"TestAssemblerDeclareData(c => c.{name}(");
|
||||
for (int j = 0; j < i; j++) {
|
||||
if (j > 0) writer.Write(", ");
|
||||
if (j > 0)
|
||||
writer.Write(", ");
|
||||
writer.Write($"({type}){j + 1}");
|
||||
}
|
||||
writer.Write($"), new {type}[] {{");
|
||||
for (int j = 0; j < i; j++) {
|
||||
if (j > 0) writer.Write(", ");
|
||||
if (j > 0)
|
||||
writer.Write(", ");
|
||||
writer.Write($"({type}){j + 1}");
|
||||
}
|
||||
writer.WriteLine("});");
|
||||
|
|
@ -634,28 +638,27 @@ namespace Generator.Assembler.CSharp {
|
|||
// Write documentation
|
||||
var methodDoc = new StringBuilder();
|
||||
methodDoc.Append($"{group.Name} instruction.");
|
||||
foreach (var code in group.Items) {
|
||||
if (!string.IsNullOrEmpty(code.Code.Documentation)) {
|
||||
foreach (var def in group.Defs) {
|
||||
if (!string.IsNullOrEmpty(def.Code.Documentation)) {
|
||||
methodDoc.Append("#(p:)#");
|
||||
methodDoc.Append(code.Code.Documentation);
|
||||
methodDoc.Append(def.Code.Documentation);
|
||||
}
|
||||
}
|
||||
|
||||
docWriter.WriteSummary(writer, methodDoc.ToString(), "");
|
||||
|
||||
writer.Write($"public void {methodName}(");
|
||||
int realArgCount = 0;
|
||||
for (var i = 0; i < renderArgs.Count; i++) {
|
||||
var renderArg = renderArgs[i];
|
||||
if (realArgCount > 0) writer.Write(", ");
|
||||
if (i > 0)
|
||||
writer.Write(", ");
|
||||
writer.Write($"{renderArg.Type} {renderArg.Name}");
|
||||
realArgCount++;
|
||||
}
|
||||
|
||||
writer.WriteLine(") {");
|
||||
using (writer.Indent()) {
|
||||
if ((group.Flags & OpCodeArgFlags.HasSpecialInstructionEncoding) != 0) {
|
||||
writer.Write($"AddInstruction(Instruction.Create{group.MemoName}(Bitness");
|
||||
writer.Write($"AddInstruction(Instruction.Create{group.MnemonicName}(Bitness");
|
||||
for (var i = 0; i < renderArgs.Count; i++) {
|
||||
var renderArg = renderArgs[i];
|
||||
writer.Write(", ");
|
||||
|
|
@ -673,7 +676,8 @@ namespace Generator.Assembler.CSharp {
|
|||
writer.Write($"{group.ParentPseudoOpsKind.Name}(");
|
||||
for (var i = 0; i < renderArgs.Count; i++) {
|
||||
var renderArg = renderArgs[i];
|
||||
if (i > 0) writer.Write(", ");
|
||||
if (i > 0)
|
||||
writer.Write(", ");
|
||||
writer.Write(renderArg.Name);
|
||||
}
|
||||
writer.Write(", ");
|
||||
|
|
@ -756,7 +760,7 @@ namespace Generator.Assembler.CSharp {
|
|||
|
||||
EncodingFlags GetEncodingFlags(OpCodeInfoGroup group) {
|
||||
var flags = EncodingFlags.None;
|
||||
foreach (var def in group.Items.Select(a => defs[(int)a.Code.Value])) {
|
||||
foreach (var def in group.Defs.Select(a => defs[(int)a.Code.Value])) {
|
||||
flags |= def.Encoding switch {
|
||||
EncodingKind.Legacy => EncodingFlags.Legacy,
|
||||
EncodingKind.VEX => EncodingFlags.VEX,
|
||||
|
|
@ -791,7 +795,8 @@ namespace Generator.Assembler.CSharp {
|
|||
return string.Join(" && ", defines.ToArray());
|
||||
}
|
||||
|
||||
void RenderTests(int bitness, InstructionDefFlags1 bitnessFlags, FileWriter writer, string methodName, OpCodeInfoGroup group, List<RenderArg> renderArgs) {
|
||||
void RenderTests(int bitness, InstructionDefFlags1 bitnessFlags, FileWriter writer, string methodName, OpCodeInfoGroup group,
|
||||
List<RenderArg> renderArgs) {
|
||||
var fullMethodName = new StringBuilder();
|
||||
fullMethodName.Append(methodName);
|
||||
foreach (var renderArg in renderArgs) {
|
||||
|
|
@ -850,10 +855,13 @@ namespace Generator.Assembler.CSharp {
|
|||
|
||||
if (group.Flags == OpCodeArgFlags.Pseudo) {
|
||||
Debug.Assert(group.ParentPseudoOpsKind is not null);
|
||||
GenerateTestAssemblerForOpCode(writer, bitness, bitnessFlags, @group, methodName, renderArgs, argValues, OpCodeArgFlags.Default, group.ParentPseudoOpsKind.Items[0]);
|
||||
GenerateTestAssemblerForOpCode(writer, bitness, bitnessFlags, group, methodName, renderArgs, argValues,
|
||||
OpCodeArgFlags.None, group.ParentPseudoOpsKind.Defs[0]);
|
||||
}
|
||||
else {
|
||||
GenerateOpCodeTest(writer, bitness, bitnessFlags, group, methodName, group.RootOpCodeNode, renderArgs,
|
||||
argValues, OpCodeArgFlags.None);
|
||||
}
|
||||
else
|
||||
GenerateOpCodeTest(writer, bitness, bitnessFlags, group, methodName, group.RootOpCodeNode, renderArgs, argValues, OpCodeArgFlags.Default);
|
||||
}
|
||||
writer.WriteLine("}");
|
||||
if (define is not null)
|
||||
|
|
@ -861,10 +869,11 @@ namespace Generator.Assembler.CSharp {
|
|||
writer.WriteLine(); ;
|
||||
}
|
||||
|
||||
void GenerateOpCodeTest(FileWriter writer, int bitness, InstructionDefFlags1 bitnessFlags, OpCodeInfoGroup group, string methodName, OpCodeNode node, List<RenderArg> args, List<object?> argValues, OpCodeArgFlags contextFlags) {
|
||||
var opCodeInfo = node.Def;
|
||||
if (opCodeInfo is not null)
|
||||
GenerateTestAssemblerForOpCode(writer, bitness, bitnessFlags, @group, methodName, args, argValues, contextFlags, opCodeInfo);
|
||||
void GenerateOpCodeTest(FileWriter writer, int bitness, InstructionDefFlags1 bitnessFlags, OpCodeInfoGroup group, string methodName,
|
||||
OpCodeNode node, List<RenderArg> args, List<object?> argValues, OpCodeArgFlags contextFlags) {
|
||||
var def = node.Def;
|
||||
if (def is not null)
|
||||
GenerateTestAssemblerForOpCode(writer, bitness, bitnessFlags, group, methodName, args, argValues, contextFlags, def);
|
||||
else {
|
||||
var selector = node.Selector;
|
||||
Debug.Assert(selector is not null);
|
||||
|
|
@ -879,7 +888,8 @@ namespace Generator.Assembler.CSharp {
|
|||
var newArgValues = new List<object?>(argValues);
|
||||
if (selector.ArgIndex >= 0)
|
||||
newArgValues[selector.ArgIndex] = argValue;
|
||||
GenerateOpCodeTest(writer, bitness, bitnessFlags, group, methodName, selector.IfTrue, args, newArgValues, contextFlags | contextIfFlags);
|
||||
GenerateOpCodeTest(writer, bitness, bitnessFlags, group, methodName, selector.IfTrue, args,
|
||||
newArgValues, contextFlags | contextIfFlags);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -893,7 +903,8 @@ namespace Generator.Assembler.CSharp {
|
|||
var newArgValues = new List<object?>(argValues);
|
||||
if (selector.ArgIndex >= 0)
|
||||
newArgValues[selector.ArgIndex] = argValue;
|
||||
GenerateOpCodeTest(writer, bitness, bitnessFlags, group, methodName, selector.IfFalse, args, newArgValues, contextFlags | contextElseFlags);
|
||||
GenerateOpCodeTest(writer, bitness, bitnessFlags, group, methodName, selector.IfFalse, args, newArgValues,
|
||||
contextFlags | contextElseFlags);
|
||||
}
|
||||
}
|
||||
else
|
||||
|
|
@ -917,11 +928,12 @@ namespace Generator.Assembler.CSharp {
|
|||
bitnessFlags = InstructionDefFlags1.Bit32;
|
||||
}
|
||||
|
||||
writer.WriteLine("AssertInvalid( () => {");
|
||||
writer.WriteLine("AssertInvalid(() => {");
|
||||
using (writer.Indent()) {
|
||||
var newArgValues = new List<object?>(argValues);
|
||||
newArgValues[selector.ArgIndex] = newArg;
|
||||
GenerateOpCodeTest(writer, bitness, bitnessFlags, group, methodName, selector.IfTrue, args, newArgValues, contextFlags | contextIfFlags);
|
||||
GenerateOpCodeTest(writer, bitness, bitnessFlags, group, methodName, selector.IfTrue, args, newArgValues,
|
||||
contextFlags | contextIfFlags);
|
||||
isGenerated = true;
|
||||
}
|
||||
writer.WriteLine("});");
|
||||
|
|
@ -940,7 +952,8 @@ namespace Generator.Assembler.CSharp {
|
|||
}
|
||||
}
|
||||
|
||||
bool GenerateTestAssemblerForOpCode(FileWriter writer, int bitness, InstructionDefFlags1 bitnessFlags, OpCodeInfoGroup @group, string methodName, List<RenderArg> args, List<object?> argValues, OpCodeArgFlags contextFlags, InstructionDef def) {
|
||||
bool GenerateTestAssemblerForOpCode(FileWriter writer, int bitness, InstructionDefFlags1 bitnessFlags, OpCodeInfoGroup group,
|
||||
string methodName, List<RenderArg> args, List<object?> argValues, OpCodeArgFlags contextFlags, InstructionDef def) {
|
||||
if ((def.Flags1 & bitnessFlags) == 0) {
|
||||
writer.WriteLine("{");
|
||||
using (writer.Indent())
|
||||
|
|
@ -990,8 +1003,10 @@ namespace Generator.Assembler.CSharp {
|
|||
if (argValueForAssembler is null) {
|
||||
var localBitness = forceBitness > 0 ? forceBitness : bitness;
|
||||
|
||||
argValueForAssembler = GetDefaultArgument(localBitness, def.OpKindDefs[@group.NumberOfLeadingArgToDiscard + i], isMemory, true, i, renderArg);
|
||||
argValueForInstructionCreate = GetDefaultArgument(localBitness, def.OpKindDefs[@group.NumberOfLeadingArgToDiscard + i], isMemory, false, i, renderArg);
|
||||
argValueForAssembler = GetDefaultArgument(localBitness, def.OpKindDefs[group.NumberOfLeadingArgsToDiscard + i],
|
||||
isMemory, true, i, renderArg);
|
||||
argValueForInstructionCreate = GetDefaultArgument(localBitness, def.OpKindDefs[group.NumberOfLeadingArgsToDiscard + i],
|
||||
isMemory, false, i, renderArg);
|
||||
}
|
||||
|
||||
if ((def.Flags1 & InstructionDefFlags1.OpMaskRegister) != 0 && i == 0) {
|
||||
|
|
@ -1033,7 +1048,7 @@ namespace Generator.Assembler.CSharp {
|
|||
optionalOpCodeFlags.Add("LocalOpCodeFlags.PreferBranchNear");
|
||||
if ((def.Flags1 & InstructionDefFlags1.Fwait) != 0)
|
||||
optionalOpCodeFlags.Add("LocalOpCodeFlags.Fwait");
|
||||
if (@group.HasLabel)
|
||||
if (group.HasLabel)
|
||||
optionalOpCodeFlags.Add((group.Flags & OpCodeArgFlags.HasLabelUlong) == 0 ? "LocalOpCodeFlags.Branch" : "LocalOpCodeFlags.BranchUlong");
|
||||
|
||||
if (group.Flags == OpCodeArgFlags.Pseudo)
|
||||
|
|
@ -1041,13 +1056,13 @@ namespace Generator.Assembler.CSharp {
|
|||
|
||||
string beginInstruction = $"Instruction.Create(Code.{def.Code.Name(idConverter)}";
|
||||
string endInstruction = ")";
|
||||
if ((@group.Flags & OpCodeArgFlags.HasSpecialInstructionEncoding) != 0) {
|
||||
beginInstruction = $"Instruction.Create{@group.MemoName}(Bitness";
|
||||
if (@group.HasLabel && (group.Flags & OpCodeArgFlags.HasLabelUlong) == 0)
|
||||
if ((group.Flags & OpCodeArgFlags.HasSpecialInstructionEncoding) != 0) {
|
||||
beginInstruction = $"Instruction.Create{group.MnemonicName}(Bitness";
|
||||
if (group.HasLabel && (group.Flags & OpCodeArgFlags.HasLabelUlong) == 0)
|
||||
beginInstruction = $"AssignLabel({beginInstruction}, {instructionCreateArgs[0]})";
|
||||
}
|
||||
else if (@group.HasLabel) {
|
||||
beginInstruction = (@group.Flags & OpCodeArgFlags.HasLabelUlong) == 0 ?
|
||||
else if (group.HasLabel) {
|
||||
beginInstruction = (group.Flags & OpCodeArgFlags.HasLabelUlong) == 0 ?
|
||||
$"AssignLabel(Instruction.CreateBranch(Code.{def.Code.Name(idConverter)}, {instructionCreateArgs[0]})" :
|
||||
$"Instruction.CreateBranch(Code.{def.Code.Name(idConverter)}";
|
||||
}
|
||||
|
|
@ -1203,11 +1218,11 @@ namespace Generator.Assembler.CSharp {
|
|||
GenerateOpCodeSelector(writer, group, true, group.RootOpCodeNode, args);
|
||||
|
||||
void GenerateOpCodeSelector(FileWriter writer, OpCodeInfoGroup group, bool isLeaf, OpCodeNode node, List<RenderArg> args) {
|
||||
var opCodeInfo = node.Def;
|
||||
if (opCodeInfo is not null) {
|
||||
var def = node.Def;
|
||||
if (def is not null) {
|
||||
if (isLeaf)
|
||||
writer.Write("op = ");
|
||||
writer.Write($"Code.{opCodeInfo.Code.Name(idConverter)}");
|
||||
writer.Write($"Code.{def.Code.Name(idConverter)}");
|
||||
if (isLeaf)
|
||||
writer.WriteLine(";");
|
||||
}
|
||||
|
|
@ -1233,7 +1248,7 @@ namespace Generator.Assembler.CSharp {
|
|||
else {
|
||||
writer.WriteLine("{");
|
||||
using (writer.Indent()) {
|
||||
writer.Write($"throw NoOpCodeFoundFor(Mnemonic.{group.MemoName}");
|
||||
writer.Write($"throw NoOpCodeFoundFor(Mnemonic.{group.MnemonicName}");
|
||||
for (var i = 0; i < args.Count; i++) {
|
||||
var renderArg = args[i];
|
||||
writer.Write(", ");
|
||||
|
|
@ -1253,14 +1268,14 @@ namespace Generator.Assembler.CSharp {
|
|||
var regName = arg.Name;
|
||||
var otherRegName = arg.Name == "src" ? "dst" : "src";
|
||||
return selectorKind switch {
|
||||
OpCodeSelectorKind.MemOffs64_RAX => $"{otherRegName}.Value == Register.RAX && Bitness == 64 && {regName}.IsDisplacementOnly",
|
||||
OpCodeSelectorKind.MemOffs64_EAX => $"{otherRegName}.Value == Register.EAX && Bitness == 64 && {regName}.IsDisplacementOnly",
|
||||
OpCodeSelectorKind.MemOffs64_AX => $"{otherRegName}.Value == Register.AX && Bitness == 64 && {regName}.IsDisplacementOnly",
|
||||
OpCodeSelectorKind.MemOffs64_AL => $"{otherRegName}.Value == Register.AL && Bitness == 64 && {regName}.IsDisplacementOnly",
|
||||
OpCodeSelectorKind.MemOffs_RAX => $"{otherRegName}.Value == Register.RAX && Bitness < 64 && {regName}.IsDisplacementOnly",
|
||||
OpCodeSelectorKind.MemOffs_EAX => $"{otherRegName}.Value == Register.EAX && Bitness < 64 && {regName}.IsDisplacementOnly",
|
||||
OpCodeSelectorKind.MemOffs_AX => $"{otherRegName}.Value == Register.AX && Bitness < 64 && {regName}.IsDisplacementOnly",
|
||||
OpCodeSelectorKind.MemOffs_AL => $"{otherRegName}.Value == Register.AL && Bitness < 64 && {regName}.IsDisplacementOnly",
|
||||
OpCodeSelectorKind.MemOffs64_RAX => $"{otherRegName}.Value == {GetRegisterString(nameof(Register.RAX))} && Bitness == 64 && {regName}.IsDisplacementOnly",
|
||||
OpCodeSelectorKind.MemOffs64_EAX => $"{otherRegName}.Value == {GetRegisterString(nameof(Register.EAX))} && Bitness == 64 && {regName}.IsDisplacementOnly",
|
||||
OpCodeSelectorKind.MemOffs64_AX => $"{otherRegName}.Value == {GetRegisterString(nameof(Register.AX))} && Bitness == 64 && {regName}.IsDisplacementOnly",
|
||||
OpCodeSelectorKind.MemOffs64_AL => $"{otherRegName}.Value == {GetRegisterString(nameof(Register.AL))} && Bitness == 64 && {regName}.IsDisplacementOnly",
|
||||
OpCodeSelectorKind.MemOffs_RAX => $"{otherRegName}.Value == {GetRegisterString(nameof(Register.RAX))} && Bitness < 64 && {regName}.IsDisplacementOnly",
|
||||
OpCodeSelectorKind.MemOffs_EAX => $"{otherRegName}.Value == {GetRegisterString(nameof(Register.EAX))} && Bitness < 64 && {regName}.IsDisplacementOnly",
|
||||
OpCodeSelectorKind.MemOffs_AX => $"{otherRegName}.Value == {GetRegisterString(nameof(Register.AX))} && Bitness < 64 && {regName}.IsDisplacementOnly",
|
||||
OpCodeSelectorKind.MemOffs_AL => $"{otherRegName}.Value == {GetRegisterString(nameof(Register.AL))} && Bitness < 64 && {regName}.IsDisplacementOnly",
|
||||
OpCodeSelectorKind.Bitness64 => "Bitness == 64",
|
||||
OpCodeSelectorKind.Bitness32 => "Bitness >= 32",
|
||||
OpCodeSelectorKind.Bitness16 => "Bitness >= 16",
|
||||
|
|
@ -1279,25 +1294,25 @@ namespace Generator.Assembler.CSharp {
|
|||
OpCodeSelectorKind.EvexBroadcastX => $"{regName}.IsBroadcast",
|
||||
OpCodeSelectorKind.EvexBroadcastY => $"{regName}.IsBroadcast",
|
||||
OpCodeSelectorKind.EvexBroadcastZ => $"{regName}.IsBroadcast",
|
||||
OpCodeSelectorKind.RegisterCL => $"{regName} == Register.CL",
|
||||
OpCodeSelectorKind.RegisterAL => $"{regName} == Register.AL",
|
||||
OpCodeSelectorKind.RegisterAX => $"{regName} == Register.AX",
|
||||
OpCodeSelectorKind.RegisterEAX => $"{regName} == Register.EAX",
|
||||
OpCodeSelectorKind.RegisterRAX => $"{regName} == Register.RAX",
|
||||
OpCodeSelectorKind.RegisterCL => $"{regName} == {GetRegisterString(nameof(Register.CL))}",
|
||||
OpCodeSelectorKind.RegisterAL => $"{regName} == {GetRegisterString(nameof(Register.AL))}",
|
||||
OpCodeSelectorKind.RegisterAX => $"{regName} == {GetRegisterString(nameof(Register.AX))}",
|
||||
OpCodeSelectorKind.RegisterEAX => $"{regName} == {GetRegisterString(nameof(Register.EAX))}",
|
||||
OpCodeSelectorKind.RegisterRAX => $"{regName} == {GetRegisterString(nameof(Register.RAX))}",
|
||||
OpCodeSelectorKind.RegisterBND => $"{regName} == Register.IsBND()",
|
||||
OpCodeSelectorKind.RegisterES => $"{regName} == Register.ES",
|
||||
OpCodeSelectorKind.RegisterCS => $"{regName} == Register.CS",
|
||||
OpCodeSelectorKind.RegisterSS => $"{regName} == Register.SS",
|
||||
OpCodeSelectorKind.RegisterDS => $"{regName} == Register.DS",
|
||||
OpCodeSelectorKind.RegisterFS => $"{regName} == Register.FS",
|
||||
OpCodeSelectorKind.RegisterGS => $"{regName} == Register.GS",
|
||||
OpCodeSelectorKind.RegisterDX => $"{regName} == Register.DX",
|
||||
OpCodeSelectorKind.RegisterES => $"{regName} == {GetRegisterString(nameof(Register.ES))}",
|
||||
OpCodeSelectorKind.RegisterCS => $"{regName} == {GetRegisterString(nameof(Register.CS))}",
|
||||
OpCodeSelectorKind.RegisterSS => $"{regName} == {GetRegisterString(nameof(Register.SS))}",
|
||||
OpCodeSelectorKind.RegisterDS => $"{regName} == {GetRegisterString(nameof(Register.DS))}",
|
||||
OpCodeSelectorKind.RegisterFS => $"{regName} == {GetRegisterString(nameof(Register.FS))}",
|
||||
OpCodeSelectorKind.RegisterGS => $"{regName} == {GetRegisterString(nameof(Register.GS))}",
|
||||
OpCodeSelectorKind.RegisterDX => $"{regName} == {GetRegisterString(nameof(Register.DX))}",
|
||||
OpCodeSelectorKind.Register8 => $"{regName}.IsGPR8()",
|
||||
OpCodeSelectorKind.Register16 => $"{regName}.IsGPR16()",
|
||||
OpCodeSelectorKind.Register32 => $"{regName}.IsGPR32()",
|
||||
OpCodeSelectorKind.Register64 => $"{regName}.IsGPR64()",
|
||||
OpCodeSelectorKind.RegisterK => $"{regName}.IsK()",
|
||||
OpCodeSelectorKind.RegisterST0 => $"{regName} == Register.ST0",
|
||||
OpCodeSelectorKind.RegisterST0 => $"{regName} == {GetRegisterString(nameof(Register.ST0))}",
|
||||
OpCodeSelectorKind.RegisterST => $"{regName}.IsST()",
|
||||
OpCodeSelectorKind.RegisterSegment => $"{regName}.IsSegmentRegister()",
|
||||
OpCodeSelectorKind.RegisterCR => $"{regName}.IsCR()",
|
||||
|
|
@ -1328,6 +1343,9 @@ namespace Generator.Assembler.CSharp {
|
|||
};
|
||||
}
|
||||
|
||||
string GetRegisterString(string fieldName) =>
|
||||
$"{registerType.Name(idConverter)}.{registerType[fieldName].Name(idConverter)}";
|
||||
|
||||
string GetMemOpSizeString(string fieldName) =>
|
||||
$"{memoryOperandSizeType.Name(idConverter)}.{memoryOperandSizeType[fieldName].Name(idConverter)}";
|
||||
|
||||
|
|
|
|||
|
|
@ -142,7 +142,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.adc(__byte_ptr[di], -5), Instruction.Create(Code.Adc_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.adc(__zmmword_ptr[di], -5), Instruction.Create(Code.Adc_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -304,7 +304,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.add(__byte_ptr[di], -5), Instruction.Create(Code.Add_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.add(__zmmword_ptr[di], -5), Instruction.Create(Code.Add_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -641,7 +641,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.and(__byte_ptr[di], -5), Instruction.Create(Code.And_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.and(__zmmword_ptr[di], -5), Instruction.Create(Code.And_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -1035,7 +1035,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.bndcl(bnd2, __dword_ptr[edi]), Instruction.Create(Code.Bndcl_bnd_rm32, bnd2, __dword_ptr[edi].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bndcl(bnd2, __zmmword_ptr[di]), Instruction.Create(Code.Bndcl_bnd_rm32, bnd2, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -1056,7 +1056,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.bndcn(bnd2, __dword_ptr[edi]), Instruction.Create(Code.Bndcn_bnd_rm32, bnd2, __dword_ptr[edi].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bndcn(bnd2, __zmmword_ptr[di]), Instruction.Create(Code.Bndcn_bnd_rm32, bnd2, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -1077,7 +1077,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.bndcu(bnd2, __dword_ptr[edi]), Instruction.Create(Code.Bndcu_bnd_rm32, bnd2, __dword_ptr[edi].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bndcu(bnd2, __zmmword_ptr[di]), Instruction.Create(Code.Bndcu_bnd_rm32, bnd2, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -1098,7 +1098,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.bndmk(bnd2, __dword_ptr[edi]), Instruction.Create(Code.Bndmk_bnd_m32, bnd2, __dword_ptr[edi].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bndmk(bnd2, __zmmword_ptr[di]), Instruction.Create(Code.Bndmk_bnd_m32, bnd2, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -1229,7 +1229,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.bt(__word_ptr[di], -5), Instruction.Create(Code.Bt_rm16_imm8, __word_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bt(__zmmword_ptr[di], -5), Instruction.Create(Code.Bt_rm16_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -1303,7 +1303,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.btc(__word_ptr[di], -5), Instruction.Create(Code.Btc_rm16_imm8, __word_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.btc(__zmmword_ptr[di], -5), Instruction.Create(Code.Btc_rm16_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -1377,7 +1377,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.btr(__word_ptr[di], -5), Instruction.Create(Code.Btr_rm16_imm8, __word_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.btr(__zmmword_ptr[di], -5), Instruction.Create(Code.Btr_rm16_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -1451,7 +1451,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.bts(__word_ptr[di], -5), Instruction.Create(Code.Bts_rm16_imm8, __word_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bts(__zmmword_ptr[di], -5), Instruction.Create(Code.Bts_rm16_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -1526,7 +1526,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.call(__word_ptr[di]), Instruction.Create(Code.Call_rm16, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.call(__zmmword_ptr[di]), Instruction.Create(Code.Call_rm16, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -2061,7 +2061,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.cmp(__byte_ptr[di], -5), Instruction.Create(Code.Cmp_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.cmp(__zmmword_ptr[di], -5), Instruction.Create(Code.Cmp_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -2624,7 +2624,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.crc32(edx, __byte_ptr[di]), Instruction.Create(Code.Crc32_r32_rm8, edx, __byte_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.crc32(edx, __zmmword_ptr[di]), Instruction.Create(Code.Crc32_r32_rm8, edx, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -2765,7 +2765,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.cvtsi2sd(xmm2, __dword_ptr[di]), Instruction.Create(Code.Cvtsi2sd_xmm_rm32, xmm2, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.cvtsi2sd(xmm2, __zmmword_ptr[di]), Instruction.Create(Code.Cvtsi2sd_xmm_rm32, xmm2, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -2786,7 +2786,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.cvtsi2ss(xmm2, __dword_ptr[di]), Instruction.Create(Code.Cvtsi2ss_xmm_rm32, xmm2, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.cvtsi2ss(xmm2, __zmmword_ptr[di]), Instruction.Create(Code.Cvtsi2ss_xmm_rm32, xmm2, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -2923,7 +2923,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.dec(__byte_ptr[di]), Instruction.Create(Code.Dec_rm8, __byte_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.dec(__zmmword_ptr[di]), Instruction.Create(Code.Dec_rm8, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -2958,7 +2958,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.div(__byte_ptr[di]), Instruction.Create(Code.Div_rm8, __byte_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.div(__zmmword_ptr[di]), Instruction.Create(Code.Div_rm8, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3176,7 +3176,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fadd(__dword_ptr[di]), Instruction.Create(Code.Fadd_m32fp, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fadd(__zmmword_ptr[di]), Instruction.Create(Code.Fadd_m32fp, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3262,7 +3262,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fcom(__dword_ptr[di]), Instruction.Create(Code.Fcom_m32fp, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fcom(__zmmword_ptr[di]), Instruction.Create(Code.Fcom_m32fp, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3291,7 +3291,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fcomp(__dword_ptr[di]), Instruction.Create(Code.Fcomp_m32fp, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fcomp(__zmmword_ptr[di]), Instruction.Create(Code.Fcomp_m32fp, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3330,7 +3330,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fdiv(__dword_ptr[di]), Instruction.Create(Code.Fdiv_m32fp, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fdiv(__zmmword_ptr[di]), Instruction.Create(Code.Fdiv_m32fp, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3356,7 +3356,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fdivr(__dword_ptr[di]), Instruction.Create(Code.Fdivr_m32fp, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fdivr(__zmmword_ptr[di]), Instruction.Create(Code.Fdivr_m32fp, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3402,7 +3402,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fiadd(__word_ptr[di]), Instruction.Create(Code.Fiadd_m16int, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fiadd(__zmmword_ptr[di]), Instruction.Create(Code.Fiadd_m16int, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3416,7 +3416,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ficom(__word_ptr[di]), Instruction.Create(Code.Ficom_m16int, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ficom(__zmmword_ptr[di]), Instruction.Create(Code.Ficom_m16int, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3430,7 +3430,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ficomp(__word_ptr[di]), Instruction.Create(Code.Ficomp_m16int, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ficomp(__zmmword_ptr[di]), Instruction.Create(Code.Ficomp_m16int, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3444,7 +3444,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fidiv(__word_ptr[di]), Instruction.Create(Code.Fidiv_m16int, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fidiv(__zmmword_ptr[di]), Instruction.Create(Code.Fidiv_m16int, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3458,7 +3458,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fidivr(__word_ptr[di]), Instruction.Create(Code.Fidivr_m16int, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fidivr(__zmmword_ptr[di]), Instruction.Create(Code.Fidivr_m16int, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3474,7 +3474,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fild(__word_ptr[di]), Instruction.Create(Code.Fild_m16int, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fild(__zmmword_ptr[di]), Instruction.Create(Code.Fild_m16int, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3488,7 +3488,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fimul(__word_ptr[di]), Instruction.Create(Code.Fimul_m16int, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fimul(__zmmword_ptr[di]), Instruction.Create(Code.Fimul_m16int, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3512,7 +3512,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fist(__word_ptr[di]), Instruction.Create(Code.Fist_m16int, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fist(__zmmword_ptr[di]), Instruction.Create(Code.Fist_m16int, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3528,7 +3528,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fistp(__word_ptr[di]), Instruction.Create(Code.Fistp_m16int, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fistp(__zmmword_ptr[di]), Instruction.Create(Code.Fistp_m16int, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3544,7 +3544,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fisttp(__word_ptr[di]), Instruction.Create(Code.Fisttp_m16int, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fisttp(__zmmword_ptr[di]), Instruction.Create(Code.Fisttp_m16int, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3558,7 +3558,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fisub(__word_ptr[di]), Instruction.Create(Code.Fisub_m16int, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fisub(__zmmword_ptr[di]), Instruction.Create(Code.Fisub_m16int, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3572,7 +3572,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fisubr(__word_ptr[di]), Instruction.Create(Code.Fisubr_m16int, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fisubr(__zmmword_ptr[di]), Instruction.Create(Code.Fisubr_m16int, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3593,7 +3593,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fld(__dword_ptr[di]), Instruction.Create(Code.Fld_m32fp, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fld(__zmmword_ptr[di]), Instruction.Create(Code.Fld_m32fp, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3653,7 +3653,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fmul(__dword_ptr[di]), Instruction.Create(Code.Fmul_m32fp, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fmul(__zmmword_ptr[di]), Instruction.Create(Code.Fmul_m32fp, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3818,7 +3818,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fst(__dword_ptr[di]), Instruction.Create(Code.Fst_m32fp, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fst(__zmmword_ptr[di]), Instruction.Create(Code.Fst_m32fp, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3855,7 +3855,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fstp(__dword_ptr[di]), Instruction.Create(Code.Fstp_m32fp, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fstp(__zmmword_ptr[di]), Instruction.Create(Code.Fstp_m32fp, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3889,7 +3889,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fsub(__dword_ptr[di]), Instruction.Create(Code.Fsub_m32fp, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fsub(__zmmword_ptr[di]), Instruction.Create(Code.Fsub_m32fp, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3915,7 +3915,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fsubr(__dword_ptr[di]), Instruction.Create(Code.Fsubr_m32fp, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fsubr(__zmmword_ptr[di]), Instruction.Create(Code.Fsubr_m32fp, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4157,7 +4157,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.idiv(__byte_ptr[di]), Instruction.Create(Code.Idiv_rm8, __byte_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.idiv(__zmmword_ptr[di]), Instruction.Create(Code.Idiv_rm8, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4192,7 +4192,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.imul(__byte_ptr[di]), Instruction.Create(Code.Imul_rm8, __byte_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.imul(__zmmword_ptr[di]), Instruction.Create(Code.Imul_rm8, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4358,7 +4358,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.inc(__byte_ptr[di]), Instruction.Create(Code.Inc_rm8, __byte_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.inc(__zmmword_ptr[di]), Instruction.Create(Code.Inc_rm8, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4735,7 +4735,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.jmp(__word_ptr[di]), Instruction.Create(Code.Jmp_rm16, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.jmp(__zmmword_ptr[di]), Instruction.Create(Code.Jmp_rm16, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6070,7 +6070,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.mov(__byte_ptr[di], -5), Instruction.Create(Code.Mov_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.mov(__zmmword_ptr[di], -5), Instruction.Create(Code.Mov_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -6483,7 +6483,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.movsx(dx, __byte_ptr[di]), Instruction.Create(Code.Movsx_r16_rm8, dx, __byte_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.movsx(dx, __zmmword_ptr[di]), Instruction.Create(Code.Movsx_r16_rm8, dx, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6497,7 +6497,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.movsx(edx, __byte_ptr[di]), Instruction.Create(Code.Movsx_r32_rm8, edx, __byte_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.movsx(edx, __zmmword_ptr[di]), Instruction.Create(Code.Movsx_r32_rm8, edx, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6561,7 +6561,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.movzx(dx, __byte_ptr[di]), Instruction.Create(Code.Movzx_r16_rm8, dx, __byte_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.movzx(dx, __zmmword_ptr[di]), Instruction.Create(Code.Movzx_r16_rm8, dx, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6575,7 +6575,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.movzx(edx, __byte_ptr[di]), Instruction.Create(Code.Movzx_r32_rm8, edx, __byte_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.movzx(edx, __zmmword_ptr[di]), Instruction.Create(Code.Movzx_r32_rm8, edx, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6630,7 +6630,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.mul(__byte_ptr[di]), Instruction.Create(Code.Mul_rm8, __byte_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.mul(__zmmword_ptr[di]), Instruction.Create(Code.Mul_rm8, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6729,7 +6729,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.neg(__byte_ptr[di]), Instruction.Create(Code.Neg_rm8, __byte_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.neg(__zmmword_ptr[di]), Instruction.Create(Code.Neg_rm8, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6763,7 +6763,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.nop(__word_ptr[di]), Instruction.Create(Code.Nop_rm16, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.nop(__zmmword_ptr[di]), Instruction.Create(Code.Nop_rm16, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6798,7 +6798,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.not(__byte_ptr[di]), Instruction.Create(Code.Not_rm8, __byte_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.not(__zmmword_ptr[di]), Instruction.Create(Code.Not_rm8, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6903,7 +6903,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.or(__byte_ptr[di], -5), Instruction.Create(Code.Or_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.or(__zmmword_ptr[di], -5), Instruction.Create(Code.Or_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -9006,7 +9006,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.pop(__word_ptr[di]), Instruction.Create(Code.Pop_rm16, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.pop(__zmmword_ptr[di]), Instruction.Create(Code.Pop_rm16, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -9836,7 +9836,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ptwrite(__dword_ptr[di]), Instruction.Create(Code.Ptwrite_rm32, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ptwrite(__zmmword_ptr[di]), Instruction.Create(Code.Ptwrite_rm32, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -10032,7 +10032,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.push(__word_ptr[di]), Instruction.Create(Code.Push_rm16, __word_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.push(__zmmword_ptr[di]), Instruction.Create(Code.Push_rm16, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -10143,7 +10143,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcl(__byte_ptr[di], cl), Instruction.Create(Code.Rcl_rm8_CL, __byte_ptr[di].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcl(__zmmword_ptr[di], cl), Instruction.Create(Code.Rcl_rm8_CL, __zmmword_ptr[di].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -10185,7 +10185,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcl(__byte_ptr[di], 1), Instruction.Create(Code.Rcl_rm8_1, __byte_ptr[di].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcl(__zmmword_ptr[di], 1), Instruction.Create(Code.Rcl_rm8_1, __zmmword_ptr[di].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -10201,7 +10201,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcl(__byte_ptr[di], 2), Instruction.Create(Code.Rcl_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcl(__zmmword_ptr[di], 2), Instruction.Create(Code.Rcl_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -10310,7 +10310,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcr(__byte_ptr[di], cl), Instruction.Create(Code.Rcr_rm8_CL, __byte_ptr[di].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcr(__zmmword_ptr[di], cl), Instruction.Create(Code.Rcr_rm8_CL, __zmmword_ptr[di].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -10352,7 +10352,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcr(__byte_ptr[di], 1), Instruction.Create(Code.Rcr_rm8_1, __byte_ptr[di].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcr(__zmmword_ptr[di], 1), Instruction.Create(Code.Rcr_rm8_1, __zmmword_ptr[di].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -10368,7 +10368,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcr(__byte_ptr[di], 2), Instruction.Create(Code.Rcr_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcr(__zmmword_ptr[di], 2), Instruction.Create(Code.Rcr_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -10759,7 +10759,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rol(__byte_ptr[di], cl), Instruction.Create(Code.Rol_rm8_CL, __byte_ptr[di].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rol(__zmmword_ptr[di], cl), Instruction.Create(Code.Rol_rm8_CL, __zmmword_ptr[di].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -10801,7 +10801,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rol(__byte_ptr[di], 1), Instruction.Create(Code.Rol_rm8_1, __byte_ptr[di].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rol(__zmmword_ptr[di], 1), Instruction.Create(Code.Rol_rm8_1, __zmmword_ptr[di].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -10817,7 +10817,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rol(__byte_ptr[di], 2), Instruction.Create(Code.Rol_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rol(__zmmword_ptr[di], 2), Instruction.Create(Code.Rol_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -10906,7 +10906,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ror(__byte_ptr[di], cl), Instruction.Create(Code.Ror_rm8_CL, __byte_ptr[di].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ror(__zmmword_ptr[di], cl), Instruction.Create(Code.Ror_rm8_CL, __zmmword_ptr[di].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -10948,7 +10948,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ror(__byte_ptr[di], 1), Instruction.Create(Code.Ror_rm8_1, __byte_ptr[di].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ror(__zmmword_ptr[di], 1), Instruction.Create(Code.Ror_rm8_1, __zmmword_ptr[di].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -10964,7 +10964,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ror(__byte_ptr[di], 2), Instruction.Create(Code.Ror_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ror(__zmmword_ptr[di], 2), Instruction.Create(Code.Ror_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -11211,7 +11211,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sal(__byte_ptr[di], cl), Instruction.Create(Code.Sal_rm8_CL, __byte_ptr[di].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sal(__zmmword_ptr[di], cl), Instruction.Create(Code.Sal_rm8_CL, __zmmword_ptr[di].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -11253,7 +11253,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sal(__byte_ptr[di], 1), Instruction.Create(Code.Sal_rm8_1, __byte_ptr[di].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sal(__zmmword_ptr[di], 1), Instruction.Create(Code.Sal_rm8_1, __zmmword_ptr[di].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -11269,7 +11269,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sal(__byte_ptr[di], 2), Instruction.Create(Code.Sal_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sal(__zmmword_ptr[di], 2), Instruction.Create(Code.Sal_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -11363,7 +11363,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sar(__byte_ptr[di], cl), Instruction.Create(Code.Sar_rm8_CL, __byte_ptr[di].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sar(__zmmword_ptr[di], cl), Instruction.Create(Code.Sar_rm8_CL, __zmmword_ptr[di].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -11405,7 +11405,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sar(__byte_ptr[di], 1), Instruction.Create(Code.Sar_rm8_1, __byte_ptr[di].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sar(__zmmword_ptr[di], 1), Instruction.Create(Code.Sar_rm8_1, __zmmword_ptr[di].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -11421,7 +11421,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sar(__byte_ptr[di], 2), Instruction.Create(Code.Sar_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sar(__zmmword_ptr[di], 2), Instruction.Create(Code.Sar_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -11599,7 +11599,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sbb(__byte_ptr[di], -5), Instruction.Create(Code.Sbb_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sbb(__zmmword_ptr[di], -5), Instruction.Create(Code.Sbb_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -11958,7 +11958,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shl(__byte_ptr[di], cl), Instruction.Create(Code.Shl_rm8_CL, __byte_ptr[di].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shl(__zmmword_ptr[di], cl), Instruction.Create(Code.Shl_rm8_CL, __zmmword_ptr[di].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -12000,7 +12000,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shl(__byte_ptr[di], 1), Instruction.Create(Code.Shl_rm8_1, __byte_ptr[di].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shl(__zmmword_ptr[di], 1), Instruction.Create(Code.Shl_rm8_1, __zmmword_ptr[di].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -12016,7 +12016,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shl(__byte_ptr[di], 2), Instruction.Create(Code.Shl_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shl(__zmmword_ptr[di], 2), Instruction.Create(Code.Shl_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -12179,7 +12179,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shr(__byte_ptr[di], cl), Instruction.Create(Code.Shr_rm8_CL, __byte_ptr[di].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shr(__zmmword_ptr[di], cl), Instruction.Create(Code.Shr_rm8_CL, __zmmword_ptr[di].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -12221,7 +12221,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shr(__byte_ptr[di], 1), Instruction.Create(Code.Shr_rm8_1, __byte_ptr[di].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shr(__zmmword_ptr[di], 1), Instruction.Create(Code.Shr_rm8_1, __zmmword_ptr[di].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -12237,7 +12237,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shr(__byte_ptr[di], 2), Instruction.Create(Code.Shr_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shr(__zmmword_ptr[di], 2), Instruction.Create(Code.Shr_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -12672,7 +12672,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sub(__byte_ptr[di], -5), Instruction.Create(Code.Sub_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sub(__zmmword_ptr[di], -5), Instruction.Create(Code.Sub_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -12884,7 +12884,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.test(__byte_ptr[di], -5), Instruction.Create(Code.Test_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.test(__zmmword_ptr[di], -5), Instruction.Create(Code.Test_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -23339,7 +23339,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtdq2ph(xmm2.k1, __xmmword_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtdq2ph_xmm_k1z_xmmm128b32, xmm2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtdq2ph(xmm2.k1, __byte_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtdq2ph_xmm_k1z_xmmm128b32, xmm2.k1, __byte_ptr[di].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -23495,7 +23495,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtneps2bf16(xmm2.k1, __xmmword_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtneps2bf16_xmm_k1z_xmmm128b32, xmm2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtneps2bf16(xmm2.k1, __byte_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtneps2bf16_xmm_k1z_xmmm128b32, xmm2.k1, __byte_ptr[di].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -23563,7 +23563,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
} /* else */ TestAssembler(c => c.vcvtpd2dq(xmm2.k1, __xmmword_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2dq_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
{ /* if (PreferVex) */
|
||||
TestAssembler(c => c.vcvtpd2dq(xmm2, __byte_ptr[di]), Instruction.Create(Code.VEX_Vcvtpd2dq_xmm_xmmm128, xmm2, __byte_ptr[di].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferVex);
|
||||
} /* else */ TestAssembler(c => c.vcvtpd2dq(xmm2.k1, __byte_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2dq_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[di].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
|
|
@ -23627,7 +23627,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtpd2ph(xmm2.k1, __xmmword_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2ph_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtpd2ph(xmm2.k1, __byte_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2ph_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[di].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -23695,7 +23695,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
} /* else */ TestAssembler(c => c.vcvtpd2ps(xmm2.k1, __xmmword_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2ps_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
{ /* if (PreferVex) */
|
||||
TestAssembler(c => c.vcvtpd2ps(xmm2, __byte_ptr[di]), Instruction.Create(Code.VEX_Vcvtpd2ps_xmm_xmmm128, xmm2, __byte_ptr[di].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferVex);
|
||||
} /* else */ TestAssembler(c => c.vcvtpd2ps(xmm2.k1, __byte_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2ps_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[di].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
|
|
@ -23799,7 +23799,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtpd2udq(xmm2.k1, __xmmword_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2udq_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtpd2udq(xmm2.k1, __byte_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2udq_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[di].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -24495,7 +24495,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtps2phx(xmm2.k1, __xmmword_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtps2phx_xmm_k1z_xmmm128b32, xmm2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtps2phx(xmm2.k1, __byte_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtps2phx_xmm_k1z_xmmm128b32, xmm2.k1, __byte_ptr[di].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -24725,7 +24725,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtqq2ph(xmm2.k1, __xmmword_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtqq2ph_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtqq2ph(xmm2.k1, __byte_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtqq2ph_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[di].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -24785,7 +24785,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtqq2ps(xmm2.k1, __xmmword_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtqq2ps_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtqq2ps(xmm2.k1, __byte_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtqq2ps_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[di].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -24959,7 +24959,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
} /* else */ TestAssembler(c => c.vcvtsi2sd(xmm2, xmm3, __dword_ptr[di]), Instruction.Create(Code.EVEX_Vcvtsi2sd_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[di].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferEvex);
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
{ /* if (PreferVex) */
|
||||
TestAssembler(c => c.vcvtsi2sd(xmm2, xmm3, __zmmword_ptr[di]), Instruction.Create(Code.VEX_Vcvtsi2sd_xmm_xmm_rm32, xmm2, xmm3, __zmmword_ptr[di].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferVex);
|
||||
} /* else */ TestAssembler(c => c.vcvtsi2sd(xmm2, xmm3, __zmmword_ptr[di]), Instruction.Create(Code.EVEX_Vcvtsi2sd_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[di].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferEvex);
|
||||
|
|
@ -24986,7 +24986,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtsi2sh(xmm2, xmm3, __dword_ptr[di]), Instruction.Create(Code.EVEX_Vcvtsi2sh_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtsi2sh(xmm2, xmm3, __zmmword_ptr[di]), Instruction.Create(Code.EVEX_Vcvtsi2sh_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -25019,7 +25019,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
} /* else */ TestAssembler(c => c.vcvtsi2ss(xmm2, xmm3, __dword_ptr[di]), Instruction.Create(Code.EVEX_Vcvtsi2ss_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[di].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferEvex);
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
{ /* if (PreferVex) */
|
||||
TestAssembler(c => c.vcvtsi2ss(xmm2, xmm3, __zmmword_ptr[di]), Instruction.Create(Code.VEX_Vcvtsi2ss_xmm_xmm_rm32, xmm2, xmm3, __zmmword_ptr[di].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferVex);
|
||||
} /* else */ TestAssembler(c => c.vcvtsi2ss(xmm2, xmm3, __zmmword_ptr[di]), Instruction.Create(Code.EVEX_Vcvtsi2ss_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[di].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferEvex);
|
||||
|
|
@ -25132,7 +25132,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
} /* else */ TestAssembler(c => c.vcvttpd2dq(xmm2.k1, __xmmword_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvttpd2dq_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
{ /* if (PreferVex) */
|
||||
TestAssembler(c => c.vcvttpd2dq(xmm2, __byte_ptr[di]), Instruction.Create(Code.VEX_Vcvttpd2dq_xmm_xmmm128, xmm2, __byte_ptr[di].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferVex);
|
||||
} /* else */ TestAssembler(c => c.vcvttpd2dq(xmm2.k1, __byte_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvttpd2dq_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[di].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
|
|
@ -25236,7 +25236,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvttpd2udq(xmm2.k1, __xmmword_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvttpd2udq_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvttpd2udq(xmm2.k1, __byte_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvttpd2udq_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[di].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -25904,7 +25904,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtudq2ph(xmm2.k1, __xmmword_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtudq2ph_xmm_k1z_xmmm128b32, xmm2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtudq2ph(xmm2.k1, __byte_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtudq2ph_xmm_k1z_xmmm128b32, xmm2.k1, __byte_ptr[di].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -26050,7 +26050,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtuqq2ph(xmm2.k1, __xmmword_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtuqq2ph_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtuqq2ph(xmm2.k1, __byte_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtuqq2ph_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[di].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -26110,7 +26110,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtuqq2ps(xmm2.k1, __xmmword_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtuqq2ps_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtuqq2ps(xmm2.k1, __byte_ptr[di]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtuqq2ps_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[di].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -26156,7 +26156,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtusi2sd(xmm2, xmm3, __dword_ptr[di]), Instruction.Create(Code.EVEX_Vcvtusi2sd_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtusi2sd(xmm2, xmm3, __zmmword_ptr[di]), Instruction.Create(Code.EVEX_Vcvtusi2sd_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -26181,7 +26181,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtusi2sh(xmm2, xmm3, __dword_ptr[di]), Instruction.Create(Code.EVEX_Vcvtusi2sh_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtusi2sh(xmm2, xmm3, __zmmword_ptr[di]), Instruction.Create(Code.EVEX_Vcvtusi2sh_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -26206,7 +26206,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtusi2ss(xmm2, xmm3, __dword_ptr[di]), Instruction.Create(Code.EVEX_Vcvtusi2ss_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtusi2ss(xmm2, xmm3, __zmmword_ptr[di]), Instruction.Create(Code.EVEX_Vcvtusi2ss_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[di].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -31733,7 +31733,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vfpclasspd(k2.k1, __xmmword_ptr[di], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclasspd_kr_k1_xmmm128b64_imm8, k2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness), -5)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vfpclasspd(k2.k1, __byte_ptr[di], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclasspd_kr_k1_xmmm128b64_imm8, k2.k1, __byte_ptr[di].ToMemoryOperand(Bitness), -5)));
|
||||
});
|
||||
}
|
||||
|
|
@ -31855,7 +31855,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vfpclassph(k2.k1, __xmmword_ptr[di], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclassph_kr_k1_xmmm128b16_imm8, k2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness), -5)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vfpclassph(k2.k1, __byte_ptr[di], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclassph_kr_k1_xmmm128b16_imm8, k2.k1, __byte_ptr[di].ToMemoryOperand(Bitness), -5)));
|
||||
});
|
||||
}
|
||||
|
|
@ -31977,7 +31977,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vfpclassps(k2.k1, __xmmword_ptr[di], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclassps_kr_k1_xmmm128b32_imm8, k2.k1, __xmmword_ptr[di].ToMemoryOperand(Bitness), -5)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vfpclassps(k2.k1, __byte_ptr[di], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclassps_kr_k1_xmmm128b32_imm8, k2.k1, __byte_ptr[di].ToMemoryOperand(Bitness), -5)));
|
||||
});
|
||||
}
|
||||
|
|
@ -32403,7 +32403,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vgatherqps(xmm2.k1, __[edi + ymm3]), ApplyK1(Instruction.Create(Code.EVEX_Vgatherqps_xmm_k1_vm64y, xmm2.k1, __[edi + ymm3].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vgatherqps(xmm2.k1, __[edi + zmm1]), ApplyK1(Instruction.Create(Code.EVEX_Vgatherqps_xmm_k1_vm64y, xmm2.k1, __[edi + zmm1].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -32426,7 +32426,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vgatherqps(xmm2, __[edi + ymm3], xmm4), Instruction.Create(Code.VEX_Vgatherqps_xmm_vm64y_xmm, xmm2, __[edi + ymm3].ToMemoryOperand(Bitness), xmm4));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vgatherqps(xmm2, __[edi + zmm1], xmm4), Instruction.Create(Code.VEX_Vgatherqps_xmm_vm64y_xmm, xmm2, __[edi + zmm1].ToMemoryOperand(Bitness), xmm4));
|
||||
});
|
||||
}
|
||||
|
|
@ -45443,7 +45443,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vpgatherqd(xmm2.k1, __[edi + ymm3]), ApplyK1(Instruction.Create(Code.EVEX_Vpgatherqd_xmm_k1_vm64y, xmm2.k1, __[edi + ymm3].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vpgatherqd(xmm2.k1, __[edi + zmm1]), ApplyK1(Instruction.Create(Code.EVEX_Vpgatherqd_xmm_k1_vm64y, xmm2.k1, __[edi + zmm1].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -45466,7 +45466,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vpgatherqd(xmm2, __[edi + ymm3], xmm4), Instruction.Create(Code.VEX_Vpgatherqd_xmm_vm64y_xmm, xmm2, __[edi + ymm3].ToMemoryOperand(Bitness), xmm4));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vpgatherqd(xmm2, __[edi + zmm1], xmm4), Instruction.Create(Code.VEX_Vpgatherqd_xmm_vm64y_xmm, xmm2, __[edi + zmm1].ToMemoryOperand(Bitness), xmm4));
|
||||
});
|
||||
}
|
||||
|
|
@ -50370,7 +50370,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vpscatterqd(__[edi + ymm2].k1, xmm3), ApplyK1(Instruction.Create(Code.EVEX_Vpscatterqd_vm64y_k1_xmm, __[edi + ymm2].k1.ToMemoryOperand(Bitness), xmm3)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vpscatterqd(__[edi + zmm0].k1, xmm3), ApplyK1(Instruction.Create(Code.EVEX_Vpscatterqd_vm64y_k1_xmm, __[edi + zmm0].k1.ToMemoryOperand(Bitness), xmm3)));
|
||||
});
|
||||
}
|
||||
|
|
@ -57057,7 +57057,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vscatterqps(__[edi + ymm2].k1, xmm3), ApplyK1(Instruction.Create(Code.EVEX_Vscatterqps_vm64y_k1_xmm, __[edi + ymm2].k1.ToMemoryOperand(Bitness), xmm3)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vscatterqps(__[edi + zmm0].k1, xmm3), ApplyK1(Instruction.Create(Code.EVEX_Vscatterqps_vm64y_k1_xmm, __[edi + zmm0].k1.ToMemoryOperand(Bitness), xmm3)));
|
||||
});
|
||||
}
|
||||
|
|
@ -58650,7 +58650,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.xor(__byte_ptr[di], -5), Instruction.Create(Code.Xor_rm8_imm8, __byte_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.xor(__zmmword_ptr[di], -5), Instruction.Create(Code.Xor_rm8_imm8, __zmmword_ptr[di].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
|
|||
|
|
@ -142,7 +142,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.adc(__byte_ptr[edx], -5), Instruction.Create(Code.Adc_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.adc(__zmmword_ptr[edx], -5), Instruction.Create(Code.Adc_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -304,7 +304,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.add(__byte_ptr[edx], -5), Instruction.Create(Code.Add_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.add(__zmmword_ptr[edx], -5), Instruction.Create(Code.Add_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -641,7 +641,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.and(__byte_ptr[edx], -5), Instruction.Create(Code.And_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.and(__zmmword_ptr[edx], -5), Instruction.Create(Code.And_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -1035,7 +1035,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.bndcl(bnd2, __dword_ptr[edx]), Instruction.Create(Code.Bndcl_bnd_rm32, bnd2, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bndcl(bnd2, __zmmword_ptr[edx]), Instruction.Create(Code.Bndcl_bnd_rm32, bnd2, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -1056,7 +1056,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.bndcn(bnd2, __dword_ptr[edx]), Instruction.Create(Code.Bndcn_bnd_rm32, bnd2, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bndcn(bnd2, __zmmword_ptr[edx]), Instruction.Create(Code.Bndcn_bnd_rm32, bnd2, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -1077,7 +1077,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.bndcu(bnd2, __dword_ptr[edx]), Instruction.Create(Code.Bndcu_bnd_rm32, bnd2, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bndcu(bnd2, __zmmword_ptr[edx]), Instruction.Create(Code.Bndcu_bnd_rm32, bnd2, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -1098,7 +1098,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.bndmk(bnd2, __dword_ptr[edx]), Instruction.Create(Code.Bndmk_bnd_m32, bnd2, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bndmk(bnd2, __zmmword_ptr[edx]), Instruction.Create(Code.Bndmk_bnd_m32, bnd2, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -1229,7 +1229,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.bt(__word_ptr[edx], -5), Instruction.Create(Code.Bt_rm16_imm8, __word_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bt(__zmmword_ptr[edx], -5), Instruction.Create(Code.Bt_rm16_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -1303,7 +1303,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.btc(__word_ptr[edx], -5), Instruction.Create(Code.Btc_rm16_imm8, __word_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.btc(__zmmword_ptr[edx], -5), Instruction.Create(Code.Btc_rm16_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -1377,7 +1377,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.btr(__word_ptr[edx], -5), Instruction.Create(Code.Btr_rm16_imm8, __word_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.btr(__zmmword_ptr[edx], -5), Instruction.Create(Code.Btr_rm16_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -1451,7 +1451,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.bts(__word_ptr[edx], -5), Instruction.Create(Code.Bts_rm16_imm8, __word_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bts(__zmmword_ptr[edx], -5), Instruction.Create(Code.Bts_rm16_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -1527,7 +1527,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.call(__word_ptr[edx]), Instruction.Create(Code.Call_rm16, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.call(__zmmword_ptr[edx]), Instruction.Create(Code.Call_rm16, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -2067,7 +2067,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.cmp(__byte_ptr[edx], -5), Instruction.Create(Code.Cmp_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.cmp(__zmmword_ptr[edx], -5), Instruction.Create(Code.Cmp_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -2630,7 +2630,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.crc32(edx, __byte_ptr[edx]), Instruction.Create(Code.Crc32_r32_rm8, edx, __byte_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.crc32(edx, __zmmword_ptr[edx]), Instruction.Create(Code.Crc32_r32_rm8, edx, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -2771,7 +2771,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.cvtsi2sd(xmm2, __dword_ptr[edx]), Instruction.Create(Code.Cvtsi2sd_xmm_rm32, xmm2, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.cvtsi2sd(xmm2, __zmmword_ptr[edx]), Instruction.Create(Code.Cvtsi2sd_xmm_rm32, xmm2, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -2792,7 +2792,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.cvtsi2ss(xmm2, __dword_ptr[edx]), Instruction.Create(Code.Cvtsi2ss_xmm_rm32, xmm2, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.cvtsi2ss(xmm2, __zmmword_ptr[edx]), Instruction.Create(Code.Cvtsi2ss_xmm_rm32, xmm2, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -2929,7 +2929,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.dec(__byte_ptr[edx]), Instruction.Create(Code.Dec_rm8, __byte_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.dec(__zmmword_ptr[edx]), Instruction.Create(Code.Dec_rm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -2964,7 +2964,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.div(__byte_ptr[edx]), Instruction.Create(Code.Div_rm8, __byte_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.div(__zmmword_ptr[edx]), Instruction.Create(Code.Div_rm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3184,7 +3184,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fadd(__dword_ptr[edx]), Instruction.Create(Code.Fadd_m32fp, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fadd(__zmmword_ptr[edx]), Instruction.Create(Code.Fadd_m32fp, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3270,7 +3270,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fcom(__dword_ptr[edx]), Instruction.Create(Code.Fcom_m32fp, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fcom(__zmmword_ptr[edx]), Instruction.Create(Code.Fcom_m32fp, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3299,7 +3299,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fcomp(__dword_ptr[edx]), Instruction.Create(Code.Fcomp_m32fp, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fcomp(__zmmword_ptr[edx]), Instruction.Create(Code.Fcomp_m32fp, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3338,7 +3338,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fdiv(__dword_ptr[edx]), Instruction.Create(Code.Fdiv_m32fp, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fdiv(__zmmword_ptr[edx]), Instruction.Create(Code.Fdiv_m32fp, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3364,7 +3364,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fdivr(__dword_ptr[edx]), Instruction.Create(Code.Fdivr_m32fp, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fdivr(__zmmword_ptr[edx]), Instruction.Create(Code.Fdivr_m32fp, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3410,7 +3410,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fiadd(__word_ptr[edx]), Instruction.Create(Code.Fiadd_m16int, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fiadd(__zmmword_ptr[edx]), Instruction.Create(Code.Fiadd_m16int, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3424,7 +3424,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ficom(__word_ptr[edx]), Instruction.Create(Code.Ficom_m16int, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ficom(__zmmword_ptr[edx]), Instruction.Create(Code.Ficom_m16int, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3438,7 +3438,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ficomp(__word_ptr[edx]), Instruction.Create(Code.Ficomp_m16int, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ficomp(__zmmword_ptr[edx]), Instruction.Create(Code.Ficomp_m16int, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3452,7 +3452,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fidiv(__word_ptr[edx]), Instruction.Create(Code.Fidiv_m16int, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fidiv(__zmmword_ptr[edx]), Instruction.Create(Code.Fidiv_m16int, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3466,7 +3466,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fidivr(__word_ptr[edx]), Instruction.Create(Code.Fidivr_m16int, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fidivr(__zmmword_ptr[edx]), Instruction.Create(Code.Fidivr_m16int, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3482,7 +3482,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fild(__word_ptr[edx]), Instruction.Create(Code.Fild_m16int, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fild(__zmmword_ptr[edx]), Instruction.Create(Code.Fild_m16int, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3496,7 +3496,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fimul(__word_ptr[edx]), Instruction.Create(Code.Fimul_m16int, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fimul(__zmmword_ptr[edx]), Instruction.Create(Code.Fimul_m16int, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3520,7 +3520,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fist(__word_ptr[edx]), Instruction.Create(Code.Fist_m16int, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fist(__zmmword_ptr[edx]), Instruction.Create(Code.Fist_m16int, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3536,7 +3536,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fistp(__word_ptr[edx]), Instruction.Create(Code.Fistp_m16int, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fistp(__zmmword_ptr[edx]), Instruction.Create(Code.Fistp_m16int, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3552,7 +3552,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fisttp(__word_ptr[edx]), Instruction.Create(Code.Fisttp_m16int, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fisttp(__zmmword_ptr[edx]), Instruction.Create(Code.Fisttp_m16int, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3566,7 +3566,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fisub(__word_ptr[edx]), Instruction.Create(Code.Fisub_m16int, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fisub(__zmmword_ptr[edx]), Instruction.Create(Code.Fisub_m16int, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3580,7 +3580,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fisubr(__word_ptr[edx]), Instruction.Create(Code.Fisubr_m16int, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fisubr(__zmmword_ptr[edx]), Instruction.Create(Code.Fisubr_m16int, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3601,7 +3601,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fld(__dword_ptr[edx]), Instruction.Create(Code.Fld_m32fp, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fld(__zmmword_ptr[edx]), Instruction.Create(Code.Fld_m32fp, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3662,7 +3662,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fmul(__dword_ptr[edx]), Instruction.Create(Code.Fmul_m32fp, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fmul(__zmmword_ptr[edx]), Instruction.Create(Code.Fmul_m32fp, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3831,7 +3831,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fst(__dword_ptr[edx]), Instruction.Create(Code.Fst_m32fp, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fst(__zmmword_ptr[edx]), Instruction.Create(Code.Fst_m32fp, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3869,7 +3869,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fstp(__dword_ptr[edx]), Instruction.Create(Code.Fstp_m32fp, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fstp(__zmmword_ptr[edx]), Instruction.Create(Code.Fstp_m32fp, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3903,7 +3903,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fsub(__dword_ptr[edx]), Instruction.Create(Code.Fsub_m32fp, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fsub(__zmmword_ptr[edx]), Instruction.Create(Code.Fsub_m32fp, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3929,7 +3929,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fsubr(__dword_ptr[edx]), Instruction.Create(Code.Fsubr_m32fp, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fsubr(__zmmword_ptr[edx]), Instruction.Create(Code.Fsubr_m32fp, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4171,7 +4171,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.idiv(__byte_ptr[edx]), Instruction.Create(Code.Idiv_rm8, __byte_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.idiv(__zmmword_ptr[edx]), Instruction.Create(Code.Idiv_rm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4206,7 +4206,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.imul(__byte_ptr[edx]), Instruction.Create(Code.Imul_rm8, __byte_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.imul(__zmmword_ptr[edx]), Instruction.Create(Code.Imul_rm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4372,7 +4372,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.inc(__byte_ptr[edx]), Instruction.Create(Code.Inc_rm8, __byte_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.inc(__zmmword_ptr[edx]), Instruction.Create(Code.Inc_rm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4788,7 +4788,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.jmp(__word_ptr[edx]), Instruction.Create(Code.Jmp_rm16, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.jmp(__zmmword_ptr[edx]), Instruction.Create(Code.Jmp_rm16, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6175,7 +6175,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.mov(__byte_ptr[edx], -5), Instruction.Create(Code.Mov_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.mov(__zmmword_ptr[edx], -5), Instruction.Create(Code.Mov_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -6588,7 +6588,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.movsx(dx, __byte_ptr[edx]), Instruction.Create(Code.Movsx_r16_rm8, dx, __byte_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.movsx(dx, __zmmword_ptr[edx]), Instruction.Create(Code.Movsx_r16_rm8, dx, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6602,7 +6602,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.movsx(edx, __byte_ptr[edx]), Instruction.Create(Code.Movsx_r32_rm8, edx, __byte_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.movsx(edx, __zmmword_ptr[edx]), Instruction.Create(Code.Movsx_r32_rm8, edx, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6666,7 +6666,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.movzx(dx, __byte_ptr[edx]), Instruction.Create(Code.Movzx_r16_rm8, dx, __byte_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.movzx(dx, __zmmword_ptr[edx]), Instruction.Create(Code.Movzx_r16_rm8, dx, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6680,7 +6680,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.movzx(edx, __byte_ptr[edx]), Instruction.Create(Code.Movzx_r32_rm8, edx, __byte_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.movzx(edx, __zmmword_ptr[edx]), Instruction.Create(Code.Movzx_r32_rm8, edx, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6735,7 +6735,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.mul(__byte_ptr[edx]), Instruction.Create(Code.Mul_rm8, __byte_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.mul(__zmmword_ptr[edx]), Instruction.Create(Code.Mul_rm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6834,7 +6834,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.neg(__byte_ptr[edx]), Instruction.Create(Code.Neg_rm8, __byte_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.neg(__zmmword_ptr[edx]), Instruction.Create(Code.Neg_rm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6869,7 +6869,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.nop(__word_ptr[edx]), Instruction.Create(Code.Nop_rm16, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.nop(__zmmword_ptr[edx]), Instruction.Create(Code.Nop_rm16, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6904,7 +6904,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.not(__byte_ptr[edx]), Instruction.Create(Code.Not_rm8, __byte_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.not(__zmmword_ptr[edx]), Instruction.Create(Code.Not_rm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -7009,7 +7009,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.or(__byte_ptr[edx], -5), Instruction.Create(Code.Or_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.or(__zmmword_ptr[edx], -5), Instruction.Create(Code.Or_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -9117,7 +9117,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.pop(__word_ptr[edx]), Instruction.Create(Code.Pop_rm16, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.pop(__zmmword_ptr[edx]), Instruction.Create(Code.Pop_rm16, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -9947,7 +9947,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ptwrite(__dword_ptr[edx]), Instruction.Create(Code.Ptwrite_rm32, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ptwrite(__zmmword_ptr[edx]), Instruction.Create(Code.Ptwrite_rm32, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -10149,7 +10149,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.push(__word_ptr[edx]), Instruction.Create(Code.Push_rm16, __word_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.push(__zmmword_ptr[edx]), Instruction.Create(Code.Push_rm16, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -10253,7 +10253,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcl(__byte_ptr[edx], cl), Instruction.Create(Code.Rcl_rm8_CL, __byte_ptr[edx].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcl(__zmmword_ptr[edx], cl), Instruction.Create(Code.Rcl_rm8_CL, __zmmword_ptr[edx].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -10295,7 +10295,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcl(__byte_ptr[edx], 1), Instruction.Create(Code.Rcl_rm8_1, __byte_ptr[edx].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcl(__zmmword_ptr[edx], 1), Instruction.Create(Code.Rcl_rm8_1, __zmmword_ptr[edx].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -10311,7 +10311,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcl(__byte_ptr[edx], 2), Instruction.Create(Code.Rcl_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcl(__zmmword_ptr[edx], 2), Instruction.Create(Code.Rcl_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -10420,7 +10420,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcr(__byte_ptr[edx], cl), Instruction.Create(Code.Rcr_rm8_CL, __byte_ptr[edx].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcr(__zmmword_ptr[edx], cl), Instruction.Create(Code.Rcr_rm8_CL, __zmmword_ptr[edx].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -10462,7 +10462,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcr(__byte_ptr[edx], 1), Instruction.Create(Code.Rcr_rm8_1, __byte_ptr[edx].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcr(__zmmword_ptr[edx], 1), Instruction.Create(Code.Rcr_rm8_1, __zmmword_ptr[edx].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -10478,7 +10478,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcr(__byte_ptr[edx], 2), Instruction.Create(Code.Rcr_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcr(__zmmword_ptr[edx], 2), Instruction.Create(Code.Rcr_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -10875,7 +10875,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rol(__byte_ptr[edx], cl), Instruction.Create(Code.Rol_rm8_CL, __byte_ptr[edx].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rol(__zmmword_ptr[edx], cl), Instruction.Create(Code.Rol_rm8_CL, __zmmword_ptr[edx].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -10917,7 +10917,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rol(__byte_ptr[edx], 1), Instruction.Create(Code.Rol_rm8_1, __byte_ptr[edx].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rol(__zmmword_ptr[edx], 1), Instruction.Create(Code.Rol_rm8_1, __zmmword_ptr[edx].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -10933,7 +10933,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rol(__byte_ptr[edx], 2), Instruction.Create(Code.Rol_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rol(__zmmword_ptr[edx], 2), Instruction.Create(Code.Rol_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -11022,7 +11022,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ror(__byte_ptr[edx], cl), Instruction.Create(Code.Ror_rm8_CL, __byte_ptr[edx].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ror(__zmmword_ptr[edx], cl), Instruction.Create(Code.Ror_rm8_CL, __zmmword_ptr[edx].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -11064,7 +11064,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ror(__byte_ptr[edx], 1), Instruction.Create(Code.Ror_rm8_1, __byte_ptr[edx].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ror(__zmmword_ptr[edx], 1), Instruction.Create(Code.Ror_rm8_1, __zmmword_ptr[edx].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -11080,7 +11080,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ror(__byte_ptr[edx], 2), Instruction.Create(Code.Ror_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ror(__zmmword_ptr[edx], 2), Instruction.Create(Code.Ror_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -11327,7 +11327,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sal(__byte_ptr[edx], cl), Instruction.Create(Code.Sal_rm8_CL, __byte_ptr[edx].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sal(__zmmword_ptr[edx], cl), Instruction.Create(Code.Sal_rm8_CL, __zmmword_ptr[edx].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -11369,7 +11369,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sal(__byte_ptr[edx], 1), Instruction.Create(Code.Sal_rm8_1, __byte_ptr[edx].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sal(__zmmword_ptr[edx], 1), Instruction.Create(Code.Sal_rm8_1, __zmmword_ptr[edx].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -11385,7 +11385,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sal(__byte_ptr[edx], 2), Instruction.Create(Code.Sal_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sal(__zmmword_ptr[edx], 2), Instruction.Create(Code.Sal_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -11479,7 +11479,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sar(__byte_ptr[edx], cl), Instruction.Create(Code.Sar_rm8_CL, __byte_ptr[edx].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sar(__zmmword_ptr[edx], cl), Instruction.Create(Code.Sar_rm8_CL, __zmmword_ptr[edx].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -11521,7 +11521,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sar(__byte_ptr[edx], 1), Instruction.Create(Code.Sar_rm8_1, __byte_ptr[edx].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sar(__zmmword_ptr[edx], 1), Instruction.Create(Code.Sar_rm8_1, __zmmword_ptr[edx].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -11537,7 +11537,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sar(__byte_ptr[edx], 2), Instruction.Create(Code.Sar_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sar(__zmmword_ptr[edx], 2), Instruction.Create(Code.Sar_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -11715,7 +11715,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sbb(__byte_ptr[edx], -5), Instruction.Create(Code.Sbb_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sbb(__zmmword_ptr[edx], -5), Instruction.Create(Code.Sbb_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -12075,7 +12075,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shl(__byte_ptr[edx], cl), Instruction.Create(Code.Shl_rm8_CL, __byte_ptr[edx].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shl(__zmmword_ptr[edx], cl), Instruction.Create(Code.Shl_rm8_CL, __zmmword_ptr[edx].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -12117,7 +12117,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shl(__byte_ptr[edx], 1), Instruction.Create(Code.Shl_rm8_1, __byte_ptr[edx].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shl(__zmmword_ptr[edx], 1), Instruction.Create(Code.Shl_rm8_1, __zmmword_ptr[edx].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -12133,7 +12133,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shl(__byte_ptr[edx], 2), Instruction.Create(Code.Shl_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shl(__zmmword_ptr[edx], 2), Instruction.Create(Code.Shl_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -12296,7 +12296,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shr(__byte_ptr[edx], cl), Instruction.Create(Code.Shr_rm8_CL, __byte_ptr[edx].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shr(__zmmword_ptr[edx], cl), Instruction.Create(Code.Shr_rm8_CL, __zmmword_ptr[edx].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -12338,7 +12338,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shr(__byte_ptr[edx], 1), Instruction.Create(Code.Shr_rm8_1, __byte_ptr[edx].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shr(__zmmword_ptr[edx], 1), Instruction.Create(Code.Shr_rm8_1, __zmmword_ptr[edx].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -12354,7 +12354,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shr(__byte_ptr[edx], 2), Instruction.Create(Code.Shr_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shr(__zmmword_ptr[edx], 2), Instruction.Create(Code.Shr_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -12793,7 +12793,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sub(__byte_ptr[edx], -5), Instruction.Create(Code.Sub_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sub(__zmmword_ptr[edx], -5), Instruction.Create(Code.Sub_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -13005,7 +13005,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.test(__byte_ptr[edx], -5), Instruction.Create(Code.Test_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.test(__zmmword_ptr[edx], -5), Instruction.Create(Code.Test_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -23460,7 +23460,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtdq2ph(xmm2.k1, __xmmword_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtdq2ph_xmm_k1z_xmmm128b32, xmm2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtdq2ph(xmm2.k1, __byte_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtdq2ph_xmm_k1z_xmmm128b32, xmm2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -23616,7 +23616,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtneps2bf16(xmm2.k1, __xmmword_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtneps2bf16_xmm_k1z_xmmm128b32, xmm2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtneps2bf16(xmm2.k1, __byte_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtneps2bf16_xmm_k1z_xmmm128b32, xmm2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -23684,7 +23684,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
} /* else */ TestAssembler(c => c.vcvtpd2dq(xmm2.k1, __xmmword_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2dq_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
{ /* if (PreferVex) */
|
||||
TestAssembler(c => c.vcvtpd2dq(xmm2, __byte_ptr[edx]), Instruction.Create(Code.VEX_Vcvtpd2dq_xmm_xmmm128, xmm2, __byte_ptr[edx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferVex);
|
||||
} /* else */ TestAssembler(c => c.vcvtpd2dq(xmm2.k1, __byte_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2dq_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
|
|
@ -23748,7 +23748,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtpd2ph(xmm2.k1, __xmmword_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2ph_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtpd2ph(xmm2.k1, __byte_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2ph_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -23816,7 +23816,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
} /* else */ TestAssembler(c => c.vcvtpd2ps(xmm2.k1, __xmmword_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2ps_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
{ /* if (PreferVex) */
|
||||
TestAssembler(c => c.vcvtpd2ps(xmm2, __byte_ptr[edx]), Instruction.Create(Code.VEX_Vcvtpd2ps_xmm_xmmm128, xmm2, __byte_ptr[edx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferVex);
|
||||
} /* else */ TestAssembler(c => c.vcvtpd2ps(xmm2.k1, __byte_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2ps_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
|
|
@ -23920,7 +23920,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtpd2udq(xmm2.k1, __xmmword_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2udq_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtpd2udq(xmm2.k1, __byte_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2udq_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -24616,7 +24616,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtps2phx(xmm2.k1, __xmmword_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtps2phx_xmm_k1z_xmmm128b32, xmm2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtps2phx(xmm2.k1, __byte_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtps2phx_xmm_k1z_xmmm128b32, xmm2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -24846,7 +24846,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtqq2ph(xmm2.k1, __xmmword_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtqq2ph_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtqq2ph(xmm2.k1, __byte_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtqq2ph_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -24906,7 +24906,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtqq2ps(xmm2.k1, __xmmword_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtqq2ps_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtqq2ps(xmm2.k1, __byte_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtqq2ps_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -25080,7 +25080,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
} /* else */ TestAssembler(c => c.vcvtsi2sd(xmm2, xmm3, __dword_ptr[edx]), Instruction.Create(Code.EVEX_Vcvtsi2sd_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[edx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferEvex);
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
{ /* if (PreferVex) */
|
||||
TestAssembler(c => c.vcvtsi2sd(xmm2, xmm3, __zmmword_ptr[edx]), Instruction.Create(Code.VEX_Vcvtsi2sd_xmm_xmm_rm32, xmm2, xmm3, __zmmword_ptr[edx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferVex);
|
||||
} /* else */ TestAssembler(c => c.vcvtsi2sd(xmm2, xmm3, __zmmword_ptr[edx]), Instruction.Create(Code.EVEX_Vcvtsi2sd_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[edx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferEvex);
|
||||
|
|
@ -25107,7 +25107,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtsi2sh(xmm2, xmm3, __dword_ptr[edx]), Instruction.Create(Code.EVEX_Vcvtsi2sh_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtsi2sh(xmm2, xmm3, __zmmword_ptr[edx]), Instruction.Create(Code.EVEX_Vcvtsi2sh_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -25140,7 +25140,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
} /* else */ TestAssembler(c => c.vcvtsi2ss(xmm2, xmm3, __dword_ptr[edx]), Instruction.Create(Code.EVEX_Vcvtsi2ss_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[edx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferEvex);
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
{ /* if (PreferVex) */
|
||||
TestAssembler(c => c.vcvtsi2ss(xmm2, xmm3, __zmmword_ptr[edx]), Instruction.Create(Code.VEX_Vcvtsi2ss_xmm_xmm_rm32, xmm2, xmm3, __zmmword_ptr[edx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferVex);
|
||||
} /* else */ TestAssembler(c => c.vcvtsi2ss(xmm2, xmm3, __zmmword_ptr[edx]), Instruction.Create(Code.EVEX_Vcvtsi2ss_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[edx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferEvex);
|
||||
|
|
@ -25253,7 +25253,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
} /* else */ TestAssembler(c => c.vcvttpd2dq(xmm2.k1, __xmmword_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvttpd2dq_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
{ /* if (PreferVex) */
|
||||
TestAssembler(c => c.vcvttpd2dq(xmm2, __byte_ptr[edx]), Instruction.Create(Code.VEX_Vcvttpd2dq_xmm_xmmm128, xmm2, __byte_ptr[edx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferVex);
|
||||
} /* else */ TestAssembler(c => c.vcvttpd2dq(xmm2.k1, __byte_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvttpd2dq_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
|
|
@ -25357,7 +25357,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvttpd2udq(xmm2.k1, __xmmword_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvttpd2udq_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvttpd2udq(xmm2.k1, __byte_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvttpd2udq_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -26025,7 +26025,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtudq2ph(xmm2.k1, __xmmword_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtudq2ph_xmm_k1z_xmmm128b32, xmm2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtudq2ph(xmm2.k1, __byte_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtudq2ph_xmm_k1z_xmmm128b32, xmm2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -26171,7 +26171,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtuqq2ph(xmm2.k1, __xmmword_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtuqq2ph_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtuqq2ph(xmm2.k1, __byte_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtuqq2ph_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -26231,7 +26231,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtuqq2ps(xmm2.k1, __xmmword_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtuqq2ps_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtuqq2ps(xmm2.k1, __byte_ptr[edx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtuqq2ps_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -26277,7 +26277,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtusi2sd(xmm2, xmm3, __dword_ptr[edx]), Instruction.Create(Code.EVEX_Vcvtusi2sd_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtusi2sd(xmm2, xmm3, __zmmword_ptr[edx]), Instruction.Create(Code.EVEX_Vcvtusi2sd_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -26302,7 +26302,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtusi2sh(xmm2, xmm3, __dword_ptr[edx]), Instruction.Create(Code.EVEX_Vcvtusi2sh_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtusi2sh(xmm2, xmm3, __zmmword_ptr[edx]), Instruction.Create(Code.EVEX_Vcvtusi2sh_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -26327,7 +26327,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtusi2ss(xmm2, xmm3, __dword_ptr[edx]), Instruction.Create(Code.EVEX_Vcvtusi2ss_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtusi2ss(xmm2, xmm3, __zmmword_ptr[edx]), Instruction.Create(Code.EVEX_Vcvtusi2ss_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[edx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -31856,7 +31856,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vfpclasspd(k2.k1, __xmmword_ptr[edx], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclasspd_kr_k1_xmmm128b64_imm8, k2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness), -5)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vfpclasspd(k2.k1, __byte_ptr[edx], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclasspd_kr_k1_xmmm128b64_imm8, k2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness), -5)));
|
||||
});
|
||||
}
|
||||
|
|
@ -31978,7 +31978,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vfpclassph(k2.k1, __xmmword_ptr[edx], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclassph_kr_k1_xmmm128b16_imm8, k2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness), -5)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vfpclassph(k2.k1, __byte_ptr[edx], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclassph_kr_k1_xmmm128b16_imm8, k2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness), -5)));
|
||||
});
|
||||
}
|
||||
|
|
@ -32100,7 +32100,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vfpclassps(k2.k1, __xmmword_ptr[edx], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclassps_kr_k1_xmmm128b32_imm8, k2.k1, __xmmword_ptr[edx].ToMemoryOperand(Bitness), -5)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vfpclassps(k2.k1, __byte_ptr[edx], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclassps_kr_k1_xmmm128b32_imm8, k2.k1, __byte_ptr[edx].ToMemoryOperand(Bitness), -5)));
|
||||
});
|
||||
}
|
||||
|
|
@ -32526,7 +32526,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vgatherqps(xmm2.k1, __[edx + ymm3]), ApplyK1(Instruction.Create(Code.EVEX_Vgatherqps_xmm_k1_vm64y, xmm2.k1, __[edx + ymm3].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vgatherqps(xmm2.k1, __[edx + zmm1]), ApplyK1(Instruction.Create(Code.EVEX_Vgatherqps_xmm_k1_vm64y, xmm2.k1, __[edx + zmm1].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -32549,7 +32549,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vgatherqps(xmm2, __[edx + ymm3], xmm4), Instruction.Create(Code.VEX_Vgatherqps_xmm_vm64y_xmm, xmm2, __[edx + ymm3].ToMemoryOperand(Bitness), xmm4));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vgatherqps(xmm2, __[edx + zmm1], xmm4), Instruction.Create(Code.VEX_Vgatherqps_xmm_vm64y_xmm, xmm2, __[edx + zmm1].ToMemoryOperand(Bitness), xmm4));
|
||||
});
|
||||
}
|
||||
|
|
@ -45569,7 +45569,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vpgatherqd(xmm2.k1, __[edx + ymm3]), ApplyK1(Instruction.Create(Code.EVEX_Vpgatherqd_xmm_k1_vm64y, xmm2.k1, __[edx + ymm3].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vpgatherqd(xmm2.k1, __[edx + zmm1]), ApplyK1(Instruction.Create(Code.EVEX_Vpgatherqd_xmm_k1_vm64y, xmm2.k1, __[edx + zmm1].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -45592,7 +45592,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vpgatherqd(xmm2, __[edx + ymm3], xmm4), Instruction.Create(Code.VEX_Vpgatherqd_xmm_vm64y_xmm, xmm2, __[edx + ymm3].ToMemoryOperand(Bitness), xmm4));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vpgatherqd(xmm2, __[edx + zmm1], xmm4), Instruction.Create(Code.VEX_Vpgatherqd_xmm_vm64y_xmm, xmm2, __[edx + zmm1].ToMemoryOperand(Bitness), xmm4));
|
||||
});
|
||||
}
|
||||
|
|
@ -50496,7 +50496,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vpscatterqd(__[edx + ymm2].k1, xmm3), ApplyK1(Instruction.Create(Code.EVEX_Vpscatterqd_vm64y_k1_xmm, __[edx + ymm2].k1.ToMemoryOperand(Bitness), xmm3)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vpscatterqd(__[edx + zmm0].k1, xmm3), ApplyK1(Instruction.Create(Code.EVEX_Vpscatterqd_vm64y_k1_xmm, __[edx + zmm0].k1.ToMemoryOperand(Bitness), xmm3)));
|
||||
});
|
||||
}
|
||||
|
|
@ -57183,7 +57183,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vscatterqps(__[edx + ymm2].k1, xmm3), ApplyK1(Instruction.Create(Code.EVEX_Vscatterqps_vm64y_k1_xmm, __[edx + ymm2].k1.ToMemoryOperand(Bitness), xmm3)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vscatterqps(__[edx + zmm0].k1, xmm3), ApplyK1(Instruction.Create(Code.EVEX_Vscatterqps_vm64y_k1_xmm, __[edx + zmm0].k1.ToMemoryOperand(Bitness), xmm3)));
|
||||
});
|
||||
}
|
||||
|
|
@ -58781,7 +58781,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.xor(__byte_ptr[edx], -5), Instruction.Create(Code.Xor_rm8_imm8, __byte_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.xor(__zmmword_ptr[edx], -5), Instruction.Create(Code.Xor_rm8_imm8, __zmmword_ptr[edx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
|
|||
|
|
@ -131,7 +131,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.adc(__byte_ptr[rdx], -5), Instruction.Create(Code.Adc_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.adc(__zmmword_ptr[rdx], -5), Instruction.Create(Code.Adc_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -322,7 +322,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.add(__byte_ptr[rdx], -5), Instruction.Create(Code.Add_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.add(__zmmword_ptr[rdx], -5), Instruction.Create(Code.Add_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -683,7 +683,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.and(__byte_ptr[rdx], -5), Instruction.Create(Code.And_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.and(__zmmword_ptr[rdx], -5), Instruction.Create(Code.And_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -1243,7 +1243,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
}
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bndcl(bnd2, __zmmword_ptr[rdx]), Instruction.Create(Code.Bndcl_bnd_rm32, bnd2, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -1264,7 +1264,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
}
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bndcn(bnd2, __zmmword_ptr[rdx]), Instruction.Create(Code.Bndcn_bnd_rm32, bnd2, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -1285,7 +1285,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
}
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bndcu(bnd2, __zmmword_ptr[rdx]), Instruction.Create(Code.Bndcu_bnd_rm32, bnd2, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -1306,7 +1306,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
}
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bndmk(bnd2, __zmmword_ptr[rdx]), Instruction.Create(Code.Bndmk_bnd_m32, bnd2, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -1468,7 +1468,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.bt(__word_ptr[rdx], -5), Instruction.Create(Code.Bt_rm16_imm8, __word_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bt(__zmmword_ptr[rdx], -5), Instruction.Create(Code.Bt_rm16_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -1558,7 +1558,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.btc(__word_ptr[rdx], -5), Instruction.Create(Code.Btc_rm16_imm8, __word_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.btc(__zmmword_ptr[rdx], -5), Instruction.Create(Code.Btc_rm16_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -1648,7 +1648,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.btr(__word_ptr[rdx], -5), Instruction.Create(Code.Btr_rm16_imm8, __word_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.btr(__zmmword_ptr[rdx], -5), Instruction.Create(Code.Btr_rm16_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -1738,7 +1738,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.bts(__word_ptr[rdx], -5), Instruction.Create(Code.Bts_rm16_imm8, __word_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.bts(__zmmword_ptr[rdx], -5), Instruction.Create(Code.Bts_rm16_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -1829,7 +1829,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.call(__word_ptr[rdx]), Instruction.Create(Code.Call_rm16, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.call(__zmmword_ptr[rdx]), Instruction.Create(Code.Call_rm16, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -2548,7 +2548,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.cmp(__byte_ptr[rdx], -5), Instruction.Create(Code.Cmp_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.cmp(__zmmword_ptr[rdx], -5), Instruction.Create(Code.Cmp_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -3136,7 +3136,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.crc32(edx, __byte_ptr[rdx]), Instruction.Create(Code.Crc32_r32_rm8, edx, __byte_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.crc32(edx, __zmmword_ptr[rdx]), Instruction.Create(Code.Crc32_r32_rm8, edx, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3150,7 +3150,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.crc32(rdx, __byte_ptr[rdx]), Instruction.Create(Code.Crc32_r64_rm8, rdx, __byte_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.crc32(rdx, __zmmword_ptr[rdx]), Instruction.Create(Code.Crc32_r64_rm8, rdx, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3304,7 +3304,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.cvtsi2sd(xmm2, __dword_ptr[rdx]), Instruction.Create(Code.Cvtsi2sd_xmm_rm32, xmm2, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.cvtsi2sd(xmm2, __zmmword_ptr[rdx]), Instruction.Create(Code.Cvtsi2sd_xmm_rm32, xmm2, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3328,7 +3328,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.cvtsi2ss(xmm2, __dword_ptr[rdx]), Instruction.Create(Code.Cvtsi2ss_xmm_rm32, xmm2, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.cvtsi2ss(xmm2, __zmmword_ptr[rdx]), Instruction.Create(Code.Cvtsi2ss_xmm_rm32, xmm2, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3490,7 +3490,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.dec(__byte_ptr[rdx]), Instruction.Create(Code.Dec_rm8, __byte_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.dec(__zmmword_ptr[rdx]), Instruction.Create(Code.Dec_rm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3528,7 +3528,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.div(__byte_ptr[rdx]), Instruction.Create(Code.Div_rm8, __byte_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.div(__zmmword_ptr[rdx]), Instruction.Create(Code.Div_rm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3761,7 +3761,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fadd(__dword_ptr[rdx]), Instruction.Create(Code.Fadd_m32fp, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fadd(__zmmword_ptr[rdx]), Instruction.Create(Code.Fadd_m32fp, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3847,7 +3847,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fcom(__dword_ptr[rdx]), Instruction.Create(Code.Fcom_m32fp, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fcom(__zmmword_ptr[rdx]), Instruction.Create(Code.Fcom_m32fp, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3876,7 +3876,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fcomp(__dword_ptr[rdx]), Instruction.Create(Code.Fcomp_m32fp, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fcomp(__zmmword_ptr[rdx]), Instruction.Create(Code.Fcomp_m32fp, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3915,7 +3915,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fdiv(__dword_ptr[rdx]), Instruction.Create(Code.Fdiv_m32fp, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fdiv(__zmmword_ptr[rdx]), Instruction.Create(Code.Fdiv_m32fp, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3941,7 +3941,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fdivr(__dword_ptr[rdx]), Instruction.Create(Code.Fdivr_m32fp, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fdivr(__zmmword_ptr[rdx]), Instruction.Create(Code.Fdivr_m32fp, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -3987,7 +3987,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fiadd(__word_ptr[rdx]), Instruction.Create(Code.Fiadd_m16int, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fiadd(__zmmword_ptr[rdx]), Instruction.Create(Code.Fiadd_m16int, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4001,7 +4001,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ficom(__word_ptr[rdx]), Instruction.Create(Code.Ficom_m16int, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ficom(__zmmword_ptr[rdx]), Instruction.Create(Code.Ficom_m16int, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4015,7 +4015,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ficomp(__word_ptr[rdx]), Instruction.Create(Code.Ficomp_m16int, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ficomp(__zmmword_ptr[rdx]), Instruction.Create(Code.Ficomp_m16int, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4029,7 +4029,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fidiv(__word_ptr[rdx]), Instruction.Create(Code.Fidiv_m16int, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fidiv(__zmmword_ptr[rdx]), Instruction.Create(Code.Fidiv_m16int, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4043,7 +4043,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fidivr(__word_ptr[rdx]), Instruction.Create(Code.Fidivr_m16int, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fidivr(__zmmword_ptr[rdx]), Instruction.Create(Code.Fidivr_m16int, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4059,7 +4059,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fild(__word_ptr[rdx]), Instruction.Create(Code.Fild_m16int, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fild(__zmmword_ptr[rdx]), Instruction.Create(Code.Fild_m16int, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4073,7 +4073,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fimul(__word_ptr[rdx]), Instruction.Create(Code.Fimul_m16int, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fimul(__zmmword_ptr[rdx]), Instruction.Create(Code.Fimul_m16int, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4097,7 +4097,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fist(__word_ptr[rdx]), Instruction.Create(Code.Fist_m16int, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fist(__zmmword_ptr[rdx]), Instruction.Create(Code.Fist_m16int, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4113,7 +4113,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fistp(__word_ptr[rdx]), Instruction.Create(Code.Fistp_m16int, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fistp(__zmmword_ptr[rdx]), Instruction.Create(Code.Fistp_m16int, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4129,7 +4129,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fisttp(__word_ptr[rdx]), Instruction.Create(Code.Fisttp_m16int, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fisttp(__zmmword_ptr[rdx]), Instruction.Create(Code.Fisttp_m16int, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4143,7 +4143,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fisub(__word_ptr[rdx]), Instruction.Create(Code.Fisub_m16int, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fisub(__zmmword_ptr[rdx]), Instruction.Create(Code.Fisub_m16int, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4157,7 +4157,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fisubr(__word_ptr[rdx]), Instruction.Create(Code.Fisubr_m16int, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fisubr(__zmmword_ptr[rdx]), Instruction.Create(Code.Fisubr_m16int, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4178,7 +4178,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fld(__dword_ptr[rdx]), Instruction.Create(Code.Fld_m32fp, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fld(__zmmword_ptr[rdx]), Instruction.Create(Code.Fld_m32fp, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4239,7 +4239,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fmul(__dword_ptr[rdx]), Instruction.Create(Code.Fmul_m32fp, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fmul(__zmmword_ptr[rdx]), Instruction.Create(Code.Fmul_m32fp, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4393,7 +4393,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fst(__dword_ptr[rdx]), Instruction.Create(Code.Fst_m32fp, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fst(__zmmword_ptr[rdx]), Instruction.Create(Code.Fst_m32fp, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4426,7 +4426,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fstp(__dword_ptr[rdx]), Instruction.Create(Code.Fstp_m32fp, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fstp(__zmmword_ptr[rdx]), Instruction.Create(Code.Fstp_m32fp, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4455,7 +4455,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fsub(__dword_ptr[rdx]), Instruction.Create(Code.Fsub_m32fp, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fsub(__zmmword_ptr[rdx]), Instruction.Create(Code.Fsub_m32fp, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4481,7 +4481,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.fsubr(__dword_ptr[rdx]), Instruction.Create(Code.Fsubr_m32fp, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.fsubr(__zmmword_ptr[rdx]), Instruction.Create(Code.Fsubr_m32fp, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4721,7 +4721,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.idiv(__byte_ptr[rdx]), Instruction.Create(Code.Idiv_rm8, __byte_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.idiv(__zmmword_ptr[rdx]), Instruction.Create(Code.Idiv_rm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4759,7 +4759,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.imul(__byte_ptr[rdx]), Instruction.Create(Code.Imul_rm8, __byte_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.imul(__zmmword_ptr[rdx]), Instruction.Create(Code.Imul_rm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -4956,7 +4956,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.inc(__byte_ptr[rdx]), Instruction.Create(Code.Inc_rm8, __byte_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.inc(__zmmword_ptr[rdx]), Instruction.Create(Code.Inc_rm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -5322,7 +5322,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.jmp(__word_ptr[rdx]), Instruction.Create(Code.Jmp_rm16, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.jmp(__zmmword_ptr[rdx]), Instruction.Create(Code.Jmp_rm16, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -6809,7 +6809,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.mov(__byte_ptr[rdx], -5), Instruction.Create(Code.Mov_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.mov(__zmmword_ptr[rdx], -5), Instruction.Create(Code.Mov_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -7292,7 +7292,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.movsx(dx, __byte_ptr[rdx]), Instruction.Create(Code.Movsx_r16_rm8, dx, __byte_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.movsx(dx, __zmmword_ptr[rdx]), Instruction.Create(Code.Movsx_r16_rm8, dx, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -7306,7 +7306,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.movsx(edx, __byte_ptr[rdx]), Instruction.Create(Code.Movsx_r32_rm8, edx, __byte_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.movsx(edx, __zmmword_ptr[rdx]), Instruction.Create(Code.Movsx_r32_rm8, edx, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -7320,7 +7320,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.movsx(rdx, __byte_ptr[rdx]), Instruction.Create(Code.Movsx_r64_rm8, rdx, __byte_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.movsx(rdx, __zmmword_ptr[rdx]), Instruction.Create(Code.Movsx_r64_rm8, rdx, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -7424,7 +7424,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.movzx(dx, __byte_ptr[rdx]), Instruction.Create(Code.Movzx_r16_rm8, dx, __byte_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.movzx(dx, __zmmword_ptr[rdx]), Instruction.Create(Code.Movzx_r16_rm8, dx, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -7438,7 +7438,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.movzx(edx, __byte_ptr[rdx]), Instruction.Create(Code.Movzx_r32_rm8, edx, __byte_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.movzx(edx, __zmmword_ptr[rdx]), Instruction.Create(Code.Movzx_r32_rm8, edx, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -7452,7 +7452,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.movzx(rdx, __byte_ptr[rdx]), Instruction.Create(Code.Movzx_r64_rm8, rdx, __byte_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.movzx(rdx, __zmmword_ptr[rdx]), Instruction.Create(Code.Movzx_r64_rm8, rdx, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -7510,7 +7510,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.mul(__byte_ptr[rdx]), Instruction.Create(Code.Mul_rm8, __byte_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.mul(__zmmword_ptr[rdx]), Instruction.Create(Code.Mul_rm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -7626,7 +7626,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.neg(__byte_ptr[rdx]), Instruction.Create(Code.Neg_rm8, __byte_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.neg(__zmmword_ptr[rdx]), Instruction.Create(Code.Neg_rm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -7664,7 +7664,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.nop(__word_ptr[rdx]), Instruction.Create(Code.Nop_rm16, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.nop(__zmmword_ptr[rdx]), Instruction.Create(Code.Nop_rm16, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -7702,7 +7702,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.not(__byte_ptr[rdx]), Instruction.Create(Code.Not_rm8, __byte_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.not(__zmmword_ptr[rdx]), Instruction.Create(Code.Not_rm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -7826,7 +7826,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.or(__byte_ptr[rdx], -5), Instruction.Create(Code.Or_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.or(__zmmword_ptr[rdx], -5), Instruction.Create(Code.Or_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -10008,7 +10008,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.pop(__word_ptr[rdx]), Instruction.Create(Code.Pop_rm16, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.pop(__zmmword_ptr[rdx]), Instruction.Create(Code.Pop_rm16, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -10836,7 +10836,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ptwrite(__dword_ptr[rdx]), Instruction.Create(Code.Ptwrite_rm32, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ptwrite(__zmmword_ptr[rdx]), Instruction.Create(Code.Ptwrite_rm32, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -11044,7 +11044,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.push(__word_ptr[rdx]), Instruction.Create(Code.Push_rm16, __word_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.push(__zmmword_ptr[rdx]), Instruction.Create(Code.Push_rm16, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -11145,7 +11145,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcl(__byte_ptr[rdx], cl), Instruction.Create(Code.Rcl_rm8_CL, __byte_ptr[rdx].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcl(__zmmword_ptr[rdx], cl), Instruction.Create(Code.Rcl_rm8_CL, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -11192,7 +11192,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcl(__byte_ptr[rdx], 1), Instruction.Create(Code.Rcl_rm8_1, __byte_ptr[rdx].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcl(__zmmword_ptr[rdx], 1), Instruction.Create(Code.Rcl_rm8_1, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -11206,7 +11206,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcl(__byte_ptr[rdx], 2), Instruction.Create(Code.Rcl_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcl(__zmmword_ptr[rdx], 2), Instruction.Create(Code.Rcl_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -11321,7 +11321,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcr(__byte_ptr[rdx], cl), Instruction.Create(Code.Rcr_rm8_CL, __byte_ptr[rdx].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcr(__zmmword_ptr[rdx], cl), Instruction.Create(Code.Rcr_rm8_CL, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -11368,7 +11368,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcr(__byte_ptr[rdx], 1), Instruction.Create(Code.Rcr_rm8_1, __byte_ptr[rdx].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcr(__zmmword_ptr[rdx], 1), Instruction.Create(Code.Rcr_rm8_1, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -11382,7 +11382,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rcr(__byte_ptr[rdx], 2), Instruction.Create(Code.Rcr_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rcr(__zmmword_ptr[rdx], 2), Instruction.Create(Code.Rcr_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -11899,7 +11899,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rol(__byte_ptr[rdx], cl), Instruction.Create(Code.Rol_rm8_CL, __byte_ptr[rdx].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rol(__zmmword_ptr[rdx], cl), Instruction.Create(Code.Rol_rm8_CL, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -11946,7 +11946,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rol(__byte_ptr[rdx], 1), Instruction.Create(Code.Rol_rm8_1, __byte_ptr[rdx].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rol(__zmmword_ptr[rdx], 1), Instruction.Create(Code.Rol_rm8_1, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -11960,7 +11960,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.rol(__byte_ptr[rdx], 2), Instruction.Create(Code.Rol_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.rol(__zmmword_ptr[rdx], 2), Instruction.Create(Code.Rol_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -12055,7 +12055,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ror(__byte_ptr[rdx], cl), Instruction.Create(Code.Ror_rm8_CL, __byte_ptr[rdx].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ror(__zmmword_ptr[rdx], cl), Instruction.Create(Code.Ror_rm8_CL, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -12102,7 +12102,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ror(__byte_ptr[rdx], 1), Instruction.Create(Code.Ror_rm8_1, __byte_ptr[rdx].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ror(__zmmword_ptr[rdx], 1), Instruction.Create(Code.Ror_rm8_1, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -12116,7 +12116,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.ror(__byte_ptr[rdx], 2), Instruction.Create(Code.Ror_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.ror(__zmmword_ptr[rdx], 2), Instruction.Create(Code.Ror_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -12382,7 +12382,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sal(__byte_ptr[rdx], cl), Instruction.Create(Code.Sal_rm8_CL, __byte_ptr[rdx].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sal(__zmmword_ptr[rdx], cl), Instruction.Create(Code.Sal_rm8_CL, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -12429,7 +12429,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sal(__byte_ptr[rdx], 1), Instruction.Create(Code.Sal_rm8_1, __byte_ptr[rdx].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sal(__zmmword_ptr[rdx], 1), Instruction.Create(Code.Sal_rm8_1, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -12443,7 +12443,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sal(__byte_ptr[rdx], 2), Instruction.Create(Code.Sal_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sal(__zmmword_ptr[rdx], 2), Instruction.Create(Code.Sal_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -12538,7 +12538,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sar(__byte_ptr[rdx], cl), Instruction.Create(Code.Sar_rm8_CL, __byte_ptr[rdx].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sar(__zmmword_ptr[rdx], cl), Instruction.Create(Code.Sar_rm8_CL, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -12585,7 +12585,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sar(__byte_ptr[rdx], 1), Instruction.Create(Code.Sar_rm8_1, __byte_ptr[rdx].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sar(__zmmword_ptr[rdx], 1), Instruction.Create(Code.Sar_rm8_1, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -12599,7 +12599,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sar(__byte_ptr[rdx], 2), Instruction.Create(Code.Sar_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sar(__zmmword_ptr[rdx], 2), Instruction.Create(Code.Sar_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -12813,7 +12813,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sbb(__byte_ptr[rdx], -5), Instruction.Create(Code.Sbb_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sbb(__zmmword_ptr[rdx], -5), Instruction.Create(Code.Sbb_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -13200,7 +13200,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shl(__byte_ptr[rdx], cl), Instruction.Create(Code.Shl_rm8_CL, __byte_ptr[rdx].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shl(__zmmword_ptr[rdx], cl), Instruction.Create(Code.Shl_rm8_CL, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -13247,7 +13247,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shl(__byte_ptr[rdx], 1), Instruction.Create(Code.Shl_rm8_1, __byte_ptr[rdx].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shl(__zmmword_ptr[rdx], 1), Instruction.Create(Code.Shl_rm8_1, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -13261,7 +13261,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shl(__byte_ptr[rdx], 2), Instruction.Create(Code.Shl_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shl(__zmmword_ptr[rdx], 2), Instruction.Create(Code.Shl_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -13474,7 +13474,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shr(__byte_ptr[rdx], cl), Instruction.Create(Code.Shr_rm8_CL, __byte_ptr[rdx].ToMemoryOperand(Bitness), cl));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shr(__zmmword_ptr[rdx], cl), Instruction.Create(Code.Shr_rm8_CL, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), cl));
|
||||
});
|
||||
}
|
||||
|
|
@ -13521,7 +13521,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shr(__byte_ptr[rdx], 1), Instruction.Create(Code.Shr_rm8_1, __byte_ptr[rdx].ToMemoryOperand(Bitness), 1));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shr(__zmmword_ptr[rdx], 1), Instruction.Create(Code.Shr_rm8_1, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), 1));
|
||||
});
|
||||
}
|
||||
|
|
@ -13535,7 +13535,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.shr(__byte_ptr[rdx], 2), Instruction.Create(Code.Shr_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), 2));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.shr(__zmmword_ptr[rdx], 2), Instruction.Create(Code.Shr_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), 2));
|
||||
});
|
||||
}
|
||||
|
|
@ -14068,7 +14068,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.sub(__byte_ptr[rdx], -5), Instruction.Create(Code.Sub_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.sub(__zmmword_ptr[rdx], -5), Instruction.Create(Code.Sub_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -14344,7 +14344,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.test(__byte_ptr[rdx], -5), Instruction.Create(Code.Test_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.test(__zmmword_ptr[rdx], -5), Instruction.Create(Code.Test_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
@ -24853,7 +24853,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtdq2ph(xmm2.k1, __xmmword_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtdq2ph_xmm_k1z_xmmm128b32, xmm2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtdq2ph(xmm2.k1, __byte_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtdq2ph_xmm_k1z_xmmm128b32, xmm2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -25009,7 +25009,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtneps2bf16(xmm2.k1, __xmmword_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtneps2bf16_xmm_k1z_xmmm128b32, xmm2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtneps2bf16(xmm2.k1, __byte_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtneps2bf16_xmm_k1z_xmmm128b32, xmm2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -25077,7 +25077,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
} /* else */ TestAssembler(c => c.vcvtpd2dq(xmm2.k1, __xmmword_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2dq_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
{ /* if (PreferVex) */
|
||||
TestAssembler(c => c.vcvtpd2dq(xmm2, __byte_ptr[rdx]), Instruction.Create(Code.VEX_Vcvtpd2dq_xmm_xmmm128, xmm2, __byte_ptr[rdx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferVex);
|
||||
} /* else */ TestAssembler(c => c.vcvtpd2dq(xmm2.k1, __byte_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2dq_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
|
|
@ -25141,7 +25141,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtpd2ph(xmm2.k1, __xmmword_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2ph_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtpd2ph(xmm2.k1, __byte_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2ph_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -25209,7 +25209,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
} /* else */ TestAssembler(c => c.vcvtpd2ps(xmm2.k1, __xmmword_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2ps_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
{ /* if (PreferVex) */
|
||||
TestAssembler(c => c.vcvtpd2ps(xmm2, __byte_ptr[rdx]), Instruction.Create(Code.VEX_Vcvtpd2ps_xmm_xmmm128, xmm2, __byte_ptr[rdx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferVex);
|
||||
} /* else */ TestAssembler(c => c.vcvtpd2ps(xmm2.k1, __byte_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2ps_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
|
|
@ -25313,7 +25313,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtpd2udq(xmm2.k1, __xmmword_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2udq_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtpd2udq(xmm2.k1, __byte_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtpd2udq_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -26009,7 +26009,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtps2phx(xmm2.k1, __xmmword_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtps2phx_xmm_k1z_xmmm128b32, xmm2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtps2phx(xmm2.k1, __byte_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtps2phx_xmm_k1z_xmmm128b32, xmm2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -26239,7 +26239,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtqq2ph(xmm2.k1, __xmmword_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtqq2ph_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtqq2ph(xmm2.k1, __byte_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtqq2ph_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -26299,7 +26299,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtqq2ps(xmm2.k1, __xmmword_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtqq2ps_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtqq2ps(xmm2.k1, __byte_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtqq2ps_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -26538,7 +26538,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
} /* else */ TestAssembler(c => c.vcvtsi2sd(xmm2, xmm3, __dword_ptr[rdx]), Instruction.Create(Code.EVEX_Vcvtsi2sd_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[rdx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferEvex);
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
{ /* if (PreferVex) */
|
||||
TestAssembler(c => c.vcvtsi2sd(xmm2, xmm3, __zmmword_ptr[rdx]), Instruction.Create(Code.VEX_Vcvtsi2sd_xmm_xmm_rm32, xmm2, xmm3, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferVex);
|
||||
} /* else */ TestAssembler(c => c.vcvtsi2sd(xmm2, xmm3, __zmmword_ptr[rdx]), Instruction.Create(Code.EVEX_Vcvtsi2sd_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferEvex);
|
||||
|
|
@ -26570,7 +26570,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtsi2sh(xmm2, xmm3, __dword_ptr[rdx]), Instruction.Create(Code.EVEX_Vcvtsi2sh_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtsi2sh(xmm2, xmm3, __zmmword_ptr[rdx]), Instruction.Create(Code.EVEX_Vcvtsi2sh_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -26608,7 +26608,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
} /* else */ TestAssembler(c => c.vcvtsi2ss(xmm2, xmm3, __dword_ptr[rdx]), Instruction.Create(Code.EVEX_Vcvtsi2ss_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[rdx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferEvex);
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
{ /* if (PreferVex) */
|
||||
TestAssembler(c => c.vcvtsi2ss(xmm2, xmm3, __zmmword_ptr[rdx]), Instruction.Create(Code.VEX_Vcvtsi2ss_xmm_xmm_rm32, xmm2, xmm3, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferVex);
|
||||
} /* else */ TestAssembler(c => c.vcvtsi2ss(xmm2, xmm3, __zmmword_ptr[rdx]), Instruction.Create(Code.EVEX_Vcvtsi2ss_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferEvex);
|
||||
|
|
@ -26753,7 +26753,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
} /* else */ TestAssembler(c => c.vcvttpd2dq(xmm2.k1, __xmmword_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvttpd2dq_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
{ /* if (PreferVex) */
|
||||
TestAssembler(c => c.vcvttpd2dq(xmm2, __byte_ptr[rdx]), Instruction.Create(Code.VEX_Vcvttpd2dq_xmm_xmmm128, xmm2, __byte_ptr[rdx].ToMemoryOperand(Bitness)), LocalOpCodeFlags.PreferVex);
|
||||
} /* else */ TestAssembler(c => c.vcvttpd2dq(xmm2.k1, __byte_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvttpd2dq_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness))), LocalOpCodeFlags.PreferEvex);
|
||||
|
|
@ -26857,7 +26857,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvttpd2udq(xmm2.k1, __xmmword_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvttpd2udq_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvttpd2udq(xmm2.k1, __byte_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvttpd2udq_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -27617,7 +27617,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtudq2ph(xmm2.k1, __xmmword_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtudq2ph_xmm_k1z_xmmm128b32, xmm2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtudq2ph(xmm2.k1, __byte_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtudq2ph_xmm_k1z_xmmm128b32, xmm2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -27763,7 +27763,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtuqq2ph(xmm2.k1, __xmmword_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtuqq2ph_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtuqq2ph(xmm2.k1, __byte_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtuqq2ph_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -27823,7 +27823,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtuqq2ps(xmm2.k1, __xmmword_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtuqq2ps_xmm_k1z_xmmm128b64, xmm2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtuqq2ps(xmm2.k1, __byte_ptr[rdx]), ApplyK1(Instruction.Create(Code.EVEX_Vcvtuqq2ps_xmm_k1z_xmmm128b64, xmm2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -27874,7 +27874,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtusi2sd(xmm2, xmm3, __dword_ptr[rdx]), Instruction.Create(Code.EVEX_Vcvtusi2sd_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtusi2sd(xmm2, xmm3, __zmmword_ptr[rdx]), Instruction.Create(Code.EVEX_Vcvtusi2sd_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -27904,7 +27904,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtusi2sh(xmm2, xmm3, __dword_ptr[rdx]), Instruction.Create(Code.EVEX_Vcvtusi2sh_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtusi2sh(xmm2, xmm3, __zmmword_ptr[rdx]), Instruction.Create(Code.EVEX_Vcvtusi2sh_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -27934,7 +27934,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vcvtusi2ss(xmm2, xmm3, __dword_ptr[rdx]), Instruction.Create(Code.EVEX_Vcvtusi2ss_xmm_xmm_rm32_er, xmm2, xmm3, __dword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vcvtusi2ss(xmm2, xmm3, __zmmword_ptr[rdx]), Instruction.Create(Code.EVEX_Vcvtusi2ss_xmm_xmm_rm32_er, xmm2, xmm3, __zmmword_ptr[rdx].ToMemoryOperand(Bitness)));
|
||||
});
|
||||
}
|
||||
|
|
@ -33491,7 +33491,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vfpclasspd(k2.k1, __xmmword_ptr[rdx], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclasspd_kr_k1_xmmm128b64_imm8, k2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness), -5)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vfpclasspd(k2.k1, __byte_ptr[rdx], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclasspd_kr_k1_xmmm128b64_imm8, k2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness), -5)));
|
||||
});
|
||||
}
|
||||
|
|
@ -33613,7 +33613,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vfpclassph(k2.k1, __xmmword_ptr[rdx], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclassph_kr_k1_xmmm128b16_imm8, k2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness), -5)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vfpclassph(k2.k1, __byte_ptr[rdx], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclassph_kr_k1_xmmm128b16_imm8, k2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness), -5)));
|
||||
});
|
||||
}
|
||||
|
|
@ -33735,7 +33735,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vfpclassps(k2.k1, __xmmword_ptr[rdx], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclassps_kr_k1_xmmm128b32_imm8, k2.k1, __xmmword_ptr[rdx].ToMemoryOperand(Bitness), -5)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vfpclassps(k2.k1, __byte_ptr[rdx], -5), ApplyK1(Instruction.Create(Code.EVEX_Vfpclassps_kr_k1_xmmm128b32_imm8, k2.k1, __byte_ptr[rdx].ToMemoryOperand(Bitness), -5)));
|
||||
});
|
||||
}
|
||||
|
|
@ -34161,7 +34161,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vgatherqps(xmm2.k1, __[rdx + ymm3]), ApplyK1(Instruction.Create(Code.EVEX_Vgatherqps_xmm_k1_vm64y, xmm2.k1, __[rdx + ymm3].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vgatherqps(xmm2.k1, __[rdx + zmm1]), ApplyK1(Instruction.Create(Code.EVEX_Vgatherqps_xmm_k1_vm64y, xmm2.k1, __[rdx + zmm1].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -34184,7 +34184,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vgatherqps(xmm2, __[rdx + ymm3], xmm4), Instruction.Create(Code.VEX_Vgatherqps_xmm_vm64y_xmm, xmm2, __[rdx + ymm3].ToMemoryOperand(Bitness), xmm4));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vgatherqps(xmm2, __[rdx + zmm1], xmm4), Instruction.Create(Code.VEX_Vgatherqps_xmm_vm64y_xmm, xmm2, __[rdx + zmm1].ToMemoryOperand(Bitness), xmm4));
|
||||
});
|
||||
}
|
||||
|
|
@ -47410,7 +47410,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vpgatherqd(xmm2.k1, __[rdx + ymm3]), ApplyK1(Instruction.Create(Code.EVEX_Vpgatherqd_xmm_k1_vm64y, xmm2.k1, __[rdx + ymm3].ToMemoryOperand(Bitness))));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vpgatherqd(xmm2.k1, __[rdx + zmm1]), ApplyK1(Instruction.Create(Code.EVEX_Vpgatherqd_xmm_k1_vm64y, xmm2.k1, __[rdx + zmm1].ToMemoryOperand(Bitness))));
|
||||
});
|
||||
}
|
||||
|
|
@ -47433,7 +47433,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vpgatherqd(xmm2, __[rdx + ymm3], xmm4), Instruction.Create(Code.VEX_Vpgatherqd_xmm_vm64y_xmm, xmm2, __[rdx + ymm3].ToMemoryOperand(Bitness), xmm4));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vpgatherqd(xmm2, __[rdx + zmm1], xmm4), Instruction.Create(Code.VEX_Vpgatherqd_xmm_vm64y_xmm, xmm2, __[rdx + zmm1].ToMemoryOperand(Bitness), xmm4));
|
||||
});
|
||||
}
|
||||
|
|
@ -52423,7 +52423,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vpscatterqd(__[rdx + ymm2].k1, xmm3), ApplyK1(Instruction.Create(Code.EVEX_Vpscatterqd_vm64y_k1_xmm, __[rdx + ymm2].k1.ToMemoryOperand(Bitness), xmm3)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vpscatterqd(__[rdx + zmm0].k1, xmm3), ApplyK1(Instruction.Create(Code.EVEX_Vpscatterqd_vm64y_k1_xmm, __[rdx + zmm0].k1.ToMemoryOperand(Bitness), xmm3)));
|
||||
});
|
||||
}
|
||||
|
|
@ -59110,7 +59110,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.vscatterqps(__[rdx + ymm2].k1, xmm3), ApplyK1(Instruction.Create(Code.EVEX_Vscatterqps_vm64y_k1_xmm, __[rdx + ymm2].k1.ToMemoryOperand(Bitness), xmm3)));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.vscatterqps(__[rdx + zmm0].k1, xmm3), ApplyK1(Instruction.Create(Code.EVEX_Vscatterqps_vm64y_k1_xmm, __[rdx + zmm0].k1.ToMemoryOperand(Bitness), xmm3)));
|
||||
});
|
||||
}
|
||||
|
|
@ -60744,7 +60744,7 @@ namespace Iced.UnitTests.Intel.AssemblerTests {
|
|||
TestAssembler(c => c.xor(__byte_ptr[rdx], -5), Instruction.Create(Code.Xor_rm8_imm8, __byte_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
}
|
||||
{
|
||||
AssertInvalid( () => {
|
||||
AssertInvalid(() => {
|
||||
TestAssembler(c => c.xor(__zmmword_ptr[rdx], -5), Instruction.Create(Code.Xor_rm8_imm8, __zmmword_ptr[rdx].ToMemoryOperand(Bitness), -5));
|
||||
});
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue