Makes our immutable state explicit.

These two variables correspond to address ranges.

Given there's no implementation, we may as well remove the code
entirely.

These source files were entirely unused throughout the rest of the
codebase. This also has the benefit of getting rid of a global variable
as well.

Removes unnecessary direct dependencies in some headers and also gets
rid of indirect dependencies that were being relied on to be included.

Instead, we can just expose functions that return the queryable state
instead of letting anything modify it.

The loop's induction variable was signed, but we were comparing against
an unsigned variable.

Provides slightly more context than only logging out the address value.

The pointed to thread's members are simply observed in this case, so we
don't need to copy it here.

This is just an unused hold-over from citra, so we can get rid of this
to trim off an exposed global, among other things.

This is a holdover from citra that's essentially unused.

Note that there's currently a dynarmic bug preventing this register from being written.

Makes the thread status strongly typed, so implicit conversions can't
happen. It also makes it easier to catch mistakes at compile time.

This introduces a slightly more generic variant of WriteBuffer().
Notably, this variant doesn't constrain the arguments to only accepting
std::vector instances. It accepts whatever adheres to the
ContiguousContainer concept in the C++ standard library.

This essentially means, std::array, std::string, and std::vector can be
used directly with this interface. The interface no longer forces you to
solely use containers that dynamically allocate.

To ensure our overloads play nice with one another, we only enable the
container-based WriteBuffer if the argument is not a pointer, otherwise
we fall back to the pointer-based one.

The reason this would never be true is that ideal_processor is a u8 and
THREADPROCESSORID_DEFAULT is an s32. In this case, it boils down to how
arithmetic conversions are performed before performing the comparison.

If an unsigned value has a lesser conversion rank (aka smaller size)
than the signed type being compared, then the unsigned value is promoted
to the signed value (i.e. u8 -> s32 happens before the comparison). No
sign-extension occurs here either.

An alternative phrasing:

Say we have a variable named core and it's given a value of -2.

u8 core = -2;

This becomes 254 due to the lack of sign. During integral promotion to
the signed type, this still remains as 254, and therefore the condition
will always be true, because no matter what value the u8 is given it
will never be -2 in terms of 32 bits.

Now, if one type was a s32 and one was a u32, this would be entirely
different, since they have the same bit width (and the signed type would
be converted to unsigned instead of the other way around) but would
still have its representation preserved in terms of bits, allowing the
comparison to be false in some cases, as opposed to being true all the
time.

---

We also get rid of two signed/unsigned comparison warnings while we're
at it.

Previously, the buffer_index parameter was unused, causing all writes to
use the buffer index of zero, which is not necessarily what is wanted
all the time.

Thankfully, all current usages don't use a buffer index other than zero,
so this just prevents a bug before it has a chance to spring.

This was introduced within 4f81bc4e, and
considering there's no comment indicating that this is intentional, this
is very likely a bug.

Without these, this would perform concatenation, which is definitely not
what we want here.

Avoids pointless copies

This would result in a lot of allocations and related object
construction, just to toss it all away immediately after the call.

These are definitely not intentional, and it was intended that all of
these should have been accessing the static function GetInstance()
through the name itself, not constructed instances.

prevent yuzu crash, if games, like Axiom Verge, trying to read 0 bytes from file