imamnurby/smpl_train_seed8 huggingface dataset:
--- initial
+++ final
@@ -1,47 +1,47 @@
 static void __init request_standard_resources(const struct machine_desc *mdesc) {
   struct memblock_region *region;
   struct resource *res;
   kernel_code.start = virt_to_phys(_text);
   kernel_code.end = virt_to_phys(__init_begin - 1);
   kernel_data.start = virt_to_phys(_sdata);
   kernel_data.end = virt_to_phys(_end - 1);
   for_each_memblock(memory, region) {
     phys_addr_t start = __pfn_to_phys(memblock_region_memory_base_pfn(region));
     phys_addr_t end = __pfn_to_phys(memblock_region_memory_end_pfn(region)) - 1;
     unsigned long boot_alias_start;
     /*
      * Some systems have a special memory alias which is only
      * used for booting.  We need to advertise this region to
      * kexec-tools so they know where bootable RAM is located.
      */
     boot_alias_start = phys_to_idmap(start);
     if (arm_has_idmap_alias() && boot_alias_start != IDMAP_INVALID_ADDR) {
-      res = memblock_virt_alloc(sizeof(*res), 0);
+      res = memblock_alloc(sizeof(*res), 0);
       res->name = "System RAM (boot alias)";
       res->start = boot_alias_start;
       res->end = phys_to_idmap(end);
       res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
       request_resource(&iomem_resource, res);
     }
-    res = memblock_virt_alloc(sizeof(*res), 0);
+    res = memblock_alloc(sizeof(*res), 0);
     res->name = "System RAM";
     res->start = start;
     res->end = end;
     res->flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
     request_resource(&iomem_resource, res);
     if (kernel_code.start >= res->start && kernel_code.end <= res->end) request_resource(res, &kernel_code);
     if (kernel_data.start >= res->start && kernel_data.end <= res->end) request_resource(res, &kernel_data);
   }
   if (mdesc->video_start) {
     video_ram.start = mdesc->video_start;
     video_ram.end = mdesc->video_end;
     request_resource(&iomem_resource, &video_ram);
   }
   /*
    * Some machines don't have the possibility of ever
    * possessing lp0, lp1 or lp2
    */
   if (mdesc->reserve_lp0) request_resource(&ioport_resource, &lp0);
   if (mdesc->reserve_lp1) request_resource(&ioport_resource, &lp1);
   if (mdesc->reserve_lp2) request_resource(&ioport_resource, &lp2);
 }<sep>@@
expression e1,e2;
@@

-                       memblock_virt_alloc
+                       memblock_alloc
				(e1,e2)
--- initial
+++ final
@@ -1,6 +1,6 @@
 void __init omap2_clk_legacy_provider_init(int index, void __iomem *mem) {
   struct clk_iomap *io;
-  io = memblock_virt_alloc(sizeof(*io), 0);
+  io = memblock_alloc(sizeof(*io), 0);
   io->mem = mem;
   clk_memmaps[index] = io;
 }<sep>@@
expression e1,e2;
@@

-                       memblock_virt_alloc
+                       memblock_alloc
				(e1,e2)
--- initial
+++ final
@@ -1 +1 @@
-void __init alloc_bootmem_cpumask_var(cpumask_var_t *mask) { *mask = memblock_virt_alloc(cpumask_size(), 0); }
+void __init alloc_bootmem_cpumask_var(cpumask_var_t *mask) { *mask = memblock_alloc(cpumask_size(), 0); }<sep>@@
expression e1,e2;
@@

-                       memblock_virt_alloc
+                       memblock_alloc
				(e1,e2)
--- initial
+++ final
@@ -1 +1 @@
-static void *__init early_init_dt_alloc_memory_arch(u64 size, u64 align) { return memblock_virt_alloc(size, align); }
+static void *__init early_init_dt_alloc_memory_arch(u64 size, u64 align) { return memblock_alloc(size, align); }<sep>@@
expression e1,e2;
@@

-                       memblock_virt_alloc
+                       memblock_alloc
				(e1,e2)
