1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
using Ryujinx.HLE.Exceptions;
using Ryujinx.HLE.HOS.Tamper.Conditions;
using Ryujinx.HLE.HOS.Tamper.Operations;
using System;
using System.Globalization;
namespace Ryujinx.HLE.HOS.Tamper
{
class InstructionHelper
{
private const int CodeTypeIndex = 0;
public static void Emit(IOperation operation, CompilationContext context)
{
context.CurrentOperations.Add(operation);
}
public static void Emit(Type instruction, byte width, CompilationContext context, params Object[] operands)
{
Emit((IOperation)Create(instruction, width, operands), context);
}
public static void EmitMov(byte width, CompilationContext context, IOperand destination, IOperand source)
{
Emit(typeof(OpMov<>), width, context, destination, source);
}
public static ICondition CreateCondition(Comparison comparison, byte width, IOperand lhs, IOperand rhs)
{
ICondition Create(Type conditionType)
{
return (ICondition)InstructionHelper.Create(conditionType, width, lhs, rhs);
}
switch (comparison)
{
case Comparison.Greater : return Create(typeof(CondGT<>));
case Comparison.GreaterOrEqual: return Create(typeof(CondGE<>));
case Comparison.Less : return Create(typeof(CondLT<>));
case Comparison.LessOrEqual : return Create(typeof(CondLE<>));
case Comparison.Equal : return Create(typeof(CondEQ<>));
case Comparison.NotEqual : return Create(typeof(CondNE<>));
default:
throw new TamperCompilationException($"Invalid comparison {comparison} in Atmosphere cheat");
}
}
public static Object Create(Type instruction, byte width, params Object[] operands)
{
Type realType;
switch (width)
{
case 1: realType = instruction.MakeGenericType(typeof(byte)); break;
case 2: realType = instruction.MakeGenericType(typeof(ushort)); break;
case 4: realType = instruction.MakeGenericType(typeof(uint)); break;
case 8: realType = instruction.MakeGenericType(typeof(ulong)); break;
default:
throw new TamperCompilationException($"Invalid instruction width {width} in Atmosphere cheat");
}
return Activator.CreateInstance(realType, operands);
}
public static ulong GetImmediate(byte[] instruction, int index, int nybbleCount)
{
ulong value = 0;
for (int i = 0; i < nybbleCount; i++)
{
value <<= 4;
value |= instruction[index + i];
}
return value;
}
public static CodeType GetCodeType(byte[] instruction)
{
int codeType = instruction[CodeTypeIndex];
if (codeType >= 0xC)
{
byte extension = instruction[CodeTypeIndex + 1];
codeType = (codeType << 4) | extension;
if (extension == 0xF)
{
extension = instruction[CodeTypeIndex + 2];
codeType = (codeType << 4) | extension;
}
}
return (CodeType)codeType;
}
public static byte[] ParseRawInstruction(string rawInstruction)
{
const int wordSize = 2 * sizeof(uint);
// Instructions are multi-word, with 32bit words. Split the raw instruction
// and parse each word into individual nybbles of bits.
var words = rawInstruction.Split((char[])null, StringSplitOptions.RemoveEmptyEntries);
byte[] instruction = new byte[wordSize * words.Length];
if (words.Length == 0)
{
throw new TamperCompilationException("Empty instruction in Atmosphere cheat");
}
for (int wordIndex = 0; wordIndex < words.Length; wordIndex++)
{
string word = words[wordIndex];
if (word.Length != wordSize)
{
throw new TamperCompilationException($"Invalid word length for {word} in Atmosphere cheat");
}
for (int nybbleIndex = 0; nybbleIndex < wordSize; nybbleIndex++)
{
int index = wordIndex * wordSize + nybbleIndex;
instruction[index] = byte.Parse(word.AsSpan(nybbleIndex, 1), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
}
}
return instruction;
}
}
}
|
