Makes it more evident that one is for actual code and one is for actual
data. Mutable and static are less than ideal terms here, because
read-only data is technically not mutable, but we were mapping it with
that label.

This should actually be using the data flags, rather than the code
flags.

Introduced as a result of #2090, we already define the copy constructor
further down below, so this isn't needed.

When #2247 was created, thread_queue_list.h was the only user of
boost-related code, however #2252 moved the page table struct into
common, which makes use of Boost.ICL, so we need to add the dependency
to the common library's link interface again.

The segment itself isn't actually modified.

Given this is utilized by the loaders, this allows avoiding inclusion of
the kernel process definitions where avoidable.

This also keeps the loading format for all executable data separate from
the kernel objects.

Given the class is now currently unused, it can be removed.

Neither the NRO or NSO loaders actually make use of the functions or
members provided by the Linker interface, so we can just remove the
inheritance altogether.

While we're at it, give each entry some documentation.

In both cases, we weren't actually returning anything, which is
undefined behavior.

Just makes the definitions a little bit more tidy.

This just acts as a basic setter for a given PID value and performs no
further checking, so we can just store the passed in value.

All this does is supply a new volume level and a fade time in
nanoseconds for the volume transition to occur within.

Like the other volume setter, this mainly just sets a data member within
the service, nothing too special.

This function passes in the desired main applet and library applet
volume levels. We can then just pass those values back within the
relevant volume getter functions, allowing us to unstub those as well.

The initial values for the library and main applet volumes differ. The
main applet volume is 0.25 by default, while the library applet volume
is initialized to 1.0 by default in the services themselves.

We don't need to universally capture by reference. We specifically just
need to capture the this pointer.

Specifying the time unit itself is sufficient here.

Certain values that are passed through the IPC buffer are actually
floating point values, not solely integral values.

We really don't need to pull in several headers of boost related
machinery just to perform the erase-remove idiom (particularly with
C++20 around the corner, which adds universal container std::erase and
std::erase_if, which we can just use instead).

With this, we don't need to link in anything boost-related into common.

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

# 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

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.

Aims to disambiguate why each priority instance exists a little bit.
While we're at it, also add an explanatory comment to UpdatePriority().

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.