Date: Saturday, January 8, 2011 @ 19:12:36 Author: rtoy Path: /project/cmucl/cvsroot/src/lisp Modified: Config.x86_darwin Darwin-os.h gencgc.c gencgc.h Changes to support building on Mac OS X 10.6. When compiled on 10.6, the resulting binary still works on 10.5. lisp/Config.x86_darwin: o Add -m32 flag to build and link a 32-bit binary. lisp/Darwin-os.h: o Include <sys/ucontext.h> instead of <ucontext.h> to get rid of the error about deprecated functions in ucontext.h. lisp/gencgc.h: o Mac OS X defines PAGE_SIZE in a header and that conflicts with our name. Rename our PAGE_SIZE to GC_PAGE_SIZE. lisp/gencgc.c: o Rename PAGE_SIZE to GC_PAGE_SIZE. -------------------+ Config.x86_darwin | 4 - Darwin-os.h | 4 - gencgc.c | 162 ++++++++++++++++++++++++++-------------------------- gencgc.h | 14 ++-- 4 files changed, 92 insertions(+), 92 deletions(-) Index: src/lisp/Config.x86_darwin diff -u src/lisp/Config.x86_darwin:1.9 src/lisp/Config.x86_darwin:1.10 --- src/lisp/Config.x86_darwin:1.9 Fri Jul 30 18:51:58 2010 +++ src/lisp/Config.x86_darwin Sat Jan 8 19:12:36 2011 @@ -5,7 +5,7 @@ # Compile code that will run on OSX 10.4 (Tiger) MIN_VER = -mmacosx-version-min=10.4 -CPPFLAGS += -DDARWIN $(MIN_VER) +CPPFLAGS += -DDARWIN $(MIN_VER) -m32 CFLAGS += -g3 ASFLAGS += -g3 $(MIN_VER) @@ -13,7 +13,7 @@ UNDEFSYMPATTERN = -Xlinker -u -Xlinker & OS_SRC += Darwin-os.c mach-o.c -OS_LINK_FLAGS = $(MIN_VER) +OS_LINK_FLAGS = -m32 $(MIN_VER) OS_LIBS = EXEC_FINAL_OBJ = exec-final.o Index: src/lisp/Darwin-os.h diff -u src/lisp/Darwin-os.h:1.7 src/lisp/Darwin-os.h:1.8 --- src/lisp/Darwin-os.h:1.7 Thu Jan 3 06:41:54 2008 +++ src/lisp/Darwin-os.h Sat Jan 8 19:12:36 2011 @@ -1,6 +1,6 @@ /* - $Header: /project/cmucl/cvsroot/src/lisp/Darwin-os.h,v 1.7 2008-01-03 11:41:54 cshapiro Rel $ + $Header: /project/cmucl/cvsroot/src/lisp/Darwin-os.h,v 1.8 2011-01-09 00:12:36 rtoy Exp $ This code was written as part of the CMU Common Lisp project at Carnegie Mellon University, and has been placed in the public domain. @@ -14,7 +14,7 @@ #include <sys/mman.h> #include <sys/signal.h> #include <signal.h> -#include <ucontext.h> +#include <sys/ucontext.h> #include <mach/vm_types.h> typedef caddr_t os_vm_address_t; Index: src/lisp/gencgc.c diff -u src/lisp/gencgc.c:1.111 src/lisp/gencgc.c:1.112 --- src/lisp/gencgc.c:1.111 Tue Dec 21 21:12:52 2010 +++ src/lisp/gencgc.c Sat Jan 8 19:12:36 2011 @@ -7,7 +7,7 @@ * * Douglas Crosher, 1996, 1997, 1998, 1999. * - * $Header: /project/cmucl/cvsroot/src/lisp/gencgc.c,v 1.111 2010-12-22 02:12:52 rtoy Exp $ + * $Header: /project/cmucl/cvsroot/src/lisp/gencgc.c,v 1.112 2011-01-09 00:12:36 rtoy Exp $ * */ @@ -324,7 +324,7 @@ /* * The minimum size for a large object. */ -unsigned large_object_size = 4 * PAGE_SIZE; +unsigned large_object_size = 4 * GC_PAGE_SIZE; /* * Enable the filtering of stack/register pointers. This could reduce @@ -394,7 +394,7 @@ static char * page_address(int page_num) { - return heap_base + PAGE_SIZE * page_num; + return heap_base + GC_PAGE_SIZE * page_num; } /* @@ -407,7 +407,7 @@ int index = (char *) addr - heap_base; if (index >= 0) { - index = (unsigned int) index / PAGE_SIZE; + index = (unsigned int) index / GC_PAGE_SIZE; if (index < dynamic_space_pages) return index; } @@ -441,7 +441,7 @@ "*** Page fault in page not marked as write protected\n"); /* Un-protect the page */ - os_protect((os_vm_address_t) page_address(page_index), PAGE_SIZE, OS_VM_PROT_ALL); + os_protect((os_vm_address_t) page_address(page_index), GC_PAGE_SIZE, OS_VM_PROT_ALL); page_table[page_index].flags &= ~PAGE_WRITE_PROTECTED_MASK; page_table[page_index].flags |= PAGE_WRITE_PROTECT_CLEARED_MASK; @@ -712,7 +712,7 @@ gens = NUM_GENERATIONS; /* Print the heap stats */ - fprintf(stderr, " Page count (%d KB)\n", PAGE_SIZE / 1024); + fprintf(stderr, " Page count (%d KB)\n", GC_PAGE_SIZE / 1024); fprintf(stderr, " Gen Boxed Unboxed LB LUB Alloc Waste Trigger WP GCs Mem-age\n"); @@ -750,7 +750,7 @@ fprintf(stderr, " %5d: %5d %5d %5d %5d %10d %6d %10d %4d %3d %7.4f\n", i, boxed_cnt, unboxed_cnt, large_boxed_cnt, large_unboxed_cnt, generations[i].bytes_allocated, - PAGE_SIZE * count_generation_pages(i) - + GC_PAGE_SIZE * count_generation_pages(i) - generations[i].bytes_allocated, generations[i].gc_trigger, count_write_protect_generation_pages(i), generations[i].num_gc, gen_av_mem_age(i)); @@ -993,7 +993,7 @@ if (!(flags & PAGE_ALLOCATED_MASK) || ((flags & mmask) == mflags && - page_table[first_page].bytes_used < PAGE_SIZE - 32)) + page_table[first_page].bytes_used < GC_PAGE_SIZE - 32)) break; first_page++; } @@ -1022,19 +1022,19 @@ * number of pages in a region. */ last_page = first_page; - bytes_found = PAGE_SIZE - page_table[first_page].bytes_used; + bytes_found = GC_PAGE_SIZE - page_table[first_page].bytes_used; num_pages = 1; while ((bytes_found < nbytes || num_pages < 2) && last_page < dynamic_space_pages - 1 && !PAGE_ALLOCATED(last_page + 1)) { last_page++; num_pages++; - bytes_found += PAGE_SIZE; + bytes_found += GC_PAGE_SIZE; gc_assert(!PAGE_WRITE_PROTECTED(last_page)); } - region_size = (PAGE_SIZE - page_table[first_page].bytes_used) - + PAGE_SIZE * (last_page - first_page); + region_size = (GC_PAGE_SIZE - page_table[first_page].bytes_used) + + GC_PAGE_SIZE * (last_page - first_page); gc_assert(bytes_found == region_size); @@ -1113,7 +1113,7 @@ if (last_page + 1 > last_free_page) { last_free_page = last_page + 1; set_alloc_pointer((lispobj) ((char *) heap_base + - PAGE_SIZE * last_free_page)); + GC_PAGE_SIZE * last_free_page)); } } @@ -1174,14 +1174,14 @@ gc_abort(); } - new_area_start = PAGE_SIZE * first_page + offset; + new_area_start = GC_PAGE_SIZE * first_page + offset; /* * Search backwards for a prior area that this follows from. If * found this will save adding a new area. */ for (i = new_areas_index - 1, c = 0; i >= 0 && c < 8; i--, c++) { - unsigned area_end = PAGE_SIZE * (*new_areas)[i].page + unsigned area_end = GC_PAGE_SIZE * (*new_areas)[i].page + (*new_areas)[i].offset + (*new_areas)[i].size; #if 0 @@ -1281,8 +1281,8 @@ */ more = 0; bytes_used = alloc_region->free_pointer - page_address(first_page); - if (bytes_used > PAGE_SIZE) { - bytes_used = PAGE_SIZE; + if (bytes_used > GC_PAGE_SIZE) { + bytes_used = GC_PAGE_SIZE; more = 1; } page_table[first_page].bytes_used = bytes_used; @@ -1309,8 +1309,8 @@ /* Calc. the number of bytes used in this page. */ more = 0; bytes_used = alloc_region->free_pointer - page_address(next_page); - if (bytes_used > PAGE_SIZE) { - bytes_used = PAGE_SIZE; + if (bytes_used > GC_PAGE_SIZE) { + bytes_used = GC_PAGE_SIZE; more = 1; } page_table[next_page].bytes_used = bytes_used; @@ -1456,7 +1456,7 @@ if (!(flags & PAGE_ALLOCATED_MASK) || ((flags & mmask) == mflags && - page_table[first_page].bytes_used < PAGE_SIZE - 32)) + page_table[first_page].bytes_used < GC_PAGE_SIZE - 32)) break; first_page++; } @@ -1478,19 +1478,19 @@ #endif last_page = first_page; - bytes_found = PAGE_SIZE - page_table[first_page].bytes_used; + bytes_found = GC_PAGE_SIZE - page_table[first_page].bytes_used; num_pages = 1; while (bytes_found < nbytes && last_page < dynamic_space_pages - 1 && !PAGE_ALLOCATED(last_page + 1)) { last_page++; num_pages++; - bytes_found += PAGE_SIZE; + bytes_found += GC_PAGE_SIZE; gc_assert(!PAGE_WRITE_PROTECTED(last_page)); } - region_size = (PAGE_SIZE - page_table[first_page].bytes_used) - + PAGE_SIZE * (last_page - first_page); + region_size = (GC_PAGE_SIZE - page_table[first_page].bytes_used) + + GC_PAGE_SIZE * (last_page - first_page); gc_assert(bytes_found == region_size); @@ -1555,8 +1555,8 @@ */ more = 0; bytes_used = nbytes + orig_first_page_bytes_used; - if (bytes_used > PAGE_SIZE) { - bytes_used = PAGE_SIZE; + if (bytes_used > GC_PAGE_SIZE) { + bytes_used = GC_PAGE_SIZE; more = 1; } page_table[first_page].bytes_used = bytes_used; @@ -1579,13 +1579,13 @@ PAGE_FLAGS_UPDATE(next_page, mmask, mflags); page_table[next_page].first_object_offset = - orig_first_page_bytes_used - PAGE_SIZE * (next_page - first_page); + orig_first_page_bytes_used - GC_PAGE_SIZE * (next_page - first_page); /* Calc. the number of bytes used in this page. */ more = 0; bytes_used = nbytes + orig_first_page_bytes_used - byte_cnt; - if (bytes_used > PAGE_SIZE) { - bytes_used = PAGE_SIZE; + if (bytes_used > GC_PAGE_SIZE) { + bytes_used = GC_PAGE_SIZE; more = 1; } page_table[next_page].bytes_used = bytes_used; @@ -1607,7 +1607,7 @@ if (last_page + 1 > last_free_page) { last_free_page = last_page + 1; set_alloc_pointer((lispobj) ((char *) heap_base + - PAGE_SIZE * last_free_page)); + GC_PAGE_SIZE * last_free_page)); } return (void *) (page_address(first_page) + orig_first_page_bytes_used); @@ -1961,7 +1961,7 @@ return page_index >= 0 && (page_index = - (unsigned int) page_index / PAGE_SIZE) < dynamic_space_pages + (unsigned int) page_index / GC_PAGE_SIZE) < dynamic_space_pages && PAGE_GENERATION(page_index) == from_space; } @@ -1972,7 +1972,7 @@ return page_index >= 0 && (page_index = - (unsigned int) page_index / PAGE_SIZE) < dynamic_space_pages + (unsigned int) page_index / GC_PAGE_SIZE) < dynamic_space_pages && PAGE_GENERATION(page_index) == new_space; } @@ -2170,14 +2170,14 @@ next_page = first_page; remaining_bytes = nwords * sizeof(lispobj); - while (remaining_bytes > PAGE_SIZE) { + while (remaining_bytes > GC_PAGE_SIZE) { gc_assert(PAGE_GENERATION(next_page) == from_space); gc_assert(PAGE_ALLOCATED(next_page)); gc_assert(!PAGE_UNBOXED(next_page)); gc_assert(PAGE_LARGE_OBJECT(next_page)); gc_assert(page_table[next_page].first_object_offset == - PAGE_SIZE * (first_page - next_page)); - gc_assert(page_table[next_page].bytes_used == PAGE_SIZE); + GC_PAGE_SIZE * (first_page - next_page)); + gc_assert(page_table[next_page].bytes_used == GC_PAGE_SIZE); PAGE_FLAGS_UPDATE(next_page, PAGE_GENERATION_MASK, new_space); @@ -2186,11 +2186,11 @@ * WP flag to avoid redundant calls. */ if (PAGE_WRITE_PROTECTED(next_page)) { - os_protect((os_vm_address_t) page_address(next_page), PAGE_SIZE, + os_protect((os_vm_address_t) page_address(next_page), GC_PAGE_SIZE, OS_VM_PROT_ALL); page_table[next_page].flags &= ~PAGE_WRITE_PROTECTED_MASK; } - remaining_bytes -= PAGE_SIZE; + remaining_bytes -= GC_PAGE_SIZE; next_page++; } @@ -2218,10 +2218,10 @@ /* Free any remaining pages; needs care. */ next_page++; - while (old_bytes_used == PAGE_SIZE && + while (old_bytes_used == GC_PAGE_SIZE && PAGE_FLAGS(next_page, mmask) == mflags && page_table[next_page].first_object_offset == - PAGE_SIZE * (first_page - next_page)) { + GC_PAGE_SIZE * (first_page - next_page)) { /* * Checks out OK, free the page. Don't need to both zeroing * pages as this should have been done before shrinking the @@ -2352,18 +2352,18 @@ next_page = first_page; remaining_bytes = nwords * sizeof(lispobj); - while (remaining_bytes > PAGE_SIZE) { + while (remaining_bytes > GC_PAGE_SIZE) { gc_assert(PAGE_GENERATION(next_page) == from_space); gc_assert(PAGE_ALLOCATED(next_page)); gc_assert(PAGE_LARGE_OBJECT(next_page)); gc_assert(page_table[next_page].first_object_offset == - PAGE_SIZE * (first_page - next_page)); - gc_assert(page_table[next_page].bytes_used == PAGE_SIZE); + GC_PAGE_SIZE * (first_page - next_page)); + gc_assert(page_table[next_page].bytes_used == GC_PAGE_SIZE); PAGE_FLAGS_UPDATE(next_page, PAGE_UNBOXED_MASK | PAGE_GENERATION_MASK, PAGE_UNBOXED_MASK | new_space); - remaining_bytes -= PAGE_SIZE; + remaining_bytes -= GC_PAGE_SIZE; next_page++; } @@ -2391,10 +2391,10 @@ /* Free any remaining pages; needs care. */ next_page++; - while (old_bytes_used == PAGE_SIZE && + while (old_bytes_used == GC_PAGE_SIZE && PAGE_FLAGS(next_page, mmask) == mflags && page_table[next_page].first_object_offset == - PAGE_SIZE * (first_page - next_page)) { + GC_PAGE_SIZE * (first_page - next_page)) { /* * Checks out OK, free the page. Don't need to both zeroing * pages as this should have been done before shrinking the @@ -5880,13 +5880,13 @@ next_page = first_page; remaining_bytes = nwords * sizeof(lispobj); - while (remaining_bytes > PAGE_SIZE) { + while (remaining_bytes > GC_PAGE_SIZE) { gc_assert(PAGE_GENERATION(next_page) == from_space); gc_assert(PAGE_ALLOCATED(next_page)); gc_assert(PAGE_LARGE_OBJECT(next_page)); gc_assert(page_table[next_page].first_object_offset == - PAGE_SIZE * (first_page - next_page)); - gc_assert(page_table[next_page].bytes_used == PAGE_SIZE); + GC_PAGE_SIZE * (first_page - next_page)); + gc_assert(page_table[next_page].bytes_used == GC_PAGE_SIZE); PAGE_FLAGS_UPDATE(next_page, PAGE_UNBOXED_MASK, unboxed << PAGE_UNBOXED_SHIFT); @@ -5896,7 +5896,7 @@ * pages aren't. */ gc_assert(!PAGE_WRITE_PROTECTED(next_page)); - remaining_bytes -= PAGE_SIZE; + remaining_bytes -= GC_PAGE_SIZE; next_page++; } @@ -5924,9 +5924,9 @@ /* Free any remaining pages; needs care. */ next_page++; - while (old_bytes_used == PAGE_SIZE && + while (old_bytes_used == GC_PAGE_SIZE && PAGE_FLAGS(next_page, mmask) == mflags && - page_table[next_page].first_object_offset == PAGE_SIZE * (first_page + page_table[next_page].first_object_offset == GC_PAGE_SIZE * (first_page - next_page)) { @@ -6010,7 +6010,7 @@ while (page_table[first_page].first_object_offset != 0) { first_page--; /* Do some checks */ - gc_assert(page_table[first_page].bytes_used == PAGE_SIZE); + gc_assert(page_table[first_page].bytes_used == GC_PAGE_SIZE); gc_assert(PAGE_GENERATION(first_page) == from_space); gc_assert(PAGE_ALLOCATED(first_page)); gc_assert(PAGE_UNBOXED(first_page) == region_unboxed); @@ -6072,8 +6072,8 @@ gc_assert(!PAGE_WRITE_PROTECTED(i)); /* Check if this is the last page in this contiguous block */ - if (page_table[i].bytes_used < PAGE_SIZE - /* Or it is PAGE_SIZE and is the last in the block */ + if (page_table[i].bytes_used < GC_PAGE_SIZE + /* Or it is GC_PAGE_SIZE and is the last in the block */ || !PAGE_ALLOCATED(i + 1) || page_table[i + 1].bytes_used == 0 /* Next page free */ || PAGE_GENERATION(i + 1) != from_space /* Diff. gen */ @@ -6214,7 +6214,7 @@ fprintf(stderr, "* WP page %d of gen %d\n", page, gen); #endif - os_protect((os_vm_address_t) page_addr, PAGE_SIZE, + os_protect((os_vm_address_t) page_addr, GC_PAGE_SIZE, OS_VM_PROT_READ | OS_VM_PROT_EXECUTE); /* Note the page as protected in the page tables */ @@ -6292,8 +6292,8 @@ */ for (last_page = i;; last_page++) /* Check if this is the last page in this contiguous block */ - if (page_table[last_page].bytes_used < PAGE_SIZE - /* Or it is PAGE_SIZE and is the last in the block */ + if (page_table[last_page].bytes_used < GC_PAGE_SIZE + /* Or it is GC_PAGE_SIZE and is the last in the block */ || !PAGE_ALLOCATED(last_page + 1) || PAGE_UNBOXED(last_page + 1) || page_table[last_page + 1].bytes_used == 0 @@ -6318,7 +6318,7 @@ #endif { scavenge(page_address(i), (page_table[last_page].bytes_used - + PAGE_SIZE * (last_page - + + GC_PAGE_SIZE * (last_page - i)) / sizeof(lispobj)); @@ -6425,8 +6425,8 @@ */ for (last_page = i;; last_page++) /* Check if this is the last page in this contiguous block */ - if (page_table[last_page].bytes_used < PAGE_SIZE - /* Or it is PAGE_SIZE and is the last in the block */ + if (page_table[last_page].bytes_used < GC_PAGE_SIZE + /* Or it is GC_PAGE_SIZE and is the last in the block */ || !PAGE_ALLOCATED(last_page + 1) || PAGE_UNBOXED(last_page + 1) || page_table[last_page + 1].bytes_used == 0 @@ -6462,7 +6462,7 @@ else size = (page_table[last_page].bytes_used + - PAGE_SIZE * (last_page - i) - + GC_PAGE_SIZE * (last_page - i) - page_table[i].first_object_offset) / sizeof(lispobj); @@ -6750,7 +6750,7 @@ * WP flag to avoid redundant calls. */ if (PAGE_WRITE_PROTECTED(i)) { - os_protect((os_vm_address_t) page_start, PAGE_SIZE, + os_protect((os_vm_address_t) page_start, GC_PAGE_SIZE, OS_VM_PROT_ALL); page_table[i].flags &= ~PAGE_WRITE_PROTECTED_MASK; } @@ -6802,7 +6802,7 @@ void *page_start = (void *) page_address(last_page); if (PAGE_WRITE_PROTECTED(last_page)) { - os_protect((os_vm_address_t) page_start, PAGE_SIZE, + os_protect((os_vm_address_t) page_start, GC_PAGE_SIZE, OS_VM_PROT_ALL); page_table[last_page].flags &= ~PAGE_WRITE_PROTECTED_MASK; } @@ -6820,10 +6820,10 @@ page_start = page_address(first_page); os_invalidate((os_vm_address_t) page_start, - PAGE_SIZE * (last_page - first_page)); + GC_PAGE_SIZE * (last_page - first_page)); addr = (char *) os_validate((os_vm_address_t) page_start, - PAGE_SIZE * (last_page - first_page)); + GC_PAGE_SIZE * (last_page - first_page)); if (addr == NULL || addr != page_start) fprintf(stderr, "gc_zero: page moved, 0x%08lx ==> 0x%08lx!\n", (unsigned long) page_start, (unsigned long) addr); @@ -6831,7 +6831,7 @@ int *page_start; page_start = (int *) page_address(first_page); - memset(page_start, 0, PAGE_SIZE * (last_page - first_page)); + memset(page_start, 0, GC_PAGE_SIZE * (last_page - first_page)); } first_page = last_page; @@ -7150,8 +7150,8 @@ */ for (last_page = i;; last_page++) /* Check if this is the last page in this contiguous block */ - if (page_table[last_page].bytes_used < PAGE_SIZE - /* Or it is PAGE_SIZE and is the last in the block */ + if (page_table[last_page].bytes_used < GC_PAGE_SIZE + /* Or it is GC_PAGE_SIZE and is the last in the block */ || !PAGE_ALLOCATED(last_page + 1) || PAGE_UNBOXED(last_page + 1) != region_unboxed || page_table[last_page + 1].bytes_used == 0 @@ -7161,7 +7161,7 @@ verify_space((lispobj *) page_address(i), (page_table[last_page].bytes_used + - PAGE_SIZE * (last_page - i)) / sizeof(lispobj)); + GC_PAGE_SIZE * (last_page - i)) / sizeof(lispobj)); i = last_page; } } @@ -7185,7 +7185,7 @@ fprintf(stderr, "** free page not zero @ %lx\n", (unsigned long) (start_addr + i)); } else { - int free_bytes = PAGE_SIZE - page_table[page].bytes_used; + int free_bytes = GC_PAGE_SIZE - page_table[page].bytes_used; if (free_bytes > 0) { unsigned long *start_addr = @@ -7251,7 +7251,7 @@ page_start = (void *) page_address(i); - os_protect((os_vm_address_t) page_start, PAGE_SIZE, + os_protect((os_vm_address_t) page_start, GC_PAGE_SIZE, OS_VM_PROT_READ | OS_VM_PROT_EXECUTE); /* Note the page as protected in the page tables */ @@ -7396,7 +7396,7 @@ fprintf(stderr, "Non-movable pages due to conservative pointers = %d, %d bytes\n", - num_dont_move_pages, PAGE_SIZE * num_dont_move_pages); + num_dont_move_pages, GC_PAGE_SIZE * num_dont_move_pages); #if !(defined(i386) || defined(__x86_64)) /* * There shouldn't be any non-movable pages because we don't have @@ -7576,7 +7576,7 @@ last_free_page = last_page + 1; set_alloc_pointer((lispobj) - ((char *) heap_base + PAGE_SIZE * last_free_page)); + ((char *) heap_base + GC_PAGE_SIZE * last_free_page)); } @@ -7770,12 +7770,12 @@ page_start = (void *) page_address(page); /* First remove any write protection */ - os_protect((os_vm_address_t) page_start, PAGE_SIZE, OS_VM_PROT_ALL); + os_protect((os_vm_address_t) page_start, GC_PAGE_SIZE, OS_VM_PROT_ALL); page_table[page].flags &= ~PAGE_WRITE_PROTECTED_MASK; - os_invalidate((os_vm_address_t) page_start, PAGE_SIZE); + os_invalidate((os_vm_address_t) page_start, GC_PAGE_SIZE); addr = - (char *) os_validate((os_vm_address_t) page_start, PAGE_SIZE); + (char *) os_validate((os_vm_address_t) page_start, GC_PAGE_SIZE); if (addr == NULL || addr != page_start) fprintf(stderr, "gc_zero: page moved, 0x%08lx ==> 0x%08lx!\n", (unsigned long) page_start, (unsigned long) addr); @@ -7853,7 +7853,7 @@ heap_base = (void *) DYNAMIC_0_SPACE_START; /* The number of pages needed for the dynamic space - rounding up. */ - dynamic_space_pages = (dynamic_space_size + (PAGE_SIZE - 1)) / PAGE_SIZE; + dynamic_space_pages = (dynamic_space_size + (GC_PAGE_SIZE - 1)) / GC_PAGE_SIZE; page_table = (struct page *) malloc(dynamic_space_pages * sizeof(struct page)); @@ -7932,16 +7932,16 @@ page_table[page].flags |= PAGE_ALLOCATED_MASK; page_table[page].flags &= ~(PAGE_UNBOXED_MASK | PAGE_GENERATION_MASK | PAGE_LARGE_OBJECT_MASK); - page_table[page].bytes_used = PAGE_SIZE; + page_table[page].bytes_used = GC_PAGE_SIZE; page_table[page].first_object_offset = (char *) DYNAMIC_0_SPACE_START - page_address(page); - addr += PAGE_SIZE; + addr += GC_PAGE_SIZE; page++; } while (addr < alloc_ptr); - generations[0].bytes_allocated = PAGE_SIZE * page; - bytes_allocated = PAGE_SIZE * page; + generations[0].bytes_allocated = GC_PAGE_SIZE * page; + bytes_allocated = GC_PAGE_SIZE * page; set_current_region_free((lispobj) boxed_region.free_pointer); set_current_region_end((lispobj) boxed_region.end_addr); Index: src/lisp/gencgc.h diff -u src/lisp/gencgc.h:1.16 src/lisp/gencgc.h:1.17 --- src/lisp/gencgc.h:1.16 Mon Nov 2 10:05:07 2009 +++ src/lisp/gencgc.h Sat Jan 8 19:12:36 2011 @@ -7,7 +7,7 @@ * * Douglas Crosher, 1996, 1997. * - * $Header: /project/cmucl/cvsroot/src/lisp/gencgc.h,v 1.16 2009-11-02 15:05:07 rtoy Rel $ + * $Header: /project/cmucl/cvsroot/src/lisp/gencgc.h,v 1.17 2011-01-09 00:12:36 rtoy Exp $ * */ @@ -124,7 +124,7 @@ */ #if defined(i386) -#define PAGE_SIZE 4096 +#define GC_PAGE_SIZE 4096 #elif defined(sparc) /* * For sparc, the minimum page size (physical page size) is 8K. @@ -134,17 +134,17 @@ * page size. (I'm assuming the gain is because we do the kernel * allocation trap less often.) */ -#define PAGE_SIZE (4*8192) +#define GC_PAGE_SIZE (4*8192) #elif defined(DARWIN) /* * The physical page size is 4K. Like sparc, this appears to be * somewhat slow (but need to verify that), so let's make the page * size 32K so we hit the allocation trap less often. */ -/*#define PAGE_SIZE 4096*/ -/*#define PAGE_SIZE (2*4096)*/ -#define PAGE_SIZE (4*4096) -/*#define PAGE_SIZE (8*4096)*/ +/*#define GC_PAGE_SIZE 4096*/ +/*#define GC_PAGE_SIZE (2*4096)*/ +#define GC_PAGE_SIZE (4*4096) +/*#define GC_PAGE_SIZE (8*4096)*/ #endif extern unsigned dynamic_space_pages;