using ARMeilleure.IntermediateRepresentation;

using ARMeilleure.Memory;

using ARMeilleure.State;

using System;

using System.Collections.Generic;

using System.Reflection;

public IMemoryManager Memory { get; }

public EntryTable<uint> CountTable { get; }

public AddressTable<ulong> FunctionTable { get; }

public TranslatorStubs Stubs { get; }

public ulong EntryAddress { get; }

public bool HighCq { get; }

public Aarch32Mode Mode { get; }

private int _ifThenBlockStateIndex = 0;

TranslatorStubs stubs,

ulong entryAddress,

bool highCq,

Aarch32Mode mode)

{

Memory = memory;

CountTable = countTable;

FunctionTable = funcTable;

Stubs = stubs;

EntryAddress = entryAddress;

HighCq = highCq;

Mode = mode;

_labels = new Dictionary<ulong, Operand>();

namespace ARMeilleure.Translation.PTC

{

{

private const string OuterHeaderMagicString = "PTCohd\0\0";

private const string InnerHeaderMagicString = "PTCihd\0\0";

private const string TitleIdTextDefault = "0000000000000000";

private const string DisplayVersionDefault = "0";

private const byte FillingByte = 0x00;

private const CompressionLevel SaveCompressionLevel = CompressionLevel.Fastest;

// Carriers.

// Progress reporting helpers.

{

InitializeCarriers();

_outerHeaderMagic = BinaryPrimitives.ReadUInt64LittleEndian(EncodingCache.UTF8NoBOM.GetBytes(OuterHeaderMagicString).AsSpan());

Disable();

}

{

Wait();

Logger.Info?.Print(LogClass.Ptc, $"Initializing Profiled Persistent Translation Cache (enabled: {enabled}).");

CachePathBackup = Path.Combine(workPathBackup, DisplayVersion);

PreLoad();

Enable();

}

{

_infosStream = new MemoryStream();

_codesList = new List<byte[]>();

_unwindInfosStream = new MemoryStream();

}

{

_infosStream.Dispose();

_codesList.Clear();

_unwindInfosStream.Dispose();

}

{

return _infosStream.Length == 0L && _codesList.Count == 0 && _relocsStream.Length == 0L && _unwindInfosStream.Length == 0L;

}

{

if (AreCarriersEmpty())

{

InitializeCarriers();

}

{

string fileNameActual = string.Concat(CachePathActual, ".cache");

string fileNameBackup = string.Concat(CachePathBackup, ".cache");

}

}

{

using (FileStream compressedStream = new(fileName, FileMode.Open))

using (DeflateStream deflateStream = new(compressedStream, CompressionMode.Decompress, true))

return true;

}

{

compressedStream.SetLength(0L);

}

{

_waitEvent.Reset();

_waitEvent.Set();

}

{

int translatedFuncsCount;

}

}

{

if (AreCarriersEmpty())

{

bool isEntryChanged = infoEntry.Hash != ComputeHash(translator.Memory, infoEntry.Address, infoEntry.GuestSize);

{

infoEntry.Stubbed = true;

infoEntry.CodeLength = 0;

Logger.Info?.Print(LogClass.Ptc, $"{translator.Functions.Count} translated functions loaded");

}

{

return _codesList.Count;

}

[Conditional("DEBUG")]

{

Debug.Assert(_codesList[index].Length == 0);

Debug.Assert(codeLength == 0);

}

{

_relocsStream.Seek(relocEntriesCount * RelocEntry.Stride, SeekOrigin.Current);

}

{

int pushEntriesLength = unwindInfosReader.ReadInt32();

_unwindInfosStream.Seek(pushEntriesLength * UnwindPushEntry.Stride + UnwindInfo.Stride, SeekOrigin.Current);

}

{

Debug.Assert(_codesList[index].Length == codeLength);

return _codesList[index];

}

{

RelocEntry[] relocEntries = new RelocEntry[relocEntriesCount];

return relocEntries;

}

{

callCounter = null;

}

}

{

int pushEntriesLength = unwindInfosReader.ReadInt32();

return new UnwindInfo(pushEntries, prologueSize);

}

byte[] code,

Counter<uint> callCounter,

ulong guestSize,

return new TranslatedFunction(gFunc, callCounter, guestSize, highCq);

}

{

_infosStream.Seek(-Unsafe.SizeOf<InfoEntry>(), SeekOrigin.Current);

SerializeStructure(_infosStream, infoEntry);

}

{

_codesList[index] = Array.Empty<byte>();

}

{

for (int i = 0; i < relocEntriesCount * RelocEntry.Stride; i++)

{

}

}

{

int pushEntriesLength = unwindInfosReader.ReadInt32();

}

}

{

_translateCount = 0;

_translateTotalCount = profiledFuncsToTranslate.Count;

{

ulong address = item.address;

TranslatedFunction func = translator.Translate(address, item.funcProfile.Mode, item.funcProfile.HighCq);

preSaveThread.Start();

}

{

const int refreshRate = 50; // ms.

while (!endEvent.WaitOne(refreshRate));

}

{

return XXHash128.ComputeHash(memory.GetSpan(address, checked((int)(guestSize))));

}

{

lock (_lock)

{

}

}

{

_codesList.Add(code.ToArray());

}

{

return BitConverter.IsLittleEndian;

}

(uint)HardwareCapabilities.FeatureInfo7Ecx);

}

