Add the TamperMachine module for runtime mods and cheats (#1928)

* Add initial implementation of the Tamper Machine

* Implement Atmosphere opcodes 0, 4 and 9

* Add missing TamperCompilationException class

* Implement Atmosphere conditional and loop opcodes 1, 2 and 3

* Inplement input conditional opcode 8

* Add register store opcode A

* Implement extended pause/resume opcodes FF0 and FF1

* Implement extended log opcode FFF

* Implement extended register conditional opcode C0

* Refactor TamperProgram to an interface

* Moved Atmosphere classes to a separate subdirectory

* Fix OpProcCtrl class not setting process

* Implement extended register save/restore opcodes C1, C2 and C3

* Refactor code emitters to separate classes

* Supress memory access errors from the Tamper Machine

* Add debug information to tamper register and memory writes

* Add block stack check to Atmosphere Cheat compiler

* Add handheld input support to Tamper Machine

* Fix code styling

* Fix build id and cheat case mismatch

* Fix invalid immediate size selection

* Print build ids of the title

* Prevent Tamper Machine from change code regions

* Remove Atmosphere namespace

* Remove empty cheats from the list

* Prevent code modification without disabling the tampering

* Fix missing addressing mode in LoadRegisterWithMemory

* Fix wrong addressing in RegisterConditional

* Add name to the tamper machine thread

* Fix code styling

Ryujinx.HLE/HOS/Tamper/Operations/Block.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    class Block : IOperation
+    {
+        private IEnumerable<IOperation> _operations;
+
+        public Block(IEnumerable<IOperation> operations)
+        {
+            _operations = operations;
+        }
+
+        public Block(params IOperation[] operations)
+        {
+            _operations = operations;
+        }
+
+        public void Execute()
+        {
+            foreach (IOperation op in _operations)
+            {
+                op.Execute();
+            }
+        }
+    }
+}

Ryujinx.HLE/HOS/Tamper/Operations/ForBlock.cs

@@ -0,0 +1,42 @@
+using Ryujinx.HLE.HOS.Tamper.Conditions;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    class ForBlock : IOperation
+    {
+        private ulong _count;
+        private Register _register;
+        private IEnumerable<IOperation> _operations;
+
+        public ForBlock(ulong count, Register register, IEnumerable<IOperation> operations)
+        {
+            _count = count;
+            _register = register;
+            _operations = operations;
+        }
+
+        public ForBlock(ulong count, Register register, params IOperation[] operations)
+        {
+            _count = count;
+            _register = register;
+            _operations = operations;
+        }
+
+        public void Execute()
+        {
+            for (ulong i = 0; i < _count; i++)
+            {
+                // Set the register and execute the operations so that changing the
+                // register during runtime does not break iteration.
+
+                _register.Set<ulong>(i);
+
+                foreach (IOperation op in _operations)
+                {
+                    op.Execute();
+                }
+            }
+        }
+    }
+}

Ryujinx.HLE/HOS/Tamper/Operations/IOperand.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    interface IOperand
+    {
+        public T Get<T>() where T : unmanaged;
+        public void Set<T>(T value) where T : unmanaged;
+    }
+}

Ryujinx.HLE/HOS/Tamper/Operations/IOperation.cs

@@ -0,0 +1,7 @@
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    interface IOperation
+    {
+        void Execute();
+    }
+}

Ryujinx.HLE/HOS/Tamper/Operations/IfBlock.cs

@@ -0,0 +1,35 @@
+using Ryujinx.HLE.HOS.Tamper.Conditions;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    class IfBlock : IOperation
+    {
+        private ICondition _condition;
+        private IEnumerable<IOperation> _operations;
+
+        public IfBlock(ICondition condition, IEnumerable<IOperation> operations)
+        {
+            _condition = condition;
+            _operations = operations;
+        }
+
+        public IfBlock(ICondition condition, params IOperation[] operations)
+        {
+            _operations = operations;
+        }
+
+        public void Execute()
+        {
+            if (!_condition.Evaluate())
+            {
+                return;
+            }
+
+            foreach (IOperation op in _operations)
+            {
+                op.Execute();
+            }
+        }
+    }
+}

