* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
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;
}
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? */
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;
}
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;
}
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;
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;
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;
}
*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])
}
default:
gc_abort();
+ return NIL; /* dummy value: return something ... */
}
}
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;
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) {
#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);
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
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
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);
#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