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.

Kernel/Memory: Changed GetPhysicalPointer so that it doesn't go through the current process' page table to obtain a pointer.

Replace it with std::move(result_val).Unwrap(), or Foo().Unwrap() in
case you already have an rvalue.

This replaces the hardcoded VRAM/DSP mappings with ones made based on
the ExHeader ARM11 Kernel caps list. While this has no visible effect
for most applications (since they use a standard set of mappings) it
does improve support for system modules and n3DS exclusives.

Also move address space mapping out of video_core.

This makes clang-format useful on those.

Also add a bunch of forgotten transitive includes, which otherwise
prevented compilation.

Reserve enough space in the vector that holds the linear heap memory to prevent relocations of the backing memory when growing too much.

Closes #1790

Kernel/Threads: Dynamically allocate the TLS region for threads in the BASE region of the linear heap.

Each thread gets a 0x200-byte area from the 0x1000-sized page, when all 8 thread slots in a single page are used up, the kernel allocates a new page to hold another 8 entries.

This is consistent with what the real kernel does.

This commit:
* Adds a new subproject, audio_core.
* Defines structures that exist in DSP shared memory.
* Hooks up various other parts of the emulator into audio core.

This sets the foundation for a later HLE DSP implementation.

This makes smealum/ctrulib@b96dd51d3349961189d4ab1bc2a5c45deff21c09 work
with Citra.

This adds some structures necessary to support multiple memory regions
in the future. It also adds support for different system memory types
and the new linear heap mapping at 0x30000000.

These helpers aren't really part of the kernel, and mem_map.cpp/h is
going to be moved there next.

The code now properly configures the process image to match the loaded
binary segments (code, rodata, data) instead of just blindly allocating
a large chunk of dummy memory.

This enables more dynamic management of the process address space,
compared to just directly configuring the page table for major areas.

This will serve as the foundation upon which the rest of the Kernel
memory management functions will be built.

memory.cpp/h contains definitions related to acessing memory and
configuring the address space
mem_map.cpp/h contains higher-level definitions related to configuring
the address space accoording to the kernel and allocating memory.

It is superfluous for Citra. (It's only really necessary if you're doing
JIT. We were using it but not taking any advantage from it.) This should
make 32-bit builds work again.

- Linear simply indicates that the mapped physical address is always MappedVAddr+0x0C000000, thus this memory can be used for hardware devices' DMA (such as the GPU).