![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c_out.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / as|
Return to c_out.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / as |
1.1 root 1: /*
2: * coff format output handler.
3: */
4: #include <asm.h>
5: #include <coff.h>
6: #include <utype.h>
7: #include <symtab.h>
8:
9: #define WHERE 0x40A09C
10:
11: #define trace(n) printf("Trace %d\n", n);
12:
13: #define CMOD 2 /* clump every 2 bytes */
14: #define LIMIT 10 /* bytes of data per line */
15: #define STARTP 31 /* start source at. Must be n * 8 -1 */
16: #define DATABUF 512 /* size of data buffer */
17: #define RELBUF 128 /* entries in relocation buffer */
18: #define LINEBUF 128 /* entries in line number buffer */
19: #define MANSEG 3 /* Segments that must go out */
20: #define ROUNDR 3 /* used to round segments */
21:
22: typedef struct seg seg;
23: struct seg { /* coff section header */
24: char s_name[8]; /* section name */
25: long s_paddr; /* physical address, aliased s_nlib */
26: long s_vaddr; /* virtual address */
27: long s_size; /* section size */
28: long s_scnptr; /* file ptr to raw data for section */
29: long s_relptr; /* file ptr to relocation */
30: long s_lnnoptr; /* file ptr to line numbers */
31: unsigned short s_nreloc; /* number of relocation entries */
32: unsigned short s_nlnno; /* number of line number entries */
33: long s_flags; /* flags */
34:
35: /* Extra data connected with this to allow running this segment */
36: long data_seekad; /* next data seek address */
37: long relo_seekad; /* next relocation seek address */
38: long line_seekad; /* next line seek address */
39: long curadd; /* current address this segment */
40: long hiadd; /* hi address this pass */
41: short segSeq; /* Segment sequence no */
42:
43: char *bp; /* data buffer pointer */
44: RELOC *relBp; /* relocation buffer pointer */
45: LINENO *lineBp; /* line number buffer pointer */
46: char buf[DATABUF]; /* data buffer */
47: RELOC relBuf[RELBUF]; /* relocation entry buffer */
48: LINENO lineBuf[LINEBUF]; /* line number entry buffer */
49: };
50:
51: static long *tracker; /* for debugging */
52:
53: static seg *segs, *segend; /* segment bases */
54: static seg *cseg; /* current segment */
55:
56: static unsigned short ct, pos, sects, symbs, usects;
57: static long datapos, relpos, linepos, sympos, debpos;
58: static long strOff = 4;
59: static long lastSeek;
60: static FILE *ofp; /* output file */
61:
62: static int coffDefCt; /* count of .def in file */
63: static int coffAuxCt; /* aux records to be written */
64: static int coffEfcnCt; /* end of function records */
65: static int txtAt; /* DEBUG_RECS from last pass */
66: #define DEBUG_RECS (coffDefCt + coffAuxCt - coffEfcnCt)
67: #define USECTS (txtAt ? usects * 2 : usects)
68: static char defSw; /* in a .def statement */
69: static char auxSw;
70: static char efcnSw;
71:
72: struct xsym { /* Symbol for debugging becomes SYMENT and maybe auxent */
73: int symno;
74: int value;
75: short scnum;
76: short type;
77: char sclass;
78: char numaux;
79: AUXENT aux; /* aux record data */
80: char *name; /* name if there is one */
81: };
82:
83: static struct xsym *syms; /* all the debug stuff */
84: static struct xsym *symptr; /* currently build debug stuff */
85:
86: union word {
87: unsigned char uc[2];
88: unsigned short us;
89: };
90:
91: union full {
92: unsigned char uc[4];
93: unsigned long ul;
94: };
95:
96: /*
97: * output spaces and tabs to a position, then output a character.
98: */
99: static void
100: outTo(to, s)
101: {
102: int i;
103:
104: if(!pos)
105: sTitle();
106:
107: for (to += (' ' == s); (i = ((pos | 7) + 1)) <= to; pos = i)
108: putchar('\t');
109:
110: for (; pos < to; pos++)
111: putchar(' ');
112:
113: if (' ' != s)
114: putchar(s);
115: }
116:
117: /*
118: * Do titles.
119: */
120: sTitle()
121: {
122: static short pageno;
123:
124: if(pswitch && (++linect > nlpp)) {
125: if(pageno)
126: printf("\n\n\n\n\n");
127: printf(
128: "\n\nMark Williams 80386 Assembler\t%s\t%s\tPage %d\n\n",
129: dTime, title, ++pageno);
130: linect = 0;
131: }
132: }
133:
134: /*
135: * output source line
136: */
137: outLine(p, s)
138: char *p, s;
139: {
140: register char c;
141:
142: if ((2 != pass) ||
143: !lswitch ||
144: (!mlistsw && (NULL != macExp)) ||
145: (NULL == p))
146: return;
147:
148: outTo(STARTP, s);
149: for (; (c = *p++) && ('\n' != c); pos++) {
150: if (lineSize <= pos) {
151: putchar('\n');
152: pos = 0;
153: outTo(STARTP, '|');
154: }
155: if ('\t' == c)
156: pos |= 7;
157: putchar(c);
158: }
159: putchar('\n');
160: pos = ct = 0;
161: }
162:
163: /*
164: * Write to obj file.
165: */
166: static void
167: owrite(buf, size)
168: char *buf;
169: {
170: if (1 != fwrite(buf, size, 1, ofp))
171: fatal("Write error on object file"); /**/
172: lastSeek += size;
173: }
174:
175: /*
176: * Seek then Write to obj file.
177: */
178: xwrite(add, buf, size)
179: long add;
180: char *buf;
181: {
182: if (add != lastSeek) {
183: if (fseek(ofp, add, 0))
184: fatal("Seek error on object file"); /**/
185: lastSeek = add;
186: }
187: owrite(buf, size);
188: }
189:
190: /*
191: * Write actual data.
192: */
193: outData(s)
194: register seg *s;
195: {
196: register size;
197:
198: if (size = s->bp - s->buf) {
199: if (s->s_flags != STYP_BSS) {
200: xwrite(s->data_seekad, s->buf, size);
201: s->data_seekad += size;
202: }
203: s->bp = s->buf;
204: }
205: }
206:
207: /*
208: * Write relocation records.
209: */
210: outRel(s)
211: register seg *s;
212: {
213: register size;
214:
215: if (size = (char *)s->relBp - (char *)s->relBuf) {
216: xwrite(s->relo_seekad, (char *)s->relBuf, size);
217: s->relo_seekad += size;
218: }
219: s->relBp = s->relBuf;
220: }
221:
222: /*
223: * Write Line records.
224: */
225: outLineRec(s)
226: register seg *s;
227: {
228: register size;
229:
230: if (size = (char *)s->lineBp - (char *)s->lineBuf) {
231: xwrite(s->line_seekad, (char *)s->lineBuf, size);
232: s->line_seekad += size;
233: }
234: s->lineBp = s->lineBuf;
235: }
236:
237: /*
238: * put object data byte to buffer.
239: */
240: binout(b, s)
241: unsigned short b;
242: register seg *s;
243: {
244: if (s->bp == (s->buf + DATABUF))
245: outData(s);
246: *s->bp++ = b;
247: }
248:
249:
250: /*
251: * Limit data on line. This allows cuts at logical points.
252: */
253: static void
254: limiter(n)
255: {
256: if (lswitch && (ct + n) > LIMIT) {
257: putchar('\n');
258: ct = 0;
259: }
260: }
261:
262: /*
263: * list data
264: */
265: outlst(b)
266: unsigned short b;
267: {
268: if (dot.sg == 3) { /* BSS */
269: static int statem = -1; /* only one err per line */
270:
271: if (statement != statem) {
272: statem = statement;
273:
274: yyerror("Data defined in .bss");
275: /* The \fB.bss\fR segment is uninitialized data.
276: * You cannot place actual values there. */
277: }
278: }
279: binout(b, cseg);
280:
281: if (!lswitch)
282: return;
283:
284: if (!ct) {
285: sTitle();
286: pos = 4;
287: printf("%04lX", dot.loc + segs[dot.sg - 1].s_vaddr);
288: }
289:
290: if (!(ct % CMOD)) {
291: pos++;
292: putchar(' ');
293: }
294: printf("%02X", b & 255);
295: pos += 2;
296: ct++;
297: }
298:
299: /*
300: * output unrelocated byte
301: */
302: outab(b)
303: unsigned short b;
304: {
305: if (2 == pass) {
306: limiter(1);
307: outlst(b);
308: }
309: dot.loc++; /* update location ctr */
310: }
311:
312: /*
313: * output unrelocated word.
314: */
315: outaw(u)
316: unsigned short u;
317: {
318: if (2 == pass) {
319: union word w;
320:
321: w.us = u;
322: limiter(2);
323: outlst(w.uc[0]);
324: outlst(w.uc[1]);
325: }
326: dot.loc += 2;
327: }
328:
329: /*
330: * output unrelocated long.
331: */
332: outal(ul)
333: long ul;
334: {
335: if (2 == pass) {
336: union full l;
337:
338: l.ul = ul;
339: limiter(4);
340: outlst(l.uc[0]);
341: outlst(l.uc[1]);
342: outlst(l.uc[2]);
343: outlst(l.uc[3]);
344: }
345: dot.loc += 4;
346: }
347:
348: /*
349: * output relocation.
350: */
351: static long
352: relOut(oper, sw)
353: register expr *oper;
354: unsigned sw;
355: {
356: register RELOC *bp;
357: register sym *sp;
358: register long rv;
359:
360: rv = oper->exp;
361: if (NULL == (sp = oper->ref) || (sp->type & S_XSYM))
362: return(rv); /* absolute addr */
363:
364: bp = cseg->relBp++;
365: bp->r_type = sw;
366: bp->r_vaddr = dot.loc + cseg->s_vaddr;
367:
368: /*
369: * Only use symbol references when forced
370: * seems to be required by a bug in the
371: * ESIX linker.
372: */
373: if (!(sp->flag & (S_EXREF|S_COMMON))) {
374: int seg = segs[sp->sg - 1].segSeq - 1;
375:
376: bp->r_symndx = txtAt ? (seg * 2) + txtAt : seg;
377: }
378: else {
379: bp->r_symndx = sp->num;
380: if (sp->flag & S_COMMON)
381: rv += sp->size;
382: rv -= sp->loc;
383: }
384:
385: if (bp == (cseg->relBuf + (RELBUF - 1)))
386: outRel(cseg);
387:
388: /* gimmic addr to make .data after .text */
389: if ((sp->sg > 1) && !(sp->flag & S_COMMON))
390: rv += segs[sp->sg - 1].s_vaddr;
391:
392: return(rv);
393: }
394:
395: /*
396: * output relocated byte
397: */
398: outrb(oper, sw)
399: expr *oper;
400: int sw; /* 0 = Relative address, 1 = PC relative address */
401: {
402: if (2 == pass) {
403: limiter(1);
404: if (sw)
405: outlst((unsigned short)(relOut(oper, R_PCRBYTE) -
406: (dot.loc + 1)));
407: else
408: outlst((unsigned short)relOut(oper, R_RELBYTE));
409: }
410: else if (NULL != oper->ref)
411: cseg->s_nreloc++;
412: dot.loc++;
413: }
414:
415: /*
416: * output relocated word.
417: */
418: outrw(oper, sw)
419: expr *oper;
420: int sw; /* 0 = Relative address, 1 = PC relative address */
421: {
422: union word w;
423:
424: if (2 == pass) {
425: if (sw)
426: w.us = relOut(oper, R_PCRWORD) - (dot.loc + 2);
427: else
428: w.us = relOut(oper, R_DIR16);
429:
430: limiter(2);
431: outlst(w.uc[0]);
432: outlst(w.uc[1]);
433: }
434: else if (NULL != oper->ref)
435: cseg->s_nreloc++;
436: dot.loc += 2;
437: }
438:
439: /*
440: * output relocated long.
441: */
442: outrl(oper, sw)
443: expr *oper;
444: int sw; /* 0 = Relative address, 1 = PC relative address */
445: {
446: union full l;
447:
448: if (2 == pass) {
449: if (sw)
450: l.ul = relOut(oper, R_PCRLONG) - (dot.loc + 4);
451: else
452: l.ul = relOut(oper, R_DIR32);
453:
454: limiter(4);
455: outlst(l.uc[0]);
456: outlst(l.uc[1]);
457: outlst(l.uc[2]);
458: outlst(l.uc[3]);
459: }
460: else if (NULL != oper->ref)
461: cseg->s_nreloc++;
462: dot.loc += 4;
463: }
464:
465: /*
466: * Output symbol table string.
467: */
468: outSymStr(sp)
469: register sym *sp;
470: {
471: register i;
472: register char *name;
473:
474: name = SYMNAME(sp);
475: if ((i = strlen(name)) > SYMNMLEN)
476: owrite(name, i + 1);
477: }
478:
479: static void showIt(sp)
480: sym *sp;
481: {
482: int i;
483: char *name;
484:
485: i = strlen(name = SYMNAME(sp));
486: fprintf(stderr, "Trace %X, '%s' flag %d len %d num %d\n",
487: sp, name, sp->flag, i, sp->num);
488: }
489:
490: /*
491: * output symbol table entry.
492: */
493: SYMENT *
494: outSym(sp)
495: register sym *sp;
496: {
497: static SYMENT s;
498: int i;
499: register char *name;
500:
501: clear(&s);
502:
503: i = strlen(name = SYMNAME(sp));
504:
505: if (i > SYMNMLEN) {
506: s.n_zeroes = 0;
507: s.n_offset = strOff;
508: strOff += i + 1;
509: }
510: else
511: strncpy(s._n._n_name, name, SYMNMLEN);
512:
513: if (sp->sg < 0)
514: s.n_scnum = sp->sg;
515: else
516: s.n_scnum = segs[sp->sg - 1].segSeq;
517: s.n_value = sp->loc;
518: s.n_sclass = C_STAT;
519:
520: if (sp->flag & S_EXDEF) {
521: s.n_sclass = C_EXT;
522: if (sp->flag & S_COMMON) { /* common */
523: s.n_value = (sp->size ? sp->size : 1);
524: s.n_scnum = 0;
525: }
526: }
527: if (sp->flag & S_EXREF) {
528: s.n_scnum = 0;
529: s.n_value = 0;
530: s.n_sclass = C_EXT;
531: }
532:
533: /* gimmic addr to make .data after .text */
534: if (s.n_scnum > 1)
535: s.n_value += segs[sp->sg - 1].s_vaddr;
536:
537: owrite((char *)&s, sizeof(s));
538: return (&s);
539: }
540:
541: /*
542: * Go from pass 0 to pass 1 or 2
543: */
544: newPass(fn)
545: char *fn;
546: {
547: register seg *s;
548: unsigned size;
549: long xaddr;
550:
551: if ((cseg->curadd = dot.loc) > cseg->hiadd)
552: cseg->hiadd = cseg->curadd;
553: cseg = segs; /* return to .text */
554: defCt = macNo = dot.loc = 0;
555: if ((txtAt = DEBUG_RECS) && !pass) {
556: xpass = 1; /* force another pass */
557: symptr = syms = alloc(coffDefCt * sizeof(*syms));
558: }
559: longMode = pass = dot.sg = 1;
560: if (indPass()) { /* take an extra pass */
561: usects = 0;
562: for (s = segs; s < segend; s++) {
563: if (s->hiadd || usects < MANSEG)
564: usects++;
565: s->segSeq = usects;
566: s->bp = s->buf;
567: s->relBp = s->relBuf;
568: s->lineBp = s->lineBuf;
569: s->s_nlnno = s->s_nreloc = s->hiadd = s->curadd = 0;
570: }
571: symGlob(txtAt + USECTS); /* fix symbol table */
572: coffDefCt = coffAuxCt = coffEfcnCt = 0;
573: return;
574: }
575:
576: pass = 2; /* last pass */
577: linect = nlpp;
578: usects = xaddr = datapos = relpos = linepos = 0;
579: ofp = xopen(fn, "wb");
580:
581: for (s = segs; s < segend; s++) {
582: if (s->hiadd || usects < MANSEG)
583: usects++;
584: s->s_paddr = s->s_vaddr = xaddr;
585: s->hiadd += ROUNDR; /* Round up */
586: s->hiadd &= ~ROUNDR;
587: xaddr += s->s_size = s->hiadd;
588: s->data_seekad = datapos; /* temp value */
589: s->s_relptr = relpos;
590: s->s_lnnoptr = linepos;
591: if (s->s_flags != STYP_BSS) {
592: datapos += s->hiadd;
593: relpos += s->s_nreloc * RELSZ;
594: linepos += s->s_nlnno * LINESZ;
595: }
596: }
597: size = sizeof(FILEHDR) + (usects * sizeof(SCNHDR));
598: debpos = size + datapos + relpos + linepos;
599: sympos = debpos + (txtAt * SYMESZ);
600: linepos = size + datapos + relpos;
601: relpos = size + datapos;
602:
603: if (fseek(ofp, lastSeek = sympos, 0))
604: fatal("Seek error on object file"); /**/
605:
606: usects = 0;
607: for (s = segs; s < segend; s++) {
608: SYMENT sym;
609: AUXENT aux;
610:
611: if (s->hiadd || usects < MANSEG)
612: usects++;
613: else
614: continue;
615:
616: /* write symbol records for segments */
617: clear(&sym);
618: s->segSeq = usects;
619: sym.n_sclass = C_STAT;
620: sym.n_value = s->s_vaddr;
621: memcpy(sym._n._n_name, s->s_name, SYMNMLEN);
622: sym.n_scnum = usects;
623: sym.n_numaux = txtAt ? 1 : 0;
624: owrite((char *)&sym, sizeof(sym));
625:
626: if (sym.n_numaux) {
627: aux.ae_scnlen = s->s_size;
628: aux.ae_nreloc = s->s_nreloc;
629: aux.ae_nlinno = s->s_nlnno;
630: owrite((char *)&aux, sizeof(aux));
631: }
632:
633: if (s->hiadd && (s->s_flags != STYP_BSS))
634: s->s_scnptr = s->data_seekad += size;
635: else
636: s->s_scnptr = s->data_seekad = 0;
637:
638: if (s->s_nreloc && (s->s_flags != STYP_BSS))
639: s->relo_seekad = s->s_relptr += relpos;
640: else
641: s->relo_seekad = s->s_relptr = 0;
642:
643: if (s->s_nlnno && (s->s_flags != STYP_BSS))
644: s->line_seekad = s->s_lnnoptr += linepos;
645: else
646: s->line_seekad = s->s_lnnoptr = 0;
647: s->hiadd = s->curadd = 0;
648: }
649:
650: sympos = ftell(ofp); /* continue the symbol table from here */
651:
652: /* fix the symbol table setting numbers */
653: symGlob(txtAt + USECTS);
654: coffDefCt = coffAuxCt = coffEfcnCt = 0;
655: }
656:
657: /*
658: * write record header then segment headers.
659: */
660: static void
661: writeHeader()
662: {
663: register seg *s;
664: FILEHDR head;
665: int i;
666: long loadd;
667:
668: head.f_magic = C_386_MAGIC;
669: time(&head.f_timdat);
670: head.f_nsyms = symbs;
671: head.f_symptr = debpos;
672: head.f_opthdr = 0;
673: head.f_flags = 0;
674: head.f_nscns = usects;
675:
676: xwrite(0L, (char *)&head, sizeof(head));
677: for (loadd = i = 0, s = segs; s < segend; s++) {
678: if (s->hiadd || i < MANSEG) {
679: i++;
680: owrite(s, sizeof(SCNHDR));
681: }
682: }
683: }
684:
685: /*
686: * Finish any output.
687: */
688: cleanUp()
689: {
690: int pad;
691: register seg *s;
692:
693: s = cseg; /* close out current seg */
694: if(s->hiadd < (s->curadd = dot.loc))
695: s->hiadd = s->curadd;
696:
697: if (coffDefCt) /* Write debug symbols */
698: writeDebug();
699:
700: fseek(ofp, sympos, 0);
701:
702: symDump(outSym, txtAt); /* write ordinary symbols */
703:
704: symbs = (ftell(ofp) - debpos) / SYMESZ; /* figure sym ct from loc */
705:
706: if (strOff > 4) {
707: owrite(&strOff, sizeof(strOff)); /* write length of tail */
708: writeDebugLong(); /* dump symbols that are too long */
709: symDump(outSymStr, txtAt);
710: }
711:
712: writeHeader(); /* now we know header data */
713:
714: for (s = segs; s < segend; s++) {
715: if (s->s_flags == STYP_BSS)
716: continue;
717:
718: /* go to end of segment */
719: if (s->curadd != s->hiadd)
720: doOrg(NULL, NULL);
721:
722: /* pad with nop or zero */
723: pad = (s->s_flags == STYP_TEXT) ? NOP : 0;
724: for (; s->hiadd & ROUNDR; s->hiadd++)
725: binout(pad, s);
726: outData(s);
727: outRel(s);
728: outLineRec(s);
729: }
730: }
731:
732: /*
733: * org command
734: */
735: doOrg(label, oper)
736: parm *label;
737: data *oper;
738: {
739: register seg *s;
740: long from, to;
741: char pad;
742:
743: buildlab(label);
744:
745: from = dot.loc;
746: s = cseg;
747: if (pass == 2)
748: outData(s);
749: s->curadd = dot.loc; /* first make segment current */
750: if (dot.loc > s->hiadd)
751: s->hiadd = dot.loc;
752:
753: /* process org */
754: switch ((NULL == oper) ? 'n' : oper->type) {
755: case 'n':
756: to = s->hiadd; /* org to hi spot in segment */
757: break;
758: case 'd':
759: case 's':
760: yyerror("Org to invalid value");
761: /* You may not \fB.org\fR to doubles or strings. */
762: return (1);
763: case 'y':
764: if (oper->d.y->sg != dot.sg) {
765: yyerror("Org to wrong segment");
766: /* You must \fB.org\fR to the current segment. */
767: return (1);
768: }
769: to = oper->d.y->loc;
770: break;
771: case 'l':
772: to = oper->d.l; /* org where requested */
773: }
774:
775: if ((pass != 2) || (s->s_flags == STYP_BSS)) { /* no disk work */
776: s->curadd = dot.loc = to; /* make segment current again */
777: if (to > s->hiadd)
778: s->hiadd = dot.loc;
779: return (0);
780: }
781: if (to <= s->hiadd) { /* no pad if we've been there */
782: s->curadd = dot.loc = to;
783: s->data_seekad += to - from;
784: return (0);
785: }
786: from = s->curadd = dot.loc = s->hiadd; /* seek to the old end */
787: s->data_seekad += s->hiadd - from;
788:
789: pad = (s->s_flags == STYP_TEXT) ? NOP : 0; /* pad out */
790: for (;from < to; from++)
791: binout(pad, s);
792: s->curadd = dot.loc = to; /* make segment current again */
793: if (to > s->hiadd)
794: s->hiadd = dot.loc;
795: return (0);
796: }
797:
798: /*
799: * Initialize segment information.
800: */
801: segInit()
802: {
803: int i;
804: register seg *s;
805:
806: static char *segclass[] = {
807: ".text", ".data", ".bss"
808: };
809: static long segflag[] = {
810: STYP_TEXT, STYP_DATA, STYP_BSS
811: };
812:
813: cseg = segs = alloc(sizeof(*segs) * MANSEG);
814: segend = segs + MANSEG;
815:
816: for (i = 0, s = segs; s < segend; s++, i++) {
817: strncpy(s->s_name, segclass[i], SYMNMLEN);
818: s->s_flags = segflag[i];
819: s->segSeq = ++sects;
820: s->bp = s->buf;
821: s->relBp = s->relBuf;
822: s->lineBp = s->lineBuf;
823: }
824: }
825:
826: /*
827: * .ident and .version set stuff in the comment section.
828: */
829: cmnt(op, p)
830: opc *op;
831: parm *p;
832: {
833: }
834:
835: /*
836: * coff debugging statements.
837: */
838: coffFile(s)
839: parm *s;
840: {
841: #ifdef NODEBUG
842: return;
843: #else
844: coffDefCt++;
845: coffAuxCt++;
846: if (2 == pass) {
847: symptr->sclass = C_FILE;
848: symptr->scnum = N_DEBUG;
849: symptr->numaux = 1;
850: if ('"' == s->str[0]) {
851: char *p;
852:
853: if (NULL != (p = strchr(s->str + 1, '"')))
854: *p = 0;
855: strncpy(symptr->aux.ae_fname, s->str + 1, FILNMLEN);
856: }
857: else
858: strncpy(symptr->aux.ae_fname, s->str, FILNMLEN);
859: symptr->name = ".file";
860: symptr++;
861: }
862: #endif
863: }
864:
865: coffDef(s)
866: parm *s;
867: {
868: #ifdef NODEBUG
869: return;
870: #else
871: if (pass) { /* initialize new symbol */
872: if (defSw)
873: yywarn("missing .endef");
874: symptr->scnum = N_ABS;
875: if (NULL != symptr->name)
876: free(symptr->name);
877: symptr->name = scpy(s->str, 0);
878: symptr->symno = DEBUG_RECS;
879: defSw = 1;
880: }
881: #endif
882: }
883:
884: coffEndef()
885: {
886: #ifdef NODEBUG
887: return;
888: #else
889: if ((1 == pass) && (symptr->scnum != N_DEBUG))
890: symReNumber(symptr->name, DEBUG_RECS);
891:
892: if (2 == pass) {
893: register struct xsym *s;
894:
895: switch (symptr->sclass) {
896: case C_BLOCK:
897: if (strcmp(symptr->name, ".eb"))
898: break;
899: for (s = symptr - 1; s != syms; s--)
900: if (C_BLOCK == s->sclass &&
901: !strcmp(s->name, ".bb") &&
902: !s->aux.ae_endndx) {
903: s->aux.ae_endndx = DEBUG_RECS + 2;
904: break;
905: }
906: if (s == syms)
907: yywarn(".eb does not connect to .bb");
908: /* A .eb statement does not connect to a
909: * .bb statement */
910: break;
911:
912: case C_EFCN: /* end of function marker */
913: for (s = symptr - 1; s != syms; s--) {
914: if (!strcmp(symptr->name, s->name)) {
915: short type;
916:
917: /* if this is a function at any level */
918: for (type = s->type & ~N_BTMASK;
919: type && !ISFCN(type);
920: type >>= N_TSHIFT)
921: ;
922:
923: if (type)
924: break;
925: }
926: }
927: if (s == syms)
928: yywarn(".type -1 does not connect");
929: /* A type of -1 C_EFCN does not connect to
930: * a .def of a function */
931: else {
932: s->aux.ae_fsize = symptr->value - s->value;
933: s->aux.ae_endndx = DEBUG_RECS;
934: }
935: }
936: symptr->numaux = auxSw;
937: symptr++;
938: if (!defSw)
939: yywarn(".endef must follow .def"); /* */
940: }
941: coffDefCt++; /* we need a spot to remember this */
942: coffEfcnCt += efcnSw; /* C_EFCN don't write to table */
943: if (!efcnSw) /* They don't have aux records */
944: coffAuxCt += auxSw;
945: auxSw = defSw = efcnSw = 0;
946: #endif
947: }
948:
949: /*
950: * .type command
951: */
952: coffType(n)
953: long n;
954: {
955: #ifdef NODEBUG
956: return;
957: #else
958: if (ISFCN(n)) { /* function build a line record */
959: register LINENO *bp;
960:
961: auxSw = 1;
962: if (2 != pass)
963: cseg->s_nlnno++;
964: else {
965: bp = cseg->lineBp++;
966: bp->l_lnno = 0;
967: bp->l_addr.l_symndx = DEBUG_RECS;
968:
969: if (bp == (cseg->lineBuf + (LINEBUF - 1)))
970: outLineRec(cseg);
971: }
972: }
973:
974: if (2 == pass) {
975: if (!defSw)
976: yywarn(".type not in .endif");
977: /* Debug command .type must be in .endif */
978: symptr->type = n;
979: }
980: #endif
981: }
982:
983: coffVal(item)
984: data *item;
985: {
986: #ifdef NODEBUG
987: return;
988: #else
989: SYMENT *s;
990:
991: if (2 != pass)
992: return;
993: if (!defSw)
994: yywarn(".val must follow .def"); /* */
995:
996: if ('y' == item->type) {
997: sym *sp = item->d.y;
998:
999: if (sp->flag & S_COMMON) {
1000: symReNumber(symptr->name, DEBUG_RECS);
1001: symptr->scnum = N_UNDEF;
1002: symptr->value = sp->size;
1003: }
1004: else {
1005: symptr->scnum = sp->sg;
1006: symptr->value = sp->loc;
1007: }
1008: }
1009: else
1010: symptr->value = item->d.l;
1011: #endif
1012: }
1013:
1014: coffScl(n)
1015: long n;
1016: {
1017: #ifdef NODEBUG
1018: return;
1019: #else
1020: if (C_EFCN == n)
1021: efcnSw = 1;
1022: if (!pass)
1023: return;
1024: if (!defSw)
1025: yywarn(".scl must follow .def"); /* */
1026: if (ISTAG(n))
1027: symptr->scnum = N_DEBUG;
1028: symptr->sclass = n;
1029: #endif
1030: }
1031:
1032: coffSize(n)
1033: long n;
1034: {
1035: #ifdef NODEBUG
1036: return;
1037: #else
1038: auxSw = 1;
1039: if (2 != pass)
1040: return;
1041: if (!defSw)
1042: yywarn(".size must follow .def"); /* */
1043: symptr->aux.ae_size = n;
1044: #endif
1045: }
1046:
1047: coffDim(n, d)
1048: long n;
1049: int d;
1050: {
1051: #ifdef NODEBUG
1052: return;
1053: #else
1054: auxSw = 1;
1055: if (2 != pass)
1056: return;
1057: if (!defSw) {
1058: yywarn(".dim must follow .def"); /* */
1059: return;
1060: }
1061: if (DIMNUM <= d) {
1062: yywarn(".dim statement too complex");
1063: /* A .dim statement may contain no more than 4 dimensions. */
1064: return;
1065: }
1066: symptr->aux.ae_dimen[d] = n;
1067: #endif
1068: }
1069:
1070: coffTag(p)
1071: parm *p;
1072: {
1073: #ifdef NODEBUG
1074: return;
1075: #else
1076: struct xsym *s;
1077:
1078: auxSw = 1;
1079: if (2 != pass)
1080: return;
1081: for (s = symptr - 1; s != syms; s--) {
1082: if (ISTAG(s->sclass) && !strcmp(p->str, s->name)) {
1083: if (C_EOS == symptr->sclass)
1084: s->aux.ae_endndx = symptr->symno + 2;
1085: symptr->aux.ae_tagndx = s->symno;
1086: break;
1087: }
1088: }
1089: if (s == syms)
1090: yywarn(".tag does not connect");
1091: /* This tag fails to connect to an earlier unconnected .def
1092: * of the same name and a proper n_sclass.
1093: */
1094: #endif
1095: }
1096:
1097: coffLn(n)
1098: long n;
1099: {
1100: #ifdef NODEBUG
1101: return;
1102: #else
1103: register LINENO *bp;
1104:
1105: if (2 != pass)
1106: cseg->s_nlnno++;
1107: else {
1108: bp = cseg->lineBp++;
1109: bp->l_lnno = n;
1110: bp->l_addr.l_paddr = dot.loc;
1111:
1112: if (bp == (cseg->lineBuf + (LINEBUF - 1)))
1113: outLineRec(cseg);
1114: }
1115: #endif
1116: }
1117:
1118: coffLine(n)
1119: long n;
1120: {
1121: #ifdef NODEBUG
1122: return;
1123: #else
1124: auxSw = 1;
1125: if (2 != pass)
1126: return;
1127: if (!defSw)
1128: yywarn(".line must follow .def"); /* */
1129: symptr->aux.ae_lnno = n;
1130: #endif
1131: }
1132:
1133: /*
1134: * Write debug records.
1135: */
1136: writeDebug()
1137: {
1138: register struct xsym *s, *ends;
1139: int ct = 0, act = 0;
1140:
1141: fseek(ofp, lastSeek = debpos, 0);
1142: for (ends = (s = syms) + coffDefCt; s != ends; s++) {
1143: int i;
1144: SYMENT sym;
1145:
1146: if (C_EFCN == s->sclass)
1147: continue;
1148:
1149: sym.n_sclass = s->sclass;
1150: sym.n_value = s->value;
1151: sym.n_scnum = s->scnum;
1152: sym.n_type = s->type;
1153: sym.n_numaux = s->numaux;
1154:
1155: if ((i = strlen(s->name)) > SYMNMLEN) {
1156: sym.n_offset = strOff;
1157: sym.n_zeroes = 0;
1158: strOff += i + 1;
1159: }
1160: else
1161: strncpy(sym.n_name, s->name, SYMNMLEN);
1162:
1163: ct++;
1164: owrite(&sym, SYMESZ);
1165: if (sym.n_numaux) {
1166: act++;
1167: owrite(&(s->aux), AUXESZ);
1168: }
1169: }
1170:
1171: }
1172:
1173: writeDebugLong()
1174: {
1175: register struct xsym *s, *ends;
1176:
1177: for (ends = (s = syms) + coffDefCt; s != ends; s++) {
1178: int i;
1179:
1180: if (C_EFCN == s->sclass)
1181: continue;
1182:
1183: if ((i = strlen(s->name)) > SYMNMLEN)
1184: owrite(s->name, i + 1);
1185: }
1186: }
1187:
1188: /*
1189: * .comm and .lcomm commands.
1190: * Improve later.
1191: */
1192: comm(op, p, n)
1193: opc *op;
1194: parm *p;
1195: long n;
1196: {
1197: if (NULL == p) {
1198: yyerror(".comm must have tag");
1199: /* The format of \fB.comm\fR is \fB.comm name, size\fR. */
1200: return;
1201: }
1202: if (op->code == 2) {
1203: sym *s;
1204:
1205: s = symLookUp(p->str, S_LOCAL, 0L, op->code + 1);
1206: s->size = n;
1207: s->flag = S_EXDEF|S_COMMON;
1208: }
1209: }
1210:
1211: /*
1212: * segment command.
1213: */
1214: void
1215: segment(op, p, n)
1216: opc *op;
1217: parm *p;
1218: long n;
1219: {
1220: register seg *s;
1221: sym *rv;
1222: static int previous = 0;
1223: int thisSg;
1224:
1225: /* Implement one level segment stack */
1226: if (10000 != op->code) {
1227: thisSg = op->code;
1228: previous = dot.sg - 1; /* save where we were */
1229: }
1230: else /* .previous pops the stack */
1231: thisSg = previous;
1232:
1233: s = segs + thisSg;
1234:
1235: if (NULL == p) { /* segment change */
1236: if ((cseg->curadd = dot.loc) > cseg->hiadd)
1237: cseg->hiadd = cseg->curadd;
1238:
1239: cseg = s;
1240: dot.loc = s->curadd;
1241: dot.sg = thisSg + 1;
1242: return;
1243: }
1244:
1245: /* set up data */
1246: rv = symLookUp(p->str, S_LOCAL, s->curadd, thisSg + 1);
1247: rv->size = n;
1248: s->curadd += n;
1249: if (s->curadd > s->hiadd)
1250: s->hiadd = s->curadd;
1251: return;
1252: }
1253:
1254: /*
1255: * Switch to a section by name.
1256: * add it if required.
1257: */
1258: void
1259: section(name)
1260: char *name;
1261: {
1262: int motion, i;
1263: char *oldsegs;
1264: register seg *s;
1265: static opc segOp = { 0, S_SEGMENT };
1266:
1267: /* These are common segment names with their flags */
1268: static char *segclass[] = {
1269: ".init", ".fini", ".rodata",
1270: ".comment", ".ctors", ".dtors"
1271: };
1272: static long segflag[] = {
1273: STYP_TEXT, STYP_DATA, STYP_DATA,
1274: STYP_INFO, STYP_DATA, STYP_DATA
1275: };
1276:
1277: /* Look for section in segment list */
1278: for (segOp.code = 0; segOp.code < sects; segOp.code++) {
1279: if (!strncmp(name, segs[segOp.code].s_name, 8)) {
1280: segment(&segOp, NULL, 0L);
1281: return;
1282: }
1283: }
1284:
1285: /* realloc segment list with room for one more */
1286: oldsegs = (char *)segs;
1287: if (NULL == (segs = realloc(segs, sizeof(*segs) * ++sects)))
1288: fatal("Out of memory"); /**/
1289:
1290: /* adjust pointers to segment list */
1291: motion = (char *)segs - oldsegs;
1292: #define adjust(ptr) ptr = (char *)(((char *)(ptr)) + motion)
1293: adjust(cseg);
1294: adjust(segend);
1295: for (s = segs; s < segend; s++) {
1296: adjust(s->bp);
1297: adjust(s->relBp);
1298: adjust(s->lineBp);
1299: }
1300: #undef adjust
1301: segend++;
1302:
1303: /* build new entry on segment list */
1304: memset(s, '\0', sizeof(*s));
1305: strncpy(s->s_name, name, SYMNMLEN);
1306:
1307: s->s_flags = STYP_TEXT; /* set default */
1308: for (i = 0; i < 6; i++) { /* look at common names */
1309: if (!strcmp(name, segclass[i])) {
1310: s->s_flags = segflag[i];
1311: break;
1312: }
1313: }
1314:
1315: s->segSeq = sects - 1;
1316: s->bp = s->buf;
1317: s->relBp = s->relBuf;
1318: s->lineBp = s->lineBuf;
1319:
1320: segment(&segOp, NULL, 0L); /* switch to the new entry */
1321: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.