LLP64: change signed long to sword_t

[sbcl.git] / src / runtime / gc-common.c

diff --git a/src/runtime/gc-common.c b/src/runtime/gc-common.c
index 1858839..c0a7119 100644 (file)
--- a/src/runtime/gc-common.c
+++ b/src/runtime/gc-common.c
@@ -85,9 +85,9 @@ set_forwarding_pointer(lispobj * pointer, lispobj newspace_copy) {
     return newspace_copy;
 }
 
-long (*scavtab[256])(lispobj *where, lispobj object);
+sword_t (*scavtab[256])(lispobj *where, lispobj object);
 lispobj (*transother[256])(lispobj object);
-long (*sizetab[256])(lispobj *where);
+sword_t (*sizetab[256])(lispobj *where);
 struct weak_pointer *weak_pointers;
 
 os_vm_size_t bytes_consed_between_gcs = 12*1024*1024;
@@ -100,28 +100,28 @@ os_vm_size_t bytes_consed_between_gcs = 12*1024*1024;
 
 /* to copy a boxed object */
 lispobj
-copy_object(lispobj object, long nwords)
+copy_object(lispobj object, sword_t nwords)
 {
     return gc_general_copy_object(object, nwords, BOXED_PAGE_FLAG);
 }
 
 lispobj
-copy_code_object(lispobj object, long nwords)
+copy_code_object(lispobj object, sword_t nwords)
 {
     return gc_general_copy_object(object, nwords, CODE_PAGE_FLAG);
 }
 
-static long scav_lose(lispobj *where, lispobj object); /* forward decl */
+static sword_t scav_lose(lispobj *where, lispobj object); /* forward decl */
 
 /* FIXME: Most calls end up going to some trouble to compute an
  * 'n_words' value for this function. The system might be a little
  * simpler if this function used an 'end' parameter instead. */
 void