{

return (byte)_memoryMode;

}

public int RelocEntriesCount;

}

{

State = PtcState.Enabled;

}

{

if (State == PtcState.Enabled)

{

}

}

{

if (State == PtcState.Enabled ||

State == PtcState.Continuing)

}

}

{

State = PtcState.Disabled;

}

{

_waitEvent.WaitOne();

}

{

if (!_disposed)

{

namespace ARMeilleure.Translation.PTC

{

{

private const string OuterHeaderMagicString = "Pohd\0\0\0\0";

private const CompressionLevel SaveCompressionLevel = CompressionLevel.Fastest;

{

_timer = new System.Timers.Timer((double)SaveInterval * 1000d);

_timer.Elapsed += PreSave;

Enabled = false;

}

{

if (IsAddressInStaticCodeRange(address))

{

}

}

{

if (IsAddressInStaticCodeRange(address))

{

}

}

{

return address >= StaticCodeStart && address < StaticCodeStart + StaticCodeSize;

}

{

var profiledFuncsToTranslate = new ConcurrentQueue<(ulong address, FuncProfile funcProfile)>();

return profiledFuncsToTranslate;

}

{

ProfiledFuncs.Clear();

ProfiledFuncs.TrimExcess();

}

{

_lastHash = default;

FileInfo fileInfoActual = new FileInfo(fileNameActual);

FileInfo fileInfoBackup = new FileInfo(fileNameBackup);

}

}

{

using (FileStream compressedStream = new(fileName, FileMode.Open))

using (DeflateStream deflateStream = new(compressedStream, CompressionMode.Decompress, true))

return DeserializeDictionary<ulong, FuncProfile>(stream, (stream) => DeserializeStructure<FuncProfile>(stream));

}

{

return new(memoryStream.GetBuffer(), (int)memoryStream.Position, (int)memoryStream.Length - (int)memoryStream.Position);

}

{

compressedStream.SetLength(0L);

}

{

_waitEvent.Reset();

FileInfo fileInfoActual = new FileInfo(fileNameActual);

_waitEvent.Set();

}

{

int profiledFuncsCount;

}

}

{

SerializeDictionary(stream, profiledFuncs, (stream, structure) => SerializeStructure(stream, structure));

}

}

[StructLayout(LayoutKind.Sequential, Pack = 1/*, Size = 5*/)]

{

public ExecutionMode Mode;

public bool HighCq;

}

}

{

{

Enabled = true;

}

}

{

Enabled = false;

}

}

{

_waitEvent.WaitOne();

}

{

if (!_disposed)

{

private readonly IJitMemoryAllocator _allocator;

private readonly ConcurrentQueue<KeyValuePair<ulong, TranslatedFunction>> _oldFuncs;

internal TranslatorCache<TranslatedFunction> Functions { get; }

internal AddressTable<ulong> FunctionTable { get; }

internal EntryTable<uint> CountTable { get; }

_oldFuncs = new ConcurrentQueue<KeyValuePair<ulong, TranslatedFunction>>();

Queue = new TranslatorQueue();

JitCache.Initialize(allocator);

}

}

public void Execute(State.ExecutionContext context, ulong address)

