This is a holdover from Citra that currently remains unused, so it can
be removed from the Thread interface.

Some objects declare their handle type as const, while others declare it
as constexpr. This makes the const ones constexpr for consistency, and
prevent unexpected compilation errors if these happen to be attempted to be
used within a constexpr context.

This doesn't modify instance state, so it can be made const.

The initial two words indicate a process ID. Also UnloadNro only
specifies one address, not two.

IDirectory's Read() function doesn't take any input parameters. It only
uses the output parameters that we already provide.

These indicate options that alter how a read/write is performed.

Currently we don't need to handle these, as the only one that seems to
be used is for writes, but all the custom options ever seem to do is
immediate flushing, which we already do by default.

These are holdovers from Citra.

We need to ensure dynarmic gets a valid pointer if the page table is
resized (the relevant pointers would be invalidated in this scenario).

In this scenario, the page table can be resized depending on what kind
of address space is specified within the NPDM metadata (if it's
present).

Adjusts the interface of the wrappers to take a system reference, which
allows accessing a system instance without using the global accessors.

This also allows getting rid of all global accessors within the
supervisor call handling code. While this does make the wrappers
themselves slightly more noisy, this will be further cleaned up in a
follow-up. This eliminates the global system accessors in the current
code while preserving the existing interface.

These are holdovers from Citra and can be removed.

Now that nothing actually touches the internal page table aside from the
memory subsystem itself, we can remove the accessor to it.

Given the page table will always be guaranteed to be that of whatever
the current process is, we no longer need to keep this around.

Centralizes the page table switching to one spot, rather than making
calling code deal with it everywhere.

Keeps the return type consistent with the function name. While we're at
it, we can also reduce the amount of boilerplate involved with handling
these by using structured bindings.

Returns the same type that the function name describes.

This is a hold over from the 3DS error codes in Citra.

BitField has been trivially copyable since
e99a1486, so we can eliminate these
TODO comments and use ReadObject() directly instead of memcpying the
data.

enum class elements from the same enum can already be compared against
one another without the need for explicitly defined comparison
operators.

The given string instance doesn't need to be copied entirely, we can
just use a view instead.

Passing around a 64 byte data struct by value is kind of wasteful,
instead pass a reference to the struct.

The unknown member here is actually padding due to being passed as a
struct. We can do the same, and remove the need to pop a padding word.

I realized that I updated the documentation on SwitchBrew a while ago,
but never actually updated the structs within yuzu.

Rather than make a full copy of the path, we can just use a string view
and truncate the viewed portion of the string instead of creating a totally
new truncated string.

In several places, we have request parsers where there's nothing to
really parse, simply because the HLE function in question operates on
buffers. In these cases we can just remove these instances altogether.

In the other cases, we can retrieve the relevant members from the parser
and at least log them out, giving them some use.

Applies the override specifier where applicable. In the case of
destructors that are  defaulted in their definition, they can
simply be removed.

This also removes the unnecessary inclusions being done in audin_u and
audrec_u, given their close proximity.

Quite a bit of these were out of sync with Switchbrew (and in some cases
entirely wrong). While we're at it, also expand the section of named
members. A segment within the control metadata is used to specify
maximum values for the user, device, and cache storage max sizes and
journal sizes.

These appear to be generally used by the am service (e.g. in
CreateCacheStorage, etc).

We need to be checking whether or not the given address is within the
kernel address space or if the given address isn't word-aligned and bail
in these scenarios instead of trashing any kernel state.

For whatever reason, shared memory was being used here instead of
transfer memory, which (quite clearly) will not work based off the name
of the function.

This corrects this wonky usage of shared memory.

Also amend erroneous use of size_t. We should be using u64 here.

Given server sessions can be given a name, we should allow retrieving
it instead of using the default implementation of GetName(), which would
just return "[UNKNOWN KERNEL OBJECT]".

The AddressArbiter type isn't actually used, given the arbiter itself
isn't a direct kernel object (or object that implements the wait object
facilities).

Given this, we can remove the enum entry entirely.

Similarly like svcGetProcessList, this retrieves the list of threads
from the current process. In the kernel itself, a process instance
maintains a list of threads, which are used within this function.

Threads are registered to a process' thread list at thread
initialization, and unregistered from the list upon thread destruction
(if said thread has a non-null owning process).

We assert on the debug event case, as we currently don't implement
kernel debug objects.

This service function simply copies out a specified number of kernel
process IDs, while simultaneously reporting the total number of
processes.

Now that ShouldWait() is a const qualified member function, this one can
be made const qualified as well, since it can handle passing a const
qualified this pointer to ShouldWait().

Given this is intended as a querying function, it doesn't make sense to
allow the implementer to modify the state of the given thread.

Previously this was performing a u64 + int sign conversion. When dealing
with addresses, we should generally be keeping the arithmetic in the
same signedness type.

This also gets rid of the static lifetime of the constant, as there's no
need to make a trivial type like this potentially live for the entire
duration of the program.

The pointed to member is never actually modified, so it can be made
const.

This doesn't really provide any benefit to the resource limit interface.
There's no way for callers to any of the service functions for resource
limits to provide a custom name, so all created instances of resource
limits other than the system resource limit would have a name of
"Unknown".

The system resource limit itself is already trivially identifiable from
its limit values, so there's no real need to take up space in the object to
identify one object meaningfully out of N total objects.