/* Portable data dumper for XEmacs. Copyright (C) 1999-2000 Olivier Galibert Copyright (C) 2001 Martin Buchholz This file is part of XEmacs. XEmacs is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. XEmacs is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with XEmacs; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Synched up with: Not in FSF. */ #include #include "lisp.h" #include "specifier.h" #include "elhash.h" #include "sysfile.h" #include "console-stream.h" #include "dumper.h" #include "sysdep.h" #ifdef WIN32_NATIVE #include "nt.h" #else #ifdef HAVE_MMAP #include #endif #endif #ifndef SEPCHAR #define SEPCHAR ':' #endif 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; static char *pdump_rt_list = 0; void pdump_objects_unmark (void) { int i; char *p = pdump_rt_list; if (p) for (;;) { pdump_reloc_table *rt = (pdump_reloc_table *)p; p += sizeof (pdump_reloc_table); if (rt->desc) { for (i=0; icount; i++) { struct lrecord_header *lh = * (struct lrecord_header **) p; if (! C_READONLY_RECORD_HEADER_P (lh)) UNMARK_RECORD_HEADER (lh); p += sizeof (EMACS_INT); } } else break; } } /* 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 */ #define PDUMP_SIGNATURE "XEmacsDP" #define PDUMP_SIGNATURE_LEN (sizeof (PDUMP_SIGNATURE) - 1) typedef struct { char signature[PDUMP_SIGNATURE_LEN]; unsigned int id; EMACS_UINT stab_offset; EMACS_UINT reloc_address; int nb_root_struct_ptrs; int nb_opaques; } pdump_header; char *pdump_start; char *pdump_end; static size_t pdump_length; #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[] = { 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 }; static inline unsigned int pdump_size_to_align (size_t size) { return pdump_align_table[size % countof (pdump_align_table)]; } typedef struct pdump_entry_list_elt { struct pdump_entry_list_elt *next; const void *obj; size_t size; int count; EMACS_INT save_offset; } pdump_entry_list_elt; typedef struct { pdump_entry_list_elt *first; int align; int count; } pdump_entry_list; typedef struct pdump_struct_list_elt { pdump_entry_list list; const struct struct_description *sdesc; } pdump_struct_list_elt; typedef struct { pdump_struct_list_elt *list; int count; int size; } pdump_struct_list; static pdump_entry_list *pdump_object_table; static pdump_entry_list pdump_opaque_data_list; static pdump_struct_list pdump_struct_table; static int *pdump_alert_undump_object; 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; /* Since most pointers are eight bytes aligned, the >>3 allows for a better hash */ static int pdump_make_hash (const void *obj) { return ((unsigned long)(obj)>>3) % PDUMP_HASHSIZE; } static pdump_entry_list_elt * pdump_get_entry (const void *obj) { int pos = pdump_make_hash (obj); pdump_entry_list_elt *e; assert (obj != 0); while ((e = pdump_hash[pos]) != 0) { if (e->obj == obj) return e; pos++; if (pos == PDUMP_HASHSIZE) pos = 0; } return 0; } static void pdump_add_entry (pdump_entry_list *list, const void *obj, size_t size, int count) { pdump_entry_list_elt *e; int pos = pdump_make_hash (obj); while ((e = pdump_hash[pos]) != 0) { if (e->obj == obj) return; pos++; if (pos == PDUMP_HASHSIZE) pos = 0; } e = xnew (pdump_entry_list_elt); e->next = list->first; e->obj = obj; e->size = size; e->count = count; list->first = e; list->count += count; pdump_hash[pos] = e; { int align = pdump_size_to_align (size); if (align < list->align) list->align = align; } } static pdump_entry_list * pdump_get_entry_list (const struct struct_description *sdesc) { int i; for (i=0; iname, 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 EMACS_INT pdump_get_indirect_count (EMACS_INT code, const struct lrecord_description *idesc, const void *idata) { EMACS_INT count = 0; /* initialize to shut up GCC */ const void *irdata; int line = XD_INDIRECT_VAL (code); int delta = XD_INDIRECT_DELTA (code); irdata = ((char *)idata) + idesc[line].offset; switch (idesc[line].type) { case XD_SIZE_T: count = *(size_t *)irdata; break; case XD_INT: count = *(int *)irdata; break; case XD_LONG: count = *(long *)irdata; break; case XD_BYTECOUNT: count = *(Bytecount *)irdata; break; default: stderr_out ("Unsupported count type : %d (line = %d, code=%ld)\n", idesc[line].type, line, (long)code); pdump_backtrace (); ABORT (); } count += delta; return count; } static void pdump_register_sub (const void *data, const struct lrecord_description *desc, int me) { int pos; restart: for (pos = 0; desc[pos].type != XD_END; pos++) { const void *rdata = (const char *)data + desc[pos].offset; backtrace[me].position = pos; backtrace[me].offset = desc[pos].offset; switch (desc[pos].type) { case XD_SPECIFIER_END: pos = 0; desc = ((const Lisp_Specifier *)data)->methods->extra_description; goto restart; case XD_SIZE_T: case XD_INT: case XD_LONG: case XD_BYTECOUNT: case XD_INT_RESET: case XD_LO_LINK: break; case XD_OPAQUE_DATA_PTR: { EMACS_INT count = desc[pos].data1; if (XD_IS_INDIRECT (count)) count = pdump_get_indirect_count (count, desc, data); pdump_add_entry (&pdump_opaque_data_list, *(void **)rdata, count, 1); 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); 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); break; } case XD_LISP_OBJECT: { const Lisp_Object *pobj = (const Lisp_Object *)rdata; assert (desc[pos].data1 == 0); backtrace[me].offset = (const char *)pobj - (const char *)data; pdump_register_object (*pobj); break; } case XD_LISP_OBJECT_ARRAY: { int i; EMACS_INT count = desc[pos].data1; if (XD_IS_INDIRECT (count)) count = pdump_get_indirect_count (count, desc, data); for (i = 0; i < count; i++) { const Lisp_Object *pobj = ((const Lisp_Object *)rdata) + i; Lisp_Object dobj = *pobj; backtrace[me].offset = (const char *)pobj - (const char *)data; pdump_register_object (dobj); } break; } case XD_STRUCT_PTR: { EMACS_INT count = desc[pos].data1; const struct struct_description *sdesc = desc[pos].data2; const char *dobj = *(const char **)rdata; if (dobj) { if (XD_IS_INDIRECT (count)) count = pdump_get_indirect_count (count, desc, data); pdump_register_struct (dobj, sdesc, count); } break; } default: stderr_out ("Unsupported dump type : %d\n", desc[pos].type); pdump_backtrace (); ABORT (); }; } } static void pdump_register_object (Lisp_Object obj) { struct lrecord_header *objh; const struct lrecord_implementation *imp; if (!POINTER_TYPE_P (XTYPE (obj))) return; objh = XRECORD_LHEADER (obj); if (!objh) return; if (pdump_get_entry (objh)) return; imp = LHEADER_IMPLEMENTATION (objh); if (imp->description) { int me = depth++; if (me>=65536) { stderr_out ("Backtrace overflow, loop ?\n"); ABORT (); } backtrace[me].obj = objh; backtrace[me].position = 0; backtrace[me].offset = 0; pdump_add_entry (pdump_object_table + objh->type, objh, imp->static_size ? imp->static_size : imp->size_in_bytes_method (objh), 1); pdump_register_sub (objh, imp->description, me); --depth; } else { pdump_alert_undump_object[objh->type]++; stderr_out ("Undumpable object type : %s\n", imp->name); pdump_backtrace (); } } static void pdump_register_struct (const void *data, const struct struct_description *sdesc, int count) { if (data && !pdump_get_entry (data)) { int me = depth++; int i; if (me>=65536) { stderr_out ("Backtrace overflow, loop ?\n"); ABORT (); } backtrace[me].obj = 0; backtrace[me].position = 0; backtrace[me].offset = 0; pdump_add_entry (pdump_get_entry_list (sdesc), data, sdesc->size, count); for (i=0; isize*i, sdesc->description, me); } --depth; } } static void pdump_dump_data (pdump_entry_list_elt *elt, const struct lrecord_description *desc) { size_t size = elt->size; int count = elt->count; if (desc) { int pos, i; memcpy (pdump_buf, elt->obj, size*count); for (i=0; iobj))->methods->extra_description; goto restart; case XD_SIZE_T: case XD_INT: case XD_LONG: case XD_BYTECOUNT: 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); *(int *)rdata = val; break; } case XD_OPAQUE_DATA_PTR: case XD_C_STRING: case XD_STRUCT_PTR: { void *ptr = *(void **)rdata; if (ptr) *(EMACS_INT *)rdata = pdump_get_entry (ptr)->save_offset; break; } case XD_LO_LINK: { Lisp_Object obj = *(Lisp_Object *)rdata; pdump_entry_list_elt *elt1; for (;;) { elt1 = pdump_get_entry (XRECORD_LHEADER (obj)); if (elt1) break; obj = *(Lisp_Object *)(desc[pos].offset + (char *)(XRECORD_LHEADER (obj))); } *(EMACS_INT *)rdata = elt1->save_offset; break; } case XD_LISP_OBJECT: { Lisp_Object *pobj = (Lisp_Object *) rdata; assert (desc[pos].data1 == 0); if (POINTER_TYPE_P (XTYPE (*pobj)) && XRECORD_LHEADER (*pobj)) *(EMACS_INT *)pobj = pdump_get_entry (XRECORD_LHEADER (*pobj))->save_offset; break; } case XD_LISP_OBJECT_ARRAY: { EMACS_INT num = desc[pos].data1; int j; if (XD_IS_INDIRECT (num)) num = pdump_get_indirect_count (num, desc, elt->obj); for (j=0; jsave_offset; } break; } case XD_DOC_STRING: { EMACS_INT str = *(EMACS_INT *)rdata; if (str > 0) *(EMACS_INT *)rdata = pdump_get_entry ((void *)str)->save_offset; break; } default: stderr_out ("Unsupported dump type : %d\n", desc[pos].type); ABORT (); } } } } fwrite (desc ? pdump_buf : elt->obj, size, count, pdump_out); } static void pdump_reloc_one (void *data, EMACS_INT delta, const struct lrecord_description *desc) { int pos; restart: for (pos = 0; desc[pos].type != XD_END; pos++) { void *rdata = (char *)data + desc[pos].offset; switch (desc[pos].type) { case XD_SPECIFIER_END: pos = 0; desc = ((const Lisp_Specifier *)data)->methods->extra_description; goto restart; case XD_SIZE_T: case XD_INT: case XD_LONG: case XD_BYTECOUNT: case XD_INT_RESET: break; case XD_OPAQUE_DATA_PTR: case XD_C_STRING: case XD_STRUCT_PTR: case XD_LO_LINK: { EMACS_INT ptr = *(EMACS_INT *)rdata; if (ptr) *(EMACS_INT *)rdata = ptr+delta; break; } case XD_LISP_OBJECT: { Lisp_Object *pobj = (Lisp_Object *) rdata; assert (desc[pos].data1 == 0); if (POINTER_TYPE_P (XTYPE (*pobj)) && ! EQ (*pobj, Qnull_pointer)) XSETOBJ (*pobj, (char *) XPNTR (*pobj) + delta); break; } case XD_LISP_OBJECT_ARRAY: { EMACS_INT num = desc[pos].data1; int j; if (XD_IS_INDIRECT (num)) num = pdump_get_indirect_count (num, desc, data); for (j=0; j 0) *(EMACS_INT *)rdata = str + delta; break; } default: stderr_out ("Unsupported dump type : %d\n", desc[pos].type); ABORT (); }; } } static void pdump_allocate_offset (pdump_entry_list_elt *elt, const struct lrecord_description *desc) { size_t size = elt->count * elt->size; elt->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 *)) { int align; for (align = ALIGNOF (max_align_t); align; align>>=1) { size_t i; pdump_entry_list_elt *elt; for (i=0; inext) f (elt, lrecord_implementations_table[i]->description); for (i=0; inext) f (elt, list.sdesc->description); } for (elt = pdump_opaque_data_list.first; elt; elt = elt->next) if (pdump_size_to_align (elt->size) == align) f (elt, 0); } } static void pdump_dump_root_struct_ptrs (void) { size_t 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++) { data[i].address = (char **) Dynarr_atp (pdump_root_struct_ptrs, i)->ptraddress; data[i].value = (char *) pdump_get_entry (* data[i].address)->save_offset; } PDUMP_ALIGN_OUTPUT (pdump_static_pointer); fwrite (data, sizeof (pdump_static_pointer), count, pdump_out); } static void pdump_dump_opaques (void) { int i; for (i = 0; i < Dynarr_length (pdump_opaques); i++) { pdump_opaque *info = Dynarr_atp (pdump_opaques, i); PDUMP_WRITE_ALIGNED (pdump_opaque, *info); fwrite (info->varaddress, info->size, 1, pdump_out); } } static void pdump_dump_rtables (void) { size_t i; pdump_entry_list_elt *elt; pdump_reloc_table rt; for (i=0; idescription; rt.count = pdump_object_table[i].count; PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt); while (elt) { EMACS_INT rdata = pdump_get_entry (elt->obj)->save_offset; PDUMP_WRITE_ALIGNED (EMACS_INT, rdata); elt = elt->next; } } rt.desc = 0; rt.count = 0; PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt); for (i=0; idescription; rt.count = pdump_struct_table.list[i].list.count; PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt); while (elt) { EMACS_INT rdata = pdump_get_entry (elt->obj)->save_offset; int j; for (j=0; jcount; j++) { PDUMP_WRITE_ALIGNED (EMACS_INT, rdata); rdata += elt->size; } elt = elt->next; } } rt.desc = 0; rt.count = 0; PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt); } static void pdump_dump_root_objects (void) { size_t count = (Dynarr_length (pdump_root_objects) + Dynarr_length (pdump_weak_object_chains)); EMACS_INT i; PDUMP_WRITE_ALIGNED (size_t, count); PDUMP_ALIGN_OUTPUT (pdump_static_Lisp_Object); for (i=0; isave_offset); PDUMP_WRITE (pdump_static_Lisp_Object, obj); } for (i=0; idescription; 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.value = wrap_object ((void *) elt->save_offset); PDUMP_WRITE (pdump_static_Lisp_Object, obj); } } void pdump (void) { size_t 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 (); /* 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; dump_add_opaque ((void *) &lrecord_implementations_table, lrecord_type_count * sizeof (lrecord_implementations_table[0])); dump_add_opaque (&lrecord_markers, lrecord_type_count * sizeof (lrecord_markers[0])); pdump_hash = xnew_array_and_zero (pdump_entry_list_elt *, PDUMP_HASHSIZE); for (i=0; iname, pdump_alert_undump_object[i]); } if (!none) return; for (i=0; i<(size_t)Dynarr_length (pdump_root_struct_ptrs); i++) { pdump_root_struct_ptr info = Dynarr_at (pdump_root_struct_ptrs, i); pdump_register_struct (*(info.ptraddress), info.desc, 1); } memcpy (header.signature, PDUMP_SIGNATURE, PDUMP_SIGNATURE_LEN); header.id = dump_id; header.reloc_address = 0; header.nb_root_struct_ptrs = Dynarr_length (pdump_root_struct_ptrs); header.nb_opaques = Dynarr_length (pdump_opaques); cur_offset = ALIGN_SIZE (sizeof (header), ALIGNOF (max_align_t)); max_size = 0; pdump_scan_by_alignment (pdump_allocate_offset); cur_offset = ALIGN_SIZE (cur_offset, ALIGNOF (max_align_t)); header.stab_offset = cur_offset; pdump_buf = xmalloc (max_size); /* Avoid use of the `open' macro. We want the real function. */ #undef open pdump_fd = open (EMACS_PROGNAME ".dmp", O_WRONLY | O_CREAT | O_TRUNC | OPEN_BINARY, 0666); pdump_out = fdopen (pdump_fd, "w"); fwrite (&header, sizeof (header), 1, pdump_out); PDUMP_ALIGN_OUTPUT (max_align_t); pdump_scan_by_alignment (pdump_dump_data); fseek (pdump_out, header.stab_offset, SEEK_SET); pdump_dump_root_struct_ptrs (); pdump_dump_opaques (); pdump_dump_rtables (); pdump_dump_root_objects (); fclose (pdump_out); /* pdump_fd is already closed by the preceding fclose call close (pdump_fd); */ free (pdump_buf); free (pdump_hash); Vterminal_console = t_console; Vterminal_frame = t_frame; Vterminal_device = t_device; } static int pdump_load_check (void) { return (!memcmp (((pdump_header *)pdump_start)->signature, PDUMP_SIGNATURE, PDUMP_SIGNATURE_LEN) && ((pdump_header *)pdump_start)->id == dump_id); } /*----------------------------------------------------------------------*/ /* Reading the dump file */ /*----------------------------------------------------------------------*/ 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; /* Put back the pdump_root_struct_ptrs */ p = (char *) ALIGN_PTR (p, ALIGNOF (pdump_static_pointer)); for (i=0; inb_root_struct_ptrs; i++) { pdump_static_pointer ptr = PDUMP_READ (p, pdump_static_pointer); (* ptr.address) = ptr.value + delta; } /* Put back the pdump_opaques */ for (i=0; inb_opaques; i++) { pdump_opaque info = PDUMP_READ_ALIGNED (p, pdump_opaque); memcpy (info.varaddress, p, info.size); p += info.size; } /* 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 *)); 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); } 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--) { pdump_static_Lisp_Object obj = PDUMP_READ (p, pdump_static_Lisp_Object); if (POINTER_TYPE_P (XTYPE (obj.value))) obj.value = wrap_object ((char *) XPNTR (obj.value) + delta); (* obj.address) = obj.value; } /* Final cleanups */ /* reorganize hash tables */ p = pdump_rt_list; for (;;) { pdump_reloc_table rt = PDUMP_READ_ALIGNED (p, pdump_reloc_table); p = (char *) ALIGN_PTR (p, ALIGNOF (Lisp_Object)); if (!rt.desc) break; if (rt.desc == hash_table_description) { for (i=0; i < rt.count; i++) pdump_reorganize_hash_table (PDUMP_READ (p, Lisp_Object)); break; } else p += sizeof (Lisp_Object) * rt.count; } return 1; } #ifdef WIN32_NATIVE /* Free the mapped file if we decide we don't want it after all */ static void pdump_file_unmap (void) { UnmapViewOfFile (pdump_start); CloseHandle (pdump_hFile); CloseHandle (pdump_hMap); } static int pdump_file_get (const char *path) { pdump_hFile = CreateFile (path, GENERIC_READ + GENERIC_WRITE, /* Required for copy on write */ 0, /* Not shared */ NULL, /* Not inheritable */ OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); /* No template file */ if (pdump_hFile == INVALID_HANDLE_VALUE) return 0; pdump_length = GetFileSize (pdump_hFile, NULL); pdump_hMap = CreateFileMapping (pdump_hFile, NULL, /* No security attributes */ PAGE_WRITECOPY, /* Copy on write */ 0, /* Max size, high half */ 0, /* Max size, low half */ NULL); /* Unnamed */ if (pdump_hMap == INVALID_HANDLE_VALUE) return 0; pdump_start = MapViewOfFile (pdump_hMap, FILE_MAP_COPY, /* Copy on write */ 0, /* Start at zero */ 0, 0); /* Map all of it */ pdump_free = pdump_file_unmap; return 1; } /* pdump_resource_free is called (via the pdump_free pointer) to release any resources allocated by pdump_resource_get. Since the Windows API specs specifically state that you don't need to (and shouldn't) free the resources allocated by FindResource, LoadResource, and LockResource this routine does nothing. */ static void pdump_resource_free (void) { } static int pdump_resource_get (void) { HRSRC hRes; /* Handle to dump resource */ HRSRC hResLoad; /* Handle to loaded dump resource */ /* See Q126630 which describes how Windows NT and 95 trap writes to resource sections and duplicate the page to allow the write to proceed. It also describes how to make the resource section read/write (and hence private to each process). Doing this avoids the exceptions and related overhead, but causes the resource section to be private to each process that is running XEmacs. Since the resource section contains little other than the dumped data, which should be private to each process, we make the whole resource section read/write so we don't have to copy it. */ hRes = FindResource (NULL, MAKEINTRESOURCE(101), "DUMP"); if (hRes == NULL) return 0; /* Found it, use the data in the resource */ hResLoad = LoadResource (NULL, hRes); if (hResLoad == NULL) return 0; pdump_start = LockResource (hResLoad); if (pdump_start == NULL) return 0; pdump_free = pdump_resource_free; pdump_length = SizeofResource (NULL, hRes); if (pdump_length <= sizeof (pdump_header)) { pdump_start = 0; return 0; } return 1; } #else /* !WIN32_NATIVE */ static void pdump_file_free (void) { xfree (pdump_start); } #ifdef HAVE_MMAP static void pdump_file_unmap (void) { munmap (pdump_start, pdump_length); } #endif static int pdump_file_get (const char *path) { int fd = open (path, O_RDONLY | OPEN_BINARY); if (fd<0) return 0; pdump_length = lseek (fd, 0, SEEK_END); if (pdump_length < sizeof (pdump_header)) { close (fd); return 0; } lseek (fd, 0, SEEK_SET); #ifdef HAVE_MMAP /* Unix 98 requires that sys/mman.h define MAP_FAILED, but many earlier implementations don't. */ # ifndef MAP_FAILED # define MAP_FAILED ((void *) -1L) # endif pdump_start = (char *) mmap (0, pdump_length, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0); if (pdump_start != (char *) MAP_FAILED) { pdump_free = pdump_file_unmap; close (fd); return 1; } #endif /* HAVE_MMAP */ pdump_start = xnew_array (char, pdump_length); pdump_free = pdump_file_free; read (fd, pdump_start, pdump_length); close (fd); return 1; } #endif /* !WIN32_NATIVE */ static int pdump_file_try (char *exe_path) { char *w = exe_path + strlen (exe_path); do { sprintf (w, "-%s-%08x.dmp", EMACS_VERSION, dump_id); if (pdump_file_get (exe_path)) { if (pdump_load_check ()) return 1; pdump_free (); } sprintf (w, "-%08x.dmp", dump_id); if (pdump_file_get (exe_path)) { if (pdump_load_check ()) return 1; pdump_free (); } sprintf (w, ".dmp"); if (pdump_file_get (exe_path)) { if (pdump_load_check ()) return 1; pdump_free (); } do 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) { char exe_path[PATH_MAX], real_exe_path[PATH_MAX]; #ifdef WIN32_NATIVE GetModuleFileName (NULL, exe_path, PATH_MAX); /* #### urk, needed for xrealpath() below */ Vdirectory_sep_char = make_char ('\\'); #else /* !WIN32_NATIVE */ char *w; const char *dir, *p; dir = argv0; if (dir[0] == '-') { /* XEmacs as a login shell, oh goody! */ dir = getenv ("SHELL"); } p = dir + strlen (dir); while (p != dir && !IS_ANY_SEP (p[-1])) p--; if (p != dir) { /* invocation-name includes a directory component -- presumably it is relative to cwd, not $PATH */ strcpy (exe_path, dir); } else { const char *path = getenv ("PATH"); const char *name = p; for (;;) { p = path; while (*p && *p != SEPCHAR) p++; if (p == path) { exe_path[0] = '.'; w = exe_path + 1; } else { memcpy (exe_path, path, p - path); w = exe_path + (p - path); } if (!IS_DIRECTORY_SEP (w[-1])) { *w++ = '/'; } strcpy (w, name); /* Check that exe_path is executable and not a directory */ #undef access /* avoid !@#$%^& encapsulated access */ #undef stat /* avoid !@#$%^& encapsulated stat */ { struct stat statbuf; if (access (exe_path, X_OK) == 0 && stat (exe_path, &statbuf) == 0 && ! S_ISDIR (statbuf.st_mode)) break; } if (!*p) { /* Oh well, let's have some kind of default */ sprintf (exe_path, "./%s", name); break; } path = p+1; } } #endif /* WIN32_NATIVE */ /* Save exe_path because pdump_file_try() modifies it */ strcpy(real_exe_path, exe_path); if (pdump_file_try (exe_path) || (xrealpath(real_exe_path, real_exe_path) && pdump_file_try (real_exe_path))) { pdump_load_finish (); return 1; } #ifdef WIN32_NATIVE if (pdump_resource_get ()) { if (pdump_load_check ()) { pdump_load_finish (); return 1; } pdump_free (); } #endif return 0; }