Ryujinx.HLE/HOS/Tamper/Operations/OpAdd.cs

@@ -0,0 +1,21 @@
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    class OpAdd<T> : IOperation where T : unmanaged
+    {
+        IOperand _destination;
+        IOperand _lhs;
+        IOperand _rhs;
+
+        public OpAdd(IOperand destination, IOperand lhs, IOperand rhs)
+        {
+            _destination = destination;
+            _lhs = lhs;
+            _rhs = rhs;
+        }
+
+        public void Execute()
+        {
+            _destination.Set((T)((dynamic)_lhs.Get<T>() + (dynamic)_rhs.Get<T>()));
+        }
+    }
+}

Ryujinx.HLE/HOS/Tamper/Operations/OpAnd.cs

@@ -0,0 +1,21 @@
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    class OpAnd<T> : IOperation where T : unmanaged
+    {
+        IOperand _destination;
+        IOperand _lhs;
+        IOperand _rhs;
+
+        public OpAnd(IOperand destination, IOperand lhs, IOperand rhs)
+        {
+            _destination = destination;
+            _lhs = lhs;
+            _rhs = rhs;
+        }
+
+        public void Execute()
+        {
+            _destination.Set((T)((dynamic)_lhs.Get<T>() & (dynamic)_rhs.Get<T>()));
+        }
+    }
+}

Ryujinx.HLE/HOS/Tamper/Operations/OpLog.cs

@@ -0,0 +1,21 @@
+using Ryujinx.Common.Logging;
+
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    class OpLog<T> : IOperation where T : unmanaged
+    {
+        int _logId;
+        IOperand _source;
+
+        public OpLog(int logId, IOperand source)
+        {
+            _logId = logId;
+            _source = source;
+        }
+
+        public void Execute()
+        {
+            Logger.Debug?.Print(LogClass.TamperMachine, $"Tamper debug log id={_logId} value={(dynamic)_source.Get<T>():X}");
+        }
+    }
+}

Ryujinx.HLE/HOS/Tamper/Operations/OpLsh.cs

@@ -0,0 +1,21 @@
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    class OpLsh<T> : IOperation where T : unmanaged
+    {
+        IOperand _destination;
+        IOperand _lhs;
+        IOperand _rhs;
+
+        public OpLsh(IOperand destination, IOperand lhs, IOperand rhs)
+        {
+            _destination = destination;
+            _lhs = lhs;
+            _rhs = rhs;
+        }
+
+        public void Execute()
+        {
+            _destination.Set((T)((dynamic)_lhs.Get<T>() << (dynamic)_rhs.Get<T>()));
+        }
+    }
+}

Ryujinx.HLE/HOS/Tamper/Operations/OpMov.cs

@@ -0,0 +1,19 @@
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    class OpMov<T> : IOperation where T : unmanaged
+    {
+        IOperand _destination;
+        IOperand _source;
+
+        public OpMov(IOperand destination, IOperand source)
+        {
+            _destination = destination;
+            _source = source;
+        }
+
+        public void Execute()
+        {
+            _destination.Set(_source.Get<T>());
+        }
+    }
+}

Ryujinx.HLE/HOS/Tamper/Operations/OpMul.cs

@@ -0,0 +1,21 @@
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    class OpMul<T> : IOperation where T : unmanaged
+    {
+        IOperand _destination;
+        IOperand _lhs;
+        IOperand _rhs;
+
+        public OpMul(IOperand destination, IOperand lhs, IOperand rhs)
+        {
+            _destination = destination;
+            _lhs = lhs;
+            _rhs = rhs;
+        }
+
+        public void Execute()
+        {
+            _destination.Set((T)((dynamic)_lhs.Get<T>() * (dynamic)_rhs.Get<T>()));
+        }
+    }
+}