-scavenge(lispobj *start, long n_words)
+scavenge(lispobj *start, sword_t n_words)
 {
     lispobj *end = start + n_words;
     lispobj *object_ptr;
-    long n_words_scavenged;
+    sword_t n_words_scavenged;
 
     for (object_ptr = start;
          object_ptr < end;
@@ -194,7 +194,7 @@ If you can reproduce this warning, please send a bug report\n\
 static lispobj trans_fun_header(lispobj object); /* forward decls */
 static lispobj trans_boxed(lispobj object);
 
-static long
+static sword_t
 scav_fun_pointer(lispobj *where, lispobj object)
 {
     lispobj *first_pointer;
@@ -317,8 +317,8 @@ trans_code(struct code *code)
 #ifdef LISP_FEATURE_GENCGC
     /* Cheneygc doesn't need this os_flush_icache, it flushes the whole
        spaces once when all copying is done. */
-    os_flush_icache((os_vm_address_t) (((long *)new_code) + nheader_words),
-                    ncode_words * sizeof(long));
+    os_flush_icache((os_vm_address_t) (((sword_t *)new_code) + nheader_words),
+                    ncode_words * sizeof(sword_t));
 
 #endif
 
@@ -329,11 +329,11 @@ trans_code(struct code *code)
     return new_code;
 }
 
-static long
+static sword_t
 scav_code_header(lispobj *where, lispobj object)
 {
     struct code *code;
-    long n_header_words, n_code_words, n_words;
+    sword_t n_header_words, n_code_words, n_words;
     lispobj entry_point;        /* tagged pointer to entry point */
     struct simple_fun *function_ptr; /* untagged pointer to entry point */
 
@@ -354,7 +354,7 @@ scav_code_header(lispobj *where, lispobj object)
 
         gc_assert_verbose(is_lisp_pointer(entry_point),
                           "Entry point %lx\n is not a lisp pointer.",
-                          (long)entry_point);
+                          (sword_t)entry_point);
 
         function_ptr = (struct simple_fun *) native_pointer(entry_point);
         gc_assert(widetag_of(function_ptr->header)==SIMPLE_FUN_HEADER_WIDETAG);
@@ -378,11 +378,11 @@ trans_code_header(lispobj object)
 }
 
 
-static long
+static sword_t
 size_code_header(lispobj *where)
 {
     struct code *code;
-    long nheader_words, ncode_words, nwords;
+    sword_t nheader_words, ncode_words, nwords;
 
     code = (struct code *) where;
 
@@ -395,7 +395,7 @@ size_code_header(lispobj *where)
 }
 
 #if !defined(LISP_FEATURE_X86) && ! defined(LISP_FEATURE_X86_64)
-static long
+static sword_t
 scav_return_pc_header(lispobj *where, lispobj object)
 {
     lose("attempted to scavenge a return PC header where=0x%08x object=0x%08x\n",
@@ -430,7 +430,7 @@ trans_return_pc_header(lispobj object)
  * have to figure out that the function is still live. */
 
 #if defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64)
-static long
+static sword_t
 scav_closure_header(lispobj *where, lispobj object)
 {
     struct closure *closure;
@@ -450,7 +450,7 @@ scav_closure_header(lispobj *where, lispobj object)
 #endif
 
 #if !(defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64))
-static long
+static sword_t
 scav_fun_header(lispobj *where, lispobj object)
 {
     lose("attempted to scavenge a function header where=0x%08x object=0x%08x\n",
@@ -483,7 +483,7 @@ trans_fun_header(lispobj object)
  * instances
  */
 
-static long
+static sword_t
 scav_instance_pointer(lispobj *where, lispobj object)
 {
     lispobj copy, *first_pointer;
@@ -509,7 +509,7 @@ scav_instance_pointer(lispobj *where, lispobj object)
 
 static lispobj trans_list(lispobj object);
 
-static long
+static sword_t
 scav_list_pointer(lispobj *where, lispobj object)
 {
     lispobj first, *first_pointer;
@@ -593,7 +593,7 @@ trans_list(lispobj object)
  * scavenging and transporting other pointers
  */
 
-static long
+static sword_t
 scav_other_pointer(lispobj *where, lispobj object)
 {
     lispobj first, *first_pointer;
@@ -623,13 +623,13 @@ scav_other_pointer(lispobj *where, lispobj object)
  * immediate, boxed, and unboxed objects
  */
 
-static long
+static sword_t
 size_pointer(lispobj *where)
 {
     return 1;
 }
 
-static long
+static sword_t
 scav_immediate(lispobj *where, lispobj object)
 {
     return 1;
@@ -642,24 +642,24 @@ trans_immediate(lispobj object)
     return NIL; /* bogus return value to satisfy static type checking */
 }
 
-static long
+static sword_t
 size_immediate(lispobj *where)
 {
     return 1;
 }
 
 
-static long
+static sword_t
 scav_boxed(lispobj *where, lispobj object)
 {
     return 1;
 }
 
-static long
+static sword_t
 scav_instance(lispobj *where, lispobj object)
 {
     lispobj nuntagged;
-    long ntotal = HeaderValue(object);
+    sword_t ntotal = HeaderValue(object);
     lispobj layout = ((struct instance *)where)->slots[0];
 
     if (!layout)
@@ -689,7 +689,7 @@ trans_boxed(lispobj object)
 }
 
 
-static long
+static sword_t
 size_boxed(lispobj *where)
 {
     lispobj header;
@@ -705,7 +705,7 @@ size_boxed(lispobj *where)
 /* Note: on the sparc we don't have to do anything special for fdefns, */
 /* 'cause the raw-addr has a function lowtag. */
 #if !defined(LISP_FEATURE_SPARC)
-static long
+static sword_t
 scav_fdefn(lispobj *where, lispobj object)
 {
     struct fdefn *fdefn;
@@ -732,7 +732,7 @@ scav_fdefn(lispobj *where, lispobj object)
 }
 #endif
 
-static long
+static sword_t
 scav_unboxed(lispobj *where, lispobj object)
 {
     uword_t length;
@@ -759,7 +759,7 @@ trans_unboxed(lispobj object)
     return copy_unboxed_object(object, length);
 }
 
-static long
+static sword_t
 size_unboxed(lispobj *where)
 {
     lispobj header;
@@ -774,11 +774,11 @@ size_unboxed(lispobj *where)
 
 \f
 /* vector-like objects */
-static long
+static sword_t
 scav_base_string(lispobj *where, lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     /* NOTE: Strings contain one more byte of data than the length */
     /* slot indicates. */
@@ -793,7 +793,7 @@ static lispobj
 trans_base_string(lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     gc_assert(is_lisp_pointer(object));
 
@@ -808,11 +808,11 @@ trans_base_string(lispobj object)
     return copy_large_unboxed_object(object, nwords);
 }
 
-static long
+static sword_t
 size_base_string(lispobj *where)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     /* NOTE: A string contains one more byte of data (a terminating
      * '\0' to help when interfacing with C functions) than indicated
@@ -825,7 +825,7 @@ size_base_string(lispobj *where)
     return nwords;
 }
 
-static long
+static sword_t
 scav_character_string(lispobj *where, lispobj object)
 {
     struct vector *vector;
@@ -859,7 +859,7 @@ trans_character_string(lispobj object)
     return copy_large_unboxed_object(object, nwords);
 }
 
-static long
+static sword_t
 size_character_string(lispobj *where)
 {
     struct vector *vector;
@@ -880,7 +880,7 @@ static lispobj
 trans_vector(lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     gc_assert(is_lisp_pointer(object));
 
@@ -892,11 +892,11 @@ trans_vector(lispobj object)
     return copy_large_object(object, nwords);
 }
 
-static long
+static sword_t
 size_vector(lispobj *where)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -905,7 +905,7 @@ size_vector(lispobj *where)
     return nwords;
 }
 
-static long
+static sword_t
 scav_vector_nil(lispobj *where, lispobj object)
 {
     return 2;
@@ -918,18 +918,18 @@ trans_vector_nil(lispobj object)
     return copy_unboxed_object(object, 2);
 }
 
-static long
+static sword_t
 size_vector_nil(lispobj *where)
 {
     /* Just the header word and the length word */
     return 2;
 }
 
-static long
+static sword_t
 scav_vector_bit(lispobj *where, lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -942,7 +942,7 @@ static lispobj
 trans_vector_bit(lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     gc_assert(is_lisp_pointer(object));
 
@@ -953,11 +953,11 @@ trans_vector_bit(lispobj object)
     return copy_large_unboxed_object(object, nwords);
 }
 
-static long
+static sword_t
 size_vector_bit(lispobj *where)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -966,11 +966,11 @@ size_vector_bit(lispobj *where)
     return nwords;
 }
 
-static long
+static sword_t
 scav_vector_unsigned_byte_2(lispobj *where, lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -983,7 +983,7 @@ static lispobj
 trans_vector_unsigned_byte_2(lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     gc_assert(is_lisp_pointer(object));
 
@@ -994,11 +994,11 @@ trans_vector_unsigned_byte_2(lispobj object)
     return copy_large_unboxed_object(object, nwords);
 }
 
-static long
+static sword_t
 size_vector_unsigned_byte_2(lispobj *where)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1007,11 +1007,11 @@ size_vector_unsigned_byte_2(lispobj *where)
     return nwords;
 }
 
-static long
+static sword_t
 scav_vector_unsigned_byte_4(lispobj *where, lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1024,7 +1024,7 @@ static lispobj
 trans_vector_unsigned_byte_4(lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     gc_assert(is_lisp_pointer(object));
 
@@ -1034,11 +1034,11 @@ trans_vector_unsigned_byte_4(lispobj object)
 
     return copy_large_unboxed_object(object, nwords);
 }
-static long
+static sword_t
 size_vector_unsigned_byte_4(lispobj *where)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1048,11 +1048,11 @@ size_vector_unsigned_byte_4(lispobj *where)
 }
 
 
-static long
+static sword_t
 scav_vector_unsigned_byte_8(lispobj *where, lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1069,7 +1069,7 @@ static lispobj
 trans_vector_unsigned_byte_8(lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     gc_assert(is_lisp_pointer(object));
 
@@ -1080,11 +1080,11 @@ trans_vector_unsigned_byte_8(lispobj object)
     return copy_large_unboxed_object(object, nwords);
 }
 
-static long
+static sword_t
 size_vector_unsigned_byte_8(lispobj *where)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1094,11 +1094,11 @@ size_vector_unsigned_byte_8(lispobj *where)
 }
 
 
-static long
+static sword_t
 scav_vector_unsigned_byte_16(lispobj *where, lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1111,7 +1111,7 @@ static lispobj
 trans_vector_unsigned_byte_16(lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     gc_assert(is_lisp_pointer(object));
 
@@ -1122,11 +1122,11 @@ trans_vector_unsigned_byte_16(lispobj object)
     return copy_large_unboxed_object(object, nwords);
 }
 
-static long
+static sword_t
 size_vector_unsigned_byte_16(lispobj *where)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1135,11 +1135,11 @@ size_vector_unsigned_byte_16(lispobj *where)
     return nwords;
 }
 
-static long
+static sword_t
 scav_vector_unsigned_byte_32(lispobj *where, lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1152,7 +1152,7 @@ static lispobj
 trans_vector_unsigned_byte_32(lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     gc_assert(is_lisp_pointer(object));
 
@@ -1163,11 +1163,11 @@ trans_vector_unsigned_byte_32(lispobj object)
     return copy_large_unboxed_object(object, nwords);
 }
 
-static long
+static sword_t
 size_vector_unsigned_byte_32(lispobj *where)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1177,11 +1177,11 @@ size_vector_unsigned_byte_32(lispobj *where)
 }
 
 #if N_WORD_BITS == 64
-static long
+static sword_t
 scav_vector_unsigned_byte_64(lispobj *where, lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1194,7 +1194,7 @@ static lispobj
 trans_vector_unsigned_byte_64(lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     gc_assert(is_lisp_pointer(object));
 
@@ -1205,11 +1205,11 @@ trans_vector_unsigned_byte_64(lispobj object)
     return copy_large_unboxed_object(object, nwords);
 }
 
-static long
+static sword_t
 size_vector_unsigned_byte_64(lispobj *where)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1219,11 +1219,11 @@ size_vector_unsigned_byte_64(lispobj *where)
 }
 #endif
 
-static long
+static sword_t
 scav_vector_single_float(lispobj *where, lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1236,7 +1236,7 @@ static lispobj
 trans_vector_single_float(lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     gc_assert(is_lisp_pointer(object));
 
@@ -1247,11 +1247,11 @@ trans_vector_single_float(lispobj object)
     return copy_large_unboxed_object(object, nwords);
 }
 
-static long
+static sword_t
 size_vector_single_float(lispobj *where)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1260,11 +1260,11 @@ size_vector_single_float(lispobj *where)
     return nwords;
 }
 
-static long
+static sword_t
 scav_vector_double_float(lispobj *where, lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1277,7 +1277,7 @@ static lispobj
 trans_vector_double_float(lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     gc_assert(is_lisp_pointer(object));
 
@@ -1288,11 +1288,11 @@ trans_vector_double_float(lispobj object)
     return copy_large_unboxed_object(object, nwords);
 }
 
-static long
+static sword_t
 size_vector_double_float(lispobj *where)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1335,7 +1335,7 @@ static long
 size_vector_long_float(lispobj *where)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1347,11 +1347,11 @@ size_vector_long_float(lispobj *where)
 
 
 #ifdef SIMPLE_ARRAY_COMPLEX_SINGLE_FLOAT_WIDETAG
-static long
+static sword_t
 scav_vector_complex_single_float(lispobj *where, lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1364,7 +1364,7 @@ static lispobj
 trans_vector_complex_single_float(lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     gc_assert(is_lisp_pointer(object));
 
@@ -1375,11 +1375,11 @@ trans_vector_complex_single_float(lispobj object)
     return copy_large_unboxed_object(object, nwords);
 }
 
-static long
+static sword_t
 size_vector_complex_single_float(lispobj *where)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1390,11 +1390,11 @@ size_vector_complex_single_float(lispobj *where)
 #endif
 
 #ifdef SIMPLE_ARRAY_COMPLEX_DOUBLE_FLOAT_WIDETAG
-static long
+static sword_t
 scav_vector_complex_double_float(lispobj *where, lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1407,7 +1407,7 @@ static lispobj
 trans_vector_complex_double_float(lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     gc_assert(is_lisp_pointer(object));
 
@@ -1418,11 +1418,11 @@ trans_vector_complex_double_float(lispobj object)
     return copy_large_unboxed_object(object, nwords);
 }
 
-static long
+static sword_t
 size_vector_complex_double_float(lispobj *where)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1438,7 +1438,7 @@ static long
 scav_vector_complex_long_float(lispobj *where, lispobj object)
 {
     struct vector *vector;
-    long length, nwords;
+    sword_t length, nwords;
 
     vector = (struct vector *) where;
     length = fixnum_value(vector->length);
@@ -1507,7 +1507,7 @@ trans_weak_pointer(lispobj object)
     return copy;
 }
 
-static long
+static sword_t
 size_weak_pointer(lispobj *where)
 {
     return WEAK_POINTER_NWORDS;
@@ -1691,7 +1691,7 @@ scav_hash_table_entries (struct hash_table *hash_table)
     }
 }
 
-long
+sword_t
 scav_vector (lispobj *where, lispobj object)
 {
     uword_t kv_length;
@@ -1860,7 +1860,7 @@ scan_weak_hash_tables (void)
  * initialization
  */
 
-static long
+static sword_t
 scav_lose(lispobj *where, lispobj object)
 {
     lose("no scavenge function for object 0x%08x (widetag 0x%x)\n",
@@ -1879,7 +1879,7 @@ trans_lose(lispobj object)
     return NIL; /* bogus return value to satisfy static type checking */
 }
 
-static long
+static sword_t
 size_lose(lispobj *where)
 {
     lose("no size function for object at 0x%08x (widetag 0x%x)\n",
@@ -2891,7 +2891,7 @@ pair_interior_pointer(os_context_t *context, uword_t pointer,
     *register_pair = -1;
     for (i = 0; i < (sizeof(boxed_registers) / sizeof(int)); i++) {
         uword_t reg;
-        long offset;
+        sword_t offset;
         int index;
 
         index = boxed_registers[i];