kernel/thread: Actually remove the definition of ExitCurrentThread()

video_core: Refactor to use MemoryManager interface for all memory access.

memory: Simplify rasterizer cache operations.

Correct CNTPCT from using CPU Cycles to using Clock Cycles

This was intended to be removed in
51d7f6bf, but I guess I forgot to
actually save the file like a dingus.

CMakeLists: Remove now-unnecessary GCC special-casing

kernel/thread: Remove WaitCurrentThread_Sleep() and ExitCurrentThread()

# Conflicts:
#	src/video_core/engines/kepler_memory.cpp
#	src/video_core/engines/maxwell_3d.cpp
#	src/video_core/morton.cpp
#	src/video_core/morton.h
#	src/video_core/renderer_opengl/gl_global_cache.cpp
#	src/video_core/renderer_opengl/gl_global_cache.h
#	src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

gpu: Use host address for caching instead of guest address.

Puts the operation on global state in the same places as the rest of the
svc calls.

Rather than make a global accessor for this sort of thing. We can make
it a part of the thread interface itself. This allows getting rid of a
hidden global accessor in the kernel code.

Port citra-emu/citra#3924: "citra_qt: Settings (configuration) rework"

This issue has since been fixed in newer versions of Boost, so we don't
need to worry about this anymore.

video_core/morton: Miscellaneous changes

vk_sampler_cache: Implement a sampler cache

kernel/process: Remove use of global system accessors

gl_rasterizer: Use system instance passed from argument

renderer_opengl/gl_global_cache: Add missing override specifiers

kernel/server_port: Make data members private

core/hle/result: Tidy up the base error code result header.

Port various Citra changes to input_common, including deadzone support 

service/vi: Unstub GetDisplayService

video_core/texture: Fix up sampler lod bias

Co-Authored-By: ReinUsesLisp <reinuseslisp@airmail.cc>

Now that we pass in a reference to the system instance, we can utilize
it to eliminate the global accessors in Process-related code.

kernel: Make the address arbiter instance per-process 

service/service: Remove unncessary calls to c_str()

gl_rasterizer: Encapsulate sampler queries into methods

The previous code had some minor issues with it, really not a big deal,
but amending it is basically 'free', so I figured, "why not?".

With the standard container maps, when:

map[key] = thing;

is done, this can cause potentially undesirable behavior in certain
scenarios. In particular, if there's no value associated with the key,
then the map constructs a default initialized instance of the value
type.

In this case, since it's a std::shared_ptr (as a type alias) that is
the value type, this will construct a std::shared_pointer, and then
assign over it (with objects that are quite large, or actively heap
allocate this can be extremely undesirable).

We also make the function take the region by value, as we can avoid a
copy (and by extension with std::shared_ptr, a copy causes an atomic
reference count increment), in certain scenarios when ownership isn't a
concern (i.e. when ReserveGlobalRegion is called with an rvalue
reference, then no copy at all occurs). So, it's more-or-less a "free"
gain without many downsides.

Two of the functions here are overridden functions, so we can append
these specifiers to make it explicit.

With this, all kernel objects finally have all of their data members
behind an interface, making it nicer to reason about interactions with
other code (as external code no longer has the freedom to totally alter
internals and potentially messing up invariants).