![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to outrel.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n2 / i8086|
Return to outrel.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n2 / i8086 |
1.1 root 1: /*
2: * The routines in this file make up
3: * a writer for the Coherent reloc.h object
4: * file. During code assembly all the bits get
5: * written to a temporary file. At the very end the
6: * bits get copied back to the final object file.
7: * The symbol table is constructed as the code is read,
8: * each symbol is declared when defined. References are
9: * tacked onto the end of the file.
10: * Relocation instructions for debug and symbol table entries are
11: * also passed through the scratch file.
12: */
13: #ifdef vax
14: #include "INC$LIB:cc2.h"
15: #include "INC$LIB:canon.h"
16: #include "INC$LIB:reloc.h"
17: #include "INC$LIB:debug.h"
18: #else
19: #include "cc2.h"
20: #include <canon.h>
21: #include <reloc.h>
22: #include <debug.h>
23: #endif
24:
25: #if !TINY
26: #define dbrpt(x,y) _dbrpt(x,y)
27: #else
28: #define dbrpt(x,y) /* dbrpt(x,y) */
29: #endif
30: #define NTXT 512 /* Text buffer size */
31: #define NREL 256 /* Relocation buffer size */
32: /*
33: * Scratch file operators.
34: */
35: #define TTYPE 017 /* Type mask */
36: #define Tflag(x) (((x)>>4)&7) /* Get flag bits */
37: #define TEND 000 /* End marker */
38: #define TENTER 001 /* Enter new area */
39: #define TBYTE 002 /* Byte data */
40: #define TWORD 003 /* Word data */
41: #if 0
42: #define TTRIP 004 /* Triple byte data */
43: #define TLONG 005 /* Long data */
44: #endif
45: #define TDLAB 006 /* Debug item */
46: #define TDLOC 007 /* Debug location */
47: #define TCODE 010 /* Code segment base */
48: #define TDATA 011 /* Data segment base */
49: #define TBASE 012 /* External segment base */
50:
51: #define TPCR 020 /* PC rel flag, ored in */
52: #define TSYM 040 /* Symbol based flag, ored in */
53: #define locrup(x) (((x)+01)&~01) /* memory alignment */
54: objhdr_t objhdr = { /* object header */
55: REL_OBJ,
56: "i8086",
57: "C",
58: VERSMWC
59: };
60:
61: summseg_t summseg = { /* Summary segment */
62: SUMMARY,
63: sizeof (summseg.seg_off)
64: };
65:
66: extern char *calloc();
67: extern char *malloc();
68: extern char *strcpy();
69:
70: ADDRESS SCODE_len; /* Length of SCODE in bytes */
71: char txt[NTXT]; /* Text buffer */
72: char rel[NREL]; /* Relocation buffer */
73: char *txtp = txt; /* Text pointer */
74: char *relp = rel; /* Relocation pointer */
75: int refnum = 0; /* Symbol reference number */
76: static int level = 0; /* Debug brace level */
77: static int dline = 0; /* Most recent line number entry */
78:
79: /*
80: * This table converts a C compiler
81: * segment index into a relocatable object segment type.
82: */
83: char segindex[] = {
84: PURCODE, /* SCODE */
85: OWNCODE, /* SLINK */
86: PURDATA, /* SPURE */
87: STRINGS, /* SSTRN */
88: OWNDATA, /* SDATA */
89: BLDATA, /* SBSS */
90: -1, /* SANY */
91: -1, /* SSTACK */
92: -1, /* SALIEN */
93: DEBUG, /* SDBG */
94: SYMBOLS /* SSYM */
95: };
96:
97: /*
98: * Output a segment switch.
99: */
100: outseg(s)
101: {
102: bput(TENTER);
103: bput(s);
104: }
105:
106: /*
107: * Output an absolute byte.
108: */
109: outab(b)
110: {
111: bput(TBYTE);
112: bput(b);
113: dot += 1;
114: }
115:
116: /*
117: * Output an absolute word.
118: */
119: outaw(w)
120: {
121: bput(TWORD);
122: iput(w);
123: dot += 2;
124: }
125:
126:
127: #ifdef TLONG
128: /*
129: * Output an absolute long.
130: */
131: outal(l)
132: long l;
133: {
134: bput(TLONG);
135: lput(l);
136: dot += 4;
137: }
138: #endif
139:
140: /*
141: * Output a full byte.
142: */
143: outxb(sp, b, pcrf)
144: register SYM *sp;
145: {
146: register opcode;
147:
148: opcode = TBYTE;
149: if (sp != NULL)
150: opcode |= TSYM;
151: if (pcrf)
152: opcode |= TPCR;
153: bput(opcode);
154: bput(b);
155: if (sp != NULL)
156: pput(sp);
157: dot += 1;
158: }
159:
160: /*
161: * Output a full word.
162: */
163: outxw(sp, w, pcrf)
164: register SYM *sp;
165: {
166: register opcode;
167:
168: opcode = TWORD;
169: if (sp != NULL)
170: opcode |= TSYM;
171: if (pcrf)
172: opcode |= TPCR;
173: bput(opcode);
174: iput(w);
175: if (sp != NULL)
176: pput(sp);
177: dot += 2;
178: }
179:
180: #ifdef TLONG
181: /*
182: * Output a full long.
183: */
184: outxl(sp, l, pcrf)
185: register SYM *sp;
186: long l;
187: {
188: register opcode;
189:
190: opcode = TLONG;
191: if (sp != NULL)
192: opcode |= TSYM;
193: if (pcrf)
194: opcode |= TPCR;
195: bput(opcode);
196: lput(lR);
197: if (sp != NULL)
198: pput(sp);
199: dot += 4;
200: }
201: #endif
202:
203: /*
204: * Copy a dlabel record from ifp to ofp.
205: * Flag the symbol table entry if appropriate.
206: */
207: outdlab(l,class)
208: {
209: register int val;
210: register SYM *sp;
211: int n;
212:
213: if (l == 0)
214: bput(TDLAB);
215: bput(class);
216:
217: /* Get line number. */
218: iput(iget());
219:
220: /* Get value */
221: if (class < DC_AUTO)
222: ;
223: else if (class < DC_MOS)
224: iput(val = iget());
225: else {
226: bput(bget());
227: bput(bget());
228: iput(iget());
229: }
230:
231: /* Get name */
232: sget(id, NCSYMB);
233:
234: /* Check for symbol table entry */
235: if (class==DC_GDEF || class==DC_SEX || class==DC_GREF) {
236: sp = glookup(id, 0);
237: sp->s_flag |= S_PUT;
238: } else if (class==DC_SIN) {
239: sp = llookup(val, 0);
240: sp->s_flag |= S_PUT;
241: }
242:
243: /* Put name */
244: sput(id);
245:
246: /* Get type */
247: for (;;) {
248: switch (bput(bget())) {
249: case DT_NONE:
250: case DT_CHAR:
251: case DT_UCHAR:
252: case DT_SHORT:
253: case DT_USHORT:
254: case DT_INT:
255: case DT_UINT:
256: case DT_LONG:
257: case DT_ULONG:
258: case DT_FLOAT:
259: case DT_DOUBLE:
260: case DT_VOID:
261: iput(iget());
262: break;
263: case DT_STRUCT:
264: case DT_UNION:
265: case DT_ENUM:
266: case DD_PTR:
267: case DD_FUNC:
268: case DD_ARRAY:
269: iput(iget());
270: continue;
271: break;
272: case DX_MEMBS:
273: bput(n = iget());
274: for ( ; n > 0; n-=1) {
275: outdlab(1, bget());
276: }
277: break;
278: case DX_NAME:
279: iget();
280: sget(id, NCSYMB);
281: sput(id);
282: break;
283: default:
284: cbotch("outdlab: %d", n);
285: }
286: break;
287: }
288: }
289:
290: /*
291: * Output a debug line record.
292: */
293: outdlin(op)
294: {
295: bput(TDLAB);
296: bput(DC_LINE);
297: iput(line);
298: bput(op);
299: bput(0);
300: bput(DT_NONE);
301: iput(0);
302: }
303:
304: /*
305: * Output a debug relocation record.
306: */
307: outdloc(n)
308: {
309: bput(TDLOC);
310: iput(n);
311: }
312:
313: /*
314: * Abort illegal output.
315: * reloc.h doesn't handle 8087 or Large model.
316: */
317: outbad()
318: {
319: cbotch("bad temp file object");
320: }
321:
322: /*
323: * Output a 1 word object containing
324: * the base address of the current code
325: * segment.
326: */
327: outcb()
328: {
329: return (outbad());
330: bput(TCODE);
331: dot += 2;
332: }
333:
334: /*
335: * Output a 1 word object containing
336: * the base address of the current data
337: * segment.
338: */
339: outdb()
340: {
341: return (outbad());
342: bput(TDATA);
343: dot += 2;
344: }
345:
346: /*
347: * Output a 1 word object containing
348: * the base address of the external symbol
349: * pointed to by `sp'.
350: */
351: outsb(sp)
352: SYM *sp;
353: {
354: return (outbad());
355: bput(TBASE);
356: pput(sp);
357: dot += 2;
358: }
359:
360: /*
361: * Initialize the code writer.
362: * This routine is called before anything is written to the scratch file.
363: * A no op on coherent reloc.h format.
364: */
365: outinit()
366: {
367: }
368:
369: /*
370: * Finish off the code writer.
371: * This routine is called just before the scratch file is closed.
372: * Write either the "end" to the output file
373: * if generating assembler,
374: * or a "TEND" code to stop the
375: * "copycode" routine if writing binary.
376: */
377: outdone()
378: {
379: register SYM *sp;
380: register int i;
381:
382: if (isvariant(VASM)) {
383: return;
384: }
385:
386: /*
387: * Assign refnums to symbols.
388: * And make dlabel items for internally generated symbols.
389: */
390: for (refnum = i = 0; i < NSHASH; i++) {
391: for (sp = hash2[i]; sp != NULL; sp = sp->s_fp) {
392: if ((sp->s_flag&S_GBL) != 0
393: || (sp->s_flag&S_DEF) == 0) {
394: if ((sp->s_flag&S_LABNO) == 0)
395: sp->s_ref = refnum++;
396: if ((sp->s_flag&S_PUT) == 0) {
397: bput(TDLAB);
398: bput(DC_GREF);
399: iput(0);
400: sput(sp->s_id);
401: bput(DT_NONE);
402: iput(0);
403: }
404: }
405: }
406: }
407:
408: bput(TEND);
409: }
410:
411: /*
412: * Copy back.
413: * Figure out the sizes and final values
414: * of everything. Copy the code from the scratch
415: * file back to the output file.
416: */
417: copycode()
418: {
419: int op, nd, nr;
420: ADDRESS data;
421: long addr;
422: fsize_t size, symsize;
423: unsigned char reltype, segtype;
424:
425: SCODE_len = seg[SCODE].s_dot;
426:
427: /*
428: * Initialize output.
429: */
430: oheader(0);
431:
432: /*
433: * Copy out code.
434: */
435: dotseg = SCODE;
436: dot = 0;
437: while ((op=bget()) != TEND) {
438: switch (op & TTYPE) {
439:
440: case TENTER:
441: oenter(bget());
442: continue;
443:
444: case TBYTE:
445: nd = 1;
446: reltype = B_0;
447: data = bget();
448: break;
449:
450: case TWORD:
451: nd = 2;
452: reltype = B_01;
453: data = iget();
454: break;
455:
456: #ifdef TLONG
457: case TLONG:
458: nd = 4;
459: reltype = B_0123;
460: data = lget();
461: break;
462: #endif
463:
464: case TDLAB:
465: getdlab();
466: continue;
467:
468: case TDLOC:
469: getdloc();
470: continue;
471:
472: default:
473: cbotch("copycode: op=%d", op);
474:
475: }
476:
477: switch (Tflag(op)) {
478:
479: case 0: /* Absolute */
480: nr = 0;
481: break;
482:
483: case Tflag(TPCR|TSYM): /* Symbol based pc relative */
484: data -= dot+nd;
485: /* Fall through */
486:
487: case Tflag(TSYM): /* Symbol based */
488: {
489: register SYM *sp;
490:
491: sp = pget();
492: if ((sp->s_flag&S_DEF) != 0) {
493: nr = 6;
494: segtype = segindex[sp->s_seg];
495: data += sp->s_value;
496: } else {
497: nr = 10;
498: segtype = SYMBOLS;
499: addr = sp->s_ref;
500: }
501: if ((op&TPCR) != 0)
502: segtype |= PCREL;
503: break;
504: }
505:
506: case Tflag(TPCR): /* Absolute pc relative */
507: data -= dot+nd;
508: segtype = ABSLUTE|PCREL;
509: nr = 10;
510: addr = 0;
511: break;
512:
513: default:
514: cbotch("copycode: flags=%o", op);
515: }
516:
517: /*
518: * Write the current record.
519: */
520: enuf(nd, nr);
521: if (nr != 0) {
522: rbbuf(reltype);
523: rbbuf(segtype);
524: rlbuf((long) dot);
525: if (nr == 10)
526: rlbuf(addr);
527: }
528: do {
529: bbuf((int) data);
530: data >>= 8;
531: } while (--nd > 0);
532: }
533:
534: if (isvariant(VLINES))
535: outbrace('}');
536: if (notvariant(VLIB))
537: dump(); /* Dump the typedefs */
538:
539: /*
540: * Flush buffers.
541: */
542: notenuf();
543:
544: /*
545: * Write symbol table.
546: */
547: summseg.seg_off[SYMBOLS] = ftell(ofp);
548: segtype = SYMBOLS;
549: bput(segtype);
550: size = symsize;
551: cansize(size);
552: owrite(&size, sizeof(size));
553: addr = refnum;
554: canuaddr(addr);
555: owrite(&addr, sizeof(addr));
556: oglobals();
557: symsize = ftell(ofp) - summseg.seg_off[SYMBOLS] - sizeof(fsize_t) - 1;
558:
559: /*
560: * Put end marker.
561: */
562: segtype = LASTSEG;
563: bput(segtype);
564:
565: /*
566: * Now go back and patch the remaining holes.
567: */
568: fseek(ofp, (fsize_t)0, 0);
569: oheader(1);
570:
571: /*
572: * Symbol segment size and count.
573: */
574: fseek(ofp, summseg.seg_off[SYMBOLS]+1, 0);
575: size = symsize;
576: cansize(size);
577: owrite(&size, sizeof(size));
578: addr = refnum;
579: canuaddr(addr);
580: owrite(&addr, sizeof(addr));
581: }
582:
583: /*
584: * Switch segments.
585: */
586: oenter(newseg)
587: register int newseg;
588: {
589: notenuf();
590: if (dotseg != SSYM)
591: seg[dotseg].s_dot = dot;
592: dotseg = newseg;
593: if (dotseg != SSYM)
594: dot = seg[dotseg].s_dot;
595: else
596: dot = 0;
597: }
598:
599: /*
600: * This routine checks to see if
601: * there is enough room in the text and relocation
602: * buffers to hold `nt' bytes of text and `nr' bytes of
603: * relocation.
604: */
605: enuf(nt, nr)
606: {
607: if (txtp+nt>&txt[NTXT] || relp+nr>&rel[NREL])
608: notenuf();
609: }
610:
611: /*
612: * Flush buffers.
613: */
614: notenuf()
615: {
616: register n;
617: unsigned char segtype;
618: fsize_t size;
619:
620: if ((n=txtp-txt) != 0) {
621: if (dotseg != SSYM) {
622: segtype = segindex[dotseg];
623: bput(segtype);
624: size = n;
625: cansize(size);
626: owrite(&size, sizeof(size));
627: }
628: owrite(txt, n);
629: if ((n=relp-rel) != 0) {
630: segtype = RELOCN;
631: bput(segtype);
632: size = n;
633: cansize(size);
634: owrite(&size, sizeof(size));
635: owrite(rel, n);
636: relp = rel;
637: }
638: }
639: txtp = txt;
640: }
641:
642: /*
643: * Write a byte or long to text or relocation buffers
644: * in canonical ordering.
645: */
646: bbuf(b)
647: {
648: *txtp++ = b;
649: dot += 1;
650: }
651:
652: lbuf(l)
653: long l;
654: {
655: *txtp++ = l >> 16;
656: *txtp++ = l >> 24;
657: *txtp++ = l;
658: *txtp++ = l >> 8;
659: dot += 4;
660: }
661:
662: rbbuf(b)
663: {
664: *relp++ = b;
665: }
666:
667: rlbuf(l)
668: long l;
669: {
670: *relp++ = l >> 16;
671: *relp++ = l >> 24;
672: *relp++ = l;
673: *relp++ = l >> 8;
674: }
675:
676: /*
677: * Write a block of bytes to the output file.
678: */
679: owrite(p, n)
680: register char *p;
681: register int n;
682: {
683: while (--n >= 0)
684: bput(*p++);
685: }
686:
687: /*
688: * Write the header and summary segment.
689: * Summary is complete on second call only.
690: */
691: oheader(n)
692: {
693: fsize_t offs;
694: register int i;
695: register struct seg *segp;
696:
697: /*
698: * Write header.
699: */
700: owrite(&objhdr, sizeof(objhdr));
701:
702: /*
703: * Copy segment sizes into summary segment.
704: */
705: for (segp = &seg[i=0]; i < NSEG; segp++, i++) {
706: if (segindex[i] < 0 || i == SSYM) continue;
707: offs = segp->s_dot;
708: if (i != SDBG)
709: offs = locrup(offs);
710: if (n == 0 || i >= SDBG)
711: summseg.seg_off[segindex[i]] += offs;
712: segp->s_dot = 0;
713: }
714: /*
715: * Write summary segment.
716: */
717: bput(summseg.seg_type);
718: offs = summseg.seg_size;
719: cansize(offs);
720: owrite(&offs, sizeof(offs));
721: for (i=0; i<SUMMARY; i+=1) {
722: offs = summseg.seg_off[i];
723: cansize(offs);
724: owrite(&offs, sizeof(offs));
725: }
726: }
727:
728: /*
729: * Structure to contain debug items on this pass.
730: */
731: struct dbgt {
732: struct dbgt *d_dp; /* Link */
733: int d_ref; /* Index number */
734: unsigned char d_class; /* Storage class */
735: unsigned char d_flag; /* Flags */
736: unsigned char d_level; /* Bracket level */
737: unsigned char d_seg; /* Segment */
738: ADDRESS d_value; /* Offset in segment */
739: int d_size; /* Size of d_data */
740: char d_data[]; /* Name and type */
741: };
742: #define D_GBL 1
743: #define D_LCL 2
744: #define D_TAG 4
745: #define D_NAM 8
746: #define D_LAB 16
747: #define D_ENU 32
748:
749: struct dbgt *newdbgt();
750: struct dbgt *getdbgt();
751: struct dbgt *dbase;
752: struct dbgt *dnext;
753: char *getmembs();
754:
755: /*
756: * Read debug table item(s) into memory.
757: */
758: getdlab()
759: {
760: register struct dbgt *dp;
761: static int refnum = 0;
762:
763: dp = getdbgt();
764:
765: /* This should be done in cc0 */
766:
767: if (isvariant(VLIB)) {
768: switch (dp->d_class) {
769: case DC_TYPE:
770: case DC_STAG:
771: case DC_UTAG:
772: case DC_ETAG:
773: return;
774: }
775: }
776: if (dp->d_class == DC_LINE || dp->d_class == DC_LAB)
777: dp->d_ref = refnum;
778:
779: refnum += 1;
780: if (dbase == NULL)
781: dbase = dp;
782: if (dnext != NULL)
783: dnext->d_dp = dp;
784: dbrpt("enter", dp);
785: while (dp->d_dp != NULL) {
786: dp = dp->d_dp;
787: dbrpt("enter", dp);
788: }
789: dnext = dp;
790: if (dp->d_class == DC_FILE)
791: outbrace('{');
792: }
793:
794: /*
795: * Read a debug relocation item and patch current `dot'
796: * into the appropriate debug/symbol table item.
797: * If the debug item is '}' and level 2, then dump the batch of locals.
798: * If the debug item is '}' and level 1, then dump the type definitions.
799: */
800: getdloc()
801: {
802: register struct dbgt *dp;
803: register int ref;
804:
805: ref = iget();
806: for (dp = dbase; ; dp = dp->d_dp) {
807: if (dp == NULL)
808: cbotch("getdloc: %d", ref);
809: if ((dp->d_flag&D_GBL) != 0)
810: continue;
811: if (dp->d_ref == ref)
812: break;
813: }
814: dp->d_seg = segindex[dotseg];
815: dp->d_value = dot;
816:
817: dbrpt("reloc", dp);
818: if (dp->d_data[0] == '}' && dp->d_level <= 2) {
819: outbrace('}');
820: level--;
821: dump();
822: }
823: }
824:
825: /*
826: * Dump the locals and type definitions
827: */
828:
829: dump()
830: {
831: register struct dbgt *dp, **dpp;
832: int saveseg;
833:
834: if ((saveseg = dotseg) != SDBG)
835: oenter(SDBG);
836: dpp = &dbase;
837: dnext = NULL;
838: while ((dp = *dpp) != NULL) {
839: if ((dp->d_flag&D_LCL) != 0) {
840: dbrpt("write", dp);
841: osymbol(dp, -1);
842: dp->d_flag &= ~D_LCL;
843: }
844: if ((dp->d_flag&D_GBL) == 0) {
845: dbrpt("free", dp);
846: *dpp = dp->d_dp;
847: free(dp);
848: } else {
849: dbrpt("save", dp);
850: dnext = dp;
851: dpp = &dp->d_dp;
852: }
853: }
854: if (saveseg != SDBG)
855: oenter(saveseg);
856: }
857:
858: /*
859: * Write out global symbol definitions and references.
860: */
861: oglobals()
862: {
863: register struct dbgt *dp, *dp1;
864: extern int refnum;
865:
866: oenter(SSYM);
867: for (dp = dbase; dp != NULL; dp = dp1) {
868: dp1 = dp->d_dp;
869: dbrpt("write", dp);
870: if (dp->d_seg == TYPESYM || dp->d_seg == ABSLUTE)
871: osymbol(dp, refnum++);
872: else
873: osymbol(dp, dp->d_ref);
874: dbrpt("free", dp);
875: free(dp);
876: }
877: notenuf();
878: }
879:
880: /*
881: * Write out a symbol to the symbol or debug table.
882: * Debug table symbols have negative refnums,
883: * and may require relocation.
884: */
885: osymbol(dp, refnum)
886: register struct dbgt *dp;
887: {
888: register char *cp;
889: unsigned char segtype;
890: uaddr_t segaddr;
891: int nd, nr;
892:
893: /* Write scope/refnum or seg/value+relocation expression */
894: nd = 5 + dp->d_size;
895: nr = 0;
896: if (refnum >= 0) {
897: if (dp->d_seg == ABSLUTE) {
898: segtype = MDSCOPE;
899: nd += 5;
900: } else if (dp->d_seg != LASTSEG) {
901: segtype = LDSCOPE;
902: nd += 5;
903: } else
904: segtype = RFSCOPE;
905: segaddr = refnum;
906: } else {
907: segtype = dp->d_seg;
908: segaddr = dp->d_value;
909: if (segtype < SUMMARY
910: && segtype != TYPESYM
911: && segtype != ABSLUTE)
912: nr = 6;
913: }
914: enuf(nd, nr);
915: bbuf(segtype);
916: if (nr != 0) {
917: rbbuf(B_2301);
918: rbbuf(dp->d_seg);
919: rlbuf((long) dot);
920: }
921: lbuf(segaddr);
922:
923: /* Write name */
924: cp = dp->d_data;
925: nd = dp->d_size;
926: do {
927: bbuf(*cp);
928: nd -= 1;
929: } while (*cp++);
930:
931: /* Write seg/value expression */
932: if (refnum >= 0 && (segtype == MDSCOPE || segtype == LDSCOPE)) {
933: bbuf(dp->d_seg);
934: lbuf((long) dp->d_value);
935: }
936:
937: /* Type */
938: while (--nd >= 0)
939: bbuf(*cp++);
940: }
941:
942: /*
943: * Read in debug items translating into loader type syntax.
944: * Member definitions are fetched recursively.
945: * If a tag or type definition, the member definitions are appended to the
946: * node surrounded by "{" and "}" nodes.
947: * If not a tag definition, the member definitions are discarded.
948: * In either case, the member types are appended to the type of the
949: * parent node.
950: */
951: #define DSZ 512
952: struct dbgt *
953: getdbgt()
954: {
955: register int n;
956: register char *dptr;
957: struct dbgt d;
958: char data[DSZ];
959: int value, width, offs;
960: int typet, subt, membs;
961: char *sdp;
962:
963: d.d_dp = NULL;
964: d.d_ref = -1;
965: d.d_flag = D_LCL;
966: d.d_level = level;
967: d.d_seg = LASTSEG;
968: d.d_value = 0;
969: d.d_size = 0;
970: width = membs = 0;
971:
972: /*
973: * Loop to read entire record:
974: * class, optional value, name, type.
975: */
976: dptr = data;
977: for (typet = 0; ; typet += 1) {
978:
979: if (dptr >= data+DSZ) {
980: dbrpt("1", &d);
981: cbotch("getdbgt buffer");
982: }
983:
984: n = bget();
985: if (n < DX_MEMBS)
986: value = iget() * NBPBYTE;
987: else if (n < DC_SEX)
988: ;
989: else {
990: dline = iget();
991: if (n < DC_AUTO)
992: ;
993: else if (n < DC_MOS)
994: value = iget();
995: else {
996: width = bget();
997: offs = bget();
998: value = iget();
999: }
1000: }
1001: subt = 0;
1002:
1003: switch (n) {
1004:
1005: /*
1006: * Classes: fetch values and set flags.
1007: */
1008: case DC_SEX:
1009: d.d_flag |= D_NAM;
1010: goto setclass;
1011:
1012: case DC_GDEF:
1013: case DC_GREF:
1014: d.d_flag = D_GBL|D_NAM;
1015: goto setclass;
1016:
1017: case DC_ETAG:
1018: d.d_flag |= D_ENU;
1019: strcpy(dptr, "enum ");
1020: dptr += 5;
1021: goto tag;
1022: case DC_STAG:
1023: strcpy(dptr, "struct ");
1024: dptr += 7;
1025: goto tag;
1026: case DC_UTAG:
1027: strcpy(dptr, "union ");
1028: dptr += 6;
1029: case DC_TYPE:
1030: tag:
1031: d.d_flag = (level == 0) ? D_TAG|D_GBL : D_TAG|D_LCL;
1032: d.d_seg = TYPESYM;
1033: goto setclass;
1034:
1035: case DC_FILE:
1036: d.d_seg = PURCODE;
1037: goto setclass;
1038:
1039: case DC_AUTO:
1040: d.d_seg = L_STACK;
1041: d.d_value = value;
1042: goto setclass;
1043:
1044: case DC_SIN:
1045: d.d_flag |= D_LAB;
1046: goto setclass;
1047:
1048: case DC_REG:
1049: d.d_seg = L_REG;
1050: d.d_value = value;
1051: goto setclass;
1052:
1053: case DC_PREG:
1054: if (level == 0) {
1055: level++;
1056: outbrace('{');
1057: }
1058: d.d_seg = L_REG;
1059: d.d_value = value;
1060: goto setclass;
1061:
1062: case DC_MOE:
1063: d.d_seg = ABSLUTE;
1064: d.d_value = value;
1065: goto setclass;
1066:
1067: case DC_PAUTO:
1068: if (level == 0) {
1069: level++;
1070: outbrace('{');
1071: }
1072: d.d_seg = P_STACK;
1073: d.d_value = value;
1074: goto setclass;
1075:
1076: case DC_LAB:
1077: case DC_LINE:
1078: goto setclass;
1079:
1080: case DC_MOS:
1081: case DC_MOU:
1082: d.d_seg = FLD_OFF;
1083: d.d_value = value * NBPBYTE + offs;
1084: goto setclass;
1085:
1086: /*
1087: * Set the class field, read the name;
1088: * Lookup globals and statics.
1089: */
1090: setclass:
1091: d.d_class = n;
1092: while (*dptr++ = bget())
1093: ;
1094: if ((d.d_flag&(D_NAM|D_LAB)) != 0) {
1095: register SYM *sp;
1096:
1097: if ((d.d_flag&D_NAM) != 0)
1098: sp = glookup(data, 0);
1099: else
1100: sp = llookup(value, 0);
1101: if ((sp->s_flag&S_DEF) != 0) {
1102: d.d_seg = segindex[sp->s_seg];
1103: d.d_value = sp->s_value;
1104: #if COMMON
1105: } else if (sp->s_value != 0) {
1106: d.d_seg = BLDATA|Cb;
1107: d.d_value = sp->s_value;
1108: #endif
1109: }
1110: if ((d.d_flag&D_GBL) != 0)
1111: d.d_ref = sp->s_ref;
1112: }
1113: continue;
1114:
1115: /*
1116: * Types: write type and prepare for trailing data.
1117: * For files and lines, write a phony type.
1118: */
1119: case DT_NONE:
1120: if (d.d_class == DC_FILE) {
1121: register char *p;
1122:
1123: *dptr++ = STRINGt;
1124: p = "source file";
1125: while (*dptr++ = *p++)
1126: ;
1127: }
1128: if (d.d_class == DC_LINE) {
1129: *dptr++ = 6; /* Line */
1130: *dptr++ = dline;
1131: *dptr++ = dline >> 8;
1132: *dptr++ = 0; /* Column */
1133: *dptr++ = 0; /* Flag */
1134: *dptr++ = 0; /* Saved instruction */
1135: *dptr++ = 0;
1136: }
1137: break;
1138:
1139: case DT_CHAR:
1140: case DT_SHORT:
1141: case DT_INT:
1142: case DT_LONG:
1143: n = Integer;
1144: goto getwidth;
1145:
1146: case DT_UCHAR:
1147: case DT_USHORT:
1148: case DT_UINT:
1149: case DT_ULONG:
1150: n = Natural;
1151: goto getwidth;
1152:
1153: case DT_FLOAT:
1154: case DT_DOUBLE:
1155: n = Rational;
1156: goto settype;
1157:
1158: case DT_VOID:
1159: n = Void;
1160: goto settype;
1161:
1162: case DT_STRUCT:
1163: membs = n;
1164: n = Record;
1165: sdp = dptr;
1166: goto settype;
1167:
1168: case DT_UNION:
1169: membs = n;
1170: n = Union;
1171: sdp = dptr;
1172: goto settype;
1173:
1174: case DT_ENUM:
1175: d.d_flag |= D_ENU;
1176: membs = n;
1177: n = Natural;
1178: sdp = dptr;
1179: goto settype;
1180:
1181: getwidth:
1182: if (width)
1183: value = width;
1184:
1185: settype:
1186: *dptr++ = 1;
1187: *dptr++ = n;
1188: if (n != Void) {
1189: if (value == 0)
1190: *dptr++ = ANYt;
1191: else if (value <= 0377) {
1192: *dptr++ = 1;
1193: *dptr++ = value;
1194: } else {
1195: *dptr++ = 2;
1196: *dptr++ = value;
1197: *dptr++ = value >> 8;
1198: }
1199: }
1200: if (subt) {
1201: *dptr++ = TYPEt;
1202: continue;
1203: }
1204: if (membs) {
1205: --typet;
1206: continue;
1207: }
1208: break;
1209:
1210: /*
1211: * Dimensions: as for types, but flag for subtypes.
1212: */
1213: case DD_PTR:
1214: n = Pointer;
1215: ++subt;
1216: goto settype;
1217:
1218: case DD_FUNC:
1219: n = Proc;
1220: ++subt;
1221: goto settype;
1222:
1223: case DD_ARRAY:
1224: n = Array;
1225: ++subt;
1226: goto settype;
1227:
1228: /*
1229: * Trailing struct/union/enum data.
1230: */
1231: case DX_NAME:
1232: dptr = sdp;
1233: *dptr++ = STRINGt;
1234: switch (membs) {
1235: case DT_STRUCT:
1236: strcpy(dptr, "struct ");
1237: dptr += 7;
1238: break;
1239: case DT_UNION:
1240: strcpy(dptr, "union ");
1241: dptr += 6;
1242: break;
1243: case DT_ENUM:
1244: strcpy(dptr, "enum ");
1245: dptr += 5;
1246: }
1247: while (*dptr++ = bget())
1248: ;
1249: membs = 0;
1250: break;
1251:
1252: case DX_MEMBS:
1253: level += 1;
1254: dptr = getmembs(&d, data, dptr);
1255: level -= 1;
1256: membs = 0;
1257: break;
1258:
1259: default:
1260: cbotch("getdbgt: %d", n);
1261: }
1262: /*
1263: * Terminate types.
1264: */
1265: if (dptr + typet >= data + DSZ) {
1266: dbrpt("2", &d);
1267: cbotch("getdbgt buffer");
1268: }
1269: while (--typet >= 0)
1270: *dptr++ = 0;
1271: break;
1272: }
1273:
1274: /*
1275: * Check level change.
1276: */
1277: if (data[0] == '{') {
1278: if (level++ == 0) {
1279: d.d_level = level++;
1280: outbrace('{');
1281: }
1282: }
1283: else if (data[0] == '}')
1284: level -= 1;
1285:
1286: /*
1287: * Copy into dynamic storage.
1288: */
1289: d.d_size = dptr - data;
1290: return (newdbgt(&d, data));
1291: }
1292:
1293: /*
1294: * Read a list of members of a union/struct/enum.
1295: * If struct/union, append member types to caller's buffer.
1296: * If making a debug table:
1297: * If struct/union tag definition, bracket member definitions.
1298: * If enum tag, make member type into "enum tag".
1299: */
1300: char *
1301: getmembs(dp0, bb, bp)
1302: struct dbgt *dp0;
1303: char *bb;
1304: register char *bp;
1305: {
1306: int nmembs, n, istag, isenu, isgbl, isdbg;
1307: char *sbp;
1308: register struct dbgt *dp;
1309: struct dbgt **dpp;
1310: register char *p;
1311: static struct dbgt dbrace = {
1312: NULL, /* d_dp */
1313: -1, /* d_ref */
1314: DT_NONE, /* d_class */
1315: D_LCL, /* d_flag */
1316: 0, /* d_level */
1317: TYPESYM, /* d_seg */
1318: 0, /* d_value */
1319: 3 /* d_size */
1320: };
1321:
1322: dp = dp0;
1323: nmembs = bget();
1324: istag = (dp->d_flag&D_TAG) != 0;
1325: isenu = (dp->d_flag&D_ENU) != 0;
1326: isgbl = (dp->d_flag&D_GBL) != 0;
1327: isdbg = (isvariant(VDSYMB) && isvariant(VTYPES)) != 0;
1328: if (isenu) {
1329: sbp = bp;
1330: isenu = strlen(bb) + 1 + 1;
1331: }
1332: if ( ! isenu) {
1333: *bp++ = 1;
1334: *bp++ = nmembs;
1335: }
1336: dpp = &dp->d_dp;
1337: if (istag && isdbg && ! isenu) {
1338: dp = *dpp = newdbgt(&dbrace, "{\0\0");
1339: if (isgbl)
1340: dp->d_flag ^= D_GBL|D_LCL;
1341: dpp = &dp->d_dp;
1342: }
1343: while (--nmembs >= 0) {
1344: dp = *dpp = getdbgt();
1345: if (isgbl)
1346: dp->d_flag ^= D_GBL|D_LCL;
1347: n = dp->d_size;
1348: p = dp->d_data;
1349: if (isenu && istag && isdbg) {
1350: dp->d_size += isenu;
1351: dp = newdbgt(dp, dp->d_data);
1352: bp = dp->d_data;
1353: while (*bp++)
1354: ;
1355: *bp++ = STRINGt;
1356: p = bb;
1357: while (*bp++ = *p++)
1358: ;
1359: *bp++ = 0;
1360: free(*dpp);
1361: *dpp = dp;
1362: bp = sbp;
1363: }
1364: if ( ! isenu) {
1365: do {
1366: --n;
1367: } while (*p++);
1368: *bp++ = TYPEt;
1369: if (bp + n >= bb + DSZ) {
1370: dbrpt("3", dp);
1371: cbotch("getdbgt buffer");
1372: }
1373: do {
1374: *bp++ = *p++;
1375: } while (--n > 0);
1376: }
1377: if (istag && isdbg)
1378: dpp = &dp->d_dp;
1379: else
1380: free(*dpp);
1381: }
1382: if (istag && isdbg && ! isenu) {
1383: dp = *dpp = newdbgt(&dbrace, "}\0\0");
1384: if (isgbl)
1385: dp->d_flag ^= D_GBL|D_LCL;
1386: dpp = &dp->d_dp;
1387: }
1388: *dpp = NULL;
1389: return (bp);
1390: }
1391:
1392: /*
1393: * Output a debug brace
1394: */
1395: outbrace(c)
1396: char c;
1397: {
1398: struct dbgt *dp;
1399:
1400: if ((dp = (struct dbgt *)calloc(1, sizeof(struct dbgt) + 10)) == NULL)
1401: cnomem("outbrace");
1402: dp->d_class = DC_LINE;
1403: dp->d_flag = D_LCL;
1404: dp->d_seg = segindex[SCODE];
1405: dp->d_value = ( dotseg == SCODE ? dot : seg[SCODE].s_dot);
1406: dp->d_size = 10;
1407: dp->d_data[0] = c;
1408: *(dp->d_data + 2) = 6;
1409: *(dp->d_data + 3) = dline;
1410: *(dp->d_data + 4) = dline >> 8;
1411: if (dnext != NULL)
1412: dnext->d_dp = dp;
1413: dnext = dp;
1414: }
1415:
1416: struct dbgt *
1417: newdbgt(dp, cp)
1418: struct dbgt *dp;
1419: register char *cp;
1420: {
1421: register struct dbgt *ndp;
1422: register char *ncp;
1423: register int n;
1424:
1425: n = dp->d_size;
1426: if ((ndp = (struct dbgt *)malloc(sizeof(struct dbgt) + n)) == NULL)
1427: cnomem("newdbgt");
1428: *ndp = *dp;
1429: for (ncp = ndp->d_data; --n >= 0; *ncp++ = *cp++)
1430: ;
1431: return (ndp);
1432: }
1433:
1434: #if !TINY
1435: _dbrpt(p, dp)
1436: char *p;
1437: register struct dbgt *dp;
1438: {
1439: if (xflag > 5) {
1440: printf("%5s: %-10s %2x %2d %2x %2x %2x %04x %2x\n",
1441: p,
1442: dp->d_data,
1443: dp->d_class,
1444: dp->d_ref,
1445: dp->d_flag,
1446: dp->d_level,
1447: dp->d_seg,
1448: dp->d_value,
1449: dp->d_size
1450: );
1451: }
1452: }
1453:
1454: dbtyp(dp)
1455: struct dbgt *dp;
1456: {
1457: register int n;
1458: register char *p;
1459:
1460: if (xflag > 20) {
1461: n = dp->d_size;
1462: p = dp->d_data;
1463: do {
1464: --n;
1465: putchar(*p);
1466: } while (*p++);
1467: while (--n >= 0) {
1468: if (*p == STRINGt) {
1469: putchar(' ');
1470: putchar('"');
1471: ++p;
1472: do {
1473: --n;
1474: } while (putchar(*p++));
1475: putchar('"');
1476: continue;
1477: } else if (*p == TYPEt)
1478: printf(" TYPEt");
1479: else if (*p == ANYt)
1480: printf(" ANYt");
1481: else
1482: printf(" %o", *p&0377);
1483: ++p;
1484: }
1485: putchar('\n');
1486: }
1487: }
1488: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.