1 /*
2 * Copyright (c) 1982 Regents of the University of California.
3 * All rights reserved. The Berkeley software License Agreement
4 * specifies the terms and conditions for redistribution.
5 */
6
7 #ifndef lint
8 static char sccsid[] = "@(#)assyms.c 5.2 (Berkeley) 10/22/87";
9 #endif not lint
10
11 #include <stdio.h>
12 #include <ctype.h>
13 #include "as.h"
14 #include "asscan.h"
15 #include "assyms.h"
16
17 /*
18 * Managers for chunks of symbols allocated from calloc()
19 * We maintain a linked list of such chunks.
20 *
21 */
22 struct allocbox *allochead; /*head of chunk list*/
23 struct allocbox *alloctail; /*tail*/
24 struct allocbox *newbox; /*for creating a new chunk*/
25 struct symtab *nextsym; /*next symbol free*/
26 int symsleft; /*slots left in current chunk*/
27
28 struct symtab **symptrs;
29 struct symtab **symdelim[NLOC + NLOC +1];
30 struct symtab **symptrub;
31 /*
32 * Managers for the dynamically extendable hash table
33 */
34 struct hashdallop *htab;
35
36 Iptr *itab[NINST]; /*maps opcodes to instructions*/
37 /*
38 * Counts what went into the symbol table, so that the
39 * size of the symbol table can be computed.
40 */
41 int nsyms; /* total number in the symbol table */
42 int njxxx; /* number of jxxx entrys */
43 int nforgotten; /* number of symbols erroneously entered */
44 int nlabels; /* number of label entries */
45
46 /*
47 * Managers of the symbol literal storage.
48 */
49 struct strpool *strplhead = 0;
50
symtabinit()51 symtabinit()
52 {
53 allochead = 0;
54 alloctail = 0;
55 nextsym = 0;
56 symsleft = 0;
57 strpoolalloc(); /* get the first strpool storage area */
58 htab = 0;
59 htaballoc(); /* get the first part of the hash table */
60 }
61
62 /*
63 * Install all known instructions in the symbol table
64 */
syminstall()65 syminstall()
66 {
67 register Iptr ip;
68 register struct symtab **hp;
69 register char *p1, *p2;
70 register int i;
71
72 for (i = 0; i < NINST; i++)
73 itab[i] = (Iptr*)BADPOINT;
74
75 for (ip = (Iptr)instab; FETCHNAME(ip)[0]; ip++) {
76 p1 = FETCHNAME(ip);
77 p2 = yytext;
78 while (*p2++ = *p1++);
79 hp = lookup(0); /* 0 => don't install this*/
80 if (*hp==NULL) {
81 *hp = (struct symtab *)ip;
82 if ( (ip->s_tag!=INSTn)
83 && (ip->s_tag!=INST0)
84 && (ip->s_tag!=0))
85 continue; /* was pseudo-op */
86 if (itab[ip->i_eopcode] == (Iptr*)BADPOINT){
87 itab[ip->i_eopcode] =
88 (Iptr*)ClearCalloc(256, sizeof(Iptr));
89 for (i = 0; i < 256; i++)
90 itab[ip->i_eopcode][i] =
91 (Iptr)BADPOINT;
92 }
93 itab[ip->i_eopcode][ip->i_popcode] = ip;
94 }
95 }
96 } /*end of syminstall*/
97
98 #define ISLABEL(sp) \
99 ( (!savelabels) \
100 && (sp->s_tag == LABELID) \
101 && (STRPLACE(sp) & STR_CORE) \
102 && (FETCHNAME(sp)[0] == 'L'))
103 /*
104 * Assign final values to symbols,
105 * and overwrite the index field with its relative position in
106 * the symbol table we give to the loader.
107 */
108 extern struct exec hdr;
109
freezesymtab()110 freezesymtab()
111 {
112 register struct symtab *sp;
113 long bs;
114 register int relpos = 0;
115 register struct symtab *ubsp;
116 register struct allocbox *allocwalk;
117
118 DECLITERATE(allocwalk, sp, ubsp)
119 {
120 if (sp->s_tag >= IGNOREBOUND)
121 continue; /*totally ignore jxxx entries */
122 /*
123 * Ignore stabs, but give them a symbol table index
124 */
125 if (sp->s_type & STABFLAG)
126 goto assignindex;
127 if ((sp->s_type&XTYPE)==XUNDEF)
128 sp->s_type = XXTRN+XUNDEF;
129 else if ((sp->s_type&XTYPE)==XDATA)
130 sp->s_value += usedot[sp->s_index].e_xvalue;
131 else if ((sp->s_type&XTYPE)==XTEXT)
132 sp->s_value += usedot[sp->s_index].e_xvalue;
133 else if ((sp->s_type&XTYPE)==XBSS) {
134 bs = sp->s_value;
135 sp->s_value = hdr.a_bss + datbase;
136 hdr.a_bss += bs;
137 }
138 assignindex:
139 if (!ISLABEL(sp))
140 sp->s_index = relpos++;
141 }
142 }
143
144 /*
145 * For all of the stabs that had their final value undefined during pass 1
146 * and during pass 2 assign a final value.
147 * We have already given stab entrys a initial approximation
148 * when we constsructed the sorted symbol table.
149 * Iteration order doesn't matter.
150 */
151
stabfix()152 stabfix()
153 {
154 register struct symtab *sp, **cosp;
155 register struct symtab *p;
156
157 SYMITERATE(cosp, sp){
158 if(sp->s_ptype && (sp->s_type & STABFLAG)) {
159 p = sp->s_dest;
160 /*
161 * STABFLOATING indicates that the offset has been saved in s_desc, s_other
162 */
163 if(sp->s_tag == STABFLOATING) {
164 sp->s_value = ( ( ((unsigned char) sp->s_other) << 16) | ( (unsigned short) sp->s_desc ) );
165 sp->s_value = sp->s_value + p->s_value;
166 }
167 else sp->s_value = p->s_value;
168 sp->s_index = p->s_index;
169 sp->s_type = p->s_type;
170
171
172 }
173 }
174 }
175
Calloc(number,size)176 char *Calloc(number, size)
177 int number, size;
178 {
179 register char *newstuff;
180 char *sbrk();
181 newstuff = sbrk(number*size);
182 if ((int)newstuff == -1){
183 yyerror("Ran out of Memory");
184 delexit();
185 }
186 return(newstuff);
187 }
188
ClearCalloc(number,size)189 char *ClearCalloc(number, size)
190 int number, size;
191 {
192 register char *newstuff; /* r11 */
193 register int length = number * size; /* r10 */
194 #ifdef lint
195 length = length;
196 #endif length
197 newstuff = Calloc(number, size);
198 asm("movc5 $0, (r0), $0, r10, (r11)");
199 return(newstuff);
200 }
201
symalloc()202 struct symtab *symalloc()
203 {
204 if (symsleft == 0){
205 newbox = (struct allocbox *)ClearCalloc(1,ALLOCQTY);
206 symsleft = SYMDALLOP;
207 nextsym = &newbox->symslots[0];
208 if (alloctail == 0){
209 allochead = alloctail = newbox;
210 } else {
211 alloctail->nextalloc = newbox;
212 alloctail = newbox;
213 }
214 }
215 --symsleft;
216 ++nsyms;
217 return(nextsym++);
218 }
219
strpoolalloc()220 strpoolalloc()
221 {
222 register struct strpool *new;
223
224 new = (struct strpool *)Calloc(1, sizeof (struct strpool));
225 new->str_nalloc = 0;
226 new->str_next = strplhead;
227 strplhead = new;
228 }
229
230 symcmp(Pptr, Qptr)
231 struct symtab **Pptr, **Qptr;
232 {
233 register struct symtab *p = *Pptr;
234 register struct symtab *q = *Qptr;
235 if (p->s_index < q->s_index)
236 return(-1);
237 if (p->s_index > q->s_index)
238 return(1);
239 if (p->s_value < q->s_value)
240 return(-1);
241 if (p->s_value > q->s_value)
242 return(1);
243 /*
244 * Force jxxx entries to virtually preceed labels defined
245 * to follow the jxxxx instruction, so that bumping the
246 * jxxx instruction correctly fixes up the following labels
247 */
248 if (p->s_tag >= IGNOREBOUND) /*p points to a jxxx*/
249 return(-1);
250 if (q->s_tag >= IGNOREBOUND)
251 return(1);
252 /*
253 * both are now just plain labels; the relative order doesn't
254 * matter. Both can't be jxxxes, as they would have different
255 * values.
256 */
257 return(0);
258 } /*end of symcmp*/
259
260 /*
261 * We construct the auxiliary table of pointers, symptrs and
262 * symdelim
263 * We also assign preliminary values to stab entries that did not yet
264 * have an absolute value (because they initially referred to
265 * forward references). We don't worry about .stabds, as they
266 * already have an estimated final value
267 */
268
sortsymtab()269 sortsymtab()
270 {
271 register struct symtab *sp;
272 register struct symtab **cowalk;
273 register struct allocbox *allocwalk;
274 struct symtab *ubsp;
275 int segno;
276 int slotno;
277 int symsin; /*number put into symptrs*/
278
279 symptrs = (struct symtab **)Calloc(nsyms + 2, sizeof *symptrs);
280 /*
281 * Allocate one word at the beginning of the symptr array
282 * so that backwards scans through the symptr array will
283 * work correctly while scanning through the zeroth segment
284 */
285 *symptrs++ = 0;
286 cowalk = symptrs;
287 symsin = 0;
288 DECLITERATE(allocwalk, sp, ubsp) {
289 if (sp->s_ptype && (sp->s_type &STABFLAG)){
290 sp->s_value = sp->s_dest->s_value;
291 sp->s_index = sp->s_dest->s_index;
292 }
293 if (symsin >= nsyms)
294 yyerror("INTERNAL ERROR: overfilled symbol table indirection table");
295 *cowalk++ = sp;
296 symsin++;
297 }
298 if (symsin != nsyms)
299 yyerror("INTERNAL ERROR: installed %d syms, should have installed %d",
300 symsin, nsyms);
301 symptrub = &symptrs[nsyms ];
302 qsort(symptrs, nsyms, sizeof *symptrs, symcmp);
303 symdelim[0] = symptrs;
304 for (cowalk = symptrs, sp = *cowalk, segno = 0, slotno = 1;
305 segno < NLOC + NLOC;
306 segno++, slotno++){
307 for (; sp && sp->s_index == segno; sp = *++cowalk);
308 symdelim[slotno] = cowalk; /*forms the ub delimeter*/
309 }
310 } /*end of sortsymtab*/
311
312 #ifdef DEBUG
dumpsymtab()313 dumpsymtab()
314 {
315 register int segno;
316 register struct symtab *sp, **cosp, *ub;
317 char *tagstring();
318
319 printf("Symbol Table dump:\n");
320 for (segno = 0; segno < NLOC + NLOC; segno++){
321 printf("Segment number: %d\n", segno);
322 SEGITERATE(segno, 0, 0, cosp, sp, ub, ++){
323 printf("\tSeg: %d \"%s\" value: %d index: %d tag %s\n",
324 segno, FETCHNAME(sp),
325 sp->s_value, sp->s_index,
326 tagstring(sp->s_tag));
327 printf("\t\ttype: %d jxbump %d jxfear: %d\n",
328 sp->s_type, sp->s_jxbump, sp->s_jxfear);
329 }
330 printf("\n\n");
331 }
332 }
333
334 static char tagbuff[4];
335
tagstring(tag)336 char *tagstring(tag)
337 unsigned char tag;
338 {
339 switch(tag){
340 case JXACTIVE: return("active");
341 case JXNOTYET: return("notyet");
342 case JXALIGN: return("align");
343 case JXQUESTIONABLE: return("jxquestionable");
344 case JXINACTIVE: return("inactive");
345 case JXTUNNEL: return("tunnel");
346 case OBSOLETE: return("obsolete");
347 case IGNOREBOUND: return("ignorebound");
348 case STABFLOATING: return("stabfloating");
349 case STABFIXED: return("stabfixed");
350 case LABELID: return("labelid");
351 case OKTOBUMP: return("oktobump");
352 case ISET: return("iset");
353 case ILSYM: return("ilsym");
354 default: (void)sprintf(tagbuff,"%d", tag);
355 return(tagbuff);
356 }
357 }
358 #endif DEBUG
359
htaballoc()360 htaballoc()
361 {
362 register struct hashdallop *new;
363 new = (struct hashdallop *)ClearCalloc(1, sizeof (struct hashdallop));
364 if (htab == 0)
365 htab = new;
366 else { /* add AFTER the 1st slot */
367 new->h_next = htab->h_next;
368 htab->h_next = new;
369 }
370 }
371
372 #define HASHCLOGGED (NHASH / 2)
373
374 /*
375 * Lookup a symbol stored in extern yytext.
376 * All strings passed in via extern yytext had better have
377 * a trailing null. Strings are placed in yytext for hashing by
378 * syminstall() and by yylex();
379 *
380 * We take pains to avoid function calls; this functdion
381 * is called quite frequently, and the calls overhead
382 * in the vax contributes significantly to the overall
383 * execution speed of as.
384 */
lookup(instflg)385 struct symtab **lookup(instflg)
386 int instflg; /* 0: don't install */
387 {
388 static int initialprobe;
389 register struct symtab **hp;
390 register char *from;
391 register char *to;
392 register int len;
393 register int nprobes;
394 static struct hashdallop *hdallop;
395 static struct symtab **emptyslot;
396 static struct hashdallop *emptyhd;
397 static struct symtab **hp_ub;
398
399 emptyslot = 0;
400 for (nprobes = 0, from = yytext;
401 *from;
402 nprobes <<= 2, nprobes += *from++)
403 continue;
404 nprobes += from[-1] << 5;
405 nprobes %= NHASH;
406 if (nprobes < 0)
407 nprobes += NHASH;
408
409 initialprobe = nprobes;
410 for (hdallop = htab; hdallop != 0; hdallop = hdallop->h_next){
411 for (hp = &(hdallop->h_htab[initialprobe]),
412 nprobes = 1,
413 hp_ub = &(hdallop->h_htab[NHASH]);
414 (*hp) && (nprobes < NHASH);
415 hp += nprobes,
416 hp -= (hp >= hp_ub) ? NHASH:0,
417 nprobes += 2)
418 {
419 from = yytext;
420 to = FETCHNAME(*hp);
421 while (*from && *to)
422 if (*from++ != *to++)
423 goto nextprobe;
424 if (*to == *from) /*assert both are == 0*/
425 return(hp);
426 nextprobe: ;
427 }
428 if (*hp == 0 && emptyslot == 0 &&
429 hdallop->h_nused < HASHCLOGGED) {
430 emptyslot = hp;
431 emptyhd = hdallop;
432 }
433 }
434 if (emptyslot == 0) {
435 htaballoc();
436 hdallop = htab->h_next; /* aren't we smart! */
437 hp = &hdallop->h_htab[initialprobe];
438 } else {
439 hdallop = emptyhd;
440 hp = emptyslot;
441 }
442 if (instflg) {
443 *hp = symalloc();
444 hdallop->h_nused++;
445 for (from = yytext, len = 0; *from++; len++)
446 continue;
447 (*hp)->s_name = (char *)savestr(yytext, len + 1, STR_BOTH);
448 }
449 return(hp);
450 } /*end of lookup*/
451 /*
452 * save a string str with len in the places indicated by place
453 */
savestr(str,len,place)454 struct strdesc *savestr(str, len, place)
455 char *str;
456 int len;
457 int place;
458 {
459 reg struct strdesc *res;
460 int tlen;
461 /*
462 * Compute the total length of the record to live in core
463 */
464 tlen = sizeof(struct strdesc) - sizeof(res->sd_string);
465 if (place & STR_CORE)
466 tlen += len;
467 /*
468 * See if there is enough space for the record,
469 * and allocate the record.
470 */
471 if (tlen >= (STRPOOLDALLOP - strplhead->str_nalloc))
472 strpoolalloc();
473 res = (struct strdesc *)(strplhead->str_names + strplhead->str_nalloc);
474 /*
475 * Save the string information that is always present
476 */
477 res->sd_stroff = strfilepos;
478 res->sd_strlen = len;
479 res->sd_place = place;
480 /*
481 * Now, save the string itself. If str is null, then
482 * the characters have already been dumped to the file
483 */
484 if ((place & STR_CORE) && str)
485 movestr(res[0].sd_string, str, len);
486 if (place & STR_FILE){
487 if (str){
488 fwrite(str, 1, len, strfile);
489 }
490 strfilepos += len;
491 }
492 /*
493 * Adjust the in core string pool size
494 */
495 strplhead->str_nalloc += tlen;
496 return(res);
497 }
498 /*
499 * The relocation information is saved internally in an array of
500 * lists of relocation buffers. The relocation buffers are
501 * exactly the same size as a token buffer; if we use VM for the
502 * temporary file we reclaim this storage, otherwise we create
503 * them by mallocing.
504 */
505 #define RELBUFLG TOKBUFLG
506 #define NRELOC ((TOKBUFLG - \
507 (sizeof (int) + sizeof (struct relbufdesc *)) \
508 ) / (sizeof (struct relocation_info)))
509
510 struct relbufdesc{
511 int rel_count;
512 struct relbufdesc *rel_next;
513 struct relocation_info rel_reloc[NRELOC];
514 };
515 extern struct relbufdesc *tok_free;
516 #define rel_free tok_free
517 static struct relbufdesc *rel_temp;
518 struct relocation_info r_can_1PC;
519 struct relocation_info r_can_0PC;
520
initoutrel()521 initoutrel()
522 {
523 r_can_0PC.r_address = 0;
524 r_can_0PC.r_symbolnum = 0;
525 r_can_0PC.r_pcrel = 0;
526 r_can_0PC.r_length = 0;
527 r_can_0PC.r_extern = 0;
528
529 r_can_1PC = r_can_0PC;
530 r_can_1PC.r_pcrel = 1;
531 }
532
outrel(xp,reloc_how)533 outrel(xp, reloc_how)
534 register struct exp *xp;
535 int reloc_how; /* TYPB..TYPH + (possibly)RELOC_PCREL */
536 {
537 struct relocation_info reloc;
538 register int x_type_mask;
539 int pcrel;
540
541 x_type_mask = xp->e_xtype & ~XFORW;
542 pcrel = reloc_how & RELOC_PCREL;
543 reloc_how &= ~RELOC_PCREL;
544
545 if (bitoff&07)
546 yyerror("Padding error");
547 if (x_type_mask == XUNDEF)
548 yyerror("Undefined reference");
549
550 if ( (x_type_mask != XABS) || pcrel ) {
551 if (ty_NORELOC[reloc_how])
552 yyerror("Illegal Relocation of floating or large int number.");
553 reloc = pcrel ? r_can_1PC : r_can_0PC;
554 reloc.r_address = dotp->e_xvalue -
555 ( (dotp < &usedot[NLOC] || readonlydata) ? 0 : datbase );
556 reloc.r_length = ty_nlg[reloc_how];
557 switch(x_type_mask){
558 case XXTRN | XUNDEF:
559 reloc.r_symbolnum = xp->e_xname->s_index;
560 reloc.r_extern = 1;
561 break;
562 default:
563 if (readonlydata && (x_type_mask&~XXTRN) == XDATA)
564 x_type_mask = XTEXT | (x_type_mask&XXTRN);
565 reloc.r_symbolnum = x_type_mask;
566 break;
567 }
568 if ( (relfil == 0) || (relfil->rel_count >= NRELOC) ){
569 if (rel_free){
570 rel_temp = rel_free;
571 rel_free = rel_temp->rel_next;
572 } else {
573 rel_temp = (struct relbufdesc *)
574 Calloc(1,sizeof (struct relbufdesc));
575 }
576 rel_temp->rel_count = 0;
577 rel_temp->rel_next = relfil;
578 relfil = rusefile[dotp - &usedot[0]] = rel_temp;
579 }
580 relfil->rel_reloc[relfil->rel_count++] = reloc;
581 }
582 /*
583 * write the unrelocated value to the text file
584 */
585 dotp->e_xvalue += ty_nbyte[reloc_how];
586 if (pcrel)
587 xp->e_xvalue -= dotp->e_xvalue;
588 switch(reloc_how){
589 case TYPO:
590 case TYPQ:
591
592 case TYPF:
593 case TYPD:
594 case TYPG:
595 case TYPH:
596 bignumwrite(xp->e_number, reloc_how);
597 break;
598
599 default:
600 bwrite((char *)&(xp->e_xvalue), ty_nbyte[reloc_how], txtfil);
601 break;
602 }
603 }
604 /*
605 * Flush out all of the relocation information.
606 * Note that the individual lists of buffers are in
607 * reverse order, so we must reverse them
608 */
closeoutrel(relocfile)609 off_t closeoutrel(relocfile)
610 BFILE *relocfile;
611 {
612 int locindex;
613 u_long Closeoutrel();
614
615 trsize = 0;
616 for (locindex = 0; locindex < NLOC; locindex++){
617 trsize += Closeoutrel(rusefile[locindex], relocfile);
618 }
619 drsize = 0;
620 for (locindex = 0; locindex < NLOC; locindex++){
621 drsize += Closeoutrel(rusefile[NLOC + locindex], relocfile);
622 }
623 return(trsize + drsize);
624 }
625
Closeoutrel(relfil,relocfile)626 u_long Closeoutrel(relfil, relocfile)
627 struct relbufdesc *relfil;
628 BFILE *relocfile;
629 {
630 u_long tail;
631 if (relfil == 0)
632 return(0L);
633 tail = Closeoutrel(relfil->rel_next, relocfile);
634 bwrite((char *)&relfil->rel_reloc[0],
635 relfil->rel_count * sizeof (struct relocation_info),
636 relocfile);
637 return(tail + relfil->rel_count * sizeof (struct relocation_info));
638 }
639
640 #define NOUTSYMS (nsyms - njxxx - nforgotten - (savelabels ? 0 : nlabels))
sizesymtab()641 int sizesymtab()
642 {
643 return (sizeof (struct nlist) * NOUTSYMS);
644 }
645 /*
646 * Write out n symbols to file f, beginning at p
647 * ignoring symbols that are obsolete, jxxx instructions, and
648 * possibly, labels
649 */
symwrite(symfile)650 int symwrite(symfile)
651 BFILE *symfile;
652 {
653 int symsout; /*those actually written*/
654 int symsdesired = NOUTSYMS;
655 reg struct symtab *sp, *ub;
656 char *name; /* temp to save the name */
657 int totalstr;
658 /*
659 * We use sp->s_index to hold the length of the
660 * name; it isn't used for anything else
661 */
662 register struct allocbox *allocwalk;
663
664 symsout = 0;
665 totalstr = sizeof(totalstr);
666 DECLITERATE(allocwalk, sp, ub) {
667 if (sp->s_tag >= IGNOREBOUND)
668 continue;
669 if (ISLABEL(sp))
670 continue;
671 symsout++;
672 name = sp->s_name; /* save pointer */
673 /*
674 * the length of the symbol table string
675 * always includes the trailing null;
676 * blast the pointer to its a.out value.
677 */
678 if (sp->s_name && (sp->s_index = STRLEN(sp))){
679 sp->s_nmx = totalstr;
680 totalstr += sp->s_index;
681 } else {
682 sp->s_nmx = 0;
683 }
684 if (sp->s_ptype != 0)
685 sp->s_type = sp->s_ptype;
686 else
687 sp->s_type = (sp->s_type & (~XFORW));
688 if (readonlydata && (sp->s_type&~N_EXT) == N_DATA)
689 sp->s_type = N_TEXT | (sp->s_type & N_EXT);
690 bwrite((char *)&sp->s_nm, sizeof (struct nlist), symfile);
691 sp->s_name = name; /* restore pointer */
692 }
693 if (symsout != symsdesired)
694 yyerror("INTERNAL ERROR: Wrote %d symbols, wanted to write %d symbols\n",
695 symsout, symsdesired);
696 /*
697 * Construct the string pool from the symbols that were written,
698 * possibly fetching from the string file if the string
699 * is not core resident.
700 */
701 bwrite(&totalstr, sizeof(totalstr), symfile);
702 symsout = 0;
703 DECLITERATE(allocwalk, sp, ub) {
704 if (sp->s_tag >= IGNOREBOUND)
705 continue;
706 if (ISLABEL(sp))
707 continue;
708 symsout++;
709 if (STRLEN(sp) > 0){
710 if (STRPLACE(sp) & STR_CORE){
711 bwrite(FETCHNAME(sp), STRLEN(sp), symfile);
712 } else if (STRPLACE(sp) & STR_FILE){
713 char rbuf[2048];
714 int left, nread;
715 fseek(strfile, STROFF(sp), 0);
716 for (left = STRLEN(sp); left > 0; left -= nread){
717 nread = fread(rbuf, sizeof(char),
718 min(sizeof(rbuf), left), strfile);
719 if (nread == 0)
720 break;
721 bwrite(rbuf, nread, symfile);
722 }
723 }
724 }
725 }
726 if (symsout != symsdesired)
727 yyerror("INTERNAL ERROR: Wrote %d strings, wanted %d\n",
728 symsout, symsdesired);
729 }
730