diff --git a/src/ikarus-collect.c b/src/ikarus-collect.c
index 3358d1d..6151bf4 100644
--- a/src/ikarus-collect.c
+++ b/src/ikarus-collect.c
@@ -373,7 +373,7 @@ extern void verify_integrity(ikpcb* pcb, char*);
 
 
 ikpcb* 
-ik_collect(int mem_req, ikpcb* pcb){
+ik_collect(unsigned long int mem_req, ikpcb* pcb){
 //  fprintf(stderr, "ik_collect\n");
 #ifndef NDEBUG
   verify_integrity(pcb, "entry");
@@ -400,10 +400,9 @@ ik_collect(int mem_req, ikpcb* pcb){
   gc.collect_gen_tag = next_gen_tag[gc.collect_gen];
   pcb->collection_id++;
 #ifndef NDEBUG
-  fprintf(stderr, "ik_collect entry %d free=%d (collect gen=%d/id=%d)\n",
+  fprintf(stderr, "ik_collect entry %ld free=%ld (collect gen=%d/id=%d)\n",
       mem_req,
-      (unsigned int) pcb->allocation_redline
-        - (unsigned int) pcb->allocation_pointer,
+       pcb->allocation_redline - pcb->allocation_pointer,
       gc.collect_gen, pcb->collection_id-1);
 #endif
 
@@ -498,12 +497,12 @@ ik_collect(int mem_req, ikpcb* pcb){
     old_heap_pages = 0;
   }
 
-  long int free_space = 
+  unsigned long int free_space = 
     ((unsigned long int)pcb->allocation_redline) - 
     ((unsigned long int)pcb->allocation_pointer);
   if((free_space <= mem_req) || (pcb->heap_size < IK_HEAPSIZE)){
 #ifndef NDEBUG
-    fprintf(stderr, "REQ=%d, got %d\n", mem_req, free_space);
+    fprintf(stderr, "REQ=%ld, got %ld\n", mem_req, free_space);
 #endif
     long int memsize = (mem_req > IK_HEAPSIZE) ? mem_req : IK_HEAPSIZE;
     memsize = align_to_next_page(memsize);
@@ -972,11 +971,11 @@ add_list(gc_t* gc, unsigned int t, ikptr x, ikptr* loc){
 
 static ikptr 
 #ifndef NDEBUG
-add_object_proc(gc_t* gc, ikptr x, char* caller)
+add_object_proc(gc_t* gc, ikptr x, char* caller) {
+  caller = caller;
 #else
-add_object_proc(gc_t* gc, ikptr x)
+add_object_proc(gc_t* gc, ikptr x) {
 #endif
-{
   if(is_fixnum(x)){ 
     return x;
   } 
@@ -1143,7 +1142,7 @@ add_object_proc(gc_t* gc, ikptr x)
       ikptr size =  ref(x, off_continuation_size);
 #ifndef NDEBUG
       if(size > 4096){
-        fprintf(stderr, "large cont size=0x%08x\n", size);
+        fprintf(stderr, "large cont size=0x%016lx\n", size);
       }
 #endif
       ikptr next = ref(x, off_continuation_next);
@@ -1173,8 +1172,8 @@ add_object_proc(gc_t* gc, ikptr x)
       ref(y,off_tcbucket_val) = ref(x, off_tcbucket_val);
       ref(y,off_tcbucket_next) = ref(x, off_tcbucket_next);
       if((! is_fixnum(key)) && (tagof(key) != immediate_tag)){
-        unsigned int kt = gc->segment_vector[page_index(key)];
-        if((kt & gen_mask) <= gc->collect_gen){
+        int gen = gc->segment_vector[page_index(key)] & gen_mask;
+        if(gen <= gc->collect_gen){
           /* key will be moved */
           gc_tconc_push(gc, y);
         }
@@ -1656,8 +1655,8 @@ scan_dirty_pointers_page(gc_t* gc, long int page_idx, int mask){
   dirty_vec[page_idx] = new_d;
 }
 
-static void            
-scan_dirty_code_page(gc_t* gc, long int page_idx, unsigned int mask){
+static void
+scan_dirty_code_page(gc_t* gc, long int page_idx){
   ikptr p = (ikptr)(page_idx << pageshift);
   ikptr start = p;
   ikptr q = p + pagesize;
@@ -1679,7 +1678,7 @@ scan_dirty_code_page(gc_t* gc, long int page_idx, unsigned int mask){
       ikptr rvec = ref(p, disp_code_reloc_vector);
       ikptr len = ref(rvec, off_vector_length);
       assert(((long)len) >= 0);
-      long int i;
+      unsigned long int i;
       unsigned long int code_d = segment_vec[page_index(rvec)];
       for(i=0; i<len; i+=wordsize){
         ikptr r = ref(rvec, i+off_vector_data);
@@ -1718,7 +1717,8 @@ scan_dirty_pages(gc_t* gc){
     unsigned int d = dirty_vec[i];
     if(d & mask){
       unsigned int t = segment_vec[i];
-      if((t & gen_mask) > collect_gen){
+      int tgen = t & gen_mask;
+      if(tgen > collect_gen){
         int type = t & type_mask;
         if(type == pointers_type){
           scan_dirty_pointers_page(gc, i, mask);
@@ -1736,11 +1736,9 @@ scan_dirty_pages(gc_t* gc){
           segment_vec = (unsigned int*)(long)pcb->segment_vector;
         }
         else if (type == code_type){
-          if((t & gen_mask) > collect_gen){
-            scan_dirty_code_page(gc, i, mask);
-            dirty_vec = (unsigned int*)(long)pcb->dirty_vector;
-            segment_vec = (unsigned int*)(long)pcb->segment_vector;
-          }
+          scan_dirty_code_page(gc, i);
+          dirty_vec = (unsigned int*)(long)pcb->dirty_vector;
+          segment_vec = (unsigned int*)(long)pcb->segment_vector;
         }
         else if (t & scannable_mask) {
           fprintf(stderr, "BUG: unhandled scan of type 0x%08x\n", t);
diff --git a/src/ikarus-data.h b/src/ikarus-data.h
index 7423c77..fb80b4e 100644
--- a/src/ikarus-data.h
+++ b/src/ikarus-data.h
@@ -146,14 +146,14 @@ typedef struct ikpcb{
   ikptr weak_pairs_ap;
   ikptr weak_pairs_ep;
   ikptr   heap_base; 
-  int   heap_size;
+  unsigned long int   heap_size;
   ikpages* heap_pages;
   ikpage* cached_pages; /* pages cached so that we don't map/unmap */
   ikpage* uncached_pages; /* ikpages cached so that we don't malloc/free */
   ikptr cached_pages_base;
   int cached_pages_size;
   ikptr   stack_base;
-  int   stack_size;
+  unsigned long int   stack_size;
   ikptr   symbol_table;
   ikptr   gensym_table;
   ik_ptr_page* protected_list[generation_count];
@@ -169,7 +169,7 @@ typedef struct ikpcb{
   struct timeval collect_rtime; 
 } ikpcb;
 
-ikpcb* ik_collect(int req, ikpcb* pcb);
+ikpcb* ik_collect(unsigned long int, ikpcb*);
 void ikarus_usage_short(void);
 
 void* ik_malloc(int);
@@ -182,7 +182,7 @@ ikptr ik_mmap_data(int size, int gen, ikpcb*);
 ikptr ik_mmap_code(int size, int gen, ikpcb*);
 ikptr ik_mmap_mixed(int size, ikpcb*);
 void ik_munmap(ikptr, int);
-void ik_munmap_from_segment(ikptr, int, ikpcb*);
+void ik_munmap_from_segment(ikptr, unsigned long int, ikpcb*);
 ikpcb* ik_make_pcb();
 void ik_delete_pcb(ikpcb*);
 void ik_free_symbol_table(ikpcb* pcb);
@@ -208,7 +208,7 @@ ikptr ik_safe_alloc(ikpcb* pcb, int size);
 #define IK_HEAP_EXT_SIZE  (32 * 4096)
 #define IK_HEAPSIZE       (1024 * ((wordsize==4)?1:2) * 4096) /* 4/8 MB */
 
-#define wordsize (sizeof(ikptr))
+#define wordsize ((int)(sizeof(ikptr)))
 #define wordshift ((wordsize == 4)?2:3)
 #define align_shift (wordshift + 1) 
 #define align_size (2 * wordsize)
diff --git a/src/ikarus-io.c b/src/ikarus-io.c
index bf059c3..2a9116f 100644
--- a/src/ikarus-io.c
+++ b/src/ikarus-io.c
@@ -32,7 +32,7 @@
 extern ikptr ik_errno_to_code();
 
 ikptr
-ikrt_close_fd(ikptr fd, ikpcb* pcb){
+ikrt_close_fd(ikptr fd /*, ikpcb* pcb */){
   int err = close(unfix(fd));
   if(err == -1){
     return ik_errno_to_code();
@@ -42,7 +42,7 @@ ikrt_close_fd(ikptr fd, ikpcb* pcb){
 }
 
 ikptr
-ikrt_open_input_fd(ikptr fn, ikpcb* pcb){
+ikrt_open_input_fd(ikptr fn /*, ikpcb* pcb */){
   int fh = open((char*)(long)(fn+off_bytevector_data), O_RDONLY, 0);
   if(fh >= 0){
     return fix(fh);
@@ -52,7 +52,7 @@ ikrt_open_input_fd(ikptr fn, ikpcb* pcb){
 }
 
 ikptr
-ikrt_open_output_fd(ikptr fn, ikptr ikopts, ikpcb* pcb){
+ikrt_open_output_fd(ikptr fn, ikptr ikopts /*, ikpcb* pcb */){
   int opts = unfix(ikopts);
   int mode = 0;
   switch (opts){
@@ -81,7 +81,7 @@ ikrt_open_output_fd(ikptr fn, ikptr ikopts, ikpcb* pcb){
 
 
 ikptr
-ikrt_read_fd(ikptr fd, ikptr bv, ikptr off, ikptr cnt, ikpcb* pcb){
+ikrt_read_fd(ikptr fd, ikptr bv, ikptr off, ikptr cnt /*, ikpcb* pcb */){
 #if 0
   fprintf(stderr, "READ: %d\n", unfix(fd));
 #endif
@@ -100,7 +100,7 @@ ikrt_read_fd(ikptr fd, ikptr bv, ikptr off, ikptr cnt, ikpcb* pcb){
 }
 
 ikptr
-ikrt_write_fd(ikptr fd, ikptr bv, ikptr off, ikptr cnt, ikpcb* pcb){
+ikrt_write_fd(ikptr fd, ikptr bv, ikptr off, ikptr cnt /*, ikpcb* pcb */){
 #if 0
   if (0) {
     fprintf(stderr, "WRITE %d, %p %d %d %d\n", 
@@ -170,17 +170,17 @@ do_connect(ikptr host, ikptr srvc, int socket_type){
 }
 
 ikptr
-ikrt_tcp_connect(ikptr host, ikptr srvc, ikpcb* pcb){
+ikrt_tcp_connect(ikptr host, ikptr srvc /*, ikpcb* pcb */){
   return do_connect(host, srvc, SOCK_STREAM);
 }
 
 ikptr
-ikrt_udp_connect(ikptr host, ikptr srvc, ikpcb* pcb){
+ikrt_udp_connect(ikptr host, ikptr srvc /*, ikpcb* pcb */){
   return do_connect(host, srvc, SOCK_DGRAM);
 }
 
 ikptr 
-ikrt_make_fd_nonblocking(ikptr fdptr, ikpcb* pcb){
+ikrt_make_fd_nonblocking(ikptr fdptr /*, ikpcb* pcb */){
   int fd = unfix(fdptr);
   int err = fcntl(fd, F_SETFL, O_NONBLOCK);
   if(err == -1){
@@ -190,7 +190,7 @@ ikrt_make_fd_nonblocking(ikptr fdptr, ikpcb* pcb){
 }
 
 ikptr 
-ikrt_select(ikptr fds, ikptr rfds, ikptr wfds, ikptr xfds, ikpcb* pcb){
+ikrt_select(ikptr fds, ikptr rfds, ikptr wfds, ikptr xfds /*, ikpcb* pcb */){
   int rv = select(unfix(fds),
                   (fd_set*)(rfds + off_bytevector_data),
                   (fd_set*)(wfds + off_bytevector_data),
@@ -203,7 +203,7 @@ ikrt_select(ikptr fds, ikptr rfds, ikptr wfds, ikptr xfds, ikpcb* pcb){
 }
 
 ikptr
-ikrt_listen(ikptr port, ikpcb* pcb){
+ikrt_listen(ikptr port /*, ikpcb* pcb */){
   
   int sock = socket(AF_INET, SOCK_STREAM, 0);
   if(sock < 0){
@@ -259,7 +259,7 @@ ikrt_getsockname(ikptr s, ikpcb* pcb){
 
 
 ikptr
-ikrt_accept(ikptr s, ikptr bv, ikpcb* pcb){
+ikrt_accept(ikptr s, ikptr bv /*, ikpcb* pcb */){
   socklen_t addrlen = unfix(ref(bv, off_bytevector_length));
   int sock = accept(unfix(s),
                     (struct sockaddr*) (bv+off_bytevector_data),
diff --git a/src/ikarus-main.c b/src/ikarus-main.c
index e9b6864..c594276 100644
--- a/src/ikarus-main.c
+++ b/src/ikarus-main.c
@@ -218,6 +218,7 @@ Notice how the bsd manpages have incorrect type for the handler.
 #endif
 
 void handler(int signo, siginfo_t* info, void* uap){
+  signo=signo; info=info; uap=uap; /* no warning */
   the_pcb->engine_counter = fix(-1);
   the_pcb->interrupted = 1;
 }
diff --git a/src/ikarus-numerics.c b/src/ikarus-numerics.c
index a0e95ed..cc92a84 100644
--- a/src/ikarus-numerics.c
+++ b/src/ikarus-numerics.c
@@ -40,14 +40,14 @@
 static ikptr
 verify_bignum(ikptr x, char* caller){
   if(tagof(x) != vector_tag){
-    fprintf(stderr, "Error in (%s) invalid primary tag %p\n", caller, x);
+    fprintf(stderr, "Error in (%s) invalid primary tag 0x%016lx\n", caller, x);
     exit(-1);
   }
   ikptr fst = ref(x, -vector_tag);
   long int limb_count = ((unsigned long int) fst) >> bignum_length_shift;
   if(limb_count <= 0){
     fprintf(stderr, 
-        "Error in (%s) invalid limb count in fst=0x%08x\n", 
+        "Error in (%s) invalid limb count in fst=0x%016lx\n",
         caller, (long int)fst);
     exit(-1);
   }
@@ -61,21 +61,21 @@ verify_bignum(ikptr x, char* caller){
     (mp_limb_t) ref(x, off_bignum_data + (limb_count - 1) * wordsize);
   if(last_limb == 0){
     fprintf(stderr, 
-        "Error in (%s) invalid last limb = 0x%08x", caller, last_limb);
+        "Error in (%s) invalid last limb = 0x%016lx", caller, last_limb);
     exit(-1);
   }
   if(limb_count == 1){
     if(pos){
       if(last_limb <= most_positive_fixnum){
         fprintf(stderr, 
-                "Error in (%s) should be a positive fixnum: 0x%08x\n", 
+                "Error in (%s) should be a positive fixnum: 0x%016lx\n", 
                 caller, last_limb);
         exit(-1);
       }
     } else {
       if(last_limb <= most_negative_fixnum){
         fprintf(stderr, 
-                "Error in (%s) should be a negative fixnum: 0x%08x\n", 
+                "Error in (%s) should be a negative fixnum: 0x%016lx\n", 
                 caller, last_limb);
         exit(-1);
       }
@@ -1045,7 +1045,7 @@ static inline int
 count_leading_ffs(int n, mp_limb_t* x){
   int idx;
   for(idx=0; idx<n; idx++){
-    if(x[idx] != -1){
+    if(x[idx] != (mp_limb_t)-1){
       return idx;
     }
   }
@@ -1189,7 +1189,7 @@ ikrt_bnlognot(ikptr x, ikpcb* pcb){
     /* positive */
     long int i;
     mp_limb_t* s1 = (mp_limb_t*)(long)(x+disp_bignum_data-vector_tag);
-    for(i=0; (i<n) && (s1[i] == -1); i++) {/*nothing*/}
+    for(i=0; (i<n) && (s1[i] == (mp_limb_t)-1); i++) {/*nothing*/}
     if(i==n){
       pcb->root0 = &x;
       ikptr r = ik_safe_alloc(pcb, align(disp_bignum_data + (n+1)*wordsize));
@@ -1789,7 +1789,7 @@ ikrt_bnfxdivrem(ikptr x, ikptr y, ikpcb* pcb){
 }
 
 ikptr
-ikrt_bnfx_modulo(ikptr x, ikptr y, ikpcb* pcb){
+ikrt_bnfx_modulo(ikptr x, ikptr y /*, ikpcb* pcb */){
   int yint = unfix(y);
   mp_limb_t* s2p = (mp_limb_t*)(long)(x+off_bignum_data);
   ikptr fst = ref(x, -vector_tag);
@@ -1838,7 +1838,7 @@ ikrt_bignum_length(ikptr x){
   int n0 = limb_length(last);
   if(((unsigned long int) fst) & bignum_sign_mask){
     /* negative */
-    if (last == (1<<(n0-1))){
+    if (last == (mp_limb_t)(1<<(n0-1))){
       /* single bit set in last limb */
       int i;
       for(i=0; i<(sn-1); i++){
diff --git a/src/ikarus-process.c b/src/ikarus-process.c
index 52496af..e1ec74f 100644
--- a/src/ikarus-process.c
+++ b/src/ikarus-process.c
@@ -52,7 +52,7 @@ list_to_vec(ikptr x){
 }
 
 ikptr 
-ikrt_process(ikptr rvec, ikptr cmd, ikptr argv, ikpcb* pcb){
+ikrt_process(ikptr rvec, ikptr cmd, ikptr argv /*, ikpcb* pcb */){
   int infds[2];
   int outfds[2];
   int errfds[2];
@@ -92,7 +92,7 @@ ikrt_process(ikptr rvec, ikptr cmd, ikptr argv, ikpcb* pcb){
 }
 
 ikptr 
-ikrt_waitpid(ikptr pid, ikpcb* pcb){
+ikrt_waitpid(ikptr pid /*, ikpcb* pcb */){
   int status;
   pid_t r = waitpid(unfix(pid), &status, 0);
   if(r >= 0){
diff --git a/src/ikarus-runtime.c b/src/ikarus-runtime.c
index 714c9b0..b18ade3 100644
--- a/src/ikarus-runtime.c
+++ b/src/ikarus-runtime.c
@@ -54,7 +54,7 @@ ikptr ik_mmap(int size);
 void ik_munmap(ikptr mem, int size);
 
 static void
-extend_table_maybe(ikptr p, int size, ikpcb* pcb){
+extend_table_maybe(ikptr p, unsigned long int size, ikpcb* pcb){
   assert(size == align_to_next_page(size));
   ikptr q = p + size;
   if(p < pcb->memory_base){
@@ -107,7 +107,7 @@ extend_table_maybe(ikptr p, int size, ikpcb* pcb){
 
 
 static void
-set_segment_type(ikptr base, int size, unsigned int type, ikpcb* pcb){
+set_segment_type(ikptr base, unsigned long int size, unsigned int type, ikpcb* pcb){
   assert(base >= pcb->memory_base);
   assert((base+size) <= pcb->memory_end);
   assert(size == align_to_next_page(size));
@@ -120,7 +120,7 @@ set_segment_type(ikptr base, int size, unsigned int type, ikpcb* pcb){
 }
 
 void
-ik_munmap_from_segment(ikptr base, int size, ikpcb* pcb){
+ik_munmap_from_segment(ikptr base, unsigned long int size, ikpcb* pcb){
   assert(base >= pcb->memory_base);
   assert((base+size) <= pcb->memory_end);
   assert(size == align_to_next_page(size));
@@ -557,7 +557,7 @@ ikptr ik_uuid(ikptr bv){
 
 
 ikptr
-ikrt_stat(ikptr filename, ikptr follow, ikpcb* pcb){
+ikrt_stat(ikptr filename, ikptr follow /*, ikpcb* pcb */){
   char* fn = (char*)(filename + off_bytevector_data);
   struct stat s;
   int r;
@@ -587,8 +587,8 @@ ikrt_stat(ikptr filename, ikptr follow, ikpcb* pcb){
 /* ikrt_file_exists needs to be removed.
    This is here only to be able to use old ikarus.boot.prebuilt */
 ikptr
-ikrt_file_exists(ikptr filename, ikpcb* pcb){
-  switch (ikrt_stat(filename, true_object, pcb)){
+ikrt_file_exists(ikptr filename /*, ikpcb* pcb */){
+  switch (ikrt_stat(filename, true_object /*, pcb */)){
     case fix(0):
     case fix(1):
     case fix(2):
@@ -648,7 +648,7 @@ ikrt_directory_list(ikptr filename, ikpcb* pcb){
 }
 
 ikptr
-ikrt_mkdir(ikptr path, ikptr mode, ikpcb* pcb){
+ikrt_mkdir(ikptr path, ikptr mode /*, ikpcb* pcb */){
   int r = mkdir((char*)(path+off_bytevector_data), unfix(mode));
   if(r == 0){
     return true_object;
@@ -657,7 +657,7 @@ ikrt_mkdir(ikptr path, ikptr mode, ikpcb* pcb){
 }
 
 ikptr
-ikrt_rmdir(ikptr path, ikpcb* pcb){
+ikrt_rmdir(ikptr path /*, ikpcb* pcb */){
   int r = rmdir((char*)(path+off_bytevector_data));
   if(r == 0){
     return true_object;
@@ -666,7 +666,7 @@ ikrt_rmdir(ikptr path, ikpcb* pcb){
 }
 
 ikptr
-ikrt_chmod(ikptr path, ikptr mode, ikpcb* pcb){
+ikrt_chmod(ikptr path, ikptr mode /*, ikpcb* pcb */){
   int r = chmod((char*)(path+off_bytevector_data), (mode_t)unfix(mode));
   if(r == 0){
     return true_object;
@@ -675,7 +675,7 @@ ikrt_chmod(ikptr path, ikptr mode, ikpcb* pcb){
 }
 
 ikptr
-ikrt_symlink(ikptr to, ikptr path, ikpcb* pcb){
+ikrt_symlink(ikptr to, ikptr path /*, ikpcb* pcb */){
   int r = symlink((char*)(to+off_bytevector_data), (char*)(path+off_bytevector_data));
   if(r == 0){
     return true_object;
@@ -998,17 +998,21 @@ ikrt_exit(ikptr status, ikpcb* pcb){
 }
 
 ikptr
-ikrt_nanosleep(ikptr secs, ikptr nsecs, ikpcb* pcb){
+ikrt_nanosleep(ikptr secs, ikptr nsecs /*, ikpcb* pcb */){
   struct timespec t;
   t.tv_sec = 
-    is_fixnum(secs) ? unfix(secs) : ref(secs, off_bignum_data);
+    is_fixnum(secs) 
+      ? (unsigned long) unfix(secs) 
+      : ref(secs, off_bignum_data);
   t.tv_nsec = 
-    is_fixnum(nsecs) ? unfix(nsecs) : ref(nsecs, off_bignum_data);
+    is_fixnum(nsecs) 
+      ? (unsigned long) unfix(nsecs)
+      : ref(nsecs, off_bignum_data);
   return fix(nanosleep(&t, NULL));
 }
 
 ikptr
-ikrt_chdir(ikptr pathbv, ikpcb* pcb){
+ikrt_chdir(ikptr pathbv /*, ikpcb* pcb */){
   int err = chdir(off_bytevector_data+(char*)pathbv);
   if(err == 0){
     return true_object;
diff --git a/src/ikarus-verify-integrity.c b/src/ikarus-verify-integrity.c
index b2c3aab..f708b93 100644
--- a/src/ikarus-verify-integrity.c
+++ b/src/ikarus-verify-integrity.c
@@ -74,7 +74,7 @@ verify_code(char* x, char* base, unsigned int* svec, unsigned int* dvec){
 
 static void 
 verify_object(ikptr x, char* base, unsigned int* svec, unsigned int* dvec){
-  
+  x=x; base=base; svec=svec; dvec=dvec; /* no warning */ 
 }
 
 
@@ -82,6 +82,7 @@ static char*
 verify_code_small(char* p, int s, unsigned int d, 
     char* base, unsigned int* svec, unsigned int* dvec){
   char* q = p + pagesize;
+  s=s; d=d; /* no warning */
   while(p < q){
     ikptr fst = ref(p, 0);
     if(fst == code_tag){
@@ -104,6 +105,7 @@ verify_code_small(char* p, int s, unsigned int d,
 static char*
 verify_code_large(char* p, unsigned int s, unsigned int d, 
     char* base, unsigned int* svec, unsigned int* dvec){
+  s=s; d=d; /* no warning */
   ikptr fst = ref(p, 0);
   fst += 0;
   assert(fst == code_tag);
@@ -144,6 +146,7 @@ verify_code_page(char* p, unsigned int s, unsigned int d,
 static char*
 verify_pointers_page(char* p, unsigned int s, unsigned int d, 
     char* base, unsigned int* svec, unsigned int* dvec){
+  s=s; d=d; /* no warning */
   {
     int i = 0;
     while(i < pagesize){