{

if (Interlocked.Increment(ref _threadCount) == 1)

{

IsReadyForTranslation.WaitOne();

{

Debug.Assert(Functions.Count == 0);

}

// Simple heuristic, should be user configurable in future. (1 for 4 core/ht or less, 2 for 6 core + ht

// etc). All threads are normal priority except from the last, which just fills as much of the last core

Stubs.Dispose();

FunctionTable.Dispose();

CountTable.Dispose();

}

}

func = oldFunc;

}

{

}

RegisterFunction(address, func);

Stubs,

address,

highCq,

mode: Aarch32Mode.User);

Logger.StartPass(PassName.Decoding);

{

Hash128 hash = Ptc.ComputeHash(Memory, address, funcSize);

}

GuestFunction func = compiledFunc.Map<GuestFunction>();

return func;

});

{

}

RegisterFunction(request.Address, func);

using ARMeilleure.Translation;

using Avalonia.Input;

using Avalonia.Threading;

using LibHac.Tools.FsSystem;

_parent.Title = $"Ryujinx {Program.Version}{titleNameSection}{titleVersionSection}{titleIdSection}{titleArchSection}";

});

Renderer.SizeChanged += Window_SizeChanged;

DisplaySleep.Restore();

NpadManager.Dispose();

TouchScreenManager.Dispose();

Device.Dispose();

if (_keyboardInterface.GetKeyboardStateSnapshot().IsPressed(Key.Delete) && _parent.WindowState != WindowState.FullScreen)

{

}

});

}

using Avalonia;

using Avalonia.Threading;

using Ryujinx.Ava.UI.Windows;

private static void ProcessUnhandledException(Exception ex, bool isTerminating)

{

string message = $"Unhandled exception caught: {ex}";

Logger.Error?.PrintMsg(LogClass.Application, message);

{

DiscordIntegrationModule.Exit();

Logger.Shutdown();

}

}

using Avalonia;

using Avalonia.Controls;

using Avalonia.Input;

using Ryujinx.Common;

using Ryujinx.Common.Configuration;

using Ryujinx.Common.Logging;

using Ryujinx.HLE;

using Ryujinx.HLE.FileSystem;

using Ryujinx.HLE.HOS;

{

ApplicationLibrary.ApplicationCountUpdated += ApplicationLibrary_ApplicationCountUpdated;

ApplicationLibrary.ApplicationAdded += ApplicationLibrary_ApplicationAdded;

}

public string SearchText

OnPropertyChanged();

}

}

public bool ShowMenuAndStatusBar

{

get => _showMenuAndStatusBar;

}

}

{

emulationContext.Gpu.ShaderCacheStateChanged -= ProgressHandler;

emulationContext.Gpu.ShaderCacheStateChanged += ProgressHandler;

}

switch (state)

{

CacheLoadStatus = $"{current} / {total}";

switch (ptcState)

{

LoadHeading = LocaleManager.Instance[LocaleKeys.CompilingPPTC];

IsLoadingIndeterminate = false;

break;

LoadHeading = string.Format(LocaleManager.Instance[LocaleKeys.LoadingHeading], TitleName);

IsLoadingIndeterminate = true;

CacheLoadStatus = "";

DirectoryInfo backupDir = new(Path.Combine(AppDataManager.GamesDirPath, selection.TitleId, "cache", "cpu", "1"));

// FIXME: Found a way to reproduce the bold effect on the title name (fork?).

string.Format(LocaleManager.Instance[LocaleKeys.DialogPPTCDeletionMessage], selection.TitleName),

LocaleManager.Instance[LocaleKeys.InputDialogYes],

LocaleManager.Instance[LocaleKeys.InputDialogNo],

/// <param name="address">Address of the region to be invalidated</param>

/// <param name="size">Size of the region to be invalidated</param>

void InvalidateCacheRegion(ulong address, ulong size);

}

}

{

_translator.InvalidateJitCacheRegion(address, size);

}

}

}

using LibHac;

using LibHac.Account;

using LibHac.Common;

using LibHac.Tools.FsSystem.NcaUtils;

using Ryujinx.Common.Configuration;

using Ryujinx.Common.Logging;

using Ryujinx.HLE.FileSystem;

using Ryujinx.HLE.Loaders.Executables;

using Ryujinx.Memory;

using System;

public string TitleIdText => TitleId.ToString("x16");

public ApplicationLoader(Switch device)

{

_device = device;

EnsureSaveData(new ApplicationId(TitleId));

}

}

public static (Nca main, Nca patch, Nca control) GetGameData(VirtualFileSystem fileSystem, PartitionFileSystem pfs, int programIndex)

