projects / sbcl.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
0.6.10.2:
[sbcl.git] / src / runtime / purify.c
diff --git a/src/runtime/purify.c b/src/runtime/purify.c
index c34eb01..2d1e4f4 100644 (file)
--- a/src/runtime/purify.c
+++ b/src/runtime/purify.c
@@ -13,10 +13,6 @@
  * files for more information.
  */
 
-/*
- * $Header$
- */
-
 #include <stdio.h>
 #include <sys/types.h>
 #include <stdlib.h>
@@ -250,14 +246,16 @@ valid_dynamic_space_pointer(lispobj *pointer, lispobj *start_addr)
     case type_ByteCodeClosure:
       if ((int)pointer != ((int)start_addr+type_FunctionPointer)) {
        if (pointer_filter_verbose) {
-         fprintf(stderr,"*Wf2: %x %x %x\n", pointer, start_addr, *start_addr);
+         fprintf(stderr,"*Wf2: %x %x %x\n", (unsigned int) pointer, 
+                 (unsigned int) start_addr, *start_addr);
        }
        return 0;
       }
       break;
     default:
       if (pointer_filter_verbose) {
-       fprintf(stderr,"*Wf3: %x %x %x\n", pointer, start_addr, *start_addr);
+       fprintf(stderr,"*Wf3: %x %x %x\n", (unsigned int) pointer, 
+               (unsigned int) start_addr, *start_addr);
       }
       return 0;
     }
@@ -265,7 +263,8 @@ valid_dynamic_space_pointer(lispobj *pointer, lispobj *start_addr)
   case type_ListPointer:
     if ((int)pointer != ((int)start_addr+type_ListPointer)) {
       if (pointer_filter_verbose)
-       fprintf(stderr,"*Wl1: %x %x %x\n", pointer, start_addr, *start_addr);
+       fprintf(stderr,"*Wl1: %x %x %x\n", (unsigned int) pointer, 
+               (unsigned int) start_addr, *start_addr);
       return 0;
     }
     /* Is it plausible cons? */
@@ -280,20 +279,23 @@ valid_dynamic_space_pointer(lispobj *pointer, lispobj *start_addr)
       break;
     } else {
       if (pointer_filter_verbose) {
-       fprintf(stderr,"*Wl2: %x %x %x\n", pointer, start_addr, *start_addr);
+       fprintf(stderr,"*Wl2: %x %x %x\n", (unsigned int) pointer, 
+               (unsigned int) start_addr, *start_addr);
       }
       return 0;
     }
   case type_InstancePointer:
     if ((int)pointer != ((int)start_addr+type_InstancePointer)) {
       if (pointer_filter_verbose) {
-       fprintf(stderr,"*Wi1: %x %x %x\n", pointer, start_addr, *start_addr);
+       fprintf(stderr,"*Wi1: %x %x %x\n", (unsigned int) pointer, 
+               (unsigned int) start_addr, *start_addr);
       }
       return 0;
     }
     if (TypeOf(start_addr[0]) != type_InstanceHeader) {
       if (pointer_filter_verbose) {
-       fprintf(stderr,"*Wi2: %x %x %x\n", pointer, start_addr, *start_addr);
+       fprintf(stderr,"*Wi2: %x %x %x\n", (unsigned int) pointer, 
+               (unsigned int) start_addr, *start_addr);
       }
       return 0;
     }
@@ -301,14 +303,16 @@ valid_dynamic_space_pointer(lispobj *pointer, lispobj *start_addr)
   case type_OtherPointer:
     if ((int)pointer != ((int)start_addr+type_OtherPointer)) {
       if (pointer_filter_verbose) {
-       fprintf(stderr,"*Wo1: %x %x %x\n", pointer, start_addr, *start_addr);
+       fprintf(stderr,"*Wo1: %x %x %x\n", (unsigned int) pointer, 
+               (unsigned int) start_addr, *start_addr);
       }
       return 0;
     }
     /* Is it plausible?  Not a cons. X should check the headers. */
     if(Pointerp(start_addr[0]) || ((start_addr[0] & 3) == 0)) {
       if (pointer_filter_verbose) {
-       fprintf(stderr,"*Wo2: %x %x %x\n", pointer, start_addr, *start_addr);
+       fprintf(stderr,"*Wo2: %x %x %x\n", (unsigned int) pointer, 
+               (unsigned int) start_addr, *start_addr);
       }
       return 0;
     }