--- initial
+++ final
@@ -1,25 +1,25 @@
 int __alloc_bootmem_huge_page(struct hstate *h) {
   struct huge_bootmem_page *m;
   int nr_nodes, node;
   for_each_node_mask_to_alloc(h, nr_nodes, node, &node_states[N_MEMORY]) {
     void *addr;
-    addr = memblock_virt_alloc_try_nid_raw(huge_page_size(h), huge_page_size(h), 0, BOOTMEM_ALLOC_ACCESSIBLE, node);
+    addr = memblock_alloc_try_nid_raw(huge_page_size(h), huge_page_size(h), 0, BOOTMEM_ALLOC_ACCESSIBLE, node);
     if (addr) {
       /*
        * Use the beginning of the huge page to store the
        * huge_bootmem_page struct (until gather_bootmem
        * puts them into the mem_map).
        */
       m = addr;
       goto found;
     }
   }
   return 0;
 found:
   BUG_ON(!IS_ALIGNED(virt_to_phys(m), huge_page_size(h)));
   /* Put them into a private list first because mem_map is not up yet */
   INIT_LIST_HEAD(&m->list);
   list_add(&m->list, &huge_boot_pages);
   m->hstate = h;
   return 1;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@

-       memblock_virt_alloc_try_nid_raw
+       memblock_alloc_try_nid_raw
		(e1,e2,e3,e4,e5)
--- initial
+++ final
@@ -1,6 +1,6 @@
 static __init void *early_alloc(size_t size, int nid, bool panic) {
   if (panic)
-    return memblock_virt_alloc_try_nid(size, size, __pa(MAX_DMA_ADDRESS), BOOTMEM_ALLOC_ACCESSIBLE, nid);
+    return memblock_alloc_try_nid(size, size, __pa(MAX_DMA_ADDRESS), BOOTMEM_ALLOC_ACCESSIBLE, nid);
   else
-    return memblock_virt_alloc_try_nid_nopanic(size, size, __pa(MAX_DMA_ADDRESS), BOOTMEM_ALLOC_ACCESSIBLE, nid);
+    return memblock_alloc_try_nid_nopanic(size, size, __pa(MAX_DMA_ADDRESS), BOOTMEM_ALLOC_ACCESSIBLE, nid);
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@

-       memblock_virt_alloc_try_nid
+       memblock_alloc_try_nid
		(e1,e2,e3,e4,e5)

@@
expression e1,e2,e3,e4,e5;
@@

-       memblock_virt_alloc_try_nid_nopanic
+       memblock_alloc_try_nid_nopanic
		(e1,e2,e3,e4,e5)
--- initial
+++ final
@@ -1 +1 @@
-static __init void *early_alloc(size_t size, int node) { return memblock_virt_alloc_try_nid(size, size, __pa(MAX_DMA_ADDRESS), BOOTMEM_ALLOC_ACCESSIBLE, node); }
+static __init void *early_alloc(size_t size, int node) { return memblock_alloc_try_nid(size, size, __pa(MAX_DMA_ADDRESS), BOOTMEM_ALLOC_ACCESSIBLE, node); }<sep>@@
expression e1,e2,e3,e4,e5;
@@

-       memblock_virt_alloc_try_nid
+       memblock_alloc_try_nid
		(e1,e2,e3,e4,e5)
--- initial
+++ final
@@ -1,7 +1,7 @@
 static void __init setup_command_line(char *command_line) {
-  saved_command_line = memblock_virt_alloc(strlen(boot_command_line) + 1, 0);
-  initcall_command_line = memblock_virt_alloc(strlen(boot_command_line) + 1, 0);
-  static_command_line = memblock_virt_alloc(strlen(command_line) + 1, 0);
+  saved_command_line = memblock_alloc(strlen(boot_command_line) + 1, 0);
+  initcall_command_line = memblock_alloc(strlen(boot_command_line) + 1, 0);
+  static_command_line = memblock_alloc(strlen(command_line) + 1, 0);
   strcpy(saved_command_line, boot_command_line);
   strcpy(static_command_line, command_line);
 }<sep>@@
expression e1,e2;
@@

-                       memblock_virt_alloc
+                       memblock_alloc
				(e1,e2)
--- initial
+++ final
@@ -1,6 +1,6 @@
 int __init firmware_map_add_early(u64 start, u64 end, const char *type) {
   struct firmware_map_entry *entry;
-  entry = memblock_virt_alloc(sizeof(struct firmware_map_entry), 0);
+  entry = memblock_alloc(sizeof(struct firmware_map_entry), 0);
   if (WARN_ON(!entry)) return -ENOMEM;
   return firmware_map_add_entry(start, end, type, entry);
 }<sep>@@
expression e1,e2;
@@

-                       memblock_virt_alloc
+                       memblock_alloc
				(e1,e2)
--- initial
+++ final
@@ -1,21 +1,21 @@
 static void __init populate(void *start, void *end) {
   unsigned long n_pages = (end - start) / PAGE_SIZE;
   unsigned long n_pmds = n_pages / PTRS_PER_PTE;
   unsigned long i, j;
   unsigned long vaddr = (unsigned long)start;
   pgd_t *pgd = pgd_offset_k(vaddr);
   pmd_t *pmd = pmd_offset(pgd, vaddr);
-  pte_t *pte = memblock_virt_alloc(n_pages * sizeof(pte_t), PAGE_SIZE);
+  pte_t *pte = memblock_alloc(n_pages * sizeof(pte_t), PAGE_SIZE);
   pr_debug("%s: %p - %p\n", __func__, start, end);
   for (i = j = 0; i < n_pmds; ++i) {
     int k;
     for (k = 0; k < PTRS_PER_PTE; ++k, ++j) {
       phys_addr_t phys = memblock_alloc_base(PAGE_SIZE, PAGE_SIZE, MEMBLOCK_ALLOC_ANYWHERE);
       set_pte(pte + j, pfn_pte(PHYS_PFN(phys), PAGE_KERNEL));
     }
   }
   for (i = 0; i < n_pmds; ++i, pte += PTRS_PER_PTE)
     set_pmd(pmd + i, __pmd((unsigned long)pte));
   local_flush_tlb_all();
   memset(start, 0, end - start);
 }<sep>@@
expression e1,e2;
@@

-                       memblock_virt_alloc
+                       memblock_alloc
				(e1,e2)
--- initial
+++ final
@@ -1,26 +1,26 @@
 void __init mmu_context_init(void) {
   /* Mark init_mm as being active on all possible CPUs since
    * we'll get called with prev == init_mm the first time
    * we schedule on a given CPU
    */
   init_mm.context.active = NR_CPUS;
   /*
    * Allocate the maps used by context management
    */
-  context_map = memblock_virt_alloc(CTX_MAP_SIZE, 0);
-  context_mm = memblock_virt_alloc(sizeof(void *) * (LAST_CONTEXT + 1), 0);
+  context_map = memblock_alloc(CTX_MAP_SIZE, 0);
+  context_mm = memblock_alloc(sizeof(void *) * (LAST_CONTEXT + 1), 0);
 #ifdef CONFIG_SMP
-  stale_map[boot_cpuid] = memblock_virt_alloc(CTX_MAP_SIZE, 0);
+  stale_map[boot_cpuid] = memblock_alloc(CTX_MAP_SIZE, 0);
   cpuhp_setup_state_nocalls(CPUHP_POWERPC_MMU_CTX_PREPARE, "powerpc/mmu/ctx:prepare", mmu_ctx_cpu_prepare, mmu_ctx_cpu_dead);
 #endif
   printk(KERN_INFO "MMU: Allocated %zu bytes of context maps for %d contexts\n", 2 * CTX_MAP_SIZE + (sizeof(void *) * (LAST_CONTEXT + 1)), LAST_CONTEXT - FIRST_CONTEXT + 1);
   /*
    * Some processors have too few contexts to reserve one for
    * init_mm, and require using context 0 for a normal task.
    * Other processors reserve the use of context zero for the kernel.
    * This code assumes FIRST_CONTEXT < 32.
    */
   context_map[0] = (1 << FIRST_CONTEXT) - 1;
   next_context = FIRST_CONTEXT;
   nr_free_contexts = LAST_CONTEXT - FIRST_CONTEXT + 1;
 }<sep>@@
expression e1,e2;
@@

-                       memblock_virt_alloc
+                       memblock_alloc
				(e1,e2)
--- initial
+++ final
@@ -1,6 +1,6 @@
 static void __ref create_core_to_node_map(void) {
   int i;
-  emu_cores = memblock_virt_alloc(sizeof(*emu_cores), 8);
+  emu_cores = memblock_alloc(sizeof(*emu_cores), 8);
   for (i = 0; i < ARRAY_SIZE(emu_cores->to_node_id); i++)
     emu_cores->to_node_id[i] = NODE_ID_FREE;
 }<sep>@@
expression e1,e2;
@@

-                       memblock_virt_alloc
+                       memblock_alloc
				(e1,e2)
--- initial
+++ final
@@ -1,23 +1,23 @@
 int __ref msi_bitmap_alloc(struct msi_bitmap *bmp, unsigned int irq_count, struct device_node *of_node) {
   int size;
   if (!irq_count) return -EINVAL;
   size = BITS_TO_LONGS(irq_count) * sizeof(long);
   pr_debug("msi_bitmap: allocator bitmap size is 0x%x bytes\n", size);
   bmp->bitmap_from_slab = slab_is_available();
   if (bmp->bitmap_from_slab)
     bmp->bitmap = kzalloc(size, GFP_KERNEL);
   else {
-    bmp->bitmap = memblock_virt_alloc(size, 0);
+    bmp->bitmap = memblock_alloc(size, 0);
     /* the bitmap won't be freed from memblock allocator */
     kmemleak_not_leak(bmp->bitmap);
   }
   if (!bmp->bitmap) {
     pr_debug("msi_bitmap: ENOMEM allocating allocator bitmap!\n");
     return -ENOMEM;
   }
   /* We zalloc'ed the bitmap, so all irqs are free by default */
   spin_lock_init(&bmp->lock);
   bmp->of_node = of_node_get(of_node);
   bmp->irq_count = irq_count;
   return 0;
 }<sep>@@
expression e1,e2;
@@

-                       memblock_virt_alloc
+                       memblock_alloc
				(e1,e2)
--- initial
+++ final
@@ -1,4 +1,4 @@
 static void *__init pcpu_fc_alloc(unsigned int cpu, size_t size, size_t align) {
   int nid = early_cpu_to_node(cpu);
-  return memblock_virt_alloc_try_nid(size, align, __pa(MAX_DMA_ADDRESS), MEMBLOCK_ALLOC_ACCESSIBLE, nid);
+  return memblock_alloc_try_nid(size, align, __pa(MAX_DMA_ADDRESS), MEMBLOCK_ALLOC_ACCESSIBLE, nid);
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@

-       memblock_virt_alloc_try_nid
+       memblock_alloc_try_nid
		(e1,e2,e3,e4,e5)
--- initial
+++ final
@@ -1,41 +1,41 @@
 static int __init core99_nvram_setup(struct device_node *dp, unsigned long addr) {
   int i;
   u32 gen_bank0, gen_bank1;
   if (nvram_naddrs < 1) {
     printk(KERN_ERR "nvram: no address\n");
     return -EINVAL;
   }
-  nvram_image = memblock_virt_alloc(NVRAM_SIZE, 0);
+  nvram_image = memblock_alloc(NVRAM_SIZE, 0);
   nvram_data = ioremap(addr, NVRAM_SIZE * 2);
   nvram_naddrs = 1; /* Make sure we get the correct case */
   DBG("nvram: Checking bank 0...\n");
   gen_bank0 = core99_check((u8 *)nvram_data);
   gen_bank1 = core99_check((u8 *)nvram_data + NVRAM_SIZE);
   core99_bank = (gen_bank0 < gen_bank1) ? 1 : 0;
   DBG("nvram: gen0=%d, gen1=%d\n", gen_bank0, gen_bank1);
   DBG("nvram: Active bank is: %d\n", core99_bank);
   for (i = 0; i < NVRAM_SIZE; i++)
     nvram_image[i] = nvram_data[i + core99_bank * NVRAM_SIZE];
   ppc_md.nvram_read_val = core99_nvram_read_byte;
   ppc_md.nvram_write_val = core99_nvram_write_byte;
   ppc_md.nvram_read = core99_nvram_read;
   ppc_md.nvram_write = core99_nvram_write;
   ppc_md.nvram_size = core99_nvram_size;
   ppc_md.nvram_sync = core99_nvram_sync;
   ppc_md.machine_shutdown = core99_nvram_sync;
   /*
    * Maybe we could be smarter here though making an exclusive list
    * of known flash chips is a bit nasty as older OF didn't provide us
    * with a useful "compatible" entry. A solution would be to really
    * identify the chip using flash id commands and base ourselves on
    * a list of known chips IDs
    */
   if (of_device_is_compatible(dp, "amd-0137")) {
     core99_erase_bank = amd_erase_bank;
     core99_write_bank = amd_write_bank;
   } else {
     core99_erase_bank = sm_erase_bank;
     core99_write_bank = sm_write_bank;
   }
   return 0;
 }<sep>@@
expression e1,e2;
@@

-                       memblock_virt_alloc
+                       memblock_alloc
				(e1,e2)
--- initial
+++ final
@@ -1,22 +1,22 @@
 static int __init _setup_clkctrl_provider(struct device_node *np) {
   const __be32 *addrp;
   struct clkctrl_provider *provider;
   u64 size;
   int i;
-  provider = memblock_virt_alloc(sizeof(*provider), 0);
+  provider = memblock_alloc(sizeof(*provider), 0);
   if (!provider) return -ENOMEM;
   provider->node = np;
   provider->num_addrs = of_property_count_elems_of_size(np, "reg", sizeof(u32)) / 2;
-  provider->addr = memblock_virt_alloc(sizeof(void *) * provider->num_addrs, 0);
+  provider->addr = memblock_alloc(sizeof(void *) * provider->num_addrs, 0);
   if (!provider->addr) return -ENOMEM;
-  provider->size = memblock_virt_alloc(sizeof(u32) * provider->num_addrs, 0);
+  provider->size = memblock_alloc(sizeof(u32) * provider->num_addrs, 0);
   if (!provider->size) return -ENOMEM;
   for (i = 0; i < provider->num_addrs; i++) {
     addrp = of_get_address(np, i, &size, NULL);
     provider->addr[i] = (u32)of_translate_address(np, addrp);
     provider->size[i] = size;
     pr_debug("%s: %pOF: %x...%x\n", __func__, np, provider->addr[i], provider->addr[i] + provider->size[i]);
   }
   list_add(&provider->link, &clkctrl_providers);
   return 0;
 }<sep>@@
expression e1,e2;
@@

-                       memblock_virt_alloc
+                       memblock_alloc
				(e1,e2)
--- initial
+++ final
@@ -1,19 +1,19 @@
 static int __init alloc_node_page_ext(int nid) {
   struct page_ext *base;
   unsigned long table_size;
   unsigned long nr_pages;
   nr_pages = NODE_DATA(nid)->node_spanned_pages;
   if (!nr_pages) return 0;
   /*
    * Need extra space if node range is not aligned with
    * MAX_ORDER_NR_PAGES. When page allocator's buddy algorithm
    * checks buddy's status, range could be out of exact node range.
    */
   if (!IS_ALIGNED(node_start_pfn(nid), MAX_ORDER_NR_PAGES) || !IS_ALIGNED(node_end_pfn(nid), MAX_ORDER_NR_PAGES)) nr_pages += MAX_ORDER_NR_PAGES;
   table_size = get_entry_size() * nr_pages;
-  base = memblock_virt_alloc_try_nid_nopanic(table_size, PAGE_SIZE, __pa(MAX_DMA_ADDRESS), BOOTMEM_ALLOC_ACCESSIBLE, nid);
+  base = memblock_alloc_try_nid_nopanic(table_size, PAGE_SIZE, __pa(MAX_DMA_ADDRESS), BOOTMEM_ALLOC_ACCESSIBLE, nid);
   if (!base) return -ENOMEM;
   NODE_DATA(nid)->node_page_ext = base;
   total_usage += table_size;
   return 0;
 }<sep>@@
expression e1,e2,e3,e4,e5;
@@

-       memblock_virt_alloc_try_nid_nopanic
+       memblock_alloc_try_nid_nopanic
		(e1,e2,e3,e4,e5)
--- initial
+++ final
@@ -1,14 +1,14 @@
 void __init pci_create_OF_bus_map(void) {
   struct property *of_prop;
   struct device_node *dn;
-  of_prop = memblock_virt_alloc(sizeof(struct property) + 256, 0);
+  of_prop = memblock_alloc(sizeof(struct property) + 256, 0);
   dn = of_find_node_by_path("/");
   if (dn) {
     memset(of_prop, -1, sizeof(struct property) + 256);
     of_prop->name = "pci-OF-bus-map";
     of_prop->length = 256;
     of_prop->value = &of_prop[1];
     of_add_property(dn, of_prop);
     of_node_put(dn);
   }
 }<sep>@@
expression e1,e2;
@@

-                       memblock_virt_alloc
+                       memblock_alloc
				(e1,e2)
--- initial
+++ final
@@ -1,18 +1,18 @@
 struct pcpu_alloc_info *__init pcpu_alloc_alloc_info(int nr_groups, int nr_units) {
   struct pcpu_alloc_info *ai;
   size_t base_size, ai_size;
   void *ptr;
   int unit;
   base_size = ALIGN(sizeof(*ai) + nr_groups * sizeof(ai->groups[0]), __alignof__(ai->groups[0].cpu_map[0]));
   ai_size = base_size + nr_units * sizeof(ai->groups[0].cpu_map[0]);
-  ptr = memblock_virt_alloc_nopanic(PFN_ALIGN(ai_size), PAGE_SIZE);
+  ptr = memblock_alloc_nopanic(PFN_ALIGN(ai_size), PAGE_SIZE);
   if (!ptr) return NULL;
   ai = ptr;
   ptr += base_size;
   ai->groups[0].cpu_map = ptr;
   for (unit = 0; unit < nr_units; unit++)
     ai->groups[0].cpu_map[unit] = NR_CPUS;
   ai->nr_groups = nr_groups;
   ai->__ai_size = PFN_ALIGN(ai_size);
   return ai;
 }<sep>@@
expression e1,e2;
@@

-                       memblock_virt_alloc_nopanic
+                       memblock_alloc_nopanic
				(e1,e2)
--- initial
+++ final
@@ -1,52 +1,52 @@
 static struct pcpu_chunk *__init pcpu_alloc_first_chunk(unsigned long tmp_addr, int map_size) {
   struct pcpu_chunk *chunk;
   unsigned long aligned_addr, lcm_align;
   int start_offset, offset_bits, region_size, region_bits;
   /* region calculations */
   aligned_addr = tmp_addr & PAGE_MASK;
   start_offset = tmp_addr - aligned_addr;
   /*
    * Align the end of the region with the LCM of PAGE_SIZE and
    * PCPU_BITMAP_BLOCK_SIZE.  One of these constants is a multiple of
    * the other.
    */
   lcm_align = lcm(PAGE_SIZE, PCPU_BITMAP_BLOCK_SIZE);
   region_size = ALIGN(start_offset + map_size, lcm_align);
   /* allocate chunk */
-  chunk = memblock_virt_alloc(sizeof(struct pcpu_chunk) + BITS_TO_LONGS(region_size >> PAGE_SHIFT), 0);
+  chunk = memblock_alloc(sizeof(struct pcpu_chunk) + BITS_TO_LONGS(region_size >> PAGE_SHIFT), 0);
   INIT_LIST_HEAD(&chunk->list);
   chunk->base_addr = (void *)aligned_addr;
   chunk->start_offset = start_offset;
   chunk->end_offset = region_size - chunk->start_offset - map_size;
   chunk->nr_pages = region_size >> PAGE_SHIFT;
   region_bits = pcpu_chunk_map_bits(chunk);
-  chunk->alloc_map = memblock_virt_alloc(BITS_TO_LONGS(region_bits) * sizeof(chunk->alloc_map[0]), 0);
-  chunk->bound_map = memblock_virt_alloc(BITS_TO_LONGS(region_bits + 1) * sizeof(chunk->bound_map[0]), 0);
-  chunk->md_blocks = memblock_virt_alloc(pcpu_chunk_nr_blocks(chunk) * sizeof(chunk->md_blocks[0]), 0);
+  chunk->alloc_map = memblock_alloc(BITS_TO_LONGS(region_bits) * sizeof(chunk->alloc_map[0]), 0);
+  chunk->bound_map = memblock_alloc(BITS_TO_LONGS(region_bits + 1) * sizeof(chunk->bound_map[0]), 0);
+  chunk->md_blocks = memblock_alloc(pcpu_chunk_nr_blocks(chunk) * sizeof(chunk->md_blocks[0]), 0);
   pcpu_init_md_blocks(chunk);
   /* manage populated page bitmap */
   chunk->immutable = true;
   bitmap_fill(chunk->populated, chunk->nr_pages);
   chunk->nr_populated = chunk->nr_pages;
   chunk->nr_empty_pop_pages = pcpu_cnt_pop_pages(chunk, start_offset / PCPU_MIN_ALLOC_SIZE, map_size / PCPU_MIN_ALLOC_SIZE);
   chunk->contig_bits = map_size / PCPU_MIN_ALLOC_SIZE;
   chunk->free_bytes = map_size;
   if (chunk->start_offset) {
     /* hide the beginning of the bitmap */
     offset_bits = chunk->start_offset / PCPU_MIN_ALLOC_SIZE;
     bitmap_set(chunk->alloc_map, 0, offset_bits);
     set_bit(0, chunk->bound_map);
     set_bit(offset_bits, chunk->bound_map);
     chunk->first_bit = offset_bits;
     pcpu_block_update_hint_alloc(chunk, 0, offset_bits);
   }
   if (chunk->end_offset) {
     /* hide the end of the bitmap */
     offset_bits = chunk->end_offset / PCPU_MIN_ALLOC_SIZE;
     bitmap_set(chunk->alloc_map, pcpu_chunk_map_bits(chunk) - offset_bits, offset_bits);
     set_bit((start_offset + map_size) / PCPU_MIN_ALLOC_SIZE, chunk->bound_map);
     set_bit(region_bits, chunk->bound_map);
     pcpu_block_update_hint_alloc(chunk, pcpu_chunk_map_bits(chunk) - offset_bits, offset_bits);
   }
   return chunk;
 }<sep>@@
expression e1,e2;
@@

-                       memblock_virt_alloc
+                       memblock_alloc
				(e1,e2)
--- initial
+++ final
@@ -1 +1 @@
-static void *__init pcpu_dfl_fc_alloc(unsigned int cpu, size_t size, size_t align) { return memblock_virt_alloc_from_nopanic(size, align, __pa(MAX_DMA_ADDRESS)); }
+static void *__init pcpu_dfl_fc_alloc(unsigned int cpu, size_t size, size_t align) { return memblock_alloc_from_nopanic(size, align, __pa(MAX_DMA_ADDRESS)); }<sep>@@
expression e1,e2,e3;
@@

-                       memblock_virt_alloc_from_nopanic
+                       memblock_alloc_from_nopanic
				(e1,e2,e3)