1 /*---------------------------------------------------------------------------*
2 Project: TwlSDK - tools - makelcf
3 File: container.c
4
5 Copyright 2003-2008 Nintendo. All rights reserved.
6
7 These coded instructions, statements, and computer programs contain
8 proprietary information of Nintendo of America Inc. and/or Nintendo
9 Company Ltd., and are protected by Federal copyright law. They may
10 not be disclosed to third parties or copied or duplicated in any form,
11 in whole or in part, without the prior written consent of Nintendo.
12
13 $Date:: 2009-11-11#$
14 $Rev: 11140 $
15 $Author: kitase_hirotake $
16 *---------------------------------------------------------------------------*/
17 #include <stdio.h>
18 #include <stdlib.h> // exit()
19 #include <string.h> // strcpy(), strcat()
20 #include <malloc.h>
21 #include "misc.h"
22 #include "makelcf.h"
23
24
25 /*============================================================================
26 * MISC
27 */
28 tStatic Static = { 0 };
29 tProperty Property = { 0 };
30
31 tOverlayList OverlayList = { 0, 0, 0 };
32 tOverlayList AutoloadList = { 0, 0, 0 };
33 tOverlayList LtdoverlayList = { 0, 0, 0 };
34 tOverlayList LtdautoloadList = { 0, 0, 0 };
35
36 static tOverlayList *CurrentOverlay = &OverlayList;
37
isSame(const char * s1,const char * s2)38 BOOL isSame(const char *s1, const char *s2)
39 {
40 if (s1 == s2)
41 {
42 return TRUE;
43 }
44
45 if (!s1 || !s2)
46 {
47 return FALSE;
48 }
49
50 while (*s1 == *s2)
51 {
52 if (!*s1)
53 {
54 return TRUE;
55 }
56 s1++;
57 s2++;
58 }
59 return FALSE;
60 }
61
62
63 /*============================================================================
64 * OVERLAY
65 */
66
GetNextOverlayID(void)67 static u32 GetNextOverlayID(void)
68 {
69 return (u32)(OverlayList.num + LtdoverlayList.num);
70 }
71
NewOverlay(tOverlayList * list)72 static tOverlay *NewOverlay(tOverlayList * list)
73 {
74 tOverlay *t = Alloc(sizeof(tOverlay));
75
76 if (list->tail)
77 list->tail->next = t;
78 else
79 list->head = t;
80 list->tail = t;
81
82 return t;
83 }
84
GetOverlay(tOverlayList * list,const char * overlayName)85 static tOverlay *GetOverlay(tOverlayList * list, const char *overlayName)
86 {
87 tOverlay *t = list->head;
88
89 while (t)
90 {
91 if (isSame(t->name, overlayName))
92 {
93 return t;
94 }
95 t = t->next;
96 }
97 return NULL;
98 }
99
100
s_AddOverlay(tOverlayList * list,const char * overlayName)101 static BOOL s_AddOverlay(tOverlayList * list, const char *overlayName)
102 {
103 if (isSame(Static.name, overlayName) || GetOverlay(&OverlayList, overlayName)
104 || GetOverlay(&AutoloadList, overlayName)
105 || GetOverlay(&LtdoverlayList, overlayName)
106 || GetOverlay(&LtdautoloadList, overlayName))
107 {
108 spec_yyerror("Same named MAIN/OVERLAY already existed. Aborted.");
109 return FALSE;
110 }
111 else
112 {
113 tOverlay *t = NewOverlay(list);
114 // t->id = list->num++;
115 t->id = GetNextOverlayID();
116 list->num++;
117 t->name = overlayName;
118 t->compressSpec = 'S';
119 CurrentOverlay = list;
120 }
121 return TRUE;
122 }
123
AddOverlay(const char * overlayName)124 BOOL AddOverlay(const char *overlayName)
125 {
126 return s_AddOverlay(&OverlayList, overlayName);
127 }
128
AddLtdoverlay(const char * overlayName)129 BOOL AddLtdoverlay(const char *overlayName)
130 {
131 return s_AddOverlay(&LtdoverlayList, overlayName);
132 }
133
AddAutoload(const char * overlayName)134 BOOL AddAutoload(const char *overlayName)
135 {
136 return s_AddOverlay(&AutoloadList, overlayName);
137 }
138
AddLtdautoload(const char * overlayName)139 BOOL AddLtdautoload(const char *overlayName)
140 {
141 return s_AddOverlay(&LtdautoloadList, overlayName);
142 }
143
144 /*============================================================================
145 * OVERLAY - id
146 */
147
OverlaySetId(u32 id)148 BOOL OverlaySetId(u32 id)
149 {
150 tOverlay *t = CurrentOverlay->tail;
151
152 if (t->id)
153 {
154 spec_yyerror("OVERLAY ID already set. Ignored.");
155 }
156 else
157 {
158 t->id = id;
159 }
160 return TRUE;
161 }
162
163
164 /*============================================================================
165 * OVERLAY - group
166 */
167
OverlaySetGroup(const char * group)168 BOOL OverlaySetGroup(const char *group)
169 {
170 tOverlay *t = CurrentOverlay->tail;
171
172 if (t->group)
173 {
174 spec_yyerror("overlay GROUP already set. Ignored.");
175 }
176 else
177 {
178 t->group = group;
179 }
180 return TRUE;
181 }
182
183
184 /*============================================================================
185 * OVERLAY - address
186 */
187
OverlaySetAddress(u32 address)188 BOOL OverlaySetAddress(u32 address)
189 {
190 tOverlay *t = CurrentOverlay->tail;
191
192 if (t->afters.tail || t->address)
193 {
194 spec_yyerror("ADDRESS/AFTER already set. Ignored.");
195 }
196 else
197 {
198 t->address = address;
199 }
200 return TRUE;
201 }
202
203
204 /*============================================================================
205 * OVERLAY - after
206 */
207
NewAfter(tAfterList * list)208 static tAfter *NewAfter(tAfterList * list)
209 {
210 tAfter *t = Alloc(sizeof(tAfter));
211
212 if (list->tail)
213 list->tail->next = t;
214 else
215 list->head = t;
216 list->tail = t;
217
218 return t;
219 }
220
221
GetAfter(tAfterList * list,const char * name)222 static tAfter *GetAfter(tAfterList * list, const char *name)
223 {
224 tAfter *t = list->head;
225
226 while (t)
227 {
228 if (isSame(t->name, name))
229 {
230 return t;
231 }
232 t = t->next;
233 }
234 return NULL;
235 }
236
237
AddAfter(tAfterList * list,const char * name)238 BOOL AddAfter(tAfterList * list, const char *name)
239 {
240 if (GetAfter(list, name))
241 {
242 spec_yyerror("Same AFTER already existed. Ignored.");
243 }
244 else
245 {
246 tAfter *t = NewAfter(list);
247 t->name = name;
248 }
249 return TRUE;
250 }
251
252
OverlayAddAfter(const char * overlayName)253 BOOL OverlayAddAfter(const char *overlayName)
254 {
255 if (CurrentOverlay->tail->address)
256 {
257 spec_yyerror("ADDRESS already set. Ignored.");
258 return TRUE;
259 }
260 return AddAfter(&CurrentOverlay->tail->afters, overlayName);
261 }
262
263
264 /*============================================================================
265 * Object/Library - common
266 */
267
NewObject(tObjectList * list)268 tObject *NewObject(tObjectList * list)
269 {
270 tObject *t = Alloc(sizeof(tObject));
271
272 if (list->tail)
273 list->tail->next = t;
274 else
275 list->head = t;
276 list->tail = t;
277
278 return t;
279 }
280
281
GetObject(tObjectList * list,const char * objectName,const char * sectionName)282 tObject *GetObject(tObjectList * list, const char *objectName, const char *sectionName)
283 {
284 tObject *t = list->head;
285
286 while (t)
287 {
288 if (isSame(t->objectName, objectName) && isSame(t->sectionName, sectionName))
289 {
290 return t;
291 }
292 t = t->next;
293 }
294 return NULL;
295 }
296
297
AddObject(tObjectList * list,const char * objectName,tObjectType objectType)298 BOOL AddObject(tObjectList * list, const char *objectName, tObjectType objectType)
299 {
300 tObject *t = NewObject(list);
301 t->objectName = objectName;
302 t->sectionName = NULL;
303 t->objectType = objectType;
304 return TRUE;
305 }
306
307
SetObjectSection(tObjectList * list,const char * sectionName)308 BOOL SetObjectSection(tObjectList * list, const char *sectionName)
309 {
310 tObject *t = list->head;
311
312 debug_printf("sectionName=[%s]\n", sectionName);
313
314 while (t)
315 {
316 if (!t->sectionName)
317 {
318 debug_printf("list=%08x\n", list);
319
320 if (!isNeedSection(t) && sectionName[0] == '*')
321 {
322 spec_yyerror("OBJECT() must be with section option like as (.text),(.data),..");
323 return FALSE;
324 }
325
326 debug_printf("t->objectName=[%s]\n", t->objectName);
327
328 if (GetObject(list, t->objectName, sectionName))
329 {
330 char *s = Alloc(strlen(t->objectName) + strlen(sectionName) + 80);
331 sprintf(s, "OBJECT '%s (%s)' already existed. Ignored.", t->objectName,
332 sectionName);
333 spec_yyerror(s);
334 Free(&s);
335 }
336
337 t->sectionName = strdup(sectionName);
338 }
339 t = t->next;
340 }
341 return TRUE;
342 }
343
344
345 /*============================================================================
346 * OVERLAY - object
347 */
348
OverlayAddObject(const char * objectName,tObjectType objectType)349 BOOL OverlayAddObject(const char *objectName, tObjectType objectType)
350 {
351 return AddObject(&CurrentOverlay->tail->objects, objectName, objectType);
352 }
353
354
OverlaySetObjectSection(const char * sectionName)355 BOOL OverlaySetObjectSection(const char *sectionName)
356 {
357 return SetObjectSection(&CurrentOverlay->tail->objects, sectionName);
358 }
359
360
361 /*============================================================================
362 * OVERLAY - library
363 */
364
OverlayAddLibrary(const char * objectName,tObjectType objectType)365 BOOL OverlayAddLibrary(const char *objectName, tObjectType objectType)
366 {
367 return AddObject(&CurrentOverlay->tail->libraries, objectName, objectType);
368 }
369
370
OverlaySetLibrarySection(const char * sectionName)371 BOOL OverlaySetLibrarySection(const char *sectionName)
372 {
373 return SetObjectSection(&CurrentOverlay->tail->libraries, sectionName);
374 }
375
376
377 /*============================================================================
378 * OVERLAY - searchsymbol
379 */
380
OverlayAddSearchSymbol(const char * searchName)381 BOOL OverlayAddSearchSymbol(const char *searchName)
382 {
383 return AddObject(&CurrentOverlay->tail->searchSymbols, searchName, OBJTYPE_NONE);
384 }
385
386
387 /*============================================================================
388 * OVERLAY - force
389 */
390
OverlayAddForce(const char * forceName)391 BOOL OverlayAddForce(const char *forceName)
392 {
393 return AddObject(&CurrentOverlay->tail->forces, forceName, OBJTYPE_NONE);
394 }
395
396
397 /*============================================================================
398 * OVERLAY - compress
399 */
400
OverlaySetCompress(const char * compressSpec)401 BOOL OverlaySetCompress(const char *compressSpec)
402 {
403 char c;
404
405 if(!strcmp(compressSpec, "SMART")) c = 'S';
406 else if(!strcmp(compressSpec, "EXCLUSION")) c = 'E';
407 else return FALSE;
408
409 CurrentOverlay->tail->compressSpec = c;
410 return TRUE;
411 }
412
413
414 /*============================================================================
415 * STATIC - name
416 */
417
StaticSetName(const char * staticName)418 BOOL StaticSetName(const char *staticName)
419 {
420 tStatic *t = &Static;
421
422 if (t->name)
423 {
424 spec_yyerror("'Static' section already existed. Aborted.");
425 return FALSE;
426 }
427 else if (GetOverlay(&OverlayList, staticName) || GetOverlay(&AutoloadList, staticName)
428 || GetOverlay(&LtdoverlayList, staticName) || GetOverlay(&LtdautoloadList, staticName))
429 {
430 spec_yyerror("Same named 'Overlay' or 'Autoload' or 'Ltdoverlay' or 'Ltdautoload' already existed. Aborted.");
431 return FALSE;
432 }
433 else
434 {
435 t->name = staticName;
436 }
437 return TRUE;
438 }
439
440
441 /*============================================================================
442 * STATIC - address
443 */
444
StaticSetAddress(u32 address)445 BOOL StaticSetAddress(u32 address)
446 {
447 tStatic *t = &Static;
448
449 if (t->address)
450 {
451 spec_yyerror("'Address' already set. Ignored.");
452 }
453 else
454 {
455 t->address = address;
456 }
457 return TRUE;
458 }
459
460
461 /*============================================================================
462 * STATIC - object
463 */
464
StaticAddObject(const char * objectName,tObjectType objectType)465 BOOL StaticAddObject(const char *objectName, tObjectType objectType)
466 {
467 return AddObject(&Static.objects, objectName, objectType);
468 }
469
470
StaticSetObjectSection(const char * sectionName)471 BOOL StaticSetObjectSection(const char *sectionName)
472 {
473 return SetObjectSection(&Static.objects, sectionName);
474 }
475
476
477 /*============================================================================
478 * STATIC - library
479 */
480
StaticAddLibrary(const char * objectName,tObjectType objectType)481 BOOL StaticAddLibrary(const char *objectName, tObjectType objectType)
482 {
483 return AddObject(&Static.libraries, objectName, objectType);
484 }
485
486
StaticSetLibrarySection(const char * sectionName)487 BOOL StaticSetLibrarySection(const char *sectionName)
488 {
489 return SetObjectSection(&Static.libraries, sectionName);
490 }
491
492
493 /*============================================================================
494 * STATIC - searchsymbol
495 */
496
StaticAddSearchSymbol(const char * searchName)497 BOOL StaticAddSearchSymbol(const char *searchName)
498 {
499 return AddObject(&Static.searchSymbols, searchName, OBJTYPE_NONE);
500 }
501
502
503 /*============================================================================
504 * STATIC - force
505 */
506
StaticAddForce(const char * forceName)507 BOOL StaticAddForce(const char *forceName)
508 {
509 return AddObject(&Static.forces, forceName, OBJTYPE_NONE);
510 }
511
512
513 /*============================================================================
514 * STATIC - address
515 */
516
StaticSetStackSize(u32 stacksize)517 BOOL StaticSetStackSize(u32 stacksize)
518 {
519 tStatic *t = &Static;
520
521 if (t->stacksize)
522 {
523 spec_yyerror("'StackSize' already set. Ignored.");
524 }
525 else
526 {
527 t->stacksize = stacksize;
528 }
529 return TRUE;
530 }
531
532
StaticSetStackSizeIrq(u32 stacksize_irq)533 BOOL StaticSetStackSizeIrq(u32 stacksize_irq)
534 {
535 tStatic *t = &Static;
536
537 if (t->stacksize_irq)
538 {
539 spec_yyerror("'IrqStackSize' already set. Ignored.");
540 }
541 else
542 {
543 t->stacksize_irq = stacksize_irq;
544 }
545 return TRUE;
546 }
547
548
549 /*============================================================================
550 * PROPERTY - OverlayTable
551 * PROPERTY - OverlayTable
552 * PROPERTY - Suffix
553 */
554
555 #define SET_PROPERTY( func, member, token ) \
556 BOOL func( const char* val ) \
557 { \
558 tProperty* t = &Property; \
559 \
560 if ( t->member ) \
561 { \
562 spec_yyerror( "'" #token "' already set. Ignored." );\
563 } \
564 else \
565 { \
566 t->member = val; \
567 } \
568 return TRUE; \
569 }
570
SET_PROPERTY(PropertySetOverlayDefs,overlaydefs,OverlayDefs)571 SET_PROPERTY(PropertySetOverlayDefs, overlaydefs, OverlayDefs)
572 SET_PROPERTY(PropertySetOverlayTable, overlaytable, OverlayTable)
573 SET_PROPERTY(PropertySetLtdoverlayDefs, ltdoverlaydefs, LtdoverlayDefs)
574 SET_PROPERTY(PropertySetLtdoverlayTable, ltdoverlaytable, LtdoverlayTable)
575 SET_PROPERTY(PropertySetSuffix, suffix, Suffix)
576 SET_PROPERTY(PropertySetFlxsuffix, flxsuffix, Flxsuffix)
577 SET_PROPERTY(PropertySetLtdsuffix, ltdsuffix, Ltdsuffix)
578 /*============================================================================
579 * CHECK SPECS
580 */
581 static BOOL CheckAfters(const char *name, tAfterList * list)
582 {
583 tAfter *t = list->head;
584
585 while (t)
586 {
587 if (!isSame(t->name, Static.name) && !GetOverlay(&OverlayList, t->name)
588 && !GetOverlay(&AutoloadList, t->name)
589 && !GetOverlay(&LtdoverlayList, t->name)
590 && !GetOverlay(&LtdautoloadList, t->name))
591 {
592 fprintf(stderr, "No such static/autoload/overlay/ltdautoload/ltdoverlay %s referred in overlay %s", t->name,
593 name);
594 return FALSE;
595 }
596 t = t->next;
597 }
598 return TRUE;
599 }
600
601
s_CheckOverlay(tOverlayList * list)602 static BOOL s_CheckOverlay(tOverlayList * list)
603 {
604 tOverlay *t = list->head;
605
606 while (t)
607 {
608 if (t->address)
609 {
610 if (t->afters.tail)
611 {
612 fprintf(stderr, "Set both of 'Address' and 'After' in overlay %s", t->name);
613 return FALSE;
614 }
615 }
616 else
617 {
618 if (t->afters.tail)
619 {
620 if (!CheckAfters(t->name, &t->afters))
621 {
622 return FALSE;
623 }
624 }
625 else
626 {
627 fprintf(stderr, "No addressing commands 'Address'/ 'After' in overlay %s", t->name);
628 return FALSE;
629 }
630 }
631 t = t->next;
632 }
633 return TRUE;
634 }
635
CheckOverlay(void)636 static BOOL CheckOverlay(void)
637 {
638 return s_CheckOverlay(&AutoloadList) && s_CheckOverlay(&OverlayList) && s_CheckOverlay(&LtdautoloadList) && s_CheckOverlay(&LtdoverlayList);
639 }
640
CheckStatic(void)641 static BOOL CheckStatic(void)
642 {
643 tStatic *t = &Static;
644
645 if (!t->address)
646 {
647 fprintf(stderr, "No addressing commands 'After' in static %s", t->name);
648 return FALSE;
649 }
650
651 if (!t->stacksize_irq)
652 {
653 t->stacksize_irq = DEFAULT_IRQSTACKSIZE;
654 }
655
656 return TRUE;
657 }
658
659
CheckProperty(void)660 static BOOL CheckProperty(void)
661 {
662 tProperty *t = &Property;
663
664 // Set default values
665 if (!t->overlaydefs)
666 {
667 t->overlaydefs = strdup(DEFAULT_OVERLAYDEFS);
668 }
669 if (t->overlaydefs[0] == '%')
670 {
671 char *name = Alloc(strlen(Static.name) + strlen(t->overlaydefs + 1) + 1);
672 strcpy(name, Static.name);
673 strcat(name, t->overlaydefs + 1);
674 Free(&t->overlaydefs);
675 t->overlaydefs = name;
676 }
677
678 if (!t->overlaytable)
679 {
680 t->overlaytable = strdup(DEFAULT_OVERLAYTABLE);
681 }
682 if (t->overlaytable[0] == '%')
683 {
684 char *name = Alloc(strlen(Static.name) + strlen(t->overlaytable + 1) + 1);
685 strcpy(name, Static.name);
686 strcat(name, t->overlaytable + 1);
687 Free(&t->overlaytable);
688 t->overlaytable = name;
689 }
690
691 if (!t->ltdoverlaydefs)
692 {
693 t->ltdoverlaydefs = strdup(DEFAULT_LTDOVERLAYDEFS);
694 }
695 if (t->ltdoverlaydefs[0] == '%')
696 {
697 char *name = Alloc(strlen(Static.name) + strlen(t->ltdoverlaydefs + 1) + 1);
698 strcpy(name, Static.name);
699 strcat(name, t->ltdoverlaydefs + 1);
700 Free(&t->ltdoverlaydefs);
701 t->ltdoverlaydefs = name;
702 }
703
704 if (!t->ltdoverlaytable)
705 {
706 t->ltdoverlaytable = strdup(DEFAULT_LTDOVERLAYTABLE);
707 }
708 if (t->ltdoverlaytable[0] == '%')
709 {
710 char *name = Alloc(strlen(Static.name) + strlen(t->ltdoverlaytable + 1) + 1);
711 strcpy(name, Static.name);
712 strcat(name, t->ltdoverlaytable + 1);
713 Free(&t->ltdoverlaytable);
714 t->ltdoverlaytable = name;
715 }
716
717 if (!t->suffix)
718 {
719 t->suffix = strdup(DEFAULT_SUFFIX);
720 }
721
722 if (!t->flxsuffix)
723 {
724 t->flxsuffix = strdup(DEFAULT_FLXSUFFIX);
725 }
726
727 if (!t->ltdsuffix)
728 {
729 t->ltdsuffix = strdup(DEFAULT_LTDSUFFIX);
730 }
731 return TRUE;
732 }
733
734
CheckSpec(void)735 BOOL CheckSpec(void)
736 {
737 return (CheckStatic() && CheckOverlay() && CheckProperty());
738 }
739
740
741 /*============================================================================
742 * DUMP UTILITIES
743 */
744
DumpAfters(tAfterList * list)745 static void DumpAfters(tAfterList * list)
746 {
747 tAfter *t = list->head;
748
749 while (t)
750 {
751 printf(" After : %s\n", t->name);
752 t = t->next;
753 }
754 }
755
756
DumpObjects(tObjectList * list)757 static void DumpObjects(tObjectList * list)
758 {
759 tObject *t = list->head;
760
761 while (t)
762 {
763 printf(" Object : %s %s\n", t->objectName, t->sectionName);
764 t = t->next;
765 }
766 }
767
768
DumpAutoload(void)769 static void DumpAutoload(void)
770 {
771 tOverlay *t = AutoloadList.head;
772
773 while (t)
774 {
775 printf("Autoload : %s\n", t->name);
776 printf(" Address : %08lx\n", t->address);
777 DumpAfters(&t->afters);
778 DumpObjects(&t->objects);
779 printf("\n");
780 t = t->next;
781 }
782 }
783
784
DumpOverlay(void)785 static void DumpOverlay(void)
786 {
787 tOverlay *t = OverlayList.head;
788
789 while (t)
790 {
791 printf("Overlay : %s\n", t->name);
792 printf(" Address : %08lx\n", t->address);
793 DumpAfters(&t->afters);
794 DumpObjects(&t->objects);
795 printf("\n");
796 t = t->next;
797 }
798 }
799
800
DumpLtdautoload(void)801 static void DumpLtdautoload(void)
802 {
803 tOverlay *t = LtdautoloadList.head;
804
805 while (t)
806 {
807 printf("Ltdautoload : %s\n", t->name);
808 printf(" Address : %08lx\n", t->address);
809 DumpAfters(&t->afters);
810 DumpObjects(&t->objects);
811 printf("\n");
812 t = t->next;
813 }
814 }
815
816
DumpLtdoverlay(void)817 static void DumpLtdoverlay(void)
818 {
819 tOverlay *t = LtdoverlayList.head;
820
821 while (t)
822 {
823 printf("Ltdoverlay : %s\n", t->name);
824 printf(" Address : %08lx\n", t->address);
825 DumpAfters(&t->afters);
826 DumpObjects(&t->objects);
827 printf("\n");
828 t = t->next;
829 }
830 }
831
832
DumpStatic(void)833 static void DumpStatic(void)
834 {
835 tStatic *t = &Static;
836
837 printf("Static : %s\n", t->name);
838 printf(" Address : %08lx\n", t->address);
839 DumpObjects(&t->objects);
840 printf(" StackSize : %08lx\n", t->stacksize);
841 printf("\n");
842 }
843
844
DumpProperty(void)845 static void DumpProperty(void)
846 {
847 tProperty *t = &Property;
848
849 printf("Property :\n");
850 printf(" OverlayDefs : %s\n", t->overlaydefs);
851 printf(" OverlayTable : %s\n", t->overlaytable);
852 printf(" LtdoverlayDefs : %s\n", t->ltdoverlaydefs);
853 printf(" LtdoverlayTable : %s\n", t->ltdoverlaytable);
854 printf(" Suffix : %s\n", t->suffix);
855 printf(" Flxsuffix : %s\n", t->flxsuffix);
856 printf(" Ltdsuffix : %s\n", t->ltdsuffix);
857 printf("\n");
858 }
859
860
DumpSpec(void)861 void DumpSpec(void)
862 {
863 DumpStatic();
864 DumpAutoload();
865 DumpOverlay();
866 DumpLtdautoload();
867 DumpLtdoverlay();
868 DumpProperty();
869 }
870