Given memory should always be expected to be valid during normal
execution, this should be a debug assertion, rather than a check in
regular builds.

This was only ever public so that code could check whether or not a
handle was valid or not. Instead of exposing the object directly and
allowing external code to potentially mess with the map contents, we
just provide a member function that allows checking whether or not a
handle is valid.

This makes all member variables of the VMManager class private except
for the page table.

Perf: Call shrink_to_fit after page-table vector resizing to actually reduce vector capacity

Call shrink_to_fit after page-table vector resizing to cause crt to actually lower vector capacity. For 36-bit titles saves 800MB of commit.

Convert high-frequency LUT arrays from constexpr to static constexpr

In some constexpr functions, msvc is building the LUT at runtime
(pushing each element onto the stack) out of an abundance of caution. Moving the
arrays into be file-scoped constexpr's avoids this and turns the functions into
simple look-ups as intended.

file_sys: Implement open source system archives

yuzu/game_list_worker: Minor cleanup and code deduplication

Avoids potentially allocating a std::string instance when it isn't
needed.

file_sys/registered_cache: Eliminate variable shadowing

crypto/key_manager: Remove unused variable in GetTicketblob()

kernel/svc: Implement svcCreateEvent and svcSignalEvent

This function simply does a handle table lookup for a writable event
instance identified by the given handle value. If a writable event
cannot be found for the given handle, then an invalid handle error is
returned. If a writable event is found, then it simply signals the
event, as one would expect.

svcCreateEvent operates by creating both a readable and writable event
and then attempts to add both to the current process' handle table.

If adding either of the events to the handle table fails, then the
relevant error from the handle table is returned.

If adding the readable event after the writable event to the table
fails, then the writable event is removed from the handle table and the
relevant error from the handle table is returned.

Note that since we do not currently test resource limits, we don't check
the resource limit table yet.

loader/{nro, nso}: Remove dependency on the System class

kernel/object: Amend handle types to distinguish between readable and writable events

* Rewrited TEX/TEXS (TEX Scalar).

* Style fixes.

* Styles issues.

 kernel/svc: Implement the resource limit svcGetInfo option

Don't try to route PFIFO methods (0-0x40) to the other engines.

Two kernel object should absolutely never have the same handle ID type.
This can cause incorrect behavior when it comes to retrieving object
types from the handle table. In this case it allows converting a
WritableEvent into a ReadableEvent and vice-versa, which is undefined
behavior, since the object types are not the same.

This also corrects ClearEvent() to check both kernel types like the
kernel itself does.

Another hold-over from Citra.

Allows a process to register the resource limit as part of its handle
table.

This is a leftover from #1792

[Kernel::CreateThread] Match format specifiers to LOG_TRACE's arguments

svc: Reorganize svcGetInfo, handle more error cases for existing implemented info categories

yuzu/configuration: Minor clean-up related changes

filesystem: De-globalize registered_cache_union

gl_shader_decompiler: Introduce a scoped object and style changes

kernel: Divide Event into ReadableEvent and WritableEvent

service/fsp_srv: Implement CleanDirectoryRecursively

service/audio/audout_u: Amend constructor initialization list order

Fixed crash with SetNpadMode

hle/service: Update function tables for erpt:c and usb's IClientEpSession

Similar to the NRO changes, we can also pass the process explicitly as a
parameter from Load instead of indirecting through the System class.

This simply acts as a forwarding function for the Load() function, so
this doesn't need to be directly exposed.

Load() is already given the process instance as a parameter, so instead
of coupling the class to the System class, we can just forward that
parameter to LoadNro()

Updates the function table for IClientEpSession based off information
provided by SwitchBrew.