Fix segfault in GC standalone large pages emulation mode (segments path)

In the non-regions (segments) path used by standalone GC (clrgc.dll),
GCLargePages=2 (emulation mode) sets use_large_pages_p=true but reserves
memory with normal pages without committing. This causes two problems:

1. virtual_commit (memory.cpp:102) returns true without actually committing
   for large pages heap memory, so accessing the memory causes a segfault.
   Fix: commit all reserved blocks upfront in init.cpp for emulation mode,
   matching the regions path behavior (init.cpp lines 895-901).

2. make_heap_segment calls virtual_commit for accounting, which hits the
   hard limit check. With large pages, segment sizes fill the entire hard
   limit budget (soh+loh+poh = heap_hard_limit), leaving zero room for
   infrastructure commits (card tables, mark lists). The hard limit check
   rejects and initialization fails.
   Fix: in make_heap_segment for large pages + non-regions, bypass
   virtual_commit (memory is already committed) but manually update the
   committed bytes accounting so diagnostics verification stays consistent.

Fixes #127668

Author: cshung

src/coreclr/gc/init.cpp

@@ -923,6 +923,22 @@ HRESULT gc_heap::initialize_gc (size_t soh_segment_size,
     if (!reserve_initial_memory (soh_segment_size, loh_segment_size, poh_segment_size, number_of_heaps,
                                  use_real_large_pages, separated_poh_p, heap_no_to_numa_node))
         return E_OUTOFMEMORY;
+    if (large_pages_emulation_mode_p)
+    {
+        // In emulation mode, memory was reserved with normal pages (not real large pages).
+        // Commit everything upfront to simulate the "always committed" property of real large pages,
+        // matching the regions path behavior (init.cpp lines 895-901).
+        imemory_data* current_block = memory_details.initial_memory;
+        int total_blocks = number_of_heaps * (total_generation_count - ephemeral_generation_count);
+        for (int i = 0; i < total_blocks; i++, current_block++)
+        {
+            size_t blk_size = memory_details.block_size (i);
+            if (!GCToOSInterface::VirtualCommit (current_block->memory_base, blk_size))
+            {
+                return E_OUTOFMEMORY;
+            }
+        }
+    }
     if (use_large_pages_p)
     {
 #ifndef HOST_64BIT

src/coreclr/gc/regions_segments.cpp

@@ -1313,10 +1313,32 @@ heap_segment* gc_heap::make_heap_segment (uint8_t* new_pages, size_t size, gc_he
         0;
 #endif //MULTIPLE_HEAPS
 
-    if (!virtual_commit (new_pages, initial_commit, oh, h_number))
+#ifndef USE_REGIONS
+    if (use_large_pages_p)
     {
-        log_init_error_to_host ("Committing %zd bytes for a region failed", initial_commit);
-        return 0;
+        // For large pages (real or emulation mode), segment memory is already fully committed
+        // at reservation time (via VirtualReserveAndCommitLargePages or upfront VirtualCommit).
+        // Skip virtual_commit's hard limit check (which would reject since segments fill the
+        // entire budget) but still update accounting so diagnostics verification stays consistent.
+        check_commit_cs.Enter();
+#if defined(MULTIPLE_HEAPS) && defined(_DEBUG)
+        if (h_number != -1)
+        {
+            g_heaps[h_number]->committed_by_oh_per_heap[oh] += initial_commit;
+        }
+#endif // MULTIPLE_HEAPS && _DEBUG
+        committed_by_oh[oh] += initial_commit;
+        current_total_committed += initial_commit;
+        check_commit_cs.Leave();
+    }
+    else
+#endif //!USE_REGIONS
+    {
+        if (!virtual_commit (new_pages, initial_commit, oh, h_number))
+        {
+            log_init_error_to_host ("Committing %zd bytes for a region failed", initial_commit);
+            return 0;
+        }
     }
 
 #ifdef USE_REGIONS