Ryujinx.HLE/HOS/Tamper/Operations/OpNot.cs

@@ -0,0 +1,19 @@
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    class OpNot<T> : IOperation where T : unmanaged
+    {
+        IOperand _destination;
+        IOperand _source;
+
+        public OpNot(IOperand destination, IOperand source)
+        {
+            _destination = destination;
+            _source = source;
+        }
+
+        public void Execute()
+        {
+            _destination.Set((T)(~(dynamic)_source.Get<T>()));
+        }
+    }
+}

Ryujinx.HLE/HOS/Tamper/Operations/OpOr.cs

@@ -0,0 +1,21 @@
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    class OpOr<T> : IOperation where T : unmanaged
+    {
+        IOperand _destination;
+        IOperand _lhs;
+        IOperand _rhs;
+
+        public OpOr(IOperand destination, IOperand lhs, IOperand rhs)
+        {
+            _destination = destination;
+            _lhs = lhs;
+            _rhs = rhs;
+        }
+
+        public void Execute()
+        {
+            _destination.Set((T)((dynamic)_lhs.Get<T>() | (dynamic)_rhs.Get<T>()));
+        }
+    }
+}

Ryujinx.HLE/HOS/Tamper/Operations/OpProcCtrl.cs

@@ -0,0 +1,26 @@
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    class OpProcCtrl : IOperation
+    {
+        private ITamperedProcess _process;
+        private bool _pause;
+
+        public OpProcCtrl(ITamperedProcess process, bool pause)
+        {
+            _process = process;
+            _pause = pause;
+        }
+
+        public void Execute()
+        {
+            if (_pause)
+            {
+                _process.PauseProcess();
+            }
+            else
+            {
+                _process.ResumeProcess();
+            }
+        }
+    }
+}

Ryujinx.HLE/HOS/Tamper/Operations/OpRsh.cs

@@ -0,0 +1,21 @@
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    class OpRsh<T> : IOperation where T : unmanaged
+    {
+        IOperand _destination;
+        IOperand _lhs;
+        IOperand _rhs;
+
+        public OpRsh(IOperand destination, IOperand lhs, IOperand rhs)
+        {
+            _destination = destination;
+            _lhs = lhs;
+            _rhs = rhs;
+        }
+
+        public void Execute()
+        {
+            _destination.Set((T)((dynamic)_lhs.Get<T>() >> (dynamic)_rhs.Get<T>()));
+        }
+    }
+}

Ryujinx.HLE/HOS/Tamper/Operations/OpSub.cs

@@ -0,0 +1,21 @@
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    class OpSub<T> : IOperation where T : unmanaged
+    {
+        IOperand _destination;
+        IOperand _lhs;
+        IOperand _rhs;
+
+        public OpSub(IOperand destination, IOperand lhs, IOperand rhs)
+        {
+            _destination = destination;
+            _lhs = lhs;
+            _rhs = rhs;
+        }
+
+        public void Execute()
+        {
+            _destination.Set((T)((dynamic)_lhs.Get<T>() - (dynamic)_rhs.Get<T>()));
+        }
+    }
+}

Ryujinx.HLE/HOS/Tamper/Operations/OpXor.cs

@@ -0,0 +1,21 @@
+namespace Ryujinx.HLE.HOS.Tamper.Operations
+{
+    class OpXor<T> : IOperation where T : unmanaged
+    {
+        IOperand _destination;
+        IOperand _lhs;
+        IOperand _rhs;
+
+        public OpXor(IOperand destination, IOperand lhs, IOperand rhs)
+        {
+            _destination = destination;
+            _lhs = lhs;
+            _rhs = rhs;
+        }
+
+        public void Execute()
+        {
+            _destination.Set((T)((dynamic)_lhs.Get<T>() ^ (dynamic)_rhs.Get<T>()));
+        }
+    }
+}