public void LoadServiceNca(string ncaFile)

{

FileStream file = new FileStream(ncaFile, FileMode.Open, FileAccess.Read);

Nca mainNca = new Nca(_device.Configuration.VirtualFileSystem.KeySet, file.AsStorage(false));

// Collect the nsos, ignoring ones that aren't used.

NsoExecutable[] programs = nsos.Where(x => x != null).ToArray();

metaData.GetNpdm(out Npdm npdm).ThrowIfFailure();

string titleIdText = npdm.Aci.Value.ProgramId.Value.ToString("x16");

bool titleIs64Bit = (npdm.Meta.Value.Flags & 1) != 0;

_device.Configuration.VirtualFileSystem.ModLoader.GetModsBasePath(),

_device.Configuration.VirtualFileSystem.ModLoader.GetSdModsBasePath());

if (controlNca != null)

{

}

else

{

string dummyTitleName = "";

BlitStruct<ApplicationControlProperty> dummyControl = new BlitStruct<ApplicationControlProperty>(1);

}

if (dataStorage == null)

{

Logger.Warning?.Print(LogClass.Loader, "No RomFS found in NCA");

EnsureSaveData(new ApplicationId(TitleId & ~0xFul));

}

Logger.Info?.Print(LogClass.Loader, $"Application Loaded: {TitleName} v{DisplayVersion} [{TitleIdText}] [{(TitleIs64Bit ? "64-bit" : "32-bit")}]");

}

}

}

{

if (_device.Configuration.VirtualFileSystem.ModLoader.ReplaceExefsPartition(TitleId, ref codeFs))

{

memoryManagerMode = MemoryManagerMode.SoftwarePageTable;

}

// We allow it for nx-hbloader because it can be used to launch homebrew.

bool allowCodeMemoryForJit = TitleId == 0x010000000000100DUL || isHomebrew;

metaData.GetNpdm(out Npdm npdm).ThrowIfFailure();

}

public void LoadProgram(string filePath)

{

MetaLoader metaData = GetDefaultNpdm();

metaData.GetNpdm(out Npdm npdm).ThrowIfFailure();

bool isNro = Path.GetExtension(filePath).ToLower() == ".nro";

Graphics.Gpu.GraphicsConfig.TitleId = null;

_device.Gpu.HostInitalized.Set();

}

private MetaLoader GetDefaultNpdm()

namespace Ryujinx.HLE.HOS

{

{

private readonly ulong _pid;

private readonly GpuContext _gpuContext;

_cpuContext.Execute(context, codeAddress);

}

public void InvalidateCacheRegion(ulong address, ulong size)

{

_cpuContext.InvalidateCacheRegion(address, size);

{

private readonly ICpuEngine _cpuEngine;

private readonly GpuContext _gpu;

{

_cpuEngine = cpuEngine;

_gpu = gpu;

}

public IProcessContext Create(KernelContext context, ulong pid, ulong addressSpaceSize, InvalidAccessHandler invalidAccessHandler, bool for64Bit)

mode = MemoryManagerMode.SoftwarePageTable;

}

switch (mode)

{

case MemoryManagerMode.SoftwarePageTable:

var memoryManager = new MemoryManager(context.Memory, addressSpaceSize, invalidAccessHandler);

case MemoryManagerMode.HostMapped:

case MemoryManagerMode.HostMappedUnsafe:

bool unsafeMode = mode == MemoryManagerMode.HostMappedUnsafe;

var memoryManagerHostMapped = new MemoryManagerHostMapped(context.Memory, addressSpaceSize, unsafeMode, invalidAccessHandler);

default:

throw new ArgumentOutOfRangeException();

}

}

}

}

using LibHac.Loader;

using LibHac.Ncm;

using LibHac.Util;

using Ryujinx.Common;

using Ryujinx.Common.Logging;

using Ryujinx.HLE.HOS.Kernel;

using Ryujinx.HLE.HOS.Kernel.Common;

using Ryujinx.HLE.HOS.Kernel.Memory;

{

public string Name;

public ulong ProgramId;

{

Name = StringUtils.Utf8ZToString(npdm.Meta.Value.ProgramName);

AllowCodeMemoryForJit = allowCodeMemoryForJit;

}

}

static class ProgramLoader

