hle: kernel: memory_manager: Rename AllocateContinuous to AllocateContinuous.

src/core/hle/kernel/memory/memory_manager.cpp

@@ -46,14 +46,15 @@ void MemoryManager::InitializeManager(Pool pool, u64 start_address, u64 end_addr
     managers[static_cast<std::size_t>(pool)].Initialize(pool, start_address, end_address);
 }
 
-VAddr MemoryManager::AllocateContinuous(std::size_t num_pages, std::size_t align_pages, Pool pool,
+VAddr MemoryManager::AllocateAndOpenContinuous(std::size_t num_pages, std::size_t align_pages,
-                                        Direction dir) {
+                                               u32 option) {
     // Early return if we're allocating no pages
     if (num_pages == 0) {
         return {};
     }
 
     // Lock the pool that we're allocating from
+    const auto [pool, dir] = DecodeOption(option);
     const auto pool_index{static_cast<std::size_t>(pool)};
     std::lock_guard lock{pool_locks[pool_index]};
 

src/core/hle/kernel/memory/memory_manager.h

@@ -6,7 +6,9 @@
 
 #include <array>
 #include <mutex>
+#include <tuple>
 
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "core/hle/kernel/memory/page_heap.h"
 #include "core/hle/result.h"
@@ -44,8 +46,8 @@ public:
     }
 
     void InitializeManager(Pool pool, u64 start_address, u64 end_address);
-    VAddr AllocateContinuous(std::size_t num_pages, std::size_t align_pages, Pool pool,
+
-                             Direction dir = Direction::FromFront);
+    VAddr AllocateAndOpenContinuous(size_t num_pages, size_t align_pages, u32 option);
     ResultCode Allocate(PageLinkedList& page_list, std::size_t num_pages, Pool pool,
                         Direction dir = Direction::FromFront);
     ResultCode Free(PageLinkedList& page_list, std::size_t num_pages, Pool pool,
@@ -53,6 +55,27 @@ public:
 
     static constexpr std::size_t MaxManagerCount = 10;
 
+public:
+    static constexpr u32 EncodeOption(Pool pool, Direction dir) {
+        return (static_cast<u32>(pool) << static_cast<u32>(Pool::Shift)) |
+               (static_cast<u32>(dir) << static_cast<u32>(Direction::Shift));
+    }
+
+    static constexpr Pool GetPool(u32 option) {
+        return static_cast<Pool>((static_cast<u32>(option) & static_cast<u32>(Pool::Mask)) >>
+                                 static_cast<u32>(Pool::Shift));
+    }
+
+    static constexpr Direction GetDirection(u32 option) {
+        return static_cast<Direction>(
+            (static_cast<u32>(option) & static_cast<u32>(Direction::Mask)) >>
+            static_cast<u32>(Direction::Shift));
+    }
+
+    static constexpr std::tuple<Pool, Direction> DecodeOption(u32 option) {
+        return std::make_tuple(GetPool(option), GetDirection(option));
+    }
+
 private:
     class Impl final : NonCopyable {
     private: