atop
int j, atop;
for (j = 0, atop = 0; j < a->dmax; j++) {
atop = constant_time_select_int(mask, j + 1, atop);
mask = constant_time_eq_int(atop, 0);
a->top = atop;
size_t i, lasti, j, atop, mask;
atop = a->dmax * BN_BYTES;
if (atop == 0) {
lasti = atop - 1;
atop = a->top * BN_BYTES;
mask = 0 - ((j - atop) >> (8 * sizeof(i) - 1));
physmem -= atop(phys_avail[pa_indx] - phys_avail[pa_indx - 1]);
Maxmem = atop(phys_avail[pa_indx]);
realmem = atop(memsize);
Maxmem = atop(physmap[physmap_idx + 1]);
Maxmem = atop(physmem_tunable);
if (Maxmem > atop(physmap[physmap_idx + 1]))
Maxmem = atop(physmap[physmap_idx + 1]);
if (atop(physmap[physmap_idx + 1]) != Maxmem &&
total = atop(addr2 - addr1);
cnt = atop(NBPDR - (va & PDRMASK));
Maxmem = atop(NDMPML5E * NBPML5);
Maxmem = atop(NDMPML4E * NBPML4);
res = atop(KERNend - (vm_paddr_t)kernphys);
for (i = 0; i < atop(0x400000); i++) {
m_start->pindex + atop(end - start));
if (!vm_object_populate(object, pindex, pindex + atop(size)))
pmap_qremove(va, atop(size));
pages = atop(maxsize) - bz->total_bpages;
pages = atop(roundup2(dmat->maxsize, PAGE_SIZE)) + 1;
m_start->pindex + atop(end - start));
if (!vm_object_populate(object, pindex, pindex + atop(size)))
bo->npages = atop(size);
pages = atop(maxsize) + 1 - bz->total_bpages;
atop(dmat->common.lowaddr));
pages = atop(roundup2(dmat->common.maxsize, PAGE_SIZE)) + 1;
m_start->pindex + atop(end - start));
l3_list = malloc(atop(size) * sizeof(l3_list[0]), M_TEMP,
for (i = 0; i < atop(size); i++) {
pstart += atop(start - entry->start);
atop(entry->end - entry->start);
pend -= atop(entry->end - end);
for (i = 0; i < atop(round_page(size)); i++)
vm86_addpage(&x86bios_vmc, atop(*offset) + i,
nfree = atop(round_page(size));
mem->am_obj = vm_object_allocate(OBJT_SWAP, atop(round_page(size)));
m = vm_radix_iter_lookup(&pages, atop(i));
atop(round_page(size)));
n = atop(end - start);
entry->pages = atop(size);
gpa[gpa_cnt].gpa_page = atop(paddr) + gpa_cnt;
txr->hn_gpa[0].gpa_page = atop(txd->rndis_pkt_paddr);
gpa->gpa_page = atop(segs[i].ds_addr);
prplist->gpa_page[i] = atop(segs[i].ds_addr);
ma = malloc(sizeof(vm_page_t) * atop(length), M_TEMP, waitok ?
for (i = 0; i < atop(length); i++) {
for (i = 0; i < atop(length); i++)
npages = atop(min(maxphys, round_page(len + (ma_offs &
KASSERT(npages <= atop(maxphys + PAGE_SIZE),
pmap_qenter(sc->s_vnode.kva, &bp->bio_ma[atop(ma_offs)],
return atop(round_page(start + len) - trunc_page(start));
if (npages > atop(maxphys))
pfn = atop(vtophys(mtod(m, vm_offset_t)));
mfn = atop(segs[i].ds_addr);
rm.gpfn = atop(map->phys_base_addr) + i;
gpfns[i] = atop(umap->phys_base_addr +
gpfns[i] = atop(umap->phys_base_addr) + i;
xs.gpfn = atop(pmap_kextract((vm_offset_t)xen_store));
Maxmem = atop(physmap[physmap_idx + 1]);
Maxmem = atop(physmem_tunable);
if (has_smap && Maxmem > atop(physmap[physmap_idx + 1]))
Maxmem = atop(physmap[physmap_idx + 1]);
if (atop(physmap[physmap_idx + 1]) != Maxmem &&
if (atop(physmap[physmap_idx + 1]) < Maxmem)
physmem -= atop(phys_avail[pa_indx] - phys_avail[pa_indx - 1]);
Maxmem = atop(phys_avail[pa_indx]);
gdt_segs[GCODE_SEL].ssd_limit = atop(0 - 1);
gdt_segs[GDATA_SEL].ssd_limit = atop(0 - 1);
gdt_segs[GUCODE_SEL].ssd_limit = atop(0 - 1);
gdt_segs[GUDATA_SEL].ssd_limit = atop(0 - 1);
gdt_segs[GUFS_SEL].ssd_limit = atop(0 - 1);
gdt_segs[GUGS_SEL].ssd_limit = atop(0 - 1);
gdt_segs[GPRIV_SEL].ssd_limit = atop(0 - 1);
ldt_segs[LUCODE_SEL].ssd_limit = atop(0 - 1);
ldt_segs[LUDATA_SEL].ssd_limit = atop(0 - 1);
realmem = atop(memsize);
for (pt = (pt_entry_t *)KPTphys + atop(va); cnt > 0;
m_start->pindex + atop(end - start));
if (!vm_object_populate(object, pindex, pindex + atop(size)))
pmap_cold_mapident(0, atop(NBPDR) * LOWPTDI);
pmap_cold_map(0, NBPDR * LOWPTDI, atop(NBPDR) * LOWPTDI);
pmap_cold_mapident(KERNBASE, atop(KERNend - KERNBASE));
for (pt = (pt_entry_t *)vm86pa + atop(ISA_HOLE_START), a = 0;
a < atop(ISA_HOLE_LENGTH); a++, pt++)
pmap_qremove(va, atop(size));
trm_pte = PTmap + atop(prev_addr);
pte_store(&trm_pte[atop(af - prev_addr)], VM_PAGE_TO_PHYS(m) |
res = atop(firstaddr - (vm_paddr_t)KERNLOAD);
SYSMAP(struct msgbuf *, unused, msgbufp, atop(round_page(msgbufsize)))
image_count += atop(segtmp[i].memsz);
pi_adv = atop(entry->end - addr);
pi_adv = atop(pagesizes[incore >> MINCORE_PSIND_SHIFT]);
npages = atop(size);
totalmem += atop((vm_offset_t)(end - start));
availmem += atop((vm_offset_t)(xstart - start));
availmem += atop((vm_offset_t)(end - start));
Maxmem = atop(phys_avail[nextidx - 1]);
atop(ktls_maxlen), 0, ~0ul, PAGE_SIZE, 0,
atop(ktls_maxlen), 0, ~0ul, PAGE_SIZE, 0,
for (j = 0; j < atop(ktls_maxlen); j++) {
*last = *first + atop(pagesizes[psind]) - 1;
vm_wire_add(atop(pagesizes[psind]));
pages = malloc(sizeof(vm_page_t) * (atop(round_page(
atop(maxphys) + 1);
MPASS(pbuf->b_npages <= atop(maxphys) + 1);
MPASS(bp->bio_ma_n <= atop(maxphys) + 1);
atop(maxbcachebuf)) * nbuf;
bzero(bp, sizeof(*bp) + sizeof(vm_page_t) * atop(maxbcachebuf));
sizeof(struct buf) + sizeof(vm_page_t) * atop(maxbcachebuf),
sizeof(vm_page_t) * atop(maxbcachebuf)) * i));
KASSERT(desiredpages <= atop(maxbcachebuf),
pmap_qremove(start, atop(end - start));
ma[i] = vm_page_grab_unlocked(obj, atop(off),
nheld = atop(round_page(((vm_offset_t)sbp) +
m_start->pindex + atop(end - start));
moea_qremove(base, atop(size));
m_start->pindex + atop(end - start));
moea64_qremove(base, atop(size));
m_start->pindex + atop(end - start));
if (!vm_object_populate(object, pindex, pindex + atop(size)))
mmu_radix_qremove(va, atop(size));
m_start->pindex + atop(end - start));
mmu_booke_qremove(base, atop(size));
pages = atop(maxsize) - bz->total_bpages;
maxpages = MIN(MAX_BPAGES, Maxmem -atop(dmat->lowaddr));
pages = MAX(atop(dmat->maxsize), 1);
pages = atop(round_page(maxsize)) - bz->total_bpages;
atop(dmat->common.lowaddr));
pages = MAX(atop(dmat->common.maxsize), 1);
m_start->pindex + atop(end - start));
kernel_pmap->pm_satp = atop(root_pt_phys) | pmap_satp_mode();
*color = atop(paddr) - OFF_TO_IDX(off - PAGE_SIZE);
pincr = atop(incr);
pincr = atop(incr);
pdecr = atop(decr);
pages = atop(kl.slabsize);
vm_object_color(fs->object, atop(fs->vaddr) - fs->pindex);
atop(fs->vaddr - e_start));
ahead = ulmin(ahead, atop(e_end - fs->vaddr) - 1);
atop(end - entry->start));
atop(start - entry->start)) {
if (atop(end - addr) > max_count)
count = atop(end - addr);
dst_object = vm_object_allocate_anon(atop(dst_entry->end -
dst_object->pg_color = atop(dst_entry->start);
atop(pagesizes[psind]));
pager_last = pager_first + atop(fs->entry->end - fs->entry->start) - 1;
for (i = 0; i < atop(pagesizes[bdry_idx]); i++)
map_last = map_first + atop(fs->entry->end - fs->entry->start) - 1;
npages = atop(pagesizes[psind]);
npages = atop(end - start);
KASSERT(atop(size) % kpages == 0,
rem = atop(*addrp - VM_MIN_KERNEL_ADDRESS) % kpages;
vm_pindex_t pindex = atop(ks - VM_MIN_KERNEL_ADDRESS);
atop(VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS));
atop(VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS));
m = kmem_alloc_contig_pages(object, atop(offset + i),
atop(round_page(size)), low, high) == -1) {
npages = atop(asize);
m = kmem_alloc_contig_pages(object, atop(offset), domain,
atop(round_page(size)), low, high) == -1) {
m = vm_page_alloc_domain_iter(object, atop(offset + i),
m = vm_radix_iter_lookup(&pages, atop(offset));
m = vm_radix_iter_lookup(&pages, atop(offset))) {
object = vm_object_allocate_anon(atop(entry->end - entry->start), NULL,
psize = atop(size);
mask = atop(pagesizes[psind]) - 1;
pend = pstart + atop(entry->end - entry->start);
pstart += atop(start - entry->start);
pend -= atop(entry->end - end);
npages = atop(entry->end - entry->start);
atop(entry->end - entry->start));
vm_map_wire_user_count_sub(atop(size));
offidxend = offidxstart + atop(size);
entry->object.vm_object = vm_object_allocate_anon(atop(size),
#define VM_FAULT_READ_AHEAD_MAX min(atop(maxphys) - 1, UINT8_MAX)
vecindex = atop(end - first_addr);
npages = atop(end - start);
vecindex = atop(addr - first_addr);
atop(size) == object->size) {
result = vm_object_allocate_anon(atop(length), source, cred);
size = atop(entry->end - entry->start);
end_pindex = pindex + atop(length);
_vm_object_allocate(OBJT_PHYS, atop(VM_MAX_KERNEL_ADDRESS -
kernel_object->pg_color = (u_short)atop(VM_MIN_KERNEL_ADDRESS);
pi = atop(pa);
m_inc = atop(roundup2(pa, alignment) - pa);
m_inc = atop(roundup2(pa, boundary) - pa);
m_inc = atop(roundup2(pa + 1, vm_reserv_size(level)) -
m_inc = atop(roundup2(pa + 1,
npages = atop(pagesizes[psind]);
pagecount = (u_long)atop(endp - startp);
#define PBUF_PAGES (atop(maxphys) + 1)
return (&seg->first_page[atop(pa - seg->start)]);
m = &seg->first_page[atop(pa - seg->start)];
pi = atop(start);
pe = atop(end);
pi = atop(start);
pe = atop(end);
lo = atop(VM_PAGE_TO_PHYS(m));
lo = atop(VM_PAGE_TO_PHYS(m));
bounds[1] = &seg->first_page[atop(pa_end - seg->start)];
npages += atop(seg->end - seg->start);
npages += atop(seg->end - seg->start);
if (rbehind + rahead + count > atop(maxphys)) {
trim = rbehind + rahead + count - atop(maxphys) + 1;
KASSERT(rbehind + rahead + count <= atop(maxphys),
KASSERT(bp->b_npages <= atop(maxphys),
count = atop(bytecount);
npages = atop(written);
i = atop(eof);
npages = atop(lpos);
pagesperblock = atop(bsize);
*run *= atop(bsize);
*run -= atop(voffset);
pagesperblock = atop(bsize);
KASSERT(count <= atop(maxphys),
poff = atop(foff % bsize);
pmap_qremove((vm_offset_t)sc->dev_tbl, atop(devtbl_sz));
sc->devtbl_obj = vm_pager_allocate(OBJT_PHYS, NULL, atop(devtbl_sz),
i * atop(seg_sz),
atop(seg_sz), 0, ~0ul, IOMMU_PAGE_SIZE, 0,
atop(seg_sz), 0, ~0ul, IOMMU_PAGE_SIZE, 0);
rval = VM_PAGE_TO_PHYS(m) | (atop(seg_sz) - 1);
for (u_int j = 0; j < atop(seg_sz);
pages = atop(dmat->common.maxsize) - bz->total_bpages;
atop(dmat->common.lowaddr));
pages = MAX(atop(dmat->common.maxsize), 1);
#define MAX_BPAGES (Maxmem > atop(0x100000000ULL) ? 8192 : 512)
xatp.gpfn = atop(early_init_vtop(&shared_page.shared_info));
sin.sin_port = htons(atop(argv[3]));
src.sin_port = htons(atop(argv[2]));
dst.sin_port = htons(atop(argv[4]));