@@ -316,7 +320,8 @@ valid_dynamic_space_pointer(lispobj *pointer, lispobj *start_addr)
     case type_UnboundMarker:
     case type_BaseChar:
       if (pointer_filter_verbose) {
-       fprintf(stderr,"*Wo3: %x %x %x\n", pointer, start_addr, *start_addr);
+       fprintf(stderr,"*Wo3: %x %x %x\n", (unsigned int) pointer, 
+               (unsigned int) start_addr, *start_addr);
       }
       return 0;
 
@@ -326,13 +331,15 @@ valid_dynamic_space_pointer(lispobj *pointer, lispobj *start_addr)
     case type_ByteCodeFunction:
     case type_ByteCodeClosure:
       if (pointer_filter_verbose) {
-       fprintf(stderr,"*Wo4: %x %x %x\n", pointer, start_addr, *start_addr);
+       fprintf(stderr,"*Wo4: %x %x %x\n", (unsigned int) pointer, 
+               (unsigned int) start_addr, *start_addr);
       }
       return 0;
 
     case type_InstanceHeader:
       if (pointer_filter_verbose) {
-       fprintf(stderr,"*Wo5: %x %x %x\n", pointer, start_addr, *start_addr);
+       fprintf(stderr,"*Wo5: %x %x %x\n", (unsigned int) pointer, 
+               (unsigned int) start_addr, *start_addr);
       }
       return 0;
 
@@ -403,14 +410,16 @@ valid_dynamic_space_pointer(lispobj *pointer, lispobj *start_addr)
 
     default:
       if (pointer_filter_verbose) {
-       fprintf(stderr,"*Wo6: %x %x %x\n", pointer, start_addr, *start_addr);
+       fprintf(stderr,"*Wo6: %x %x %x\n", (unsigned int) pointer, 
+               (unsigned int) start_addr, *start_addr);
       }
       return 0;
     }
     break;
   default:
     if (pointer_filter_verbose) {
-      fprintf(stderr,"*W?: %x %x %x\n", pointer, start_addr, *start_addr);
+      fprintf(stderr,"*W?: %x %x %x\n", (unsigned int) pointer, 
+             (unsigned int) start_addr, *start_addr);
     }
     return 0;
   }
@@ -480,7 +489,7 @@ pscav_i386_stack(void)
              *valid_stack_ra_locations[i],
              (int)(*valid_stack_ra_locations[i])
              - ((int)valid_stack_ra_code_objects[i] - (int)code_obj),
-             valid_stack_ra_code_objects[i], code_obj);
+             (unsigned int) valid_stack_ra_code_objects[i], code_obj);
     }
     *valid_stack_ra_locations[i] =
       ((int)(*valid_stack_ra_locations[i])
@@ -594,6 +603,7 @@ static lispobj ptrans_instance(lispobj thing, lispobj header, boolean constant)
        }
     default:
        gc_abort();
+       return NIL; /* dummy value: return something ... */
     }
 }
 
@@ -686,7 +696,6 @@ apply_code_fixups_during_purify(struct code *old_code, struct code *new_code)
   int nheader_words, ncode_words, nwords;
   void  *constants_start_addr, *constants_end_addr;
   void  *code_start_addr, *code_end_addr;
-  lispobj p;
   lispobj fixups = NIL;
   unsigned  displacement = (unsigned)new_code - (unsigned)old_code;
   struct vector *fixups_vector;
