0
0
Fork 0
mirror of https://github.com/ryujinx-mirror/ryujinx.git synced 2024-12-24 16:45:49 +00:00
ryujinx-fork/ARMeilleure/Translation/PTC/Symbol.cs
FICTURE7 9d7627af64
Add multi-level function table (#2228)
* Add AddressTable<T>

* Use AddressTable<T> for dispatch

* Remove JumpTable & co.

* Add fallback for out of range addresses

* Add PPTC support

* Add documentation to `AddressTable<T>`

* Make AddressTable<T> configurable

* Fix table walk

* Fix IsMapped check

* Remove CountTableCapacity

* Add PPTC support for fast path

* Rename IsMapped to IsValid

* Remove stale comment

* Change format of address in exception message

* Add TranslatorStubs

* Split DispatchStub

Avoids recompilation of stubs during tests.

* Add hint for 64bit or 32bit

* Add documentation to `Symbol`

* Add documentation to `TranslatorStubs`

Make `TranslatorStubs` disposable as well.

* Add documentation to `SymbolType`

* Add `AddressTableEventSource` to monitor function table size

Add an EventSource which measures the amount of unmanaged bytes
allocated by AddressTable<T> instances.

 dotnet-counters monitor -n Ryujinx --counters ARMeilleure

* Add `AllowLcqInFunctionTable` optimization toggle

This is to reduce the impact this change has on the test duration.
Before everytime a test was ran, the FunctionTable would be initialized
and populated so that the newly compiled test would get registered to
it.

* Implement unmanaged dispatcher

Uses the DispatchStub to dispatch into the next translation, which
allows execution to stay in unmanaged for longer and skips a
ConcurrentDictionary look up when the target translation has been
registered to the FunctionTable.

* Remove redundant null check

* Tune levels of FunctionTable

Uses 5 levels instead of 4 and change unit of AddressTableEventSource
from KB to MB.

* Use 64-bit function table

Improves codegen for direct branches:

    mov qword [rax+0x408],0x10603560
 -  mov rcx,sub_10603560_OFFSET
 -  mov ecx,[rcx]
 -  mov ecx,ecx
 -  mov rdx,JIT_CACHE_BASE
 -  add rdx,rcx
 +  mov rcx,sub_10603560
 +  mov rdx,[rcx]
    mov rcx,rax

Improves codegen for dispatch stub:

    and rax,byte +0x1f
 -  mov eax,[rcx+rax*4]
 -  mov eax,eax
 -  mov rcx,JIT_CACHE_BASE
 -  lea rax,[rcx+rax]
 +  mov rax,[rcx+rax*8]
    mov rcx,rbx

* Remove `JitCacheSymbol` & `JitCache.Offset`

* Turn `Translator.Translate` into an instance method

We do not have to add more parameter to this method and related ones as
new structures are added & needed for translation.

* Add symbol only when PTC is enabled

Address LDj3SNuD's feedback

* Change `NativeContext.Running` to a 32-bit integer

* Fix PageTable symbol for host mapped
2021-05-29 18:06:28 -03:00

100 lines
3.1 KiB
C#

using System;
namespace ARMeilleure.Translation.PTC
{
/// <summary>
/// Represents a symbol.
/// </summary>
struct Symbol
{
private readonly ulong _value;
/// <summary>
/// Gets the <see cref="SymbolType"/> of the <see cref="Symbol"/>.
/// </summary>
public SymbolType Type { get; }
/// <summary>
/// Gets the value of the <see cref="Symbol"/>.
/// </summary>
/// <exception cref="InvalidOperationException"><see cref="Type"/> is <see cref="SymbolType.None"/></exception>
public ulong Value
{
get
{
if (Type == SymbolType.None)
{
ThrowSymbolNone();
}
return _value;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Symbol"/> structure with the specified <see cref="SymbolType"/> and value.
/// </summary>
/// <param name="type">Type of symbol</param>
/// <param name="value">Value of symbol</param>
public Symbol(SymbolType type, ulong value)
{
(Type, _value) = (type, value);
}
/// <summary>
/// Determines if the specified <see cref="Symbol"/> instances are equal.
/// </summary>
/// <param name="a">First instance</param>
/// <param name="b">Second instance</param>
/// <returns><see langword="true"/> if equal; otherwise <see langword="false"/></returns>
public static bool operator ==(Symbol a, Symbol b)
{
return a.Equals(b);
}
/// <summary>
/// Determines if the specified <see cref="Symbol"/> instances are not equal.
/// </summary>
/// <param name="a">First instance</param>
/// <param name="b">Second instance</param>
/// <returns><see langword="true"/> if not equal; otherwise <see langword="false"/></returns>
/// <inheritdoc/>
public static bool operator !=(Symbol a, Symbol b)
{
return !(a == b);
}
/// <summary>
/// Determines if the specified <see cref="Symbol"/> is equal to this <see cref="Symbol"/> instance.
/// </summary>
/// <param name="other">Other <see cref="Symbol"/> instance</param>
/// <returns><see langword="true"/> if equal; otherwise <see langword="false"/></returns>
public bool Equals(Symbol other)
{
return other.Type == Type && other._value == _value;
}
/// <inheritdoc/>
public override bool Equals(object obj)
{
return obj is Symbol sym && Equals(sym);
}
/// <inheritdoc/>
public override int GetHashCode()
{
return HashCode.Combine(Type, _value);
}
/// <inheritdoc/>
public override string ToString()
{
return $"{Type}:{_value}";
}
private static void ThrowSymbolNone()
{
throw new InvalidOperationException("Symbol refers to nothing.");
}
}
}