This condition was checking against the nominal thread priority, whereas
the kernel itself checks against the current priority instead. We were
also assigning the nominal priority, when we should be assigning
current_priority, which takes priority inheritance into account.

This can lead to the incorrect priority being assigned to a thread.

Given we recursively update the relevant threads, we don't need to go
through the whole mutex waiter list. This matches what the kernel does
as well (only accessing the first entry within the waiting list).

The kernel keeps the internal waiting list ordered by priority. This is
trivial to do with std::find_if followed by an insertion.

kernel: Make the address arbiter instance per-process 

service/service: Remove unncessary calls to c_str()

gl_rasterizer: Encapsulate sampler queries into methods

These can just be passed regularly, now that we use fmt instead of our
old logging system.

While we're at it, make the parameters to MakeFunctionString
std::string_views.

service/audio/hwopus: Move decoder state to its own class

kernel/scheduler: Pass in system instance in constructor

shader_ir: Remove "extras" from the MetaTexture

gl_rasterizer_cache: Create texture views for array discrepancies

audio_core/cubeb_sink: Convert _MSC_VER ifdefs to _WIN32

gl_rasterizer: Minor logger changes

core/settings: Log more setting values

 yuzu_cmd/config: Silent implicit cast warning 

This behavior also needs to be visible for MinGW builds as well.

kernel/hle_ipc: Convert std::shared_ptr IPC header instances to std::optional

video_core/gpu_thread: Silence a -Wreorder warning

video_core/gpu: Make GPU's destructor virtual

maxwell_to_vk: Initial implementation

dma_pusher: Store command_list_header by copy

Instead of holding a reference that will get invalidated by
dma_pushbuffer.pop(), hold it as a copy. This doesn't have any
performance cost since CommandListHeader is 8 bytes long.

There's no real need to use a shared lifetime here, since we don't
actually expose them to anything else. This is also kind of an
unnecessary use of the heap given the objects themselves are so small;
small enough, in fact that changing over to optionals actually reduces
the overall size of the HLERequestContext struct (818 bytes to 808
bytes).

For whatever bizarre reason, Apple only made a few of std::optional's
member functions available on newer SDK versions. Given we can't even
run yuzu on macOS, and we keep the builder around to ensure that it
always at least compiles on macOS, we can bump this up a version.

Now that we have the address arbiter extracted to its own class, we can
fix an innaccuracy with the kernel. Said inaccuracy being that there
isn't only one address arbiter. Each process instance contains its own
AddressArbiter instance in the actual kernel.

This fixes that and gets rid of another long-standing issue that could
arise when attempting to create more than one process.

Similar to how WaitForAddress was isolated to its own function, we can
also move the necessary conditional checking into the address arbiter
class itself, allowing us to hide the implementation details of it from
public use.

Rather than let the service call itself work out which function is the
proper one to call, we can make that a behavior of the arbiter itself,
so we don't need to directly expose those implementation details.

kernel/shared_memory: Get rid of the use of global accessor functions within Create()

This makes the class much more flexible and doesn't make performing
copies with classes that contain a bitfield member a pain.

Given BitField instances are only intended to be used within unions, the
fact the full storage value would be copied isn't a big concern (only
sizeof(union_type) would be copied anyways).

While we're at it, provide defaulted move constructors for consistency.

This function didn't have a definition, so we can remove it to prevent
accidentally attempting to use it.

Moves the data members to satisfy the order they're declared as in the
constructor initializer list.

Silences a -Wreorder warning.

Because of the recent separation of GPU functionality into sync/async
variants, we need to mark the destructor virtual to provide proper
destruction behavior, given we use the base class within the System
class.

Prior to this, it was undefined behavior whether or not the destructor
in the derived classes would ever execute.

web_browser: Add shortcut to Enter key to exit applet

kernel/client_session, kernel/server_session: Make data members private

yuzu: add a hotkey to switch between undocked and docked mode