[Memory] Treat AllocRange high_page_number as exclusive

The free-block tracker search in BaseHeap::AllocRange treats
high_page_number as inclusive, shifting allocator-returned addresses
by one stride relative to the old loop-based search. Some titles
encode allocator-returned addresses in PPC code and break when that
layout shifts (Far Cry 3, Far Cry 4, Watchdogs).

In addition, reapply xe::align on the high side of AllocRange
(essentially reverting c28019e33). Without the round-up, a caller
passing a min/max window exactly the size of its request loses a
stride at the top and fails the early page_count size check.

src/xenia/base/testing/heap_test.cc

@@ -85,14 +85,15 @@ TEST_CASE("heap_alloc_basic", "[heap]") {
 TEST_CASE("heap_alloc_top_down", "[heap]") {
   TestHeap h(0x80000000, 0x100000, 0x1000);
 
+  // Top-down treats high_page_number as exclusive, so the top page is
+  // never handed out.
   uint32_t addr = 0;
   REQUIRE(h.Alloc(0x1000, 0x1000, true, &addr));
-  // Top-down: should be at the highest aligned address.
-  REQUIRE(addr == 0x800FF000);
+  REQUIRE(addr == 0x800FE000);
   REQUIRE(h.unreserved_page_count() == 255);
 
   REQUIRE(h.Alloc(0x2000, 0x1000, true, &addr));
-  REQUIRE(addr == 0x800FD000);
+  REQUIRE(addr == 0x800FC000);
   REQUIRE(h.unreserved_page_count() == 253);
 }
 
@@ -237,16 +238,18 @@ TEST_CASE("heap_alloc_alignment_top_down", "[heap]") {
   // 1MB heap, 4KB pages
   TestHeap h(0x80000000, 0x100000, 0x1000);
 
-  // Allocate 1 page at the top.
+  // Top-down skips the top page (0x800FF000), so a 1-page allocation
+  // lands on page 0xFE.
   uint32_t first = 0;
   REQUIRE(h.Alloc(0x1000, 0x1000, true, &first));
-  REQUIRE(first == 0x800FF000);
+  REQUIRE(first == 0x800FE000);
 
-  // Allocate with 64KB alignment top-down — should align down.
+  // 64KB-aligned top-down: stride 16, exclusive high at page 0xFF, so
+  // the highest aligned base is page 0xE0.
   uint32_t aligned = 0;
   REQUIRE(h.Alloc(0x1000, 0x10000, true, &aligned));
   REQUIRE((aligned % 0x10000) == 0);
-  REQUIRE(aligned == 0x800F0000);
+  REQUIRE(aligned == 0x800E0000);
 }
 
 // ============================================================================

src/xenia/base/testing/physical_heap_test.cc

@@ -161,16 +161,17 @@ TEST_CASE("PhysicalHeap vE0000000 alignment", "[memory]") {
     REQUIRE(translation_offset % heap.page_size() == 0);
   }
 
-  SECTION("alloc with alignment larger than page_size succeeds") {
-    // The translation offset (0xDFFFF000) is only 4KB-aligned, so the
-    // guest virtual address won't be 64KB-aligned. But the physical
-    // (host) address IS aligned, which is what matters.
+  SECTION("alloc with alignment larger than page_size is rejected") {
+    // vE0000000 has a 0x1000 physical translation offset, so a 64KB
+    // alignment request can't produce a 64KB-aligned guest address.
+    // PhysicalHeap::Alloc forces top-down, which here lands one stride
+    // past the end of the child heap and BaseHeap::AllocFixed rejects
+    // it as out of range.
     uint32_t alignment = 0x10000;  // 64KB
     uint32_t addr = 0;
     bool ok = heap.Alloc(0x10000, alignment, kMemoryAllocationReserve,
                          kMemoryProtectRead, false, &addr);
-    REQUIRE(ok);
-    REQUIRE(addr >= 0xE0000000);
+    REQUIRE_FALSE(ok);
   }
 }
 
@@ -192,9 +193,12 @@ TEST_CASE("PhysicalHeap vE0000000 AllocRange alignment", "[memory]") {
     REQUIRE(addr % 0x1000 == 0);
   }
 
-  SECTION("AllocRange with large alignment succeeds") {
-    // The guest virtual address won't be 64KB-aligned due to the 0x1000
-    // translation offset, but the physical (host) address is aligned.
+  SECTION("AllocRange with large alignment succeeds via bottom-up") {
+    // Bottom-up search picks a low parent address that translates to a
+    // guest address inside the child heap, so BaseHeap::AllocFixed accepts
+    // it. The PhysicalHeap alignment check is host-based
+    // ((addr + host_address_offset_) % alignment), so the misalignment of
+    // the guest address itself is not rejected here.
     uint32_t alignment = 0x10000;
     uint32_t addr = 0;
     bool ok = heap.AllocRange(0xE0000000, 0xFFFCFFFF, 0x10000, alignment,