mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-20 15:48:43 +02:00
262 lines
9 KiB
C#
262 lines
9 KiB
C#
using ARMeilleure.Diagnostics;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace ARMeilleure.Common
|
|
{
|
|
/// <summary>
|
|
/// Represents a table of guest address to a value.
|
|
/// </summary>
|
|
/// <typeparam name="TEntry">Type of the value</typeparam>
|
|
unsafe class AddressTable<TEntry> : IDisposable where TEntry : unmanaged
|
|
{
|
|
/// <summary>
|
|
/// Represents a level in an <see cref="AddressTable{TEntry}"/>.
|
|
/// </summary>
|
|
public readonly struct Level
|
|
{
|
|
/// <summary>
|
|
/// Gets the index of the <see cref="Level"/> in the guest address.
|
|
/// </summary>
|
|
public int Index { get; }
|
|
|
|
/// <summary>
|
|
/// Gets the length of the <see cref="Level"/> in the guest address.
|
|
/// </summary>
|
|
public int Length { get; }
|
|
|
|
/// <summary>
|
|
/// Gets the mask which masks the bits used by the <see cref="Level"/>.
|
|
/// </summary>
|
|
public ulong Mask => ((1ul << Length) - 1) << Index;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="Level"/> structure with the specified
|
|
/// <paramref name="index"/> and <paramref name="length"/>.
|
|
/// </summary>
|
|
/// <param name="index">Index of the <see cref="Level"/></param>
|
|
/// <param name="length">Length of the <see cref="Level"/></param>
|
|
public Level(int index, int length)
|
|
{
|
|
(Index, Length) = (index, length);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the value of the <see cref="Level"/> from the specified guest <paramref name="address"/>.
|
|
/// </summary>
|
|
/// <param name="address">Guest address</param>
|
|
/// <returns>Value of the <see cref="Level"/> from the specified guest <paramref name="address"/></returns>
|
|
public int GetValue(ulong address)
|
|
{
|
|
return (int)((address & Mask) >> Index);
|
|
}
|
|
}
|
|
|
|
private bool _disposed;
|
|
private TEntry** _table;
|
|
private readonly List<IntPtr> _pages;
|
|
|
|
/// <summary>
|
|
/// Gets the bits used by the <see cref="Levels"/> of the <see cref="AddressTable{TEntry}"/> instance.
|
|
/// </summary>
|
|
public ulong Mask { get; }
|
|
|
|
/// <summary>
|
|
/// Gets the <see cref="Level"/>s used by the <see cref="AddressTable{TEntry}"/> instance.
|
|
/// </summary>
|
|
public Level[] Levels { get; }
|
|
|
|
/// <summary>
|
|
/// Gets or sets the default fill value of newly created leaf pages.
|
|
/// </summary>
|
|
public TEntry Fill { get; set; }
|
|
|
|
/// <summary>
|
|
/// Gets the base address of the <see cref="EntryTable{TEntry}"/>.
|
|
/// </summary>
|
|
/// <exception cref="ObjectDisposedException"><see cref="EntryTable{TEntry}"/> instance was disposed</exception>
|
|
public IntPtr Base
|
|
{
|
|
get
|
|
{
|
|
if (_disposed)
|
|
{
|
|
throw new ObjectDisposedException(null);
|
|
}
|
|
|
|
lock (_pages)
|
|
{
|
|
return (IntPtr)GetRootPage();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructs a new instance of the <see cref="AddressTable{TEntry}"/> class with the specified list of
|
|
/// <see cref="Level"/>.
|
|
/// </summary>
|
|
/// <exception cref="ArgumentNullException"><paramref name="levels"/> is null</exception>
|
|
/// <exception cref="ArgumentException">Length of <paramref name="levels"/> is less than 2</exception>
|
|
public AddressTable(Level[] levels)
|
|
{
|
|
if (levels == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(levels));
|
|
}
|
|
|
|
if (levels.Length < 2)
|
|
{
|
|
throw new ArgumentException("Table must be at least 2 levels deep.", nameof(levels));
|
|
}
|
|
|
|
_pages = new List<IntPtr>(capacity: 16);
|
|
|
|
Levels = levels;
|
|
Mask = 0;
|
|
|
|
foreach (var level in Levels)
|
|
{
|
|
Mask |= level.Mask;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Determines if the specified <paramref name="address"/> is in the range of the
|
|
/// <see cref="AddressTable{TEntry}"/>.
|
|
/// </summary>
|
|
/// <param name="address">Guest address</param>
|
|
/// <returns><see langword="true"/> if is valid; otherwise <see langword="false"/></returns>
|
|
public bool IsValid(ulong address)
|
|
{
|
|
return (address & ~Mask) == 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a reference to the value at the specified guest <paramref name="address"/>.
|
|
/// </summary>
|
|
/// <param name="address">Guest address</param>
|
|
/// <returns>Reference to the value at the specified guest <paramref name="address"/></returns>
|
|
/// <exception cref="ObjectDisposedException"><see cref="EntryTable{TEntry}"/> instance was disposed</exception>
|
|
/// <exception cref="ArgumentException"><paramref name="address"/> is not mapped</exception>
|
|
public ref TEntry GetValue(ulong address)
|
|
{
|
|
if (_disposed)
|
|
{
|
|
throw new ObjectDisposedException(null);
|
|
}
|
|
|
|
if (!IsValid(address))
|
|
{
|
|
throw new ArgumentException($"Address 0x{address:X} is not mapped onto the table.", nameof(address));
|
|
}
|
|
|
|
lock (_pages)
|
|
{
|
|
return ref GetPage(address)[Levels[^1].GetValue(address)];
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the leaf page for the specified guest <paramref name="address"/>.
|
|
/// </summary>
|
|
/// <param name="address">Guest address</param>
|
|
/// <returns>Leaf page for the specified guest <paramref name="address"/></returns>
|
|
private TEntry* GetPage(ulong address)
|
|
{
|
|
TEntry** page = GetRootPage();
|
|
|
|
for (int i = 0; i < Levels.Length - 1; i++)
|
|
{
|
|
ref Level level = ref Levels[i];
|
|
ref TEntry* nextPage = ref page[level.GetValue(address)];
|
|
|
|
if (nextPage == null)
|
|
{
|
|
ref Level nextLevel = ref Levels[i + 1];
|
|
|
|
nextPage = i == Levels.Length - 2 ?
|
|
(TEntry*)Allocate(1 << nextLevel.Length, Fill, leaf: true) :
|
|
(TEntry*)Allocate(1 << nextLevel.Length, IntPtr.Zero, leaf: false);
|
|
}
|
|
|
|
page = (TEntry**)nextPage;
|
|
}
|
|
|
|
return (TEntry*)page;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Lazily initialize and get the root page of the <see cref="AddressTable{TEntry}"/>.
|
|
/// </summary>
|
|
/// <returns>Root page of the <see cref="AddressTable{TEntry}"/></returns>
|
|
private TEntry** GetRootPage()
|
|
{
|
|
if (_table == null)
|
|
{
|
|
_table = (TEntry**)Allocate(1 << Levels[0].Length, fill: IntPtr.Zero, leaf: false);
|
|
}
|
|
|
|
return _table;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Allocates a block of memory of the specified type and length.
|
|
/// </summary>
|
|
/// <typeparam name="T">Type of elements</typeparam>
|
|
/// <param name="length">Number of elements</param>
|
|
/// <param name="fill">Fill value</param>
|
|
/// <param name="leaf"><see langword="true"/> if leaf; otherwise <see langword="false"/></param>
|
|
/// <returns>Allocated block</returns>
|
|
private IntPtr Allocate<T>(int length, T fill, bool leaf) where T : unmanaged
|
|
{
|
|
var size = sizeof(T) * length;
|
|
var page = (IntPtr)NativeAllocator.Instance.Allocate((uint)size);
|
|
var span = new Span<T>((void*)page, length);
|
|
|
|
span.Fill(fill);
|
|
|
|
_pages.Add(page);
|
|
|
|
TranslatorEventSource.Log.AddressTableAllocated(size, leaf);
|
|
|
|
return page;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Releases all resources used by the <see cref="AddressTable{TEntry}"/> instance.
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
Dispose(true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Releases all unmanaged and optionally managed resources used by the <see cref="AddressTable{TEntry}"/>
|
|
/// instance.
|
|
/// </summary>
|
|
/// <param name="disposing"><see langword="true"/> to dispose managed resources also; otherwise just unmanaged resouces</param>
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (!_disposed)
|
|
{
|
|
foreach (var page in _pages)
|
|
{
|
|
Marshal.FreeHGlobal(page);
|
|
}
|
|
|
|
_disposed = true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Frees resources used by the <see cref="AddressTable{TEntry}"/> instance.
|
|
/// </summary>
|
|
~AddressTable()
|
|
{
|
|
Dispose(false);
|
|
}
|
|
}
|
|
}
|