{

private const bool AslrEnabled = true;

KProcess process = new KProcess(context);

result = process.InitializeKip(

creationInfo,

return true;

}

KernelContext context,

MetaLoader metaData,

ProgramInfo programInfo,

byte[] arguments = null,

if (rc.IsFailure())

{

}

ref readonly var meta = ref npdm.Meta.Value;

}

}

int codePagesCount = (int)(codeSize / KPageTableBase.PageSize);

int personalMmHeapPagesCount = (int)(meta.SystemResourceSize / KPageTableBase.PageSize);

{

Logger.Error?.Print(LogClass.Loader, $"Process initialization failed setting resource limit values.");

}

KProcess process = new KProcess(context, programInfo.AllowCodeMemoryForJit);

{

Logger.Error?.Print(LogClass.Loader, $"Process initialization failed due to invalid ACID flags.");

}

result = process.Initialize(

creationInfo,

{

Logger.Error?.Print(LogClass.Loader, $"Process initialization returned error \"{result}\".");

}

for (int index = 0; index < executables.Length; index++)

{

Logger.Error?.Print(LogClass.Loader, $"Process initialization returned error \"{result}\".");

}

}

{

Logger.Error?.Print(LogClass.Loader, $"Process start returned error \"{result}\".");

}

context.Processes.TryAdd(process.Pid, process);

// Keep the build ids because the tamper machine uses them to know which process to associate a

// tamper to and also keep the starting address of each executable inside a process because some

// memory modifications are relative to this address.

}

private static Result LoadIntoMemory(KProcess process, IExecutable image, ulong baseAddress)

using ARMeilleure.Translation;

using CommandLine;

using LibHac.Tools.FsSystem;

using Ryujinx.Audio.Backends.SDL2;

using Ryujinx.Common.Logging;

using Ryujinx.Common.SystemInterop;

using Ryujinx.Common.Utilities;

using Ryujinx.Graphics.GAL;

using Ryujinx.Graphics.GAL.Multithreading;

using Ryujinx.Graphics.Gpu;

private static void SetupProgressHandler()

{

_emulationContext.Gpu.ShaderCacheStateChanged -= ProgressHandler;

_emulationContext.Gpu.ShaderCacheStateChanged += ProgressHandler;

switch (state)

{

label = $"PTC : {current}/{total}";

break;

case ShaderCacheState shaderCacheState:

_window.Execute();

_emulationContext.Dispose();

_window.Dispose();

using Gtk;

using Ryujinx.Common;

using Ryujinx.Common.Configuration;

private static void ProcessUnhandledException(Exception ex, bool isTerminating)

{

string message = $"Unhandled exception caught: {ex}";

Logger.Error?.PrintMsg(LogClass.Application, message);

{

DiscordIntegrationModule.Exit();

Logger.Shutdown();

}

}

using ARMeilleure.Translation;

using Gtk;

using LibHac.Common;

using LibHac.Common.Keys;

using Ryujinx.Common.Configuration;

using Ryujinx.Common.Logging;

using Ryujinx.Common.SystemInterop;

using Ryujinx.Graphics.GAL;

using Ryujinx.Graphics.GAL.Multithreading;

using Ryujinx.Graphics.OpenGL;

using System.Threading.Tasks;

using GUI = Gtk.Builder.ObjectAttribute;

using ShaderCacheLoadingState = Ryujinx.Graphics.Gpu.Shader.ShaderCacheState;

namespace Ryujinx.Ui

private void SetupProgressUiHandlers()

{

_emulationContext.Gpu.ShaderCacheStateChanged -= ProgressHandler;

_emulationContext.Gpu.ShaderCacheStateChanged += ProgressHandler;

switch (state)

{

label = $"PTC : {current}/{total}";

break;

case ShaderCacheLoadingState shaderCacheState:

UpdateGraphicsConfig();

SystemVersion firmwareVersion = _contentManager.GetCurrentFirmwareVersion();

bool isDirectory = Directory.Exists(path);

return;

}

_currentEmulatedGamePath = path;

_deviceExitStatus.Reset();

RendererWidget.Start();

_emulationContext.Dispose();

_deviceExitStatus.Set();

using ARMeilleure.Translation;

using Gdk;

using Gtk;

using Ryujinx.Common;

_gpuCancellationTokenSource.Cancel();

_isStopped = true;

if (_isActive)

{

_isActive = false;

{

if (!ParentWindow.State.HasFlag(WindowState.Fullscreen))

{

}

}

});