yuzu/bootmanager: Resolve constructor initializer list warnings

kernel/svc: Name supervisor call 0x36

core: Reorganize boot order

This call was added to the SVC handlers in the 8.0.0 kernel, so we can
finally give it a name.

kernel/thread: Remove unused guest_handle member variable

gl_sampler_cache: Port sampler cache to OpenGL

Implement Bindless Textures on Shader Decompiler and GL backend

The default constructor will always run, even when not specified, so
this is redundant.

However, the context member can indeed be initialized in the constructor
initializer list.

This include isn't used anymore so it can be removed.

Resolves -Wreorder warnings. These will automatically be initialized to
nullptr anyways, so these were redundant.

shader_ir/decode: Reduce the severity of common assertions

gl_rasterizer: Apply just the needed state on Clear

CMakeLists: Define QT_USE_QSTRINGBUILDER for the Qt target

shader/memory: Implement STG and global memory flushing

yuzu/configure_hotkey: Minor changes

common/{lz4_compression, zstd_compression}: Add missing header guards

service: Update service function tables

kernel/svc: Implement svcMapProcessCodeMemory/svcUnmapProcessCodeMemory

kernel/thread: Remove BoostPriority()

Correct Pitch in Fermi2D

This is a compile definition introduced in Qt 4.8 for reducing the total
potential number of strings created when performing string
concatenation. This allows for less memory churn.

This can be read about here:
https://blog.qt.io/blog/2011/06/13/string-concatenation-with-qstringbuilder/

For a change that isn't source-compatible, we only had one occurrence
that actually need to have its type clarified, which is pretty good, as
far as transitioning goes.

Allows the handle to be seen alongside the entry point.

These two files were missing the #pragma once directive.

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

This member variable is entirely unused. It was only set but never
actually utilized. Given that, we can remove it to get rid of noise in
the thread interface.

ldr: Minor amendments to IPC-related parameters

Set Pixel Format to Z32 if its R32F and depth compare enabled, and Implement format ZF32_X24S8

Add a toggle to force 30FPS mode

fsp_srv: Minor cleanup related changes

gl_shader_manager: Move code to source file and minor clean up

Frontend: Migrate to QOpenGLWindow and support shared contexts

ui_settings: Rename game directory variables

Essentially performs the inverse of svcMapProcessCodeMemory. This unmaps
the aliasing region first, then restores the general traits of the
aliased memory.

What this entails, is:

- Restoring Read/Write permissions to the VMA.
- Restoring its memory state to reflect it as a general heap memory region.
- Clearing the memory attributes on the region.

This is utilized for mapping code modules into memory. Notably, the
ldr service would call this in order to map objects into memory.

common/scope_exit: Replace std::move with std::forward in ScopeExit()

common/swap: Minor cleanup and improvements to byte swapping functions

Uses arithmetic that can be identified more trivially by compilers for
optimizations. e.g. Rather than shifting the halves of the value and
then swapping and combining them, we can swap them in place.

e.g. for the original swap32 code on x86-64, clang 8.0 would generate:

    mov     ecx, edi
    rol     cx, 8
    shl     ecx, 16
    shr     edi, 16
    rol     di, 8
    movzx   eax, di
    or      eax, ecx
    ret

while GCC 8.3 would generate the ideal:

    mov     eax, edi
    bswap   eax
    ret

now both generate the same optimal output.

MSVC used to generate the following with the old code:

    mov     eax, ecx
    rol     cx, 8
    shr     eax, 16
    rol     ax, 8
    movzx   ecx, cx
    movzx   eax, ax
    shl     ecx, 16
    or      eax, ecx
    ret     0

Now MSVC also generates a similar, but equally optimal result as clang/GCC:

    bswap   ecx
    mov     eax, ecx
    ret     0

====

In the swap64 case, for the original code, clang 8.0 would generate:

    mov     eax, edi
    bswap   eax
    shl     rax, 32
    shr     rdi, 32
    bswap   edi
    or      rax, rdi
    ret

(almost there, but still missing the mark)

while, again, GCC 8.3 would generate the more ideal:

    mov     rax, rdi
    bswap   rax
    ret

now clang also generates the optimal sequence for this fallback as well.

This is a case where MSVC unfortunately falls short, despite the new
code, this one still generates a doozy of an output.

    mov     r8, rcx
    mov     r9, rcx
    mov     rax, 71776119061217280
    mov     rdx, r8
    and     r9, rax
    and     edx, 65280
    mov     rax, rcx
    shr     rax, 16
    or      r9, rax
    mov     rax, rcx
    shr     r9, 16
    mov     rcx, 280375465082880
    and     rax, rcx
    mov     rcx, 1095216660480
    or      r9, rax
    mov     rax, r8
    and     rax, rcx
    shr     r9, 16
    or      r9, rax
    mov     rcx, r8
    mov     rax, r8
    shr     r9, 8
    shl     rax, 16
    and     ecx, 16711680
    or      rdx, rax
    mov     eax, -16777216
    and     rax, r8
    shl     rdx, 16
    or      rdx, rcx
    shl     rdx, 16
    or      rax, rdx
    shl     rax, 8
    or      rax, r9
    ret     0

which is pretty unfortunate.