X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fdumper.c;h=1bb3172cfdb59bda12a3add72dd12d48b8e6a626;hb=6b1f1b2af579009e8a95f9c79f3cfe119f2f595d;hp=644d98f03a7db1d17ad9d784da52a2e528c16b90;hpb=1cc5b779cb8755e01e02aead4fba711c06158b90;p=chise%2Fxemacs-chise.git.1 diff --git a/src/dumper.c b/src/dumper.c index 644d98f..1bb3172 100644 --- a/src/dumper.c +++ b/src/dumper.c @@ -1,6 +1,5 @@ /* Portable data dumper for XEmacs. Copyright (C) 1999-2000 Olivier Galibert - Copyright (C) 2001 Martin Buchholz This file is part of XEmacs. @@ -23,20 +22,17 @@ Boston, MA 02111-1307, USA. */ #include #include "lisp.h" - +#include "dump-id.h" #include "specifier.h" +#include "alloc.h" #include "elhash.h" #include "sysfile.h" #include "console-stream.h" #include "dumper.h" -#ifdef WIN32_NATIVE -#include "nt.h" -#else #ifdef HAVE_MMAP #include #endif -#endif #ifndef SEPCHAR #define SEPCHAR ':' @@ -44,119 +40,6 @@ Boston, MA 02111-1307, USA. */ typedef struct { - void *varaddress; - size_t size; -} pdump_opaque; - -typedef struct -{ - Dynarr_declare (pdump_opaque); -} pdump_opaque_dynarr; - -typedef struct -{ - void **ptraddress; - const struct struct_description *desc; -} pdump_root_struct_ptr; - -typedef struct -{ - Dynarr_declare (pdump_root_struct_ptr); -} pdump_root_struct_ptr_dynarr; - -typedef struct -{ - Lisp_Object *address; - Lisp_Object value; -} pdump_static_Lisp_Object; - -typedef struct -{ - char **address; /* char * for ease of doing relocation */ - char * value; -} pdump_static_pointer; - -static pdump_opaque_dynarr *pdump_opaques; -static pdump_root_struct_ptr_dynarr *pdump_root_struct_ptrs; -static Lisp_Object_ptr_dynarr *pdump_root_objects; -static Lisp_Object_ptr_dynarr *pdump_weak_object_chains; - -/* Mark SIZE bytes at non-heap address VARADDRESS for dumping as is, - without any bit-twiddling. */ -void -dump_add_opaque (void *varaddress, size_t size) -{ - pdump_opaque info; - info.varaddress = varaddress; - info.size = size; - if (pdump_opaques == NULL) - pdump_opaques = Dynarr_new (pdump_opaque); - Dynarr_add (pdump_opaques, info); -} - -/* Mark the struct described by DESC and pointed to by the pointer at - non-heap address VARADDRESS for dumping. - All the objects reachable from this pointer will also be dumped. */ -void -dump_add_root_struct_ptr (void *ptraddress, const struct struct_description *desc) -{ - pdump_root_struct_ptr info; - info.ptraddress = (void **) ptraddress; - info.desc = desc; - if (pdump_root_struct_ptrs == NULL) - pdump_root_struct_ptrs = Dynarr_new (pdump_root_struct_ptr); - Dynarr_add (pdump_root_struct_ptrs, info); -} - -/* Mark the Lisp_Object at non-heap address VARADDRESS for dumping. - All the objects reachable from this var will also be dumped. */ -void -dump_add_root_object (Lisp_Object *varaddress) -{ - if (pdump_root_objects == NULL) - pdump_root_objects = Dynarr_new2 (Lisp_Object_ptr_dynarr, Lisp_Object *); - Dynarr_add (pdump_root_objects, varaddress); -} - -/* Mark the list pointed to by the Lisp_Object at VARADDRESS for dumping. */ -void -dump_add_weak_object_chain (Lisp_Object *varaddress) -{ - if (pdump_weak_object_chains == NULL) - pdump_weak_object_chains = Dynarr_new2 (Lisp_Object_ptr_dynarr, Lisp_Object *); - Dynarr_add (pdump_weak_object_chains, varaddress); -} - - -inline static void -pdump_align_stream (FILE *stream, size_t alignment) -{ - long offset = ftell (stream); - long adjustment = ALIGN_SIZE (offset, alignment) - offset; - if (adjustment) - fseek (stream, adjustment, SEEK_CUR); -} - -#define PDUMP_ALIGN_OUTPUT(type) pdump_align_stream (pdump_out, ALIGNOF (type)) - -#define PDUMP_WRITE(type, object) \ -fwrite (&object, sizeof (object), 1, pdump_out); - -#define PDUMP_WRITE_ALIGNED(type, object) do { \ - PDUMP_ALIGN_OUTPUT (type); \ - PDUMP_WRITE (type, object); \ -} while (0) - -#define PDUMP_READ(ptr, type) \ -(((type *) (ptr = (char*) (((type *) ptr) + 1)))[-1]) - -#define PDUMP_READ_ALIGNED(ptr, type) \ -((ptr = (char *) ALIGN_PTR (ptr, ALIGNOF (type))), PDUMP_READ (ptr, type)) - - - -typedef struct -{ const struct lrecord_description *desc; int count; } pdump_reloc_table; @@ -189,101 +72,101 @@ pdump_objects_unmark (void) /* The structure of the file - 0 - header - - dumped objects - stab_offset - nb_root_struct_ptrs*pair(void *, adr) - for pointers to structures - - nb_opaques*pair(void *, size) for raw bits to restore - - relocation table - - root lisp object address/value couples with the count - preceding the list + * + * 0 - header + * 256 - dumped objects + * stab_offset - nb_staticpro*(Lisp_Object *) from staticvec + * - nb_staticpro*(relocated Lisp_Object) pointed to by staticpro + * - nb_structdmp*pair(void *, adr) for pointers to structures + * - lrecord_implementations_table[] + * - relocation table + * - wired variable address/value couples with the count preceding the list */ -#define PDUMP_SIGNATURE "XEmacsDP" -#define PDUMP_SIGNATURE_LEN (sizeof (PDUMP_SIGNATURE) - 1) +#define DUMP_SIGNATURE "XEmacsDP" +#define DUMP_SIGNATURE_LEN (sizeof (DUMP_SIGNATURE) - 1) typedef struct { - char signature[PDUMP_SIGNATURE_LEN]; + char signature[DUMP_SIGNATURE_LEN]; unsigned int id; EMACS_UINT stab_offset; EMACS_UINT reloc_address; - int nb_root_struct_ptrs; - int nb_opaques; -} pdump_header; + int nb_staticpro; + int nb_structdmp; + int nb_opaquedmp; +} dump_header; -char *pdump_start; -char *pdump_end; +char *pdump_start, *pdump_end; static size_t pdump_length; +void (*pdump_free) (void); -#ifdef WIN32_NATIVE -/* Handle for the dump file */ -static HANDLE pdump_hFile = INVALID_HANDLE_VALUE; -/* Handle for the file mapping object for the dump file */ -static HANDLE pdump_hMap = INVALID_HANDLE_VALUE; -#endif - -static void (*pdump_free) (void); - -static unsigned char pdump_align_table[] = +static const unsigned char align_table[256] = { - 64, 1, 2, 1, 4, 1, 2, 1, 8, 1, 2, 1, 4, 1, 2, 1, - 16, 1, 2, 1, 4, 1, 2, 1, 8, 1, 2, 1, 4, 1, 2, 1, - 32, 1, 2, 1, 4, 1, 2, 1, 8, 1, 2, 1, 4, 1, 2, 1, - 16, 1, 2, 1, 4, 1, 2, 1, 8, 1, 2, 1, 4, 1, 2, 1 + 8, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, + 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0 }; -static inline unsigned int -pdump_size_to_align (size_t size) +typedef struct pdump_entry_list_elmt { - return pdump_align_table[size % countof (pdump_align_table)]; -} - -typedef struct pdump_entry_list_elt -{ - struct pdump_entry_list_elt *next; + struct pdump_entry_list_elmt *next; const void *obj; size_t size; int count; + int is_lrecord; EMACS_INT save_offset; -} pdump_entry_list_elt; +} pdump_entry_list_elmt; typedef struct { - pdump_entry_list_elt *first; + pdump_entry_list_elmt *first; int align; int count; } pdump_entry_list; -typedef struct pdump_struct_list_elt +typedef struct pdump_struct_list_elmt { pdump_entry_list list; const struct struct_description *sdesc; -} pdump_struct_list_elt; +} pdump_struct_list_elmt; typedef struct { - pdump_struct_list_elt *list; + pdump_struct_list_elmt *list; int count; int size; } pdump_struct_list; -static pdump_entry_list *pdump_object_table; +static pdump_entry_list pdump_object_table[256]; static pdump_entry_list pdump_opaque_data_list; static pdump_struct_list pdump_struct_table; +static pdump_entry_list_elmt *pdump_qnil; -static int *pdump_alert_undump_object; +static int pdump_alert_undump_object[256]; static unsigned long cur_offset; static size_t max_size; static int pdump_fd; static void *pdump_buf; -static FILE *pdump_out; #define PDUMP_HASHSIZE 200001 -static pdump_entry_list_elt **pdump_hash; +static pdump_entry_list_elmt **pdump_hash; /* Since most pointers are eight bytes aligned, the >>3 allows for a better hash */ static int @@ -292,11 +175,11 @@ pdump_make_hash (const void *obj) return ((unsigned long)(obj)>>3) % PDUMP_HASHSIZE; } -static pdump_entry_list_elt * +static pdump_entry_list_elmt * pdump_get_entry (const void *obj) { int pos = pdump_make_hash (obj); - pdump_entry_list_elt *e; + pdump_entry_list_elmt *e; assert (obj != 0); @@ -313,10 +196,10 @@ pdump_get_entry (const void *obj) } static void -pdump_add_entry (pdump_entry_list *list, const void *obj, size_t size, - int count) +pdump_add_entry (pdump_entry_list *list, const void *obj, size_t size, int count, int is_lrecord) { - pdump_entry_list_elt *e; + pdump_entry_list_elmt *e; + int align; int pos = pdump_make_hash (obj); while ((e = pdump_hash[pos]) != 0) @@ -329,23 +212,24 @@ pdump_add_entry (pdump_entry_list *list, const void *obj, size_t size, pos = 0; } - e = xnew (pdump_entry_list_elt); + e = xnew (pdump_entry_list_elmt); e->next = list->first; e->obj = obj; e->size = size; e->count = count; + e->is_lrecord = is_lrecord; list->first = e; list->count += count; pdump_hash[pos] = e; - { - int align = pdump_size_to_align (size); + align = align_table[size & 255]; + if (align < 2 && is_lrecord) + align = 2; - if (align < list->align) - list->align = align; - } + if (align < list->align) + list->align = align; } static pdump_entry_list * @@ -362,12 +246,12 @@ pdump_get_entry_list (const struct struct_description *sdesc) pdump_struct_table.size = 10; else pdump_struct_table.size = pdump_struct_table.size * 2; - pdump_struct_table.list = (pdump_struct_list_elt *) + pdump_struct_table.list = (pdump_struct_list_elmt *) xrealloc (pdump_struct_table.list, - pdump_struct_table.size * sizeof (pdump_struct_list_elt)); + pdump_struct_table.size * sizeof (pdump_struct_list_elmt)); } pdump_struct_table.list[pdump_struct_table.count].list.first = 0; - pdump_struct_table.list[pdump_struct_table.count].list.align = ALIGNOF (max_align_t); + pdump_struct_table.list[pdump_struct_table.count].list.align = 8; pdump_struct_table.list[pdump_struct_table.count].list.count = 0; pdump_struct_table.list[pdump_struct_table.count].sdesc = sdesc; @@ -383,36 +267,29 @@ static struct static int depth; -static void -pdump_backtrace (void) +static void pdump_backtrace (void) { int i; stderr_out ("pdump backtrace :\n"); for (i=0;iname, - backtrace[i].position, - backtrace[i].offset); + LHEADER_IMPLEMENTATION (backtrace[i].obj)->name, + backtrace[i].position, + backtrace[i].offset); } } } static void pdump_register_object (Lisp_Object obj); -static void pdump_register_struct (const void *data, - const struct struct_description *sdesc, - int count); +static void pdump_register_struct (const void *data, const struct struct_description *sdesc, int count); static EMACS_INT -pdump_get_indirect_count (EMACS_INT code, - const struct lrecord_description *idesc, - const void *idata) +pdump_get_indirect_count (EMACS_INT code, const struct lrecord_description *idesc, const void *idata) { EMACS_INT count; const void *irdata; @@ -436,8 +313,7 @@ pdump_get_indirect_count (EMACS_INT code, count = *(Bytecount *)irdata; break; default: - stderr_out ("Unsupported count type : %d (line = %d, code=%ld)\n", - idesc[line].type, line, (long)code); + stderr_out ("Unsupported count type : %d (line = %d, code=%ld)\n", idesc[line].type, line, (long)code); pdump_backtrace (); abort (); } @@ -468,6 +344,7 @@ pdump_register_sub (const void *data, const struct lrecord_description *desc, in case XD_INT: case XD_LONG: case XD_BYTECOUNT: + case XD_LO_RESET_NIL: case XD_INT_RESET: case XD_LO_LINK: break; @@ -478,21 +355,24 @@ pdump_register_sub (const void *data, const struct lrecord_description *desc, in count = pdump_get_indirect_count (count, desc, data); pdump_add_entry (&pdump_opaque_data_list, - *(void **)rdata, count, 1); + *(void **)rdata, + count, + 1, + 0); break; } case XD_C_STRING: { const char *str = *(const char **)rdata; if (str) - pdump_add_entry (&pdump_opaque_data_list, str, strlen (str)+1, 1); + pdump_add_entry (&pdump_opaque_data_list, str, strlen (str)+1, 1, 0); break; } case XD_DOC_STRING: { const char *str = *(const char **)rdata; if ((EMACS_INT)str > 0) - pdump_add_entry (&pdump_opaque_data_list, str, strlen (str)+1, 1); + pdump_add_entry (&pdump_opaque_data_list, str, strlen (str)+1, 1, 0); break; } case XD_LISP_OBJECT: @@ -548,7 +428,6 @@ static void pdump_register_object (Lisp_Object obj) { struct lrecord_header *objh; - const struct lrecord_implementation *imp; if (!POINTER_TYPE_P (XTYPE (obj))) return; @@ -560,9 +439,7 @@ pdump_register_object (Lisp_Object obj) if (pdump_get_entry (objh)) return; - imp = LHEADER_IMPLEMENTATION (objh); - - if (imp->description) + if (LHEADER_IMPLEMENTATION (objh)->description) { int me = depth++; if (me>65536) @@ -576,25 +453,26 @@ pdump_register_object (Lisp_Object obj) pdump_add_entry (pdump_object_table + objh->type, objh, - imp->static_size ? - imp->static_size : - imp->size_in_bytes_method (objh), + LHEADER_IMPLEMENTATION (objh)->static_size ? + LHEADER_IMPLEMENTATION (objh)->static_size : + LHEADER_IMPLEMENTATION (objh)->size_in_bytes_method (objh), + 1, 1); - pdump_register_sub (objh, imp->description, me); + pdump_register_sub (objh, + LHEADER_IMPLEMENTATION (objh)->description, + me); --depth; } else { pdump_alert_undump_object[objh->type]++; - stderr_out ("Undumpable object type : %s\n", imp->name); + stderr_out ("Undumpable object type : %s\n", LHEADER_IMPLEMENTATION (objh)->name); pdump_backtrace (); } } static void -pdump_register_struct (const void *data, - const struct struct_description *sdesc, - int count) +pdump_register_struct (const void *data, const struct struct_description *sdesc, int count) { if (data && !pdump_get_entry (data)) { @@ -610,7 +488,10 @@ pdump_register_struct (const void *data, backtrace[me].offset = 0; pdump_add_entry (pdump_get_entry_list (sdesc), - data, sdesc->size, count); + data, + sdesc->size, + count, + 0); for (i=0; isize*i, @@ -622,15 +503,14 @@ pdump_register_struct (const void *data, } static void -pdump_dump_data (pdump_entry_list_elt *elt, - const struct lrecord_description *desc) +pdump_dump_data (pdump_entry_list_elmt *elmt, const struct lrecord_description *desc) { - size_t size = elt->size; - int count = elt->count; + size_t size = elmt->size; + int count = elmt->count; if (desc) { int pos, i; - memcpy (pdump_buf, elt->obj, size*count); + memcpy (pdump_buf, elmt->obj, size*count); for (i=0; iobj))->methods->extra_description; + desc = ((const Lisp_Specifier *)(elmt->obj))->methods->extra_description; goto restart; case XD_SIZE_T: case XD_INT: case XD_LONG: case XD_BYTECOUNT: break; + case XD_LO_RESET_NIL: + { + EMACS_INT num = desc[pos].data1; + int j; + if (XD_IS_INDIRECT (num)) + num = pdump_get_indirect_count (num, desc, elmt->obj); + for (j=0; jsave_offset; + break; + } case XD_INT_RESET: { EMACS_INT val = desc[pos].data1; if (XD_IS_INDIRECT (val)) - val = pdump_get_indirect_count (val, desc, elt->obj); + val = pdump_get_indirect_count (val, desc, elmt->obj); *(int *)rdata = val; break; } @@ -669,15 +559,15 @@ pdump_dump_data (pdump_entry_list_elt *elt, case XD_LO_LINK: { Lisp_Object obj = *(Lisp_Object *)rdata; - pdump_entry_list_elt *elt1; + pdump_entry_list_elmt *elmt1; for (;;) { - elt1 = pdump_get_entry (XRECORD_LHEADER (obj)); - if (elt1) + elmt1 = pdump_get_entry (XRECORD_LHEADER (obj)); + if (elmt1) break; obj = *(Lisp_Object *)(desc[pos].offset + (char *)(XRECORD_LHEADER (obj))); } - *(EMACS_INT *)rdata = elt1->save_offset; + *(EMACS_INT *)rdata = elmt1->save_offset; break; } case XD_LISP_OBJECT: @@ -696,7 +586,7 @@ pdump_dump_data (pdump_entry_list_elt *elt, EMACS_INT num = desc[pos].data1; int j; if (XD_IS_INDIRECT (num)) - num = pdump_get_indirect_count (num, desc, elt->obj); + num = pdump_get_indirect_count (num, desc, elmt->obj); for (j=0; jobj, size, count, pdump_out); + write (pdump_fd, desc ? pdump_buf : elmt->obj, size*count); + if (elmt->is_lrecord && ((size*count) & 3)) + write (pdump_fd, "\0\0\0", 4-((size*count) & 3)); } static void -pdump_reloc_one (void *data, EMACS_INT delta, - const struct lrecord_description *desc) +pdump_reloc_one (void *data, EMACS_INT delta, const struct lrecord_description *desc) { int pos; @@ -764,11 +655,12 @@ pdump_reloc_one (void *data, EMACS_INT delta, if (POINTER_TYPE_P (XTYPE (*pobj)) && ! EQ (*pobj, Qnull_pointer)) - XSETOBJ (*pobj, (char *) XPNTR (*pobj) + delta); + XSETOBJ (*pobj, XTYPE (*pobj), (char *) XPNTR (*pobj) + delta); break; } case XD_LISP_OBJECT_ARRAY: + case XD_LO_RESET_NIL: { EMACS_INT num = desc[pos].data1; int j; @@ -781,7 +673,7 @@ pdump_reloc_one (void *data, EMACS_INT delta, if (POINTER_TYPE_P (XTYPE (*pobj)) && ! EQ (*pobj, Qnull_pointer)) - XSETOBJ (*pobj, (char *) XPNTR (*pobj) + delta); + XSETOBJ (*pobj, XTYPE (*pobj), (char *) XPNTR (*pobj) + delta); } break; } @@ -800,169 +692,195 @@ pdump_reloc_one (void *data, EMACS_INT delta, } static void -pdump_allocate_offset (pdump_entry_list_elt *elt, - const struct lrecord_description *desc) +pdump_allocate_offset (pdump_entry_list_elmt *elmt, const struct lrecord_description *desc) { - size_t size = elt->count * elt->size; - elt->save_offset = cur_offset; + size_t size = (elmt->is_lrecord ? (elmt->size + 3) & ~3 : elmt->size)*elmt->count; + elmt->save_offset = cur_offset; if (size>max_size) max_size = size; cur_offset += size; } static void -pdump_scan_by_alignment (void (*f)(pdump_entry_list_elt *, - const struct lrecord_description *)) +pdump_scan_by_alignment (void (*f)(pdump_entry_list_elmt *, const struct lrecord_description *)) { - int align; - - for (align = ALIGNOF (max_align_t); align; align>>=1) + int align, i; + const struct lrecord_description *idesc; + pdump_entry_list_elmt *elmt; + for (align=8; align>=0; align--) { - int i; - pdump_entry_list_elt *elt; - for (i=0; inext) - f (elt, lrecord_implementations_table[i]->description); + { + elmt = pdump_object_table[i].first; + if (!elmt) + continue; + idesc = lrecord_implementations_table[i]->description; + while (elmt) + { + f (elmt, idesc); + elmt = elmt->next; + } + } for (i=0; idescription; + while (elmt) + { + f (elmt, idesc); + elmt = elmt->next; + } + } + + elmt = pdump_opaque_data_list.first; + while (elmt) { - pdump_struct_list_elt list = pdump_struct_table.list[i]; - if (list.list.align == align) - for (elt = list.list.first; elt; elt = elt->next) - f (elt, list.sdesc->description); + if (align_table[elmt->size & 255] == align) + f (elmt, 0); + elmt = elmt->next; } + } +} + +static void +pdump_dump_staticvec (void) +{ + EMACS_INT *reloc = xnew_array (EMACS_INT, staticidx); + int i; + write (pdump_fd, staticvec, staticidx*sizeof (Lisp_Object *)); - for (elt = pdump_opaque_data_list.first; elt; elt = elt->next) - if (pdump_size_to_align (elt->size) == align) - f (elt, 0); + for (i=0; isave_offset; + else + reloc[i] = *(EMACS_INT *)(staticvec[i]); } + write (pdump_fd, reloc, staticidx*sizeof (Lisp_Object)); + free (reloc); } static void -pdump_dump_root_struct_ptrs (void) +pdump_dump_structvec (void) { int i; - size_t count = Dynarr_length (pdump_root_struct_ptrs); - pdump_static_pointer *data = alloca_array (pdump_static_pointer, count); - for (i = 0; i < count; i++) + for (i=0; iptraddress; - data[i].value = (char *) pdump_get_entry (* data[i].address)->save_offset; + EMACS_INT adr; + write (pdump_fd, &(dumpstructvec[i].data), sizeof (void *)); + adr = pdump_get_entry (*(void **)(dumpstructvec[i].data))->save_offset; + write (pdump_fd, &adr, sizeof (adr)); } - PDUMP_ALIGN_OUTPUT (pdump_static_pointer); - fwrite (data, sizeof (pdump_static_pointer), count, pdump_out); } static void -pdump_dump_opaques (void) +pdump_dump_opaquevec (void) { int i; - for (i = 0; i < Dynarr_length (pdump_opaques); i++) + for (i=0; ivaraddress, info->size, 1, pdump_out); + write (pdump_fd, &(dumpopaquevec[i]), sizeof (dumpopaquevec[i])); + write (pdump_fd, dumpopaquevec[i].data, dumpopaquevec[i].size); } } static void +pdump_dump_itable (void) +{ + write (pdump_fd, lrecord_implementations_table, lrecord_type_count*sizeof (lrecord_implementations_table[0])); +} + +static void pdump_dump_rtables (void) { - int i; - pdump_entry_list_elt *elt; + int i, j; + pdump_entry_list_elmt *elmt; pdump_reloc_table rt; for (i=0; idescription; rt.count = pdump_object_table[i].count; - PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt); - while (elt) + write (pdump_fd, &rt, sizeof (rt)); + while (elmt) { - EMACS_INT rdata = pdump_get_entry (elt->obj)->save_offset; - PDUMP_WRITE_ALIGNED (EMACS_INT, rdata); - elt = elt->next; + EMACS_INT rdata = pdump_get_entry (elmt->obj)->save_offset; + write (pdump_fd, &rdata, sizeof (rdata)); + elmt = elmt->next; } } rt.desc = 0; rt.count = 0; - PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt); + write (pdump_fd, &rt, sizeof (rt)); for (i=0; idescription; rt.count = pdump_struct_table.list[i].list.count; - PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt); - while (elt) + write (pdump_fd, &rt, sizeof (rt)); + while (elmt) { - EMACS_INT rdata = pdump_get_entry (elt->obj)->save_offset; - int j; - for (j=0; jcount; j++) + EMACS_INT rdata = pdump_get_entry (elmt->obj)->save_offset; + for (j=0; jcount; j++) { - PDUMP_WRITE_ALIGNED (EMACS_INT, rdata); - rdata += elt->size; + write (pdump_fd, &rdata, sizeof (rdata)); + rdata += elmt->size; } - elt = elt->next; + elmt = elmt->next; } } rt.desc = 0; rt.count = 0; - PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt); + write (pdump_fd, &rt, sizeof (rt)); } static void -pdump_dump_root_objects (void) +pdump_dump_wired (void) { - size_t count = (Dynarr_length (pdump_root_objects) + - Dynarr_length (pdump_weak_object_chains)); - size_t i; + EMACS_INT count = pdump_wireidx + pdump_wireidx_list; + int i; - PDUMP_WRITE_ALIGNED (size_t, count); - PDUMP_ALIGN_OUTPUT (pdump_static_Lisp_Object); + write (pdump_fd, &count, sizeof (count)); - for (i=0; isave_offset); - - PDUMP_WRITE (pdump_static_Lisp_Object, obj); + EMACS_INT obj = pdump_get_entry (XRECORD_LHEADER (*(pdump_wirevec[i])))->save_offset; + write (pdump_fd, &pdump_wirevec[i], sizeof (pdump_wirevec[i])); + write (pdump_fd, &obj, sizeof (obj)); } - for (i=0; idescription; + desc = XRECORD_LHEADER_IMPLEMENTATION (obj)->description; for (pos = 0; desc[pos].type != XD_LO_LINK; pos++) assert (desc[pos].type != XD_END); - obj.value = *(Lisp_Object *)(desc[pos].offset + (char *)(XRECORD_LHEADER (obj.value))); + obj = *(Lisp_Object *)(desc[pos].offset + (char *)(XRECORD_LHEADER (obj))); } - obj.value = wrap_object ((void *) elt->save_offset); + res = elmt->save_offset; - PDUMP_WRITE (pdump_static_Lisp_Object, obj); + write (pdump_fd, &pdump_wirevec_list[i], sizeof (pdump_wirevec_list[i])); + write (pdump_fd, &res, sizeof (res)); } } @@ -972,35 +890,23 @@ pdump (void) int i; Lisp_Object t_console, t_device, t_frame; int none; - pdump_header header; - - pdump_object_table = xnew_array (pdump_entry_list, lrecord_type_count); - pdump_alert_undump_object = xnew_array (int, lrecord_type_count); - - assert (ALIGNOF (max_align_t) <= pdump_align_table[0]); - - for (i = 0; i < countof (pdump_align_table); i++) - if (pdump_align_table[i] > ALIGNOF (max_align_t)) - pdump_align_table[i] = ALIGNOF (max_align_t); - - flush_all_buffer_local_cache (); + dump_header hd; /* These appear in a DEFVAR_LISP, which does a staticpro() */ - t_console = Vterminal_console; Vterminal_console = Qnil; - t_frame = Vterminal_frame; Vterminal_frame = Qnil; - t_device = Vterminal_device; Vterminal_device = Qnil; + t_console = Vterminal_console; + t_frame = Vterminal_frame; + t_device = Vterminal_device; - dump_add_opaque (&lrecord_implementations_table, - lrecord_type_count * sizeof (lrecord_implementations_table[0])); - dump_add_opaque (&lrecord_markers, - lrecord_type_count * sizeof (lrecord_markers[0])); + Vterminal_console = Qnil; + Vterminal_frame = Qnil; + Vterminal_device = Qnil; - pdump_hash = xnew_array_and_zero (pdump_entry_list_elt *, PDUMP_HASHSIZE); + pdump_hash = xnew_array_and_zero (pdump_entry_list_elmt *, PDUMP_HASHSIZE); for (i=0; isignature, - PDUMP_SIGNATURE, PDUMP_SIGNATURE_LEN) - && ((pdump_header *)pdump_start)->id == dump_id); + return (!memcmp (((dump_header *)pdump_start)->signature, DUMP_SIGNATURE, DUMP_SIGNATURE_LEN) + && ((dump_header *)pdump_start)->id == dump_id); } -/*----------------------------------------------------------------------*/ -/* Reading the dump file */ -/*----------------------------------------------------------------------*/ -static int -pdump_load_finish (void) +static int pdump_load_finish (void) { int i; char *p; EMACS_INT delta; EMACS_INT count; - pdump_header *header = (pdump_header *)pdump_start; pdump_end = pdump_start + pdump_length; - delta = ((EMACS_INT)pdump_start) - header->reloc_address; - p = pdump_start + header->stab_offset; +#define PDUMP_READ(p, type) (p = (char*) (((type *) p) + 1), *((type *) p - 1)) - /* Put back the pdump_root_struct_ptrs */ - p = (char *) ALIGN_PTR (p, ALIGNOF (pdump_static_pointer)); - for (i=0; inb_root_struct_ptrs; i++) + staticidx = ((dump_header *)(pdump_start))->nb_staticpro; + delta = ((EMACS_INT)pdump_start) - ((dump_header *)pdump_start)->reloc_address; + p = pdump_start + ((dump_header *)pdump_start)->stab_offset; + + /* Put back the staticvec in place */ + memcpy (staticvec, p, staticidx*sizeof (Lisp_Object *)); + p += staticidx*sizeof (Lisp_Object *); + for (i=0; inb_opaques; i++) + /* Put back the dumpstructs */ + for (i=0; i<((dump_header *)pdump_start)->nb_structdmp; i++) { - pdump_opaque info = PDUMP_READ_ALIGNED (p, pdump_opaque); - memcpy (info.varaddress, p, info.size); - p += info.size; + void **adr = PDUMP_READ (p, void **); + *adr = (void *) (PDUMP_READ (p, char *) + delta); } + /* Put back the opaques */ + for (i=0; i<((dump_header *)pdump_start)->nb_opaquedmp; i++) + { + struct pdump_dumpopaqueinfo di = PDUMP_READ (p, struct pdump_dumpopaqueinfo); + memcpy (di.data, p, di.size); + p += di.size; + } + + /* Put back the lrecord_implementations_table */ + /* The (void *) cast is there to make Ben happy. */ + memcpy ((void *) lrecord_implementations_table, p, lrecord_type_count*sizeof (lrecord_implementations_table[0])); + p += lrecord_type_count*sizeof (lrecord_implementations_table[0]); + + /* Reinitialize lrecord_markers from lrecord_implementations_table */ + for (i=0; i < lrecord_type_count; i++) + if (lrecord_implementations_table[i]) + lrecord_markers[i] = lrecord_implementations_table[i]->marker; + /* Do the relocations */ pdump_rt_list = p; count = 2; for (;;) { - pdump_reloc_table rt = PDUMP_READ_ALIGNED (p, pdump_reloc_table); - p = (char *) ALIGN_PTR (p, ALIGNOF (char *)); + pdump_reloc_table rt = PDUMP_READ (p, pdump_reloc_table); if (rt.desc) { - char **reloc = (char **)p; for (i=0; i < rt.count; i++) { - reloc[i] += delta; - pdump_reloc_one (reloc[i], delta, rt.desc); + char *adr = delta + *(char **)p; + *(char **)p = adr; + pdump_reloc_one (adr, delta, rt.desc); + p += sizeof (char *); } - p += rt.count * sizeof (char *); } else if (!(--count)) break; } - /* Put the pdump_root_objects variables in place */ - i = PDUMP_READ_ALIGNED (p, size_t); - p = (char *) ALIGN_PTR (p, ALIGNOF (pdump_static_Lisp_Object)); - while (i--) + /* Put the pdump_wire variables in place */ + count = PDUMP_READ (p, EMACS_INT); + + for (i=0; iexe_path && !IS_DIRECTORY_SEP (*w) && (*w != '-') && (*w != '.')); + while (w>exe_path && !IS_DIRECTORY_SEP (*w) && (*w != '-') && (*w != '.')); } while (w>exe_path && !IS_DIRECTORY_SEP (*w)); return 0; } -int -pdump_load (const char *argv0) +int pdump_load(const char *argv0) { char exe_path[PATH_MAX]; -#ifdef WIN32_NATIVE - GetModuleFileName (NULL, exe_path, PATH_MAX); -#else /* !WIN32_NATIVE */ char *w; +#ifdef WINDOWSNT + GetModuleFileName (NULL, exe_name, PATH_MAX); +#else /* !WINDOWSNT */ const char *dir, *p; dir = argv0; if (dir[0] == '-') { /* XEmacs as a login shell, oh goody! */ - dir = getenv ("SHELL"); + dir = getenv("SHELL"); } - p = dir + strlen (dir); + p = dir + strlen(dir); while (p != dir && !IS_ANY_SEP (p[-1])) p--; - + if (p != dir) { /* invocation-name includes a directory component -- presumably it @@ -1410,13 +1313,13 @@ pdump_load (const char *argv0) { *w++ = '/'; } - strcpy (w, name); - + strcpy(w, name); + /* ### #$%$#^$^@%$^#%@$ ! */ #ifdef access #undef access #endif - + if (!access (exe_path, X_OK)) break; if (!*p) @@ -1425,10 +1328,10 @@ pdump_load (const char *argv0) sprintf (exe_path, "./%s", name); break; } - path = p+1; + path = p+1; } } -#endif /* WIN32_NATIVE */ +#endif /* WINDOWSNT */ if (pdump_file_try (exe_path)) { @@ -1436,7 +1339,7 @@ pdump_load (const char *argv0) return 1; } -#ifdef WIN32_NATIVE +#ifdef WINDOWSNT if (pdump_resource_get ()) { if (pdump_load_check ())