Memory rework pt 2 (#801)

* Memory: Rework FCRAM management entirely

Disables a lot of functionality... but I didn't want to commit too much to this commit
Also reworks virtual memory management somewhat (but needs more work)

* Accurately handle MemoryState for virtual memory

Previously all non-free blocks were marked as Reserved

* Memory: Consolidate state and permission changes

Can now use a single function to change either state, permissions, or both
Also merge vmem blocks that have the same state and permissions

* Memory: Fix double reset for FCRAM manager

Fix minor bug with permission tracking

* Memory: Implement Protect operation in ControlMemory

* Memory: Implement Unmap in ControlMemory

Also do a sanity check to make sure the memory region is free for linear allocations

* Memory: Make TLS only 0x200 bytes for each thread

Also move TLS to Base region

* RO: Unmap CROs when unloaded

Thanks @noumidev

* Kernel: Return used app memory for Commit ResourceLimit

Not quite correct, but nothing to be done until process management is improved
Also remove the stack limit for CXIs (thanks amogus)

* Kernel: Report used app memory for GetProcessInfo 2

Not really correct, but it should be accurate for applications at least

* Formatting changes

* Initial fastmem support

* PCSX2 fastmem depression

* Move away from PCSX2 fastmem

* Add enum_flag_ops.hpp

* Finally building on Windows

* Almost got a PoC

* Fix arm64 builds

* This somehow works

* This also works...

* Properly fix fastmem

* Add free region manager

* Update boost

* Add ScopeExit

* Comment out asserts on Linux/Mac/Android

* Comment out ASSERT_MSG asserts too

* Fix derp

* Attempt to fix Android

* Disable fastmem on Android

* Fix Android again maybe pt 2

* android pls

* AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

* AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

* Update host_memory.cpp

* Properly reset memory arena on reset

* Proper ashmem code for Android

* more

* Add temporary Android buildjet script for faster prototype builds

* Fix fastmem (again)

* Clean up shared memory

* Remove Android BuildJet runner

* a

* Revert "a"

This reverts commit 5443ad6f2a794c19c9b1a1567ca1c7f58eed78cd.

* Re-add ELF support

* Re-add 3DSX support

* GetSystemInfo, GetProcessInfo: Memory sizes should be in bytes

* Update Boost

* Update metal-cpp

* Fix metal renderer compilation

* Fix fastmem mapping

* Clean up fastmem code

* Fix oopsie again

* Emulator: Reorder struct

* Kernel types: Cleanup

* Cleanup

* More cleanup

* Make invalid mprotects warn instead of panicking

* Add setting for toggling fastmem

* More cleanup

* Properly initialize BSS to zeroes

* Remove unused code

* Formatting

* Cleanup

* Memory/CRO: Workaround for Pokemon XY

* NCSD loader: Fix BSS (again)

* NCSD loader: Fix BSS (again) (again)

* More memory fixes

* Memory: Remove unused code

* FS: Warn on unimplemented functions instead of panic

* Update software_keyboard.cpp

* Libretro: Add fastmem option

* FRD: Stub SaveLocalAccountData

---------

Co-authored-by: PSI-Rockin <PSI-Rockin@users.noreply.github.com>

include/dynamic_library.hpp

@@ -0,0 +1,73 @@
+// SPDX-FileCopyrightText: 2019 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string>
+
+namespace Common {
+	/**
+	 * Provides a platform-independent interface for loading a dynamic library and retrieving symbols.
+	 * The interface maintains an internal reference count to allow one handle to be shared between
+	 * multiple users.
+	 */
+	class DynamicLibrary final {
+	  public:
+		/// Default constructor, does not load a library.
+		explicit DynamicLibrary();
+
+		/// Automatically loads the specified library. Call IsOpen() to check validity before use.
+		explicit DynamicLibrary(const char* filename);
+
+		/// Initializes the dynamic library with an already opened handle.
+		explicit DynamicLibrary(void* handle_);
+
+		/// Moves the library.
+		DynamicLibrary(DynamicLibrary&&) noexcept;
+		DynamicLibrary& operator=(DynamicLibrary&&) noexcept;
+
+		/// Delete copies, we can't copy a dynamic library.
+		DynamicLibrary(const DynamicLibrary&) = delete;
+		DynamicLibrary& operator=(const DynamicLibrary&) = delete;
+
+		/// Closes the library.
+		~DynamicLibrary();
+
+		/// Returns the specified library name with the platform-specific suffix added.
+		[[nodiscard]] static std::string getUnprefixedFilename(const char* filename);
+
+		/// Returns the specified library name in platform-specific format.
+		/// Major/minor versions will not be included if set to -1.
+		/// If libname already contains the "lib" prefix, it will not be added again.
+		/// Windows: LIBNAME-MAJOR-MINOR.dll
+		/// Linux: libLIBNAME.so.MAJOR.MINOR
+		/// Mac: libLIBNAME.MAJOR.MINOR.dylib
+		[[nodiscard]] static std::string getVersionedFilename(const char* libname, int major = -1, int minor = -1);
+
+		/// Returns true if a module is loaded, otherwise false.
+		[[nodiscard]] bool isOpen() const { return handle != nullptr; }
+
+		/// Loads (or replaces) the handle with the specified library file name.
+		/// Returns true if the library was loaded and can be used.
+		[[nodiscard]] bool open(const char* filename);
+
+		/// Unloads the library, any function pointers from this library are no longer valid.
+		void close();
+
+		/// Returns the address of the specified symbol (function or variable) as an untyped pointer.
+		/// If the specified symbol does not exist in this library, nullptr is returned.
+		[[nodiscard]] void* getSymbolAddress(const char* name) const;
+
+		/// Obtains the address of the specified symbol, automatically casting to the correct type.
+		/// Returns true if the symbol was found and assigned, otherwise false.
+		template <typename T>
+		[[nodiscard]] bool getSymbol(const char* name, T* ptr) const {
+			*ptr = reinterpret_cast<T>(getSymbolAddress(name));
+			return *ptr != nullptr;
+		}
+
+	  private:
+		/// Platform-dependent data type representing a dynamic library handle.
+		void* handle = nullptr;
+	};
+}  // namespace Common