mirror of
https://github.com/danbulant/Cosmos
synced 2026-05-29 20:30:44 +00:00
685 lines
No EOL
37 KiB
C#
685 lines
No EOL
37 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.IO;
|
|
using Indy.IL2CPU.Assembler.X86;
|
|
|
|
namespace Indy.IL2CPU.Tests.AssemblerTests.X86 {
|
|
public static partial class TestCodeGenerator {
|
|
private static string mOutFile;
|
|
class ConstraintsContainer {
|
|
public Constraints SourceInfo;
|
|
public Constraints DestInfo;
|
|
public Instruction.InstructionSizes InvalidSizes = Instruction.InstructionSizes.None;
|
|
public bool MemToMem = false;
|
|
public bool ImmediateToImmediate = false;
|
|
}
|
|
|
|
public class TestState {
|
|
public string Description;
|
|
public bool Success;
|
|
public string Message;
|
|
}
|
|
|
|
class Constraints {
|
|
public bool TestMem32 = true;
|
|
public bool TestMem16 = true;
|
|
public bool TestMem8 = true;
|
|
public bool TestImmediate8 = true;
|
|
public bool TestImmediate16 = true;
|
|
public bool TestImmediate32 = true;
|
|
public bool TestRegisters = true;
|
|
public bool TestCR = false;
|
|
public bool TestSegments = false;
|
|
public IEnumerable<Guid> InvalidRegisters = new Guid[0];
|
|
}
|
|
|
|
private static Dictionary<Type, ConstraintsContainer> opcodesException;
|
|
|
|
private static void Initialize() {
|
|
var xTempPath = typeof(TestCodeGenerator).Assembly.Location;
|
|
xTempPath = xTempPath.Substring(0, xTempPath.LastIndexOf("source", StringComparison.InvariantCultureIgnoreCase) + "source".Length);
|
|
xTempPath = Path.Combine(xTempPath, "Indy.IL2CPU.Tests");
|
|
xTempPath = Path.Combine(xTempPath, "AssemblerTests");
|
|
xTempPath = Path.Combine(xTempPath, "X86");
|
|
mOutFile = Path.Combine(xTempPath, "AutoGeneratedTests.cs");
|
|
opcodesException = new Dictionary<Type, ConstraintsContainer>();
|
|
AddExceptions();
|
|
}
|
|
|
|
public static void Execute() {
|
|
Initialize();
|
|
if ((File.GetAttributes(mOutFile) & FileAttributes.ReadOnly) != 0) {
|
|
throw new Exception(String.Format("File '{0}' is readonly, please check the file out!", mOutFile));
|
|
}
|
|
using (var xOutput = new StreamWriter(mOutFile, false)) {
|
|
xOutput.WriteLine("using System;");
|
|
xOutput.WriteLine("using System.Collections.Generic;");
|
|
xOutput.WriteLine("using System.Linq;");
|
|
xOutput.WriteLine("using System.Text;");
|
|
xOutput.WriteLine("using Indy.IL2CPU.Assembler.X86;");
|
|
xOutput.WriteLine("using NUnit.Framework;");
|
|
xOutput.WriteLine();
|
|
xOutput.WriteLine("namespace Indy.IL2CPU.Tests.AssemblerTests.X86 {");
|
|
|
|
foreach (Type type in typeof(Instruction).Assembly.GetTypes()) {
|
|
if (type == typeof(AddWithCarry)) {
|
|
System.Diagnostics.Debugger.Break();
|
|
}
|
|
GenerateSingle(type, xOutput);
|
|
}
|
|
xOutput.WriteLine("}");
|
|
}
|
|
}
|
|
|
|
private static void GenerateSingle(Type aType, StreamWriter aOutput) {
|
|
if (aType.IsAbstract) {
|
|
return;
|
|
}
|
|
if (!aType.IsSubclassOf(typeof(Instruction))) {
|
|
return;
|
|
}
|
|
if (!Instruction.HasEncodingOptions(aType)) {
|
|
WriteTestFixtureHeader(aType, aOutput);
|
|
{
|
|
aOutput.WriteLine("[Test]");
|
|
aOutput.WriteLine("[Category(\"MissingEncodingOptions\")]");
|
|
aOutput.WriteLine("public void DoTest(){");
|
|
aOutput.WriteLine("Assert.Fail(\"No Encoding Options specified\");");
|
|
aOutput.WriteLine("}");
|
|
}
|
|
WriteTestFixtureFooter(aType, aOutput);
|
|
return;
|
|
}
|
|
if (aType.IsSubclassOf(typeof(Assembler.X86.InstructionWithDestinationAndSourceAndSize))) {
|
|
GenerateInstructionWithDestinationAndSourceAndSize(aType, aOutput);
|
|
return;
|
|
}
|
|
if (aType.IsSubclassOf(typeof(Assembler.X86.InstructionWithDestinationAndSource))) {
|
|
GenerateInstructionWithDestinationAndSource(aType,
|
|
aOutput);
|
|
return;
|
|
}
|
|
if (aType.IsSubclassOf(typeof(Assembler.X86.InstructionWithDestinationAndSize))) {
|
|
GenerateInstructionWithDestinationAndSize(aType,
|
|
aOutput);
|
|
return;
|
|
}
|
|
if (aType.IsSubclassOf(typeof(Assembler.X86.InstructionWithDestination))) {
|
|
GenerateInstructionWithDestination(aType,
|
|
aOutput);
|
|
return;
|
|
}
|
|
if (aType.IsSubclassOf(typeof(Assembler.X86.InstructionWithSize))) {
|
|
GenerateInstructionWithSize(aType,
|
|
aOutput);
|
|
return;
|
|
}
|
|
if (aType.IsSubclassOf(typeof(Assembler.X86.Instruction))) {
|
|
GenerateSimpleInstruction(aType, aOutput);
|
|
return;
|
|
}
|
|
throw new Exception("Type not handled: " + aType.FullName);
|
|
}
|
|
|
|
private static void WriteTestFixtureHeader(Type aType, StreamWriter aOutput) {
|
|
aOutput.WriteLine("\t[TestFixture]");
|
|
aOutput.WriteLine("\tpublic partial class {0}Tests: BaseTest {{", aType.Name);
|
|
}
|
|
|
|
private static void WriteTestFixtureFooter(Type aType, StreamWriter aOutput) {
|
|
aOutput.WriteLine("\t}");
|
|
}
|
|
|
|
private static void WriteTestMethodHeader(string aName, StreamWriter aOutput) {
|
|
if (aName == "ImmediateSourceImmediateDestinationSize16") {
|
|
System.Diagnostics.Debugger.Break();
|
|
}
|
|
aOutput.WriteLine("\t\t[Test]");
|
|
aOutput.WriteLine("\t\tpublic void Test{0}() {{", aName);
|
|
}
|
|
|
|
private static void WriteTestMethodFooter(string aName, StreamWriter aOutput) {
|
|
aOutput.WriteLine("\t\t\tVerify();");
|
|
aOutput.WriteLine("\t\t}");
|
|
}
|
|
|
|
|
|
private static void GenerateSimpleInstruction(Type aType, StreamWriter aOutput) {
|
|
WriteTestFixtureHeader(aType, aOutput);
|
|
{
|
|
WriteTestMethodHeader("Instruction", aOutput);
|
|
{
|
|
aOutput.WriteLine("\t\t\tnew global::{0}();", aType.FullName);
|
|
}
|
|
WriteTestMethodFooter("Instruction", aOutput);
|
|
}
|
|
WriteTestFixtureFooter(aType, aOutput);
|
|
}
|
|
|
|
private static void GenerateInstructionWithSize(Type aType, StreamWriter aOutput) {
|
|
ConstraintsContainer xInfo = null;
|
|
if (opcodesException.ContainsKey(aType)) {
|
|
xInfo = opcodesException[aType];
|
|
}
|
|
WriteTestFixtureHeader(aType, aOutput);
|
|
{
|
|
if (!(xInfo != null && ((xInfo.InvalidSizes & Instruction.InstructionSizes.DWord) != 0))) {
|
|
WriteTestMethodHeader("InstructionSize32", aOutput);
|
|
{
|
|
aOutput.WriteLine("\t\t\tnew global::{0}{{Size = 32}};", aType.FullName);
|
|
}
|
|
WriteTestMethodFooter("InstructionSize32", aOutput);
|
|
}
|
|
if (!(xInfo != null && ((xInfo.InvalidSizes & Instruction.InstructionSizes.Word) != 0))) {
|
|
WriteTestMethodHeader("InstructionSize16", aOutput);
|
|
{
|
|
aOutput.WriteLine("\t\t\tnew global::{0}{{Size = 16}};", aType.FullName);
|
|
}
|
|
WriteTestMethodFooter("InstructionSize16", aOutput);
|
|
}
|
|
if (!(xInfo != null && ((xInfo.InvalidSizes & Instruction.InstructionSizes.Byte) != 0))) {
|
|
WriteTestMethodHeader("InstructionSize8", aOutput);
|
|
{
|
|
aOutput.WriteLine("\t\t\tnew global::{0}{{Size = 8}};", aType.FullName);
|
|
}
|
|
WriteTestMethodFooter("InstructionSize8", aOutput);
|
|
}
|
|
}
|
|
WriteTestFixtureFooter(aType, aOutput);
|
|
}
|
|
|
|
private static void GenerateInstructionWithDestination(Type aType, StreamWriter aOutput) {
|
|
WriteTestFixtureHeader(aType, aOutput);
|
|
{
|
|
foreach (var xItem in GetDestinationPossibilities(aType)) {
|
|
if (xItem.Value.Length > 0) {
|
|
WriteTestMethodHeader(xItem.Key, aOutput);
|
|
{
|
|
foreach (var xLine in xItem.Value) {
|
|
aOutput.WriteLine("\t\t\tnew global::{0}{{{1}}};", aType.FullName, xLine);
|
|
}
|
|
}
|
|
WriteTestMethodFooter(xItem.Key, aOutput);
|
|
}
|
|
}
|
|
}
|
|
WriteTestFixtureFooter(aType, aOutput);
|
|
}
|
|
|
|
private static bool ShouldTestMemorySource(Type aType, byte aSize) {
|
|
if (!opcodesException.ContainsKey(aType)) {
|
|
return true;
|
|
}
|
|
if (opcodesException[aType].SourceInfo == null) {
|
|
return true;
|
|
}
|
|
switch (aSize) {
|
|
case 8:
|
|
return opcodesException[aType].SourceInfo.TestMem8;
|
|
case 16:
|
|
return opcodesException[aType].SourceInfo.TestMem16;
|
|
case 32:
|
|
return opcodesException[aType].SourceInfo.TestMem32;
|
|
default:
|
|
throw new Exception("Wrong Size: " + aSize);
|
|
}
|
|
}
|
|
|
|
private static bool ShouldTestImmediateSource(Type aType, byte aSize) {
|
|
if (!opcodesException.ContainsKey(aType)) {
|
|
return true;
|
|
}
|
|
if (opcodesException[aType].SourceInfo == null) {
|
|
return true;
|
|
}
|
|
switch (aSize) {
|
|
case 8:
|
|
return opcodesException[aType].SourceInfo.TestImmediate8;
|
|
case 16:
|
|
return opcodesException[aType].SourceInfo.TestImmediate16;
|
|
case 32:
|
|
return opcodesException[aType].SourceInfo.TestImmediate32;
|
|
default:
|
|
throw new Exception("Wrong Size: " + aSize);
|
|
}
|
|
}
|
|
|
|
private static bool ShouldTestMemoryDestination(Type aType, byte aSize) {
|
|
if (!opcodesException.ContainsKey(aType)) {
|
|
return true;
|
|
}
|
|
if (opcodesException[aType].DestInfo == null) {
|
|
return true;
|
|
}
|
|
switch (aSize) {
|
|
case 8:
|
|
return opcodesException[aType].DestInfo.TestMem8;
|
|
case 16:
|
|
return opcodesException[aType].DestInfo.TestMem16;
|
|
case 32:
|
|
return opcodesException[aType].DestInfo.TestMem32;
|
|
default:
|
|
throw new Exception("Wrong Size: " + aSize);
|
|
}
|
|
}
|
|
|
|
private static bool ShouldTestImmediateDestination(Type aType, byte aSize) {
|
|
if (!opcodesException.ContainsKey(aType)) {
|
|
return true;
|
|
}
|
|
if (opcodesException[aType].DestInfo == null) {
|
|
return true;
|
|
}
|
|
switch (aSize) {
|
|
case 8:
|
|
return opcodesException[aType].DestInfo.TestImmediate8;
|
|
case 16:
|
|
return opcodesException[aType].DestInfo.TestImmediate16;
|
|
case 32:
|
|
return opcodesException[aType].DestInfo.TestImmediate32;
|
|
default:
|
|
throw new Exception("Wrong Size: " + aSize);
|
|
}
|
|
}
|
|
|
|
private static void GenerateInstructionWithDestinationAndSize(Type aType, StreamWriter aOutput) {
|
|
WriteTestFixtureHeader(aType, aOutput);
|
|
{
|
|
foreach (var xSize in new byte[] { 8, 16, 32 }) {
|
|
foreach (var xItem in GetDestinationWithSizePossibilities(aType, xSize)) {
|
|
if (xItem.Value.Length == 0) {
|
|
continue;
|
|
}
|
|
WriteTestMethodHeader(xItem.Key + "Size" + xSize, aOutput);
|
|
{
|
|
foreach (var xLine in xItem.Value) {
|
|
aOutput.WriteLine("\t\t\tnew global::{0}{{{1}, Size = {2}}};", aType.FullName, xLine, xSize);
|
|
}
|
|
}
|
|
WriteTestMethodFooter(xItem.Key + "Size" + xSize, aOutput);
|
|
}
|
|
}
|
|
}
|
|
WriteTestFixtureFooter(aType, aOutput);
|
|
}
|
|
|
|
private static IEnumerable<KeyValuePair<string, string[]>> GetDestinationPossibilities(Type aType) {
|
|
if (!opcodesException.ContainsKey(aType) || opcodesException[aType].DestInfo == null || opcodesException[aType].DestInfo.TestImmediate32) {
|
|
yield return new KeyValuePair<string, string[]>("ImmediateDestination",
|
|
new string[] { "DestinationValue = 30", "DestinationValue = 300", "DestinationValue = 300000" });
|
|
}
|
|
if (!opcodesException.ContainsKey(aType) || opcodesException[aType].DestInfo == null || opcodesException[aType].DestInfo.TestMem32) {
|
|
yield return new KeyValuePair<string, string[]>("8BitMemoryAddressDestination",
|
|
new string[] { "DestinationValue = 65, DestinationIsIndirect = true"});
|
|
yield return new KeyValuePair<string, string[]>("16BitMemoryAddressDestination",
|
|
new string[] { "DestinationValue = 650, DestinationIsIndirect = true"});
|
|
yield return new KeyValuePair<string, string[]>("32BitMemoryAddressDestination",
|
|
new string[] { "DestinationValue = 650000, DestinationIsIndirect = true"});
|
|
}
|
|
if (!opcodesException.ContainsKey(aType) || opcodesException[aType].DestInfo.TestRegisters) {
|
|
var xRegistersToSkip = new List<Guid>();
|
|
if (opcodesException.ContainsKey(aType) && opcodesException[aType].DestInfo.InvalidRegisters != null) {
|
|
xRegistersToSkip.AddRange(opcodesException[aType].DestInfo.InvalidRegisters);
|
|
}
|
|
foreach (var xReg in Registers.GetRegisters()) {
|
|
if (xRegistersToSkip.Contains(xReg)) {
|
|
continue;
|
|
}
|
|
if (!Registers.Is32Bit(xReg)) {
|
|
continue;
|
|
}
|
|
if (Registers.IsCR(xReg)) {
|
|
continue;
|
|
}
|
|
if (!opcodesException.ContainsKey(aType) || (opcodesException.ContainsKey(aType) && opcodesException[aType].DestInfo.TestMem32)) {
|
|
yield return new KeyValuePair<string, string[]>("MemoryAtRegister" + Registers.GetRegisterName(xReg) + "Destination",
|
|
new string[] {
|
|
String.Format("DestinationReg = Registers.{0}, DestinationIsIndirect=true", Registers.GetRegisterName(xReg)),
|
|
//offset 8
|
|
String.Format("DestinationReg = Registers.{0}, DestinationIsIndirect=true, DestinationDisplacement = 203", Registers.GetRegisterName(xReg)),
|
|
//offset 16
|
|
String.Format("DestinationReg = Registers.{0}, DestinationIsIndirect=true, DestinationDisplacement = 2030", Registers.GetRegisterName(xReg)),
|
|
//offset 32
|
|
String.Format("DestinationReg = Registers.{0}, DestinationIsIndirect=true, DestinationDisplacement = 203000", Registers.GetRegisterName(xReg))});
|
|
}
|
|
}
|
|
var xItems = new List<string>();
|
|
foreach (Guid register in Registers.GetRegisters()) {
|
|
if (!aType.Namespace.Contains("SSE") && (Registers.getXMMs().Contains(register)))
|
|
continue;
|
|
if (Registers.getCRs().Contains(register) && (!opcodesException.ContainsKey(aType) || (opcodesException.ContainsKey(aType) && (!opcodesException[aType].DestInfo.TestCR))))
|
|
continue;
|
|
if ((!opcodesException.ContainsKey(aType) ||
|
|
(opcodesException.ContainsKey(aType) && opcodesException[aType].DestInfo.InvalidRegisters != null &&
|
|
(opcodesException[aType].DestInfo.InvalidRegisters.Contains(register)))))
|
|
continue;
|
|
if (Registers.IsSegment(register) && !(opcodesException.ContainsKey(aType) && opcodesException[aType].DestInfo.TestSegments)) {
|
|
continue;
|
|
}
|
|
if (Registers.GetSize(register) == 32) {
|
|
xItems.Add("DestinationReg = Registers." + Registers.GetRegisterName(register));
|
|
}
|
|
}
|
|
if (xItems.Count > 0) {
|
|
yield return new KeyValuePair<string, string[]>("RegisterDestination",
|
|
xItems.ToArray());
|
|
}
|
|
}
|
|
yield break;
|
|
}
|
|
|
|
private static IEnumerable<KeyValuePair<string, string[]>> GetSourcePossibilities(Type aType) {
|
|
if (!opcodesException.ContainsKey(aType) || opcodesException[aType].SourceInfo == null || opcodesException[aType].SourceInfo.TestImmediate32) {
|
|
yield return new KeyValuePair<string, string[]>("ImmediateSource",
|
|
new string[] { "SourceValue = 30", "SourceValue = 300", "SourceValue = 300000" });
|
|
}
|
|
if (!opcodesException.ContainsKey(aType) || opcodesException[aType].SourceInfo == null || opcodesException[aType].SourceInfo.TestMem32) {
|
|
yield return new KeyValuePair<string, string[]>("8BitMemoryAddressSource",
|
|
new string[] { "SourceValue = 65, SourceIsIndirect = true"});
|
|
yield return new KeyValuePair<string, string[]>("16BitMemoryAddressSource",
|
|
new string[] { "SourceValue = 650, SourceIsIndirect = true"});
|
|
yield return new KeyValuePair<string, string[]>("32BitMemoryAddressSource",
|
|
new string[] { "SourceValue = 650000, SourceIsIndirect = true"});
|
|
}
|
|
if (!opcodesException.ContainsKey(aType) || opcodesException[aType].SourceInfo.TestRegisters) {
|
|
var xRegistersToSkip = new List<Guid>();
|
|
if (opcodesException.ContainsKey(aType) && opcodesException[aType].SourceInfo.InvalidRegisters != null) {
|
|
xRegistersToSkip.AddRange(opcodesException[aType].SourceInfo.InvalidRegisters);
|
|
}
|
|
foreach (var xReg in Registers.GetRegisters()) {
|
|
if (xRegistersToSkip.Contains(xReg)) {
|
|
continue;
|
|
}
|
|
if (!Registers.Is32Bit(xReg)) {
|
|
continue;
|
|
}
|
|
if (Registers.IsCR(xReg)) {
|
|
continue;
|
|
}
|
|
if (!opcodesException.ContainsKey(aType) || (opcodesException.ContainsKey(aType) && opcodesException[aType].SourceInfo.TestMem32)) {
|
|
yield return new KeyValuePair<string, string[]>("MemoryAtRegister" + Registers.GetRegisterName(xReg) + "Source",
|
|
new string[] {
|
|
String.Format("SourceReg = Registers.{0}, SourceIsIndirect=true", Registers.GetRegisterName(xReg)),
|
|
//offset 8
|
|
String.Format("SourceReg = Registers.{0}, SourceIsIndirect=true, SourceDisplacement = 203", Registers.GetRegisterName(xReg)),
|
|
//offset 16
|
|
String.Format("SourceReg = Registers.{0}, SourceIsIndirect=true, SourceDisplacement = 2030", Registers.GetRegisterName(xReg)),
|
|
//offset 32
|
|
String.Format("SourceReg = Registers.{0}, SourceIsIndirect=true, SourceDisplacement = 203000", Registers.GetRegisterName(xReg))});
|
|
}
|
|
}
|
|
var xItems = new List<string>();
|
|
foreach (Guid register in Registers.GetRegisters()) {
|
|
if (!aType.Namespace.Contains("SSE") && (Registers.getXMMs().Contains(register)))
|
|
continue;
|
|
if (Registers.getCRs().Contains(register) && (!opcodesException.ContainsKey(aType) || (opcodesException.ContainsKey(aType) && (!opcodesException[aType].SourceInfo.TestCR))))
|
|
continue;
|
|
if ((!opcodesException.ContainsKey(aType) ||
|
|
(opcodesException.ContainsKey(aType) && opcodesException[aType].SourceInfo.InvalidRegisters != null &&
|
|
(opcodesException[aType].SourceInfo.InvalidRegisters.Contains(register)))))
|
|
continue;
|
|
if (Registers.IsSegment(register) && !(opcodesException.ContainsKey(aType) && opcodesException[aType].SourceInfo.TestSegments)) {
|
|
continue;
|
|
}
|
|
if (Registers.GetSize(register) == 32) {
|
|
xItems.Add("SourceReg = Registers." + Registers.GetRegisterName(register));
|
|
}
|
|
}
|
|
if (xItems.Count > 0) {
|
|
yield return new KeyValuePair<string, string[]>("RegisterSource",
|
|
xItems.ToArray());
|
|
}
|
|
}
|
|
yield break;
|
|
}
|
|
private static IEnumerable<KeyValuePair<string, string[]>> GetDestinationWithSizePossibilities(Type aType, byte aSize) {
|
|
var xItems = new List<string>();
|
|
{
|
|
if (aSize == 8 && ShouldTestImmediateDestination(aType, aSize)) {
|
|
//Test Immediate 8
|
|
xItems.Add(String.Format("DestinationValue = 30"));
|
|
}
|
|
|
|
if (aSize == 16 && ShouldTestImmediateDestination(aType, aSize)) {
|
|
//Test Immediate 16
|
|
xItems.Add(String.Format("DestinationValue = 300"));
|
|
}
|
|
if (aSize == 32 && ShouldTestImmediateDestination(aType, aSize)) {
|
|
//Test Immediate 32
|
|
xItems.Add(String.Format("DestinationValue = 300000"));
|
|
}
|
|
}
|
|
yield return new KeyValuePair<string, string[]>("ImmediateDestination", xItems.ToArray());
|
|
xItems.Clear();
|
|
if (ShouldTestMemoryDestination(aType, aSize)) {
|
|
yield return new KeyValuePair<string, string[]>(String.Format("MemoryDestination", aSize),
|
|
new string[]{
|
|
//memory 8 bits address
|
|
//no offset
|
|
String.Format("DestinationValue = 65, DestinationIsIndirect = true"),
|
|
//memory 16 bits address
|
|
//no offset
|
|
String.Format("DestinationValue = 650, DestinationIsIndirect = true"),
|
|
// memory 32 bits address
|
|
//no offset
|
|
String.Format("DestinationValue = 650000, DestinationIsIndirect = true")});
|
|
}
|
|
if (!opcodesException.ContainsKey(aType) || opcodesException[aType].DestInfo.TestRegisters) {
|
|
var xRegistersToSkip = new List<Guid>();
|
|
if (opcodesException.ContainsKey(aType) && opcodesException[aType].DestInfo.InvalidRegisters != null) {
|
|
xRegistersToSkip.AddRange(opcodesException[aType].DestInfo.InvalidRegisters);
|
|
}
|
|
foreach (var xReg in Registers.GetRegisters()) {
|
|
if (xRegistersToSkip.Contains(xReg)) {
|
|
continue;
|
|
}
|
|
if (!Registers.Is32Bit(xReg)) {
|
|
continue;
|
|
}
|
|
if (Registers.IsCR(xReg)) {
|
|
continue;
|
|
}
|
|
if (ShouldTestMemoryDestination(aType, aSize)) {
|
|
yield return new KeyValuePair<string, string[]>("MemoryAtRegister" + Registers.GetRegisterName(xReg) + "Destination",
|
|
new string[] {
|
|
//memory
|
|
//no offset
|
|
String.Format("DestinationReg = Registers.{0}, DestinationIsIndirect = true", Registers.GetRegisterName(xReg)),
|
|
//offset 8
|
|
String.Format("DestinationReg = Registers.{0}, DestinationIsIndirect = true, DestinationDisplacement = 203", Registers.GetRegisterName(xReg)),
|
|
//offset 16
|
|
String.Format("DestinationReg = Registers.{0}, DestinationIsIndirect = true, DestinationDisplacement = 2030", Registers.GetRegisterName(xReg)),
|
|
//offset 32
|
|
String.Format("DestinationReg = Registers.{0}, DestinationIsIndirect = true, DestinationDisplacement = 203000", Registers.GetRegisterName(xReg))
|
|
});
|
|
}
|
|
}
|
|
xItems.Clear();
|
|
foreach (Guid register in Registers.GetRegisters()) {
|
|
if (!aType.Namespace.Contains("SSE") && (Registers.getXMMs().Contains(register)))
|
|
continue;
|
|
if (Registers.getCRs().Contains(register) && (!opcodesException.ContainsKey(aType) || (opcodesException.ContainsKey(aType) && (!opcodesException[aType].DestInfo.TestCR))))
|
|
continue;
|
|
if ((!opcodesException.ContainsKey(aType) ||
|
|
(opcodesException.ContainsKey(aType) && opcodesException[aType].DestInfo.InvalidRegisters != null &&
|
|
(opcodesException[aType].DestInfo.InvalidRegisters.Contains(register)))))
|
|
continue;
|
|
if (Registers.IsSegment(register) && !(opcodesException.ContainsKey(aType) && opcodesException[aType].DestInfo.TestSegments)) {
|
|
continue;
|
|
}
|
|
if (Registers.GetSize(register) == aSize) {
|
|
xItems.Add(String.Format("DestinationReg = Registers.{0}", Registers.GetRegisterName(register)));
|
|
}
|
|
}
|
|
if (xItems.Count > 0) {
|
|
yield return new KeyValuePair<string, string[]>("RegisterDestination", xItems.ToArray());
|
|
}
|
|
}
|
|
}
|
|
|
|
private static IEnumerable<KeyValuePair<string, string[]>> GetSourceWithSizePossibilities(Type aType, byte aSize) {
|
|
var xItems = new List<string>();
|
|
{
|
|
if (aSize == 8 && ShouldTestImmediateSource(aType, aSize)) {
|
|
//Test Immediate 8
|
|
xItems.Add(String.Format("SourceValue = 30"));
|
|
}
|
|
|
|
if (aSize == 16 && ShouldTestImmediateSource(aType, aSize)) {
|
|
//Test Immediate 16
|
|
xItems.Add(String.Format("SourceValue = 300"));
|
|
}
|
|
if (aSize == 32 && ShouldTestImmediateSource(aType, aSize)) {
|
|
//Test Immediate 32
|
|
xItems.Add(String.Format("SourceValue = 300000"));
|
|
}
|
|
}
|
|
yield return new KeyValuePair<string, string[]>("ImmediateSource", xItems.ToArray());
|
|
xItems.Clear();
|
|
if (ShouldTestMemorySource(aType, aSize)) {
|
|
yield return new KeyValuePair<string, string[]>(String.Format("MemorySource", aSize),
|
|
new string[]{
|
|
//memory 8 bits address
|
|
//no offset
|
|
String.Format("SourceValue = 65, SourceIsIndirect = true"),
|
|
//memory 16 bits address
|
|
//no offset
|
|
String.Format("SourceValue = 650, SourceIsIndirect = true"),
|
|
// memory 32 bits address
|
|
//no offset
|
|
String.Format("SourceValue = 650000, SourceIsIndirect = true"),
|
|
});
|
|
}
|
|
if (!opcodesException.ContainsKey(aType) || opcodesException[aType].SourceInfo.TestRegisters) {
|
|
var xRegistersToSkip = new List<Guid>();
|
|
if (opcodesException.ContainsKey(aType) && opcodesException[aType].SourceInfo.InvalidRegisters != null) {
|
|
xRegistersToSkip.AddRange(opcodesException[aType].SourceInfo.InvalidRegisters);
|
|
}
|
|
foreach (var xReg in Registers.GetRegisters()) {
|
|
if (xRegistersToSkip.Contains(xReg)) {
|
|
continue;
|
|
}
|
|
if (!Registers.Is32Bit(xReg)) {
|
|
continue;
|
|
}
|
|
if (Registers.IsCR(xReg)) {
|
|
continue;
|
|
}
|
|
if (ShouldTestMemorySource(aType, aSize)) {
|
|
yield return new KeyValuePair<string, string[]>("MemoryAtRegister" + Registers.GetRegisterName(xReg) + "Source",
|
|
new string[] {
|
|
//memory
|
|
//no offset
|
|
String.Format("SourceReg = Registers.{0}, SourceIsIndirect = true", Registers.GetRegisterName(xReg)),
|
|
//offset 8
|
|
String.Format("SourceReg = Registers.{0}, SourceIsIndirect = true, SourceDisplacement = 203", Registers.GetRegisterName(xReg)),
|
|
//offset 16
|
|
String.Format("SourceReg = Registers.{0}, SourceIsIndirect = true, SourceDisplacement = 2030", Registers.GetRegisterName(xReg)),
|
|
//offset 32
|
|
String.Format("SourceReg = Registers.{0}, SourceIsIndirect = true, SourceDisplacement = 203000", Registers.GetRegisterName(xReg))
|
|
});
|
|
}
|
|
}
|
|
xItems.Clear();
|
|
foreach (Guid register in Registers.GetRegisters()) {
|
|
if (!aType.Namespace.Contains("SSE") && (Registers.getXMMs().Contains(register)))
|
|
continue;
|
|
if (Registers.getCRs().Contains(register) && (!opcodesException.ContainsKey(aType) || (opcodesException.ContainsKey(aType) && (!opcodesException[aType].SourceInfo.TestCR))))
|
|
continue;
|
|
if ((!opcodesException.ContainsKey(aType) ||
|
|
(opcodesException.ContainsKey(aType) && opcodesException[aType].SourceInfo.InvalidRegisters != null &&
|
|
(opcodesException[aType].SourceInfo.InvalidRegisters.Contains(register)))))
|
|
continue;
|
|
if (Registers.IsSegment(register) && !(opcodesException.ContainsKey(aType) && opcodesException[aType].SourceInfo.TestSegments)) {
|
|
continue;
|
|
}
|
|
if (Registers.GetSize(register) == aSize) {
|
|
xItems.Add(String.Format("SourceReg = Registers.{0}", Registers.GetRegisterName(register)));
|
|
}
|
|
}
|
|
if (xItems.Count > 0) {
|
|
yield return new KeyValuePair<string, string[]>("RegisterSource", xItems.ToArray());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private static void GenerateInstructionWithDestinationAndSource(Type aType, StreamWriter aOutput) {
|
|
WriteTestFixtureHeader(aType, aOutput);
|
|
{
|
|
foreach (var xSourceItem in GetSourcePossibilities(aType)) {
|
|
foreach (var xDestItem in GetDestinationPossibilities(aType)) {
|
|
if (opcodesException.ContainsKey(aType)) {
|
|
if (!opcodesException[aType].MemToMem) {
|
|
if (xSourceItem.Key.Contains("Memory") && xDestItem.Key.Contains("Memory")) {
|
|
continue;
|
|
}
|
|
}
|
|
if(!opcodesException[aType].ImmediateToImmediate) {
|
|
if (xSourceItem.Key.Contains("Value") && xDestItem.Key.Contains("Value") &&
|
|
!xSourceItem.Key.Contains("IsIndirect") && !xDestItem.Key.Contains("IsIndirect")) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
if(xSourceItem.Value.Length ==0) {
|
|
continue;
|
|
}
|
|
WriteTestMethodHeader(xSourceItem.Key + xDestItem.Key, aOutput);
|
|
{
|
|
foreach (var xSourceLine in xSourceItem.Value) {
|
|
{
|
|
foreach (var xLine in xDestItem.Value) {
|
|
aOutput.WriteLine("\t\t\tnew global::{0}{{{1}, {2}}};", aType.FullName, xSourceLine, xLine);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
WriteTestMethodFooter(xSourceItem.Key + xDestItem.Key, aOutput);
|
|
}
|
|
}
|
|
}
|
|
WriteTestFixtureFooter(aType, aOutput);
|
|
}
|
|
|
|
private static void GenerateInstructionWithDestinationAndSourceAndSize(Type aType, StreamWriter aOutput) {
|
|
WriteTestFixtureHeader(aType, aOutput);
|
|
{
|
|
foreach(var xSize in new byte[] {8, 16, 32}){
|
|
foreach (var xSourceItem in GetSourceWithSizePossibilities(aType, xSize)) {
|
|
foreach (var xDestItem in GetDestinationWithSizePossibilities(aType, xSize)) {
|
|
if (opcodesException.ContainsKey(aType)) {
|
|
if (!opcodesException[aType].MemToMem) {
|
|
if (xSourceItem.Key.Contains("Memory") && xDestItem.Key.Contains("Memory")) {
|
|
continue;
|
|
}
|
|
}
|
|
if (!opcodesException[aType].ImmediateToImmediate) {
|
|
if (xSourceItem.Key.Contains("Immediate") && xDestItem.Key.Contains("Immediate") &&
|
|
!xSourceItem.Key.Contains("IsIndirect") && !xDestItem.Key.Contains("IsIndirect")) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
if (xSourceItem.Value.Length == 0) {
|
|
continue;
|
|
}
|
|
WriteTestMethodHeader(xSourceItem.Key + xDestItem.Key + "Size" + xSize, aOutput);
|
|
{
|
|
foreach (var xSourceLine in xSourceItem.Value) {
|
|
foreach (var xLine in xDestItem.Value) {
|
|
aOutput.WriteLine("\t\t\tnew global::{0}{{{1}, {2}, Size = {3}}};", aType.FullName, xSourceLine, xLine, xSize);
|
|
}
|
|
}
|
|
}
|
|
WriteTestMethodFooter(xSourceItem.Key + xDestItem.Key + "Size" + xSize, aOutput);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
WriteTestFixtureFooter(aType, aOutput);
|
|
}
|
|
}
|
|
} |