@@ -1147,7 +1156,7 @@ pscav_code(struct code*code)
 static lispobj *pscav(lispobj *addr, int nwords, boolean constant)
 {
     lispobj thing, *thingp, header;
-    int count;
+    int count = 0; /* (0 = dummy init value to stop GCC warning) */
     struct vector *vector;
 
     while (nwords > 0) {
@@ -1401,8 +1410,8 @@ int purify(lispobj static_roots, lispobj read_only_roots)
 #endif
 
 #ifdef GENCGC
-    gc_assert(control_stack_end > ((&read_only_roots)+1));
-    setup_i386_stack_scav(((&static_roots)-2), control_stack_end);
+    gc_assert((lispobj *)CONTROL_STACK_END > ((&read_only_roots)+1));
+    setup_i386_stack_scav(((&static_roots)-2), (lispobj *)CONTROL_STACK_END);
 #endif
 
     pscav(&static_roots, 1, 0);
@@ -1421,14 +1430,17 @@ int purify(lispobj static_roots, lispobj read_only_roots)
     fflush(stdout);
 #endif
 #ifndef __i386__
-    pscav(control_stack, current_control_stack_pointer - control_stack, 0);
+    pscav((lispobj *)control_stack,
+         current_control_stack_pointer - (lispobj *)CONTROL_STACK_START,
+         0);
 #else
 #ifdef GENCGC
     pscav_i386_stack();
 #endif
 #ifdef WANT_CGC
-    gc_assert(control_stack_end > ((&read_only_roots)+1));
-    carefully_pscav_stack(((&read_only_roots)+1), control_stack_end);
+    gc_assert((lispobj *)control_stack_end > ((&read_only_roots)+1));
+    carefully_pscav_stack(((&read_only_roots)+1),
+                         (lispobj *)CONTROL_STACK_END);
 #endif
 #endif
 
@@ -1437,20 +1449,26 @@ int purify(lispobj static_roots, lispobj read_only_roots)
     fflush(stdout);
 #endif
 #if !defined(ibmrt) && !defined(__i386__)
-    pscav(binding_stack, current_binding_stack_pointer - binding_stack, 0);
+    pscav( (lispobj *)BINDING_STACK_START,
+         (lispobj *)current_binding_stack_pointer - (lispobj *)BINDING_STACK_START,
+         0);
 #else
-    pscav(binding_stack, (lispobj *)SymbolValue(BINDING_STACK_POINTER) - binding_stack, 0);
+    pscav( (lispobj *)BINDING_STACK_START,
+         (lispobj *)SymbolValue(BINDING_STACK_POINTER) -
+         (lispobj *)BINDING_STACK_START,
+         0);
 #endif
 
 #ifdef SCAVENGE_READ_ONLY_SPACE
     if (SymbolValue(SCAVENGE_READ_ONLY_SPACE) != type_UnboundMarker
        && SymbolValue(SCAVENGE_READ_ONLY_SPACE) != NIL) {
       unsigned  read_only_space_size =
-       (lispobj *)SymbolValue(READ_ONLY_SPACE_FREE_POINTER) - read_only_space;
+         (lispobj *)SymbolValue(READ_ONLY_SPACE_FREE_POINTER) -
+         (lispobj *)READ_ONLY_SPACE_START;
       fprintf(stderr,
              "scavenging read only space: %d bytes\n",
              read_only_space_size * sizeof(lispobj));
-      pscav(read_only_space, read_only_space_size, 0);
+      pscav( (lispobj *)READ_ONLY_SPACE_START, read_only_space_size, 0);
     }
 #endif
 
@@ -1458,7 +1476,7 @@ int purify(lispobj static_roots, lispobj read_only_roots)
     printf(" static");
     fflush(stdout);
 #endif
-    clean = static_space;
+    clean = (lispobj *)STATIC_SPACE_START;
     do {
         while (clean != static_free)
             clean = pscav(clean, static_free - clean, 0);
@@ -1504,7 +1522,8 @@ int purify(lispobj static_roots, lispobj read_only_roots)
 #ifndef __i386__
     os_zero((os_vm_address_t) current_control_stack_pointer,
             (os_vm_size_t) (CONTROL_STACK_SIZE -
-                            ((current_control_stack_pointer - control_stack) *
+                            ((current_control_stack_pointer -
+                             (lispobj *)CONTROL_STACK_START) *
                              sizeof(lispobj))));
 #endif
 
Mirror of Steel Bank Common Lisp SBCL's official repository