Mercurial > hg > xemacs-beta

comparison src/dumper.c @ 460:223736d75acb r21-2-45

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import from CVS: tag r21-2-45
author cvs
date Mon, 13 Aug 2007 11:43:24 +0200
parents c33ae14dd6d0
children 0784d089fdc9
comparison
equal deleted inserted replaced
459:9d4fd877b885 460:223736d75acb
22 /* Synched up with: Not in FSF. */ 22 /* Synched up with: Not in FSF. */
23 23
24 #include <config.h> 24 #include <config.h>
25 #include "lisp.h" 25 #include "lisp.h"
26 26
27 #include "dump-id.h"
28 #include "specifier.h" 27 #include "specifier.h"
29 #include "elhash.h" 28 #include "elhash.h"
30 #include "sysfile.h" 29 #include "sysfile.h"
31 #include "console-stream.h" 30 #include "console-stream.h"
32 #include "dumper.h" 31 #include "dumper.h"
225 static HANDLE pdump_hMap = INVALID_HANDLE_VALUE; 224 static HANDLE pdump_hMap = INVALID_HANDLE_VALUE;
226 #endif 225 #endif
227 226
228 static void (*pdump_free) (void); 227 static void (*pdump_free) (void);
229 228
230 static const unsigned char pdump_align_table[256] = 229 static unsigned char pdump_align_table[] =
231 { 230 {
232 8, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 231 64, 1, 2, 1, 4, 1, 2, 1, 8, 1, 2, 1, 4, 1, 2, 1,
233 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 232 16, 1, 2, 1, 4, 1, 2, 1, 8, 1, 2, 1, 4, 1, 2, 1,
234 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 233 32, 1, 2, 1, 4, 1, 2, 1, 8, 1, 2, 1, 4, 1, 2, 1,
235 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 234 16, 1, 2, 1, 4, 1, 2, 1, 8, 1, 2, 1, 4, 1, 2, 1
236 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
237 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
238 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
239 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
240 7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
241 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
242 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
243 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
244 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
245 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
246 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
247 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
248 }; 235 };
249 236
250 typedef struct pdump_entry_list_elmt 237 static inline unsigned int
251 { 238 pdump_size_to_align (size_t size)
252 struct pdump_entry_list_elmt *next; 239 {
240 return pdump_align_table[size % countof (pdump_align_table)];
241 }
242
243 typedef struct pdump_entry_list_elt
244 {
245 struct pdump_entry_list_elt *next;
253 const void *obj; 246 const void *obj;
254 size_t size; 247 size_t size;
255 int count; 248 int count;
256 EMACS_INT save_offset; 249 EMACS_INT save_offset;
257 } pdump_entry_list_elmt; 250 } pdump_entry_list_elt;
258 251
259 typedef struct 252 typedef struct
260 { 253 {
261 pdump_entry_list_elmt *first; 254 pdump_entry_list_elt *first;
262 int align; 255 int align;
263 int count; 256 int count;
264 } pdump_entry_list; 257 } pdump_entry_list;
265 258
266 typedef struct pdump_struct_list_elmt 259 typedef struct pdump_struct_list_elt
267 { 260 {
268 pdump_entry_list list; 261 pdump_entry_list list;
269 const struct struct_description *sdesc; 262 const struct struct_description *sdesc;
270 } pdump_struct_list_elmt; 263 } pdump_struct_list_elt;
271 264
272 typedef struct 265 typedef struct
273 { 266 {
274 pdump_struct_list_elmt *list; 267 pdump_struct_list_elt *list;
275 int count; 268 int count;
276 int size; 269 int size;
277 } pdump_struct_list; 270 } pdump_struct_list;
278 271
279 static pdump_entry_list pdump_object_table[256]; 272 static pdump_entry_list *pdump_object_table;
280 static pdump_entry_list pdump_opaque_data_list; 273 static pdump_entry_list pdump_opaque_data_list;
281 static pdump_struct_list pdump_struct_table; 274 static pdump_struct_list pdump_struct_table;
282 275
283 static int pdump_alert_undump_object[256]; 276 static int *pdump_alert_undump_object;
284 277
285 static unsigned long cur_offset; 278 static unsigned long cur_offset;
286 static size_t max_size; 279 static size_t max_size;
287 static int pdump_fd; 280 static int pdump_fd;
288 static void *pdump_buf; 281 static void *pdump_buf;
289 static FILE *pdump_out; 282 static FILE *pdump_out;
290 283
291 #define PDUMP_HASHSIZE 200001 284 #define PDUMP_HASHSIZE 200001
292 285
293 static pdump_entry_list_elmt **pdump_hash; 286 static pdump_entry_list_elt **pdump_hash;
294 287
295 /* Since most pointers are eight bytes aligned, the >>3 allows for a better hash */ 288 /* Since most pointers are eight bytes aligned, the >>3 allows for a better hash */
296 static int 289 static int
297 pdump_make_hash (const void *obj) 290 pdump_make_hash (const void *obj)
298 { 291 {
299 return ((unsigned long)(obj)>>3) % PDUMP_HASHSIZE; 292 return ((unsigned long)(obj)>>3) % PDUMP_HASHSIZE;
300 } 293 }
301 294
302 static pdump_entry_list_elmt * 295 static pdump_entry_list_elt *
303 pdump_get_entry (const void *obj) 296 pdump_get_entry (const void *obj)
304 { 297 {
305 int pos = pdump_make_hash (obj); 298 int pos = pdump_make_hash (obj);
306 pdump_entry_list_elmt *e; 299 pdump_entry_list_elt *e;
307 300
308 assert (obj != 0); 301 assert (obj != 0);
309 302
310 while ((e = pdump_hash[pos]) != 0) 303 while ((e = pdump_hash[pos]) != 0)
311 { 304 {
321 314
322 static void 315 static void
323 pdump_add_entry (pdump_entry_list *list, const void *obj, size_t size, 316 pdump_add_entry (pdump_entry_list *list, const void *obj, size_t size,
324 int count) 317 int count)
325 { 318 {
326 pdump_entry_list_elmt *e; 319 pdump_entry_list_elt *e;
327 int align;
328 int pos = pdump_make_hash (obj); 320 int pos = pdump_make_hash (obj);
329 321
330 while ((e = pdump_hash[pos]) != 0) 322 while ((e = pdump_hash[pos]) != 0)
331 { 323 {
332 if (e->obj == obj) 324 if (e->obj == obj)
335 pos++; 327 pos++;
336 if (pos == PDUMP_HASHSIZE) 328 if (pos == PDUMP_HASHSIZE)
337 pos = 0; 329 pos = 0;
338 } 330 }
339 331
340 e = xnew (pdump_entry_list_elmt); 332 e = xnew (pdump_entry_list_elt);
341 333
342 e->next = list->first; 334 e->next = list->first;
343 e->obj = obj; 335 e->obj = obj;
344 e->size = size; 336 e->size = size;
345 e->count = count; 337 e->count = count;
346 list->first = e; 338 list->first = e;
347 339
348 list->count += count; 340 list->count += count;
349 pdump_hash[pos] = e; 341 pdump_hash[pos] = e;
350 342
351 align = pdump_align_table[size & 255]; 343 {
352 344 int align = pdump_size_to_align (size);
353 if (align < list->align) 345
354 list->align = align; 346 if (align < list->align)
347 list->align = align;
348 }
355 } 349 }
356 350
357 static pdump_entry_list * 351 static pdump_entry_list *
358 pdump_get_entry_list (const struct struct_description *sdesc) 352 pdump_get_entry_list (const struct struct_description *sdesc)
359 { 353 {
366 { 360 {
367 if (pdump_struct_table.size == -1) 361 if (pdump_struct_table.size == -1)
368 pdump_struct_table.size = 10; 362 pdump_struct_table.size = 10;
369 else 363 else
370 pdump_struct_table.size = pdump_struct_table.size * 2; 364 pdump_struct_table.size = pdump_struct_table.size * 2;
371 pdump_struct_table.list = (pdump_struct_list_elmt *) 365 pdump_struct_table.list = (pdump_struct_list_elt *)
372 xrealloc (pdump_struct_table.list, 366 xrealloc (pdump_struct_table.list,
373 pdump_struct_table.size * sizeof (pdump_struct_list_elmt)); 367 pdump_struct_table.size * sizeof (pdump_struct_list_elt));
374 } 368 }
375 pdump_struct_table.list[pdump_struct_table.count].list.first = 0; 369 pdump_struct_table.list[pdump_struct_table.count].list.first = 0;
376 pdump_struct_table.list[pdump_struct_table.count].list.align = 8; 370 pdump_struct_table.list[pdump_struct_table.count].list.align = ALIGNOF (max_align_t);
377 pdump_struct_table.list[pdump_struct_table.count].list.count = 0; 371 pdump_struct_table.list[pdump_struct_table.count].list.count = 0;
378 pdump_struct_table.list[pdump_struct_table.count].sdesc = sdesc; 372 pdump_struct_table.list[pdump_struct_table.count].sdesc = sdesc;
379 373
380 return &pdump_struct_table.list[pdump_struct_table.count++].list; 374 return &pdump_struct_table.list[pdump_struct_table.count++].list;
381 } 375 }
626 --depth; 620 --depth;
627 } 621 }
628 } 622 }
629 623
630 static void 624 static void
631 pdump_dump_data (pdump_entry_list_elmt *elmt, 625 pdump_dump_data (pdump_entry_list_elt *elt,
632 const struct lrecord_description *desc) 626 const struct lrecord_description *desc)
633 { 627 {
634 size_t size = elmt->size; 628 size_t size = elt->size;
635 int count = elmt->count; 629 int count = elt->count;
636 if (desc) 630 if (desc)
637 { 631 {
638 int pos, i; 632 int pos, i;
639 memcpy (pdump_buf, elmt->obj, size*count); 633 memcpy (pdump_buf, elt->obj, size*count);
640 634
641 for (i=0; i<count; i++) 635 for (i=0; i<count; i++)
642 { 636 {
643 char *cur = ((char *)pdump_buf) + i*size; 637 char *cur = ((char *)pdump_buf) + i*size;
644 restart: 638 restart:
646 { 640 {
647 void *rdata = cur + desc[pos].offset; 641 void *rdata = cur + desc[pos].offset;
648 switch (desc[pos].type) 642 switch (desc[pos].type)
649 { 643 {
650 case XD_SPECIFIER_END: 644 case XD_SPECIFIER_END:
651 desc = ((const Lisp_Specifier *)(elmt->obj))->methods->extra_description; 645 desc = ((const Lisp_Specifier *)(elt->obj))->methods->extra_description;
652 goto restart; 646 goto restart;
653 case XD_SIZE_T: 647 case XD_SIZE_T:
654 case XD_INT: 648 case XD_INT:
655 case XD_LONG: 649 case XD_LONG:
656 case XD_BYTECOUNT: 650 case XD_BYTECOUNT:
657 break; 651 break;
658 case XD_INT_RESET: 652 case XD_INT_RESET:
659 { 653 {
660 EMACS_INT val = desc[pos].data1; 654 EMACS_INT val = desc[pos].data1;
661 if (XD_IS_INDIRECT (val)) 655 if (XD_IS_INDIRECT (val))
662 val = pdump_get_indirect_count (val, desc, elmt->obj); 656 val = pdump_get_indirect_count (val, desc, elt->obj);
663 *(int *)rdata = val; 657 *(int *)rdata = val;
664 break; 658 break;
665 } 659 }
666 case XD_OPAQUE_DATA_PTR: 660 case XD_OPAQUE_DATA_PTR:
667 case XD_C_STRING: 661 case XD_C_STRING:
673 break; 667 break;
674 } 668 }
675 case XD_LO_LINK: 669 case XD_LO_LINK:
676 { 670 {
677 Lisp_Object obj = *(Lisp_Object *)rdata; 671 Lisp_Object obj = *(Lisp_Object *)rdata;
678 pdump_entry_list_elmt *elmt1; 672 pdump_entry_list_elt *elt1;
679 for (;;) 673 for (;;)
680 { 674 {
681 elmt1 = pdump_get_entry (XRECORD_LHEADER (obj)); 675 elt1 = pdump_get_entry (XRECORD_LHEADER (obj));
682 if (elmt1) 676 if (elt1)
683 break; 677 break;
684 obj = *(Lisp_Object *)(desc[pos].offset + (char *)(XRECORD_LHEADER (obj))); 678 obj = *(Lisp_Object *)(desc[pos].offset + (char *)(XRECORD_LHEADER (obj)));
685 } 679 }
686 *(EMACS_INT *)rdata = elmt1->save_offset; 680 *(EMACS_INT *)rdata = elt1->save_offset;
687 break; 681 break;
688 } 682 }
689 case XD_LISP_OBJECT: 683 case XD_LISP_OBJECT:
690 { 684 {
691 Lisp_Object *pobj = (Lisp_Object *) rdata; 685 Lisp_Object *pobj = (Lisp_Object *) rdata;
700 case XD_LISP_OBJECT_ARRAY: 694 case XD_LISP_OBJECT_ARRAY:
701 { 695 {
702 EMACS_INT num = desc[pos].data1; 696 EMACS_INT num = desc[pos].data1;
703 int j; 697 int j;
704 if (XD_IS_INDIRECT (num)) 698 if (XD_IS_INDIRECT (num))
705 num = pdump_get_indirect_count (num, desc, elmt->obj); 699 num = pdump_get_indirect_count (num, desc, elt->obj);
706 700
707 for (j=0; j<num; j++) 701 for (j=0; j<num; j++)
708 { 702 {
709 Lisp_Object *pobj = ((Lisp_Object *)rdata) + j; 703 Lisp_Object *pobj = ((Lisp_Object *)rdata) + j;
710 if (POINTER_TYPE_P (XTYPE (*pobj)) && XRECORD_LHEADER (*pobj)) 704 if (POINTER_TYPE_P (XTYPE (*pobj)) && XRECORD_LHEADER (*pobj))
725 abort (); 719 abort ();
726 } 720 }
727 } 721 }
728 } 722 }
729 } 723 }
730 fwrite (desc ? pdump_buf : elmt->obj, size, count, pdump_out); 724 fwrite (desc ? pdump_buf : elt->obj, size, count, pdump_out);
731 } 725 }
732 726
733 static void 727 static void
734 pdump_reloc_one (void *data, EMACS_INT delta, 728 pdump_reloc_one (void *data, EMACS_INT delta,
735 const struct lrecord_description *desc) 729 const struct lrecord_description *desc)
804 }; 798 };
805 } 799 }
806 } 800 }
807 801
808 static void 802 static void
809 pdump_allocate_offset (pdump_entry_list_elmt *elmt, 803 pdump_allocate_offset (pdump_entry_list_elt *elt,
810 const struct lrecord_description *desc) 804 const struct lrecord_description *desc)
811 { 805 {
812 size_t size = elmt->count * elmt->size; 806 size_t size = elt->count * elt->size;
813 elmt->save_offset = cur_offset; 807 elt->save_offset = cur_offset;
814 if (size>max_size) 808 if (size>max_size)
815 max_size = size; 809 max_size = size;
816 cur_offset += size; 810 cur_offset += size;
817 } 811 }
818 812
819 static void 813 static void
820 pdump_scan_by_alignment (void (*f)(pdump_entry_list_elmt *, 814 pdump_scan_by_alignment (void (*f)(pdump_entry_list_elt *,
821 const struct lrecord_description *)) 815 const struct lrecord_description *))
822 { 816 {
823 int align, i; 817 int align;
824 const struct lrecord_description *idesc; 818
825 pdump_entry_list_elmt *elmt; 819 for (align = ALIGNOF (max_align_t); align; align>>=1)
826 for (align=8; align>=0; align--) 820 {
827 { 821 int i;
822 pdump_entry_list_elt *elt;
823
828 for (i=0; i<lrecord_type_count; i++) 824 for (i=0; i<lrecord_type_count; i++)
829 if (pdump_object_table[i].align == align) 825 if (pdump_object_table[i].align == align)
830 { 826 for (elt = pdump_object_table[i].first; elt; elt = elt->next)
831 elmt = pdump_object_table[i].first; 827 f (elt, lrecord_implementations_table[i]->description);
832 if (!elmt)
833 continue;
834 idesc = lrecord_implementations_table[i]->description;
835 while (elmt)
836 {
837 f (elmt, idesc);
838 elmt = elmt->next;
839 }
840 }
841 828
842 for (i=0; i<pdump_struct_table.count; i++) 829 for (i=0; i<pdump_struct_table.count; i++)
843 if (pdump_struct_table.list[i].list.align == align) 830 {
844 { 831 pdump_struct_list_elt list = pdump_struct_table.list[i];
845 elmt = pdump_struct_table.list[i].list.first; 832 if (list.list.align == align)
846 idesc = pdump_struct_table.list[i].sdesc->description; 833 for (elt = list.list.first; elt; elt = elt->next)
847 while (elmt) 834 f (elt, list.sdesc->description);
848 {
849 f (elmt, idesc);
850 elmt = elmt->next;
851 }
852 }
853
854 elmt = pdump_opaque_data_list.first;
855 while (elmt)
856 {
857 if (pdump_align_table[elmt->size & 255] == align)
858 f (elmt, 0);
859 elmt = elmt->next;
860 } 835 }
836
837 for (elt = pdump_opaque_data_list.first; elt; elt = elt->next)
838 if (pdump_size_to_align (elt->size) == align)
839 f (elt, 0);
861 } 840 }
862 } 841 }
863 842
864 static void 843 static void
865 pdump_dump_root_struct_ptrs (void) 844 pdump_dump_root_struct_ptrs (void)
890 869
891 static void 870 static void
892 pdump_dump_rtables (void) 871 pdump_dump_rtables (void)
893 { 872 {
894 int i; 873 int i;
895 pdump_entry_list_elmt *elmt; 874 pdump_entry_list_elt *elt;
896 pdump_reloc_table rt; 875 pdump_reloc_table rt;
897 876
898 for (i=0; i<lrecord_type_count; i++) 877 for (i=0; i<lrecord_type_count; i++)
899 { 878 {
900 elmt = pdump_object_table[i].first; 879 elt = pdump_object_table[i].first;
901 if (!elmt) 880 if (!elt)
902 continue; 881 continue;
903 rt.desc = lrecord_implementations_table[i]->description; 882 rt.desc = lrecord_implementations_table[i]->description;
904 rt.count = pdump_object_table[i].count; 883 rt.count = pdump_object_table[i].count;
905 PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt); 884 PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt);
906 while (elmt) 885 while (elt)
907 { 886 {
908 EMACS_INT rdata = pdump_get_entry (elmt->obj)->save_offset; 887 EMACS_INT rdata = pdump_get_entry (elt->obj)->save_offset;
909 PDUMP_WRITE_ALIGNED (EMACS_INT, rdata); 888 PDUMP_WRITE_ALIGNED (EMACS_INT, rdata);
910 elmt = elmt->next; 889 elt = elt->next;
911 } 890 }
912 } 891 }
913 892
914 rt.desc = 0; 893 rt.desc = 0;
915 rt.count = 0; 894 rt.count = 0;
916 PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt); 895 PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt);
917 896
918 for (i=0; i<pdump_struct_table.count; i++) 897 for (i=0; i<pdump_struct_table.count; i++)
919 { 898 {
920 elmt = pdump_struct_table.list[i].list.first; 899 elt = pdump_struct_table.list[i].list.first;
921 rt.desc = pdump_struct_table.list[i].sdesc->description; 900 rt.desc = pdump_struct_table.list[i].sdesc->description;
922 rt.count = pdump_struct_table.list[i].list.count; 901 rt.count = pdump_struct_table.list[i].list.count;
923 PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt); 902 PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt);
924 while (elmt) 903 while (elt)
925 { 904 {
926 EMACS_INT rdata = pdump_get_entry (elmt->obj)->save_offset; 905 EMACS_INT rdata = pdump_get_entry (elt->obj)->save_offset;
927 int j; 906 int j;
928 for (j=0; j<elmt->count; j++) 907 for (j=0; j<elt->count; j++)
929 { 908 {
930 PDUMP_WRITE_ALIGNED (EMACS_INT, rdata); 909 PDUMP_WRITE_ALIGNED (EMACS_INT, rdata);
931 rdata += elmt->size; 910 rdata += elt->size;
932 } 911 }
933 elmt = elmt->next; 912 elt = elt->next;
934 } 913 }
935 } 914 }
936 rt.desc = 0; 915 rt.desc = 0;
937 rt.count = 0; 916 rt.count = 0;
938 PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt); 917 PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt);
951 for (i=0; i<Dynarr_length (pdump_root_objects); i++) 930 for (i=0; i<Dynarr_length (pdump_root_objects); i++)
952 { 931 {
953 pdump_static_Lisp_Object obj; 932 pdump_static_Lisp_Object obj;
954 obj.address = Dynarr_at (pdump_root_objects, i); 933 obj.address = Dynarr_at (pdump_root_objects, i);
955 obj.value = * obj.address; 934 obj.value = * obj.address;
956 935
957 if (POINTER_TYPE_P (XTYPE (obj.value))) 936 if (POINTER_TYPE_P (XTYPE (obj.value)))
958 obj.value = wrap_object ((void *) pdump_get_entry (XRECORD_LHEADER (obj.value))->save_offset); 937 obj.value = wrap_object ((void *) pdump_get_entry (XRECORD_LHEADER (obj.value))->save_offset);
959 938
960 PDUMP_WRITE (pdump_static_Lisp_Object, obj); 939 PDUMP_WRITE (pdump_static_Lisp_Object, obj);
961 } 940 }
962 941
963 for (i=0; i<Dynarr_length (pdump_weak_object_chains); i++) 942 for (i=0; i<Dynarr_length (pdump_weak_object_chains); i++)
964 { 943 {
965 pdump_entry_list_elmt *elmt; 944 pdump_entry_list_elt *elt;
966 pdump_static_Lisp_Object obj; 945 pdump_static_Lisp_Object obj;
967 946
968 obj.address = Dynarr_at (pdump_weak_object_chains, i); 947 obj.address = Dynarr_at (pdump_weak_object_chains, i);
969 obj.value = * obj.address; 948 obj.value = * obj.address;
970 949
971 for (;;) 950 for (;;)
972 { 951 {
973 const struct lrecord_description *desc; 952 const struct lrecord_description *desc;
974 int pos; 953 int pos;
975 elmt = pdump_get_entry (XRECORD_LHEADER (obj.value)); 954 elt = pdump_get_entry (XRECORD_LHEADER (obj.value));
976 if (elmt) 955 if (elt)
977 break; 956 break;
978 desc = XRECORD_LHEADER_IMPLEMENTATION (obj.value)->description; 957 desc = XRECORD_LHEADER_IMPLEMENTATION (obj.value)->description;
979 for (pos = 0; desc[pos].type != XD_LO_LINK; pos++) 958 for (pos = 0; desc[pos].type != XD_LO_LINK; pos++)
980 assert (desc[pos].type != XD_END); 959 assert (desc[pos].type != XD_END);
981 960
982 obj.value = *(Lisp_Object *)(desc[pos].offset + (char *)(XRECORD_LHEADER (obj.value))); 961 obj.value = *(Lisp_Object *)(desc[pos].offset + (char *)(XRECORD_LHEADER (obj.value)));
983 } 962 }
984 obj.value = wrap_object ((void *) elmt->save_offset); 963 obj.value = wrap_object ((void *) elt->save_offset);
985 964
986 PDUMP_WRITE (pdump_static_Lisp_Object, obj); 965 PDUMP_WRITE (pdump_static_Lisp_Object, obj);
987 } 966 }
988 } 967 }
989 968
993 int i; 972 int i;
994 Lisp_Object t_console, t_device, t_frame; 973 Lisp_Object t_console, t_device, t_frame;
995 int none; 974 int none;
996 pdump_header header; 975 pdump_header header;
997 976
977 pdump_object_table = xnew_array (pdump_entry_list, lrecord_type_count);
978 pdump_alert_undump_object = xnew_array (int, lrecord_type_count);
979
980 assert (ALIGNOF (max_align_t) <= pdump_align_table[0]);
981
982 for (i = 0; i < countof (pdump_align_table); i++)
983 if (pdump_align_table[i] > ALIGNOF (max_align_t))
984 pdump_align_table[i] = ALIGNOF (max_align_t);
985
998 flush_all_buffer_local_cache (); 986 flush_all_buffer_local_cache ();
999 987
1000 /* These appear in a DEFVAR_LISP, which does a staticpro() */ 988 /* These appear in a DEFVAR_LISP, which does a staticpro() */
1001 t_console = Vterminal_console; Vterminal_console = Qnil; 989 t_console = Vterminal_console; Vterminal_console = Qnil;
1002 t_frame = Vterminal_frame; Vterminal_frame = Qnil; 990 t_frame = Vterminal_frame; Vterminal_frame = Qnil;
1005 dump_add_opaque (&lrecord_implementations_table, 993 dump_add_opaque (&lrecord_implementations_table,
1006 lrecord_type_count * sizeof (lrecord_implementations_table[0])); 994 lrecord_type_count * sizeof (lrecord_implementations_table[0]));
1007 dump_add_opaque (&lrecord_markers, 995 dump_add_opaque (&lrecord_markers,
1008 lrecord_type_count * sizeof (lrecord_markers[0])); 996 lrecord_type_count * sizeof (lrecord_markers[0]));
1009 997
1010 pdump_hash = xnew_array_and_zero (pdump_entry_list_elmt *, PDUMP_HASHSIZE); 998 pdump_hash = xnew_array_and_zero (pdump_entry_list_elt *, PDUMP_HASHSIZE);
1011 999
1012 for (i=0; i<lrecord_type_count; i++) 1000 for (i=0; i<lrecord_type_count; i++)
1013 { 1001 {
1014 pdump_object_table[i].first = 0; 1002 pdump_object_table[i].first = 0;
1015 pdump_object_table[i].align = 8; 1003 pdump_object_table[i].align = ALIGNOF (max_align_t);
1016 pdump_object_table[i].count = 0; 1004 pdump_object_table[i].count = 0;
1017 pdump_alert_undump_object[i] = 0; 1005 pdump_alert_undump_object[i] = 0;
1018 } 1006 }
1019 pdump_struct_table.count = 0; 1007 pdump_struct_table.count = 0;
1020 pdump_struct_table.size = -1; 1008 pdump_struct_table.size = -1;
1021 1009
1022 pdump_opaque_data_list.first = 0; 1010 pdump_opaque_data_list.first = 0;
1023 pdump_opaque_data_list.align = 8; 1011 pdump_opaque_data_list.align = ALIGNOF (max_align_t);
1024 pdump_opaque_data_list.count = 0; 1012 pdump_opaque_data_list.count = 0;
1025 depth = 0; 1013 depth = 0;
1026 1014
1027 for (i=0; i<Dynarr_length (pdump_root_objects); i++) 1015 for (i=0; i<Dynarr_length (pdump_root_objects); i++)
1028 pdump_register_object (* Dynarr_at (pdump_root_objects, i)); 1016 pdump_register_object (* Dynarr_at (pdump_root_objects, i));
1277 return 1; 1265 return 1;
1278 } 1266 }
1279 1267
1280 #else /* !WIN32_NATIVE */ 1268 #else /* !WIN32_NATIVE */
1281 1269
1282 static void *pdump_mallocadr;
1283
1284 static void 1270 static void
1285 pdump_file_free (void) 1271 pdump_file_free (void)
1286 { 1272 {
1287 xfree (pdump_mallocadr); 1273 xfree (pdump_start);
1288 } 1274 }
1289 1275
1290 #ifdef HAVE_MMAP 1276 #ifdef HAVE_MMAP
1291 static void 1277 static void
1292 pdump_file_unmap (void) 1278 pdump_file_unmap (void)
1324 close (fd); 1310 close (fd);
1325 return 1; 1311 return 1;
1326 } 1312 }
1327 #endif /* HAVE_MMAP */ 1313 #endif /* HAVE_MMAP */
1328 1314
1329 pdump_mallocadr = xmalloc (pdump_length+255); 1315 pdump_start = xnew_array (char, pdump_length);
1330 pdump_free = pdump_file_free; 1316 pdump_free = pdump_file_free;
1331 pdump_start = (char *)((255 + (unsigned long)pdump_mallocadr) & ~255);
1332 read (fd, pdump_start, pdump_length); 1317 read (fd, pdump_start, pdump_length);
1333 1318
1334 close (fd); 1319 close (fd);
1335 return 1; 1320 return 1;
1336 } 1321 }
1338 1323
1339 1324
1340 static int 1325 static int
1341 pdump_file_try (char *exe_path) 1326 pdump_file_try (char *exe_path)
1342 { 1327 {
1343 char *w; 1328 char *w = exe_path + strlen (exe_path);
1344 1329
1345 w = exe_path + strlen (exe_path);
1346 do 1330 do
1347 { 1331 {
1348 sprintf (w, "-%s-%08x.dmp", EMACS_VERSION, dump_id); 1332 sprintf (w, "-%s-%08x.dmp", EMACS_VERSION, dump_id);
1349 if (pdump_file_get (exe_path)) 1333 if (pdump_file_get (exe_path))
1350 { 1334 {