![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to out286.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 / c / n2 / i8086|
Return to out286.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / c / n2 / i8086 |
1.1 root 1: /*
2: * This file contains an output writer for Intel iAPX-80286 OMF.
3: * Some of this code is from the i8086 OMF output writer.
4: *
5: * References: "The Concrete Representation of 80286
6: * Object Module Formats," Rev. 1.91 (c) Intel 1983.
7: * "Type Definition Records for High Level Languages,"
8: * Version 2.0, 6/25/84, #114834 (Intel proprietary).
9: *
10: * During code assembly, the 'out...' routines write to a temporary file.
11: * At the end of assembly, 'copycode' writes the object file
12: * using the 'write...' routines.
13: * The 'put...' routines copy bits to the object file.
14: * The object file contains a single linkable module
15: * which in turn contains a single partition.
16: * It may include SEGDEF, TYPDEF, PUBDEF, EXTDEF and TXTFIX sections.
17: * The section lengths and locations in the table of contents
18: * and the segment attributes and lengths in the SEGDEF section
19: * are initially 0; 'fixoutput' seeks back in the output file
20: * (or copies it back, in the case of the VAX version)
21: * and patches them with the correct values.
22: */
23:
24: #ifdef vax
25: #include "INC$LIB:cc2.h"
26: #include <time.h>
27: #else
28: #include "cc2.h"
29: #endif
30: #ifdef COHERENT
31: #include <time.h>
32: #include <sys/timeb.h>
33: #endif
34: #ifdef UDI
35: #include <udi.h>
36: #endif
37: #ifndef __LINE__
38: #define __LINE__ 0
39: #endif
40: #if !TINY
41: #define dbrpt(x,y) _dbrpt(x,y)
42: #else
43: #define dbrpt(x,y) /* _dbrpt(x,y) */
44: #endif
45:
46: /*
47: * As of 4/29/85, PSCOPE does not support unnamed blocks correctly.
48: * The output writer therefore suppresses unnamed blocks #ifdef NOABLOCKS.
49: */
50: #if INTEL
51: #define NOABLOCKS 1
52: int blkcount;
53: #endif
54:
55: #define NTXT 256 /* Text buffer size */
56: #define NFIX 256 /* Fixup buffer size */
57:
58: /*
59: * Scratch file opcodes.
60: */
61: #define TTYPE 0x0F /* Type */
62: #define TPCR 0x10 /* PC rel flag, ored in */
63: #define TSYM 0x20 /* Symbol based flag, ored in */
64: #define TEND 0 /* End marker */
65: #define TENTER 1 /* Enter new area */
66: #define TBYTE 2 /* Byte data */
67: #define TWORD 3 /* Word data */
68: #define TCODE 4 /* Code segment base */
69: #define TDATA 5 /* Data segment base */
70: #define TBASE 6 /* External segment base */
71: #define TDLAB 7 /* Debug label */
72: #define TDLOC 8 /* Debug location */
73:
74: /*
75: * Sections, in the order of the table of contents.
76: */
77: #define NSECS 6 /* Number of sections */
78: #define SEGSEC 0 /* SEGDEF section */
79: #define GATSEC 1 /* GATDEF section */
80: #define TYPSEC 2 /* TYPDEF section */
81: #define PUBSEC 3 /* PUBDEF section */
82: #define EXTSEC 4 /* EXTDEF section */
83: #define TXTSEC 5 /* TXTFIX section */
84:
85: /*
86: * Segment indices, in the order of 'writesegdef'.
87: */
88: #define NSEGS 6 /* Number of segments if DEBUG */
89: #define CODESEG 1 /* CODE */
90: #define DATASEG 2 /* DATA */
91: #define STKSEG 3 /* STACK */
92: #define MODSEG 4 /* MODULES: */
93: #define SYMSEG 5 /* SYMBOLS: */
94: #define LINESEG 6 /* LINES: */
95:
96: /*
97: * 80286 OMF bits.
98: */
99: #define TID 6 /* C-286 translator id */
100: #define SEGIN (1<<13) /* Segment internal name field */
101: #define EXTIN (3<<13) /* External symbol int name field */
102: #define BTEXT 0 /* TXTFIX text block */
103: #define BFIXUP 1 /* TXTFIX fixup block */
104: #define BITEXT 2 /* TXTFIX iterated text block */
105: #define FORMSEL (0<<2) /* Fixup format selector only */
106: #define FORMOFF (1<<2) /* Fixup format offset only */
107: #define FORMSRO (2<<2) /* Fixup format self-relative offset */
108: #define FORMFVA (3<<2) /* Fixup format full virtual addr */
109: #define FIXGEN 0 /* Fixup type general */
110: #define FIXISEG 1 /* Fixup type intrasegment */
111: #define FIXCALL 2 /* Fixup type call */
112: #define SYMBBEG 0 /* SYMBOLS block start */
113: #define SYMPBEG 1 /* SYMBOLS procedure start */
114: #define SYMBEND 2 /* SYMBOLS block end */
115: #define SYMBASE 3 /* SYMBOLS base */
116: #define SYMBPRB 4 /* SYMBOLS BP-relative base */
117: #define SYMSYMB 5 /* SYMBOLS symbol */
118: #define SEGARO (0<<13) /* SEGDEF access readonly */
119: #define SEGARW (1<<13) /* SEGDEF access read-write */
120: #define SEGAXR (3<<13) /* SEGDEF access execute-read */
121: #define SEGDPL (3<<11) /* SEGDEF DPL */
122: #define SEGEXT (1<<6) /* SEGDEF external */
123: #define SEGNOC 0 /* SEGDEF combine type no-combine */
124: #define SEGCOM 1 /* SEGDEF combine type normal */
125: #define SEGSTK 2 /* SEGDEF combine type stack */
126: #define SEGDEB 6 /* SEGDEF combine type debug */
127:
128: /*
129: * Type representation constants for i80286 TYPDEF records.
130: * Some differ from the corresponding i8086 OMF constants.
131: */
132: #if INTEL
133: /* Intel proprietary. */
134: #define OTSFUNC 0x63 /* SHORT$NOPOP */
135: #define OTLFUNC 0x64 /* LONG$NOPOP */
136: #define OTUPACK 0x69 /* UNPACKED */
137: #define OTLABEL 0x72 /* LABEL */
138: #define OTLONG 0x73 /* LONG */
139: #define OTSHORT 0x74 /* SHORT */
140: #define OTPROC 0x75 /* PROCEDURE */
141: #define OTPARA 0x76 /* PARAMETER */
142: #define OTARRAY 0x78 /* ARRAY */
143: #define OTSTRUC 0x79 /* STRUCTURE */
144: #define OTPOINT 0x7A /* POINTER */
145: #define OTSCAL 0x7B /* SCALAR */
146: #define OTUINT 0x7C /* UNSINT */
147: #define OTSINT 0x7D /* SGNINT */
148: #define OTREAL 0x7E /* REAL */
149: #define OTLIST 0x7F /* LIST */
150: #endif
151: #define OTNIL 0x80 /* NIL */
152: #define OTNAME 0x82 /* Name leaf */
153: #define OTINDEX 0x83 /* Index leaf */
154: #define OTUNUM2 0x85 /* Unsigned numeric 2 byte leaf */
155: #define OTUNUM4 0x86 /* Unsigned numeric 4 byte leaf */
156:
157: /*
158: * Length and OMF type of scalar C types.
159: * The order corresponds to the order of DT_ types in ops.h.
160: */
161: #if INTEL
162: static char ntypes [DT_DOUBLE+1][2] = {
163: { 0x00, OTNIL }, /* DT_NONE */
164: { 0x08, OTSINT }, /* DT_CHAR */
165: { 0x08, OTUINT }, /* DT_UCHAR */
166: { 0x10, OTSINT }, /* DT_SHORT */
167: { 0x10, OTUINT }, /* DT_USHORT */
168: { 0x10, OTSINT }, /* DT_INT */
169: { 0x10, OTUINT }, /* DT_UINT */
170: { 0x20, OTSINT }, /* DT_LONG */
171: { 0x20, OTUINT }, /* DT_ULONG */
172: { 0x20, OTREAL }, /* DT_FLOAT */
173: { 0x40, OTREAL } /* DT_DOUBLE */
174: };
175: #endif
176:
177: /*
178: * The compiler generates a linked list of TINFO records
179: * containing OMF type definitions while reading DLABEL records.
180: * The type index corresponds to the position in the TINFO list.
181: * The tflag keeps track of whether a forward reference
182: * tagname type ever gets resolved.
183: */
184: typedef struct typeinfo {
185: struct typeinfo *t_tp; /* link */
186: char t_tflag; /* tag name flag */
187: int t_length; /* length */
188: char t_info[]; /* info */
189: } TINFO;
190:
191: /*
192: * To generate correct references to tagged types, the compiler
193: * enters the tag name as a type and refers to the type by tag name.
194: * When the compiler dumps the types, it consults the patch list
195: * and substitutes the tag definition for the tag name.
196: */
197: typedef struct typefix {
198: struct typefix *t_tp; /* Link */
199: int t_ttype; /* Dummy definition */
200: int t_type; /* Fixed definition */
201: } TYFIX;
202:
203: /*
204: * Structure to contain debug items on this pass.
205: */
206: struct dbgt {
207: struct dbgt *d_dp; /* Link */
208: int d_ref; /* Index number */
209: unsigned char d_class; /* Storage class */
210: unsigned char d_flag; /* Flags */
211: unsigned char d_level; /* Bracket level */
212: unsigned char d_seg; /* Segment */
213: ADDRESS d_value; /* Offset in segment */
214: int d_type; /* Type index */
215: int d_line; /* Line number */
216: char d_id[]; /* Name */
217: };
218:
219: /*
220: * Globals.
221: */
222: static int checksum; /* For putbyte */
223: static int lastline; /* Last line number */
224: static long lastsize; /* Last number size */
225: static int txtseg; /* Current text segment */
226: static unsigned char txt[NTXT]; /* Text buffer */
227: static unsigned char *txtp = txt; /* Text pointer */
228: static int fixseg; /* Current fixup segment */
229: static unsigned char fix[NFIX]; /* Fixup buffer */
230: static unsigned char *fixp = fix; /* Fixup pointer */
231: static unsigned char *ofixp = NULL; /* Previous fixup pointer for fva kludge */
232: static int symbase; /* Symbol base, -1 for BP-rel */
233: static ADDRESS seg_size; /* Size of segment thus far */
234: static ADDRESS bss_size; /* Size of BSS */
235: static ADDRESS seglen[NSEGS+1]; /* Segment text length */
236: static long secloc[NSECS]; /* Section locations */
237: static long seclen[NSECS]; /* Section lengths */
238: static long oflength; /* Output file length */
239: static int nsegs; /* Number of SEGDEFs */
240: static int npubs; /* Number of PUBDEFs */
241: static int nexts; /* Number of EXTDEFs */
242: static TINFO *typelistp; /* Typdef list */
243: static TYFIX *typefixp; /* Type fix list */
244: static SYM *curfsp; /* Current function sp */
245: static int curfna; /* Current function nargs */
246: static int curfar[NARGS]; /* Current function arg types */
247: static struct dbgt *dbase; /* First debug table entry */
248: static struct dbgt *dnext; /* Last debug table entry */
249:
250: /*
251: * Object file offsets.
252: * Used by fixoutput() to fix information in output file.
253: */
254: static long mhdseek; /* Module header offset */
255: static long tocseek; /* Table of contents offset */
256: static long segseek[NSEGS+1]; /* SEGDEF attribute byte offsets */
257: static long lenseek; /* SYMBOLS module length offset */
258:
259: /*
260: * Functions.
261: */
262: extern struct dbgt *getdbgt();
263: extern TINFO *gettype();
264: extern long putsegdef();
265: extern char *setindex();
266: extern char *setname();
267: extern char *setnumb();
268: extern char *setsize();
269: extern char *setsymid();
270:
271: #if VAXFMT
272: /*
273: * The Intel cross software packs the OMF data into 512 byte blocks
274: * as 510 byte variable length records, with the last record short.
275: */
276: #define NVDATA 510 /* Blocksize - 2 */
277: static char vaxbuf[NVDATA]; /* Buffer */
278: static char *vaxptr = vaxbuf; /* Pointer */
279: extern int filo;
280: extern char *wfn[];
281: extern char ofn[];
282: extern int trace();
283: #endif
284:
285: /*
286: * Routine 'segindex' uses the following tables
287: * to find the OMF segment index corresponding
288: * to a given compiler internal segment name.
289: * The tables understand the ROM and RAM options.
290: * SMALL model always uses ramseg[] (because the compiler assumes
291: * SMALL model SPURE, SSTRN, SDATA and SBSS references to be DS-relative).
292: */
293: static char nonseg[] = {
294: CODESEG, /* SCODE => CODE */
295: CODESEG, /* SLINK => CODE */
296: CODESEG, /* SPURE => CODE */
297: DATASEG, /* SSTRN => DATA */
298: DATASEG, /* SDATA => DATA */
299: DATASEG /* SBSS => DATA */
300: };
301: static char romseg[] = {
302: CODESEG, /* SCODE => CODE */
303: CODESEG, /* SLINK => CODE */
304: CODESEG, /* SPURE => CODE */
305: CODESEG, /* SSTRN => CODE */
306: DATASEG, /* SDATA => DATA */
307: DATASEG /* SDATA => DATA */
308: };
309: static char ramseg[] = {
310: CODESEG, /* SCODE => CODE */
311: CODESEG, /* SLINK => CODE */
312: DATASEG, /* SPURE => DATA */
313: DATASEG, /* SSTRN => DATA */
314: DATASEG, /* SDATA => DATA */
315: DATASEG /* SDATA => DATA */
316: };
317:
318: /*
319: ** First pass routines.
320: ** Output items to the temporary file.
321: */
322:
323: /*
324: * Output a segment switch.
325: */
326: outseg(s)
327: {
328: bput(TENTER);
329: bput(s);
330: }
331:
332: /*
333: * Output an absolute byte.
334: */
335: outab(b)
336: {
337: bput(TBYTE);
338: bput(b);
339: ++dot;
340: }
341:
342: /*
343: * Output an absolute word.
344: */
345: outaw(w)
346: {
347: bput(TWORD);
348: iput(w);
349: dot += 2;
350: }
351:
352: /*
353: * Output a full byte.
354: */
355: outxb(sp, b, pcrf)
356: register SYM *sp;
357: {
358: register opcode;
359: opcode = TBYTE;
360: if (sp != NULL)
361: opcode |= TSYM;
362: if (pcrf)
363: opcode |= TPCR;
364: bput(opcode);
365: bput(b);
366: if (sp != NULL)
367: pput(sp);
368: ++dot;
369: }
370:
371: /*
372: * Output a full word.
373: */
374: outxw(sp, w, pcrf)
375: register SYM *sp;
376: {
377: register opcode;
378: opcode = TWORD;
379: if (sp != NULL)
380: opcode |= TSYM;
381: if (pcrf)
382: opcode |= TPCR;
383: bput(opcode);
384: iput(w);
385: if (sp != NULL)
386: pput(sp);
387: dot += 2;
388: }
389:
390: #if 0
391: /*
392: * Because the compiler now generates LARGE model code with links,
393: * the following routines are currently unused.
394: * They are retained for future reference.
395: */
396: /*
397: * Output a 1 word object containing
398: * the base address of the current code segment.
399: */
400: outcb()
401: {
402: bput(TCODE);
403: dot += 2;
404: }
405:
406: /*
407: * Output a 1 word object containing
408: * the base address of the current data segment.
409: */
410: outdb()
411: {
412: bput(TDATA);
413: dot += 2;
414: }
415: #endif
416:
417: /*
418: * Output a 1 word object containing
419: * the base address of the external symbol pointed to by 'sp'.
420: */
421: outsb(sp)
422: SYM *sp;
423: {
424: bput(TBASE);
425: pput(sp);
426: dot += 2;
427: }
428:
429: /*
430: * Initialize the code writer.
431: */
432: outinit()
433: {
434: register TINFO *tp;
435: #if MONOLITHIC
436: /* UNDONE: initialize all globals here */
437: txtp = &txt[0];
438: fixp = &fix[0];
439: #if VAXFMT
440: vaxptr = &vaxbuf[0];
441: #endif
442: #endif
443: /* Initialize type list to contain NIL type as type 1. */
444: typelistp = tp = (TINFO *)malloc(sizeof(TINFO)+1);
445: typefixp = tp->t_tp = NULL;
446: tp->t_tflag = 0;
447: tp->t_length = 1;
448: tp->t_info[0] = OTNIL;
449: }
450:
451: /*
452: * Finish up the code.
453: * If writing binary code, put out a TEND item
454: * to tell 'copycode' when to stop.
455: */
456: outdone()
457: {
458: if (notvariant(VASM))
459: bput(TEND);
460: }
461:
462: /*
463: * Read a dlabel record from ifp.
464: * If l(evel) == 0, then only the DLABEL and class bytes have been read.
465: * For GDEF's and SEX's in SCODE, save the symbol pointer, accumulate the
466: * argument list types, and back patch the type appropriately.
467: * For everything else at level zero, translate the compiler type
468: * to OMF type and write a truncated record to the scratch file.
469: */
470: outdlab(l, class)
471: {
472: register int value;
473: register int nline;
474: register SYM *sp;
475: register int type;
476: register int seg;
477: register int ttype;
478:
479: /* Get line number */
480: nline = iget();
481:
482: if (l != 0)
483: dbfatal(__LINE__);
484: value = 0;
485: seg = dotseg;
486: /* Get value */
487: if (class < DC_AUTO)
488: ;
489: else if (class < DC_MOS)
490: value = iget();
491: else
492: dbfatal(__LINE__);
493:
494: /* Get name */
495: sget(id, NCSYMB);
496:
497: /* Check for symbol table entry */
498: sp = NULL;
499: if (class==DC_GDEF || class==DC_SEX || class==DC_GREF) {
500: sp = glookup(id, 0);
501: } else {
502: /* Make all c names the same, hopefully */
503: }
504: if (sp != NULL) {
505: seg = sp->s_seg;
506: value = sp->s_value;
507: }
508: /* Check for tag definition */
509: if (class==DC_ETAG
510: || class==DC_STAG
511: || class==DC_UTAG)
512: ttype = tlookup(id, strlen(id)+1);
513: else
514: ttype = 0;
515:
516: /* Write part of truncated record */
517: bput(TDLAB);
518: bput(class);
519: iput(nline);
520: iput(value);
521: bput(seg);
522: sput(id);
523:
524: /* Get type and enter into table */
525: /* This will possibly overwrite id[], so it must come after glookup */
526: type = dbtmap(ttype);
527:
528: /* Write out truncated record */
529: iput(type);
530:
531: /* Store the type for pubdef and extdef records */
532: if (sp != NULL) {
533: sp->s_type = type;
534: /* Begin collecting parameter types */
535: if ((class == DC_GDEF || class == DC_SEX)
536: && sp->s_seg == SCODE) {
537: curfsp = sp;
538: curfna = 0;
539: }
540: }
541: /* Collect parameter types */
542: if (class == DC_PAUTO || class == DC_PREG)
543: curfar[curfna++] = type;
544: /* Dump the parameter list, tricky stuff. */
545: if (class == DC_LINE && id[0] == '{' && curfna >= 0) {
546: arglisttype();
547: curfna = -1;
548: }
549: /* Back patch tag definition */
550: if (ttype != 0)
551: tpatch(ttype, type);
552: }
553:
554: /*
555: * Enter a patch into the typefix list.
556: */
557: tpatch(ttype, type)
558: {
559: register TYFIX *tp;
560: tp = (TYFIX *) malloc(sizeof(*tp));
561: if (tp == NULL) dbmemory(__LINE__);
562: tp->t_ttype = ttype;
563: tp->t_type = type;
564: tp->t_tp = typefixp;
565: typefixp = tp;
566: }
567:
568: /*
569: * Return type index associated with type definition
570: * at infop of length len.
571: * Define a new TINFO item if necessary.
572: */
573: tlookup(infop, len)
574: register char *infop;
575: int len;
576: {
577: #if INTEL
578: register TINFO *tp, *lasttp;
579: register int i, index;
580: register char *cp1, *cp2;
581: tp = typelistp;
582: index = 1;
583: /* Search the TINFO list for the type. */
584: while (tp != NULL) {
585: if (tp->t_length == len) {
586: cp1 = infop;
587: cp2 = tp->t_info;
588: i = len;
589: while ((*cp1++ == *cp2++) && (--i > 0))
590: ;
591: if (i == 0)
592: return (index);
593: }
594: index++;
595: lasttp = tp;
596: tp = tp->t_tp;
597: }
598: /* Not found, add new type to TINFO list. */
599: if ((tp=(TINFO *)malloc(sizeof(TINFO)+len)) == NULL)
600: cnomem("tlookup");
601: tp->t_tp = NULL;
602: tp->t_tflag = 0;
603: tp->t_length = len;
604: cp1 = tp->t_info;
605: while (len--)
606: *cp1++ = *infop++;
607: /* outinit puts NIL type on the list, so it's never empty. */
608: lasttp->t_tp = tp;
609: return (index);
610: #else
611: return (1);
612: #endif
613: }
614:
615: /*
616: * Read the dimension/type/info list from input and return the type index.
617: * Store the size back through the pointer supplied.
618: * This routine is reentrant so it can map the types of structure members
619: * while mapping the structure definition.
620: */
621: dbtmap(ttype)
622: {
623: int type;
624: unsigned size;
625: register char *bp;
626: char bb[10];
627:
628: bp = bb;
629: type = bget();
630: size = iget();
631: switch (type) {
632: case DT_NONE:
633: #if INTEL
634: /* NIL */
635: *bp++ = OTNIL;
636: #endif
637: break;
638: case DT_CHAR:
639: case DT_UCHAR:
640: case DT_SHORT:
641: case DT_USHORT:
642: case DT_INT:
643: case DT_UINT:
644: case DT_LONG:
645: case DT_ULONG:
646: case DT_FLOAT:
647: case DT_DOUBLE:
648: #if INTEL
649: /* SCALAR length type */
650: *bp++ = OTSCAL;
651: bp = setsize(bp, (long)(ntypes[type][0]));
652: *bp++ = ntypes[type][1];
653: #endif
654: break;
655: case DT_VOID:
656: #if INTEL
657: *bp++ = OTNIL; /* undone */
658: #endif
659: break;
660: case DT_STRUCT:
661: case DT_UNION:
662: case DT_ENUM:
663: if (bget() == DX_NAME) {
664: lastsize = ((long)size) * NBPBYTE;
665: return (dbxname(ttype));
666: }
667: else if (type == DT_STRUCT)
668: return (dbxstruct(size, ttype));
669: else if (type == DT_UNION)
670: return (dbxunion(size, ttype));
671: else
672: return (dbxenum(size, ttype));
673: case DD_PTR:
674: #if INTEL
675: /* SCALAR length @pointer */
676: /* POINTER @type */
677: *bp++ = OTPOINT;
678: #endif
679: type = dbtmap(ttype);
680: #if INTEL
681: bp = setindex(bp, type);
682: type = tlookup(bb, bp-bb);
683: bp = bb;
684: *bp++ = OTSCAL;
685: bp = setsize(bp, isvariant(VLARGE) ? 0x20L : 0x10L);
686: bp = setindex(bp, type);
687: #endif
688: break;
689: case DD_FUNC:
690: #if INTEL
691: /* PROCEDURE NIL @type calltype count @plist */
692: /* arglisttype will fix the count and @plist later. */
693: *bp++ = OTPROC;
694: *bp++ = OTNIL;
695: #endif
696: type = dbtmap(ttype);
697: #if INTEL
698: bp = setindex(bp, type);
699: *bp++ = (isvariant(VLARGE)) ? OTLFUNC : OTSFUNC;
700: *bp++ = 0; /* Zero args, possibly corrected later */
701: #endif
702: break;
703: case DD_ARRAY:
704: type = dbtmap(ttype);
705: #if INTEL
706: /* ARRAY length @type */
707: *bp++ = OTARRAY;
708: bp = setsize(bp, ((long)size)*NBPBYTE);
709: bp = setindex(bp, type);
710: #endif
711: break;
712: default:
713: dbfatal(__LINE__);
714: }
715: return (tlookup(bb, bp-bb));
716: }
717:
718: /*
719: * Construct typdef for enum, struct, or union.
720: * DX_NAME records supply tag name of type which will be defined later.
721: * Tag references point to type consisting of the tag name;
722: * the type will be backpatched into a struct/union/enum typdef.
723: */
724: dbxname(ttype)
725: {
726: register char *bp;
727: register TINFO *tp;
728: register int i;
729: iget(); /* Dummy size */
730: bp = &id[0];
731: while (*bp++ = bget())
732: ;
733: i = tlookup(id, bp-id);
734: tp = gettype(i);
735: tp->t_tflag = 1;
736: return(i);
737: }
738:
739: dbxstruct(s, ttype)
740: unsigned s; /* Size of structure in bytes */
741: {
742: int nmemb; /* Number of members */
743: int i; /* Member counter */
744: unsigned bwid; /* Bit width of current field */
745: unsigned boff; /* Bit offset of current field */
746: unsigned valu; /* Byte offset of current member */
747: int type; /* Type index of current member */
748: #if INTEL
749: int size; /* Size of name field */
750: long offs; /* Bit offset computed from valu and boff */
751: long loffs; /* Bit offset computed from previous member */
752: int nname; /* Number of bytes required for name list */
753: int tlist; /* Type list index */
754: int nlist; /* Name list index */
755: struct slist {
756: struct slist *sl_sp;
757: int sl_type;
758: char sl_id[];
759: };
760: struct slist *sp1;
761: register struct slist *sp2;
762: char *lp;
763: register char *bp;
764: char bb[64];
765: #endif
766:
767: /* Struct member list */
768: #if INTEL
769: /* STRUCT length count @tlist @nlist name */
770: /* tLIST @type1 ... @typen */
771: /* nLIST name1 ... namen */
772: sp1 = NULL;
773: offs = loffs = 0;
774: nname = 0;
775: #endif
776: nmemb = iget(); /* Number of members */
777: /* Does not include filler fields */
778: /* Read in member descriptions */
779: for (i = nmemb; i > 0; i--) {
780: if (bget() != DC_MOS)
781: dbfatal(__LINE__);
782: iget(); /* forget line */
783: bwid = bget(); /* bit width */
784: boff = bget(); /* bit offset */
785: valu = iget(); /* byte offset */
786: sget(id, NCSYMB);
787: #if INTEL
788: /* Enter into list, possibly prefixing nil filler field */
789: offs = (long)valu * (long)NBPBYTE + boff;
790: if (offs != loffs) {
791: /* Add filler field with name "" so PSCOPE */
792: /* does not lose its place in the structure. */
793: nmemb++; /* Add a member */
794: nname += 2; /* Bytes required for nlist */
795: sp2 = (struct slist *)malloc(sizeof(*sp2)+1);
796: if (sp2 == NULL) dbmemory(__LINE__);
797: sp2->sl_type = dbfmap((int)(offs-loffs), DT_UINT);
798: sp2->sl_id[0] = 0;
799: sp2->sl_sp = sp1;
800: sp1 = sp2;
801: }
802: size = strlen(id)+2; /* OTNAME+count+length */
803: nname += size;
804: sp2 = (struct slist *)malloc(sizeof(*sp2)+size);
805: if (sp2 == NULL) dbmemory(__LINE__);
806: strcpy(sp2->sl_id, id);
807: #endif
808: /* Now get the type with its possible id field */
809: if (bwid != 0) {
810: /* Only fields have non-zero widths and offsets */
811: type = dbfmap(bwid, bget());
812: iget(); /* Subtype size */
813: lastsize = bwid;
814: } else {
815: /* Non field member, must lookup its width */
816: type = dbtmap(0);
817: }
818: #if INTEL
819: sp2->sl_type = type;
820: sp2->sl_sp = sp1;
821: sp1 = sp2;
822: loffs = offs + lastsize;
823: #endif
824: }
825: #if INTEL
826: /* Reverse member list */
827: sp2 = sp1;
828: sp1 = NULL;
829: while (sp2 != NULL) {
830: struct slist *tsp;
831:
832: tsp = sp2->sl_sp;
833: sp2->sl_sp = sp1;
834: sp1 = sp2;
835: sp2 = tsp;
836: }
837: /* Construct type list */
838: lp = bp = malloc(nmemb*3+1);
839: if (bp == NULL) dbmemory(__LINE__);
840: *bp++ = OTLIST;
841: sp2 = sp1;
842: for (i = 0; i < nmemb; i++) {
843: bp = setindex(bp, sp2->sl_type);
844: sp2 = sp2->sl_sp;
845: }
846: tlist = tlookup(lp, bp-lp);
847: free(lp);
848: /* Construct name list */
849: lp = bp = malloc(nname+1);
850: if (bp == NULL) dbmemory(__LINE__);
851: *bp++ = OTLIST;
852: sp2 = sp1;
853: for (i = 0; i < nmemb; i++) {
854: if (sp2==NULL) dbfatal(__LINE__);
855: bp = setname(bp, sp2->sl_id);
856: sp2 = sp2->sl_sp;
857: free(sp1);
858: sp1 = sp2;
859: }
860: nlist = tlookup(lp, bp-lp);
861: free(lp);
862: /* Construct the true type record */
863: bp = &bb[0];
864: *bp++ = OTSTRUC; /* STRUCT */
865: bp = setsize(bp, ((long)s)*NBPBYTE); /* length */
866: bp = setnumb(bp, (long)nmemb); /* count */
867: bp = setindex(bp, tlist); /* @tlist */
868: bp = setindex(bp, nlist); /* @nlist */
869: bp = setname(bp, (ttype)?gettype(ttype)->t_info:""); /* name */
870: return (tlookup(bb, bp-bb));
871: #else
872: return (1);
873: #endif
874: }
875:
876: /*
877: * Map a bitfield type.
878: * Should only have CHAR, UCHAR, sort of type.
879: */
880: dbfmap(bw, bt)
881: int bw; /* Bit width */
882: int bt; /* Base type */
883: {
884: #if INTEL
885: /* SCALAR length type */
886: char bb[4];
887: bb[0] = OTSCAL;
888: bb[1] = bw;
889: switch (bt) {
890: case DT_CHAR: case DT_SHORT: case DT_INT: case DT_LONG:
891: bb[2] = OTSINT;
892: break;
893: case DT_UCHAR: case DT_USHORT: case DT_UINT: case DT_ULONG:
894: bb[2] = OTUINT;
895: break;
896: default:
897: dbfatal(__LINE__);
898: }
899: return (tlookup(bb, 3));
900: #else
901: return (1);
902: #endif
903: }
904:
905: dbxunion(s, ttype)
906: unsigned s; /* Size of union in bytes */
907: {
908: int nmemb;
909: int i;
910: #if INTEL
911: char *lp;
912: register char *bp;
913: int namelen;
914: #endif
915: /* Union member list */
916: nmemb = iget(); /* Number of members in union */
917: #if INTEL
918: /* STRUCT length 0 NIL NIL name UNPACKED count NIL NIL
919: 1 @tlist1 @nlist1 ... 1 @tlistn @nlistn */
920: namelen = (ttype) ? strlen(gettype(ttype)->t_info) : 0;
921: lp = bp = malloc(17+7*nmemb+namelen);
922: if (bp == NULL) dbmemory(__LINE__);
923: *bp++ = OTSTRUC; /* STRUCT */
924: bp = setsize(bp, ((long)s)*NBPBYTE); /* length */
925: *bp++ = 0; /* Invariant records */
926: *bp++ = OTNIL; /* Invariant type list */
927: *bp++ = OTNIL; /* Invariant name list */
928: bp = setname(bp, (ttype)?gettype(ttype)->t_info:""); /* name */
929: *bp++ = OTUPACK; /* UNPACKED */
930: bp = setnumb(bp, (long)nmemb); /* count */
931: *bp++ = OTNIL; /* Selector field type */
932: *bp++ = OTNIL; /* Selector field name */
933: #endif
934: i = 1;
935: while (--nmemb >= 0) {
936: int type;
937: #if INTEL
938: int tlist;
939: int nlist;
940: char bb[50];
941: register char *tbp;
942: #endif
943:
944: if (bget() != DC_MOU) dbfatal(__LINE__);
945: iget(); /* forget line */
946: bget(); /* forget bit width */
947: bget(); /* forget bit offset */
948: iget(); /* forget byte offset */
949: sget(id, NCSYMB);
950: #if INTEL
951: /* Make name list item */
952: tbp = bb;
953: *tbp++ = OTLIST;
954: tbp = setname(tbp, id);
955: nlist = tlookup(bb, tbp-bb);
956: #endif
957: type = dbtmap(0);
958: #if INTEL
959: /* Make type list item */
960: tbp = bb;
961: *tbp++ = OTLIST;
962: tbp = setindex(tbp, type);
963: tlist = tlookup(bb, tbp-bb);
964: /* Append member items to typdef */
965: *bp++ = 1;
966: bp = setindex(bp, tlist);
967: bp = setindex(bp, nlist);
968: #endif
969: }
970: #if INTEL
971: lastsize = ((long)s) * NBPBYTE;
972: i = tlookup(lp, bp-lp);
973: free(lp);
974: return (i);
975: #else
976: return (1);
977: #endif
978: }
979:
980: dbxenum(s, ttype)
981: unsigned s; /* Size of enum type in bytes */
982: {
983: int nmemb;
984: int i;
985: int valu;
986: int nname;
987: #if INTEL
988: int minvalu;
989: int maxvalu;
990: int range;
991: int nlist;
992: struct el {
993: struct el *el_ep;
994: int el_valu;
995: char el_id[];
996: };
997: struct el **epp;
998: register char *bp;
999: char *lp;
1000: char bb[16];
1001: #endif
1002: /* Enum member list */
1003: nname = 0;
1004: nmemb = iget(); /* Number of members in enum */
1005: #if INTEL
1006: /* SCALAR size type @list lbound ubound */
1007: /* LIST name1 ... namen */
1008: epp = (struct el **)malloc(nmemb * sizeof(*epp));
1009: if (epp == NULL) dbmemory(__LINE__);
1010: maxvalu = -MAXIV-1;
1011: minvalu = MAXIV;
1012: #endif
1013: for (i = 0; i < nmemb; i++) {
1014: #if INTEL
1015: int size;
1016: register struct el *ep;
1017: #endif
1018:
1019:
1020: if (bget() != DC_MOE) dbfatal(__LINE__);
1021: iget(); /* forget line */
1022: valu = iget(); /* value */
1023: sget(id, NCSYMB);
1024: #if INTEL
1025: size = strlen(id)+2;
1026: nname += size;
1027: #endif
1028: dbtmap(0);
1029: #if INTEL
1030: ep = malloc(sizeof(*ep)+size);
1031: if (ep == NULL) dbmemory(__LINE__);
1032: ep->el_valu = valu;
1033: strcpy(ep->el_id, id);
1034: if (valu < minvalu)
1035: minvalu = valu;
1036: else if (valu > maxvalu)
1037: maxvalu = valu;
1038: epp[i] = ep;
1039: #endif
1040: }
1041: #if INTEL
1042: /* Construct name list */
1043: range = maxvalu - minvalu + 1;
1044: if (range > nmemb)
1045: nname += (range-nmemb)*2;
1046: nname += range/8 + 3;
1047: lp = bp = malloc(nname);
1048: if (bp == NULL) dbmemory(__LINE__);
1049: *bp++ = OTLIST;
1050: for (valu = minvalu; valu <= maxvalu; valu++) {
1051: *bp++ = OTNAME;
1052: for (i = 0; i < nmemb; i++)
1053: if (epp[i]->el_valu == valu)
1054: break;
1055: if (i < nmemb) {
1056: bp = setsymid(bp, epp[i]->el_id);
1057: free(epp[i]);
1058: } else
1059: *bp++ = 0;
1060: if (bp > lp + nname) cbotch("enum overrun");
1061: }
1062: free(epp);
1063: nlist = tlookup(lp, bp-lp);
1064: free(lp);
1065: /* Construct type record */
1066: bp = &bb[0];
1067: *bp++ = OTSCAL;
1068: bp = setsize(bp, ((long)s)*NBPBYTE);
1069: *bp++ = OTSINT;
1070: bp = setname(bp, (ttype)?gettype(ttype)->t_info:"");
1071: bp = setindex(bp, nlist);
1072: bp = setnumb(bp, (long)minvalu);
1073: bp = setnumb(bp, (long)maxvalu);
1074: return (tlookup(bb, bp-bb));
1075: #else
1076: return (1);
1077: #endif
1078: }
1079:
1080: /*
1081: * Construct list of arg types and return its type.
1082: * The function's type with zero args has already been computed.
1083: * Expand the type and append nargs and arglist type.
1084: */
1085: arglisttype()
1086: {
1087: #if INTEL
1088: /* LIST @param1 ... @paramn */
1089: /* PARAM @type1 */
1090: /* ... */
1091: /* PARAM @typen */
1092: int type;
1093: int oldtypesize;
1094: char *oldtype;
1095: register char *bp;
1096: register int i;
1097: register char *sbp;
1098: char b[3*NARGS+3];
1099: register TINFO *tp;
1100: char b2[16];
1101:
1102: if (curfna == 0)
1103: return;
1104: /* Compute argument list type */
1105: bp = &b[0];
1106: *bp++ = OTLIST;
1107: for (i=0; i<curfna; ++i) {
1108: *bp++ = OTINDEX;
1109: sbp = bp;
1110: *bp++ = OTPARA;
1111: bp = setindex(bp, curfar[i]);
1112: bp = setindex(sbp-1, tlookup(sbp, bp-sbp));
1113: }
1114: type = tlookup(b, bp-b);
1115:
1116: /* Find old type */
1117: tp = gettype(curfsp->s_type);
1118: oldtype = tp->t_info;
1119: oldtypesize = tp->t_length;
1120:
1121: /* Expand and compute new type */
1122: bp = b2;
1123: while (--oldtypesize > 0) /* Last byte should be zero */
1124: *bp++ = *oldtype++;
1125: bp = setnumb(bp, (long)curfna); /* Number of args */
1126: bp = setindex(bp, type); /* Arg types */
1127: curfsp->s_type = tlookup(b2, bp-b2);
1128: #else
1129: return;
1130: #endif
1131: }
1132:
1133: /*
1134: * Output a debug line record.
1135: */
1136: outdlin(op)
1137: {
1138: bput(TDLAB);
1139: bput(DC_LINE);
1140: iput(line);
1141: bput(op);
1142: bput(0);
1143: bput(1); /* Nil type */
1144: }
1145:
1146: /*
1147: * Output a debug relocation record.
1148: * This 'n' is an index into the list of debug records written.
1149: */
1150: outdloc(n)
1151: {
1152: bput(TDLOC);
1153: iput(n);
1154: }
1155:
1156: /*
1157: * Finish up.
1158: * Figure out the sizes and final values of everything.
1159: * Write the output file.
1160: */
1161: copycode()
1162: {
1163: register SYM *sp;
1164: register i;
1165:
1166: /*
1167: * Assign base addresses to the compiler's logical segments
1168: * based on the settings of the VROM and VRAM flags.
1169: */
1170: seg_size = 0;
1171: bss_size = seg[SBSS].s_dot;
1172: lseg(SCODE);
1173: lseg(SLINK);
1174: if (isvariant(VSMALL) || isvariant(VRAM))
1175: seg_size = 0;
1176: lseg(SPURE);
1177: if (notvariant(VSMALL) && notvariant(VROM) && notvariant(VRAM))
1178: seg_size = 0;
1179: lseg(SSTRN);
1180: if (notvariant(VSMALL) && isvariant(VROM))
1181: seg_size = 0;
1182: lseg(SDATA);
1183: lseg(SBSS);
1184:
1185: /*
1186: * Adjust symbol base addresses to make them LSEG relative
1187: * instead of compiler segment relative.
1188: */
1189: for (i=0; i<NSHASH; ++i) {
1190: sp = hash2[i];
1191: while (sp != NULL) {
1192: if ((sp->s_flag&S_DEF) != 0)
1193: sp->s_value += seg[sp->s_seg].s_mseek;
1194: sp = sp->s_fp;
1195: }
1196: }
1197:
1198: /*
1199: * Write the object file.
1200: * Information in header and SEGDEF section is fixed ex post facto.
1201: */
1202: putbyte(0xA0); /* file type = linkable module */
1203: checksum = 0; /* file type byte not in checksum */
1204: writeheader(); /* file header */
1205: writesegdef(); /* SEGDEF section */
1206: writetypdef(); /* TYPDEF section */
1207: writesymdef(PUBSEC); /* PUBDEF section */
1208: writesymdef(EXTSEC); /* EXTDEF section */
1209: writetxtfix(); /* TXTFIX section */
1210: fixoutput(); /* fix output file */
1211: putbyte(-checksum); /* and write checksum */
1212: #if VAXFMT
1213: vaxflush();
1214: #endif
1215: }
1216:
1217: /*
1218: * Write linkable module header and table of contents.
1219: * Some of this gets fixed up after writing the object.
1220: */
1221: writeheader()
1222: {
1223: register int n;
1224: mhdseek = oflength; /* save header location */
1225: putrept (0, 13); /* 13 bytes of 0, fixed later */
1226: putdate(); /* date and time */
1227: n = strlen(module);
1228: putbyte(n);
1229: putupper(module, n); /* module name */
1230: putrept(' ', 40 - n); /* padded with spaces */
1231: putcreator(); /* module creator */
1232: tocseek = oflength; /* save toc location */
1233: putrept(0, 64); /* table of contents, fixed later */
1234: }
1235:
1236: /*
1237: * Write SEGDEF section.
1238: */
1239: writesegdef()
1240: {
1241: char b[NMNAME+5];
1242: secloc[SEGSEC] = oflength;
1243: if (isvariant(VSMALL)) {
1244: segseek[CODESEG] = putsegdef(0, "CODE");
1245: segseek[DATASEG] = putsegdef(0, "DATA");
1246: putsegdef(SEGDPL|SEGARW|SEGSTK|SEGEXT, "DATA");
1247: }
1248: else {
1249: strcpy(b, module);
1250: strcat(b, "_CODE");
1251: segseek[CODESEG] = putsegdef(0, b);
1252: strcpy(b, module);
1253: strcat(b, "_DATA");
1254: segseek[DATASEG] = putsegdef(0, b);
1255: putsegdef(SEGDPL|SEGARW|SEGSTK|SEGEXT, "STACK");
1256: }
1257: if (isvariant(VDEBUG)) {
1258: segseek[MODSEG] = putsegdef(0, "MODULES:");
1259: segseek[SYMSEG] = putsegdef(0, "SYMBOLS:");
1260: segseek[LINESEG] = putsegdef(0, "LINES:");
1261: }
1262: endsec(SEGSEC);
1263: }
1264:
1265: /*
1266: * Write TYPDEF section.
1267: */
1268: writetypdef()
1269: {
1270: register TINFO *tp;
1271: register int length;
1272: register TINFO *ttp;
1273: secloc[TYPSEC] = oflength;
1274: fixpatch();
1275: tp = typelistp;
1276: while (tp != NULL) {
1277: putbyte(0xFF); /* linkage = TRUE */
1278: if (tp->t_tflag) {
1279: length = 1;
1280: tp->t_info[0] = OTNIL;
1281: }
1282: else
1283: length = tp->t_length;
1284: putword(length); /* length */
1285: putblock(tp->t_info, length); /* type string */
1286: ttp = tp;
1287: tp = tp->t_tp;
1288: free(ttp);
1289: }
1290: endsec(TYPSEC);
1291: }
1292:
1293: /*
1294: * Write PUBDEF or EXTDEF section.
1295: */
1296: writesymdef(n)
1297: int n;
1298: {
1299: register int isdefined;
1300: register SYM *sp;
1301: int flag, i, type, ispubsec;
1302: secloc[n] = oflength;
1303: ispubsec = (n == PUBSEC);
1304: for (i=0; i<NSHASH; i++) {
1305: sp = hash2[i];
1306: while (sp != NULL) {
1307: flag = sp->s_flag;
1308: isdefined = ((flag&S_DEF)!=0);
1309: if ((flag&S_GBL)!=0 || !isdefined) {
1310: type = sp->s_type;
1311: if (type == 0)
1312: ++type;
1313: if (isdefined && ispubsec) {
1314: /* Public symbol. */
1315: putword(sp->s_value);
1316: putword(segindex(sp->s_seg));
1317: putword(type);
1318: putbyte(0); /* wordcount */
1319: putname(sp->s_id);
1320: sp->s_ref = 0;
1321: ++npubs;
1322: }
1323: else if (!isdefined && !ispubsec) {
1324: /* External symbol. */
1325: putword(0); /* segment unknown */
1326: putword(type);
1327: putbyte(0);
1328: putname(sp->s_id);
1329: sp->s_ref = ++nexts;
1330: }
1331: }
1332: sp = sp->s_fp;
1333: }
1334: }
1335: endsec(n);
1336: }
1337:
1338: /*
1339: * Write TXTFIX section.
1340: */
1341: writetxtfix()
1342: {
1343: register int op, data, nd, i;
1344: register char *cp;
1345: register SYM *sp;
1346:
1347: secloc[TXTSEC] = oflength;
1348: if (isvariant(VDEBUG)) {
1349: need(SYMSEG, 5+strlen(module)+1);
1350: lenseek = oflength+10; /* length fixed later */
1351: *txtp++ = SYMBBEG; /* block begin */
1352: fixsym(FORMOFF, CODESEG, 0); /* offset fixup */
1353: text2(0); /* offset */
1354: text2(0); /* length */
1355: txtp = setsymid(txtp, module); /* name */
1356: }
1357: dotseg = SCODE;
1358: dot = seg[SCODE].s_dot;
1359: while ((op=bget()) != TEND) {
1360: switch(op) {
1361: case TENTER:
1362: flush();
1363: dotseg = bget();
1364: dot = seg[dotseg].s_dot;
1365: continue;
1366: case TDLAB:
1367: getdlab();
1368: continue;
1369: case TDLOC:
1370: getdloc();
1371: continue;
1372: #if 0
1373: /* See comment on outcb()/outdb() above. */
1374: case TCODE:
1375: case TDATA:
1376: if (isvariant(VSMALL))
1377: cbotch("code:data");
1378: need(segindex(dotseg), 2);
1379: text2(0);
1380: fixdot(FORMSEL, SEGIN | ((op == TCODE) ? CODESEG : DATASEG), 0);
1381: dot += 2;
1382: continue;
1383: #endif
1384: case TBASE:
1385: if (isvariant(VSMALL))
1386: cbotch("base");
1387: sp = pget();
1388: need(segindex(dotseg), 2);
1389: text2(0);
1390: fixdot(FORMSEL, ((sp->s_flag&S_DEF)!=0) ? segindex(sp->s_seg) : EXTIN|(sp->s_ref), 0);
1391: dot += 2;
1392: continue;
1393: }
1394: if ((op&TTYPE) == TBYTE) {
1395: nd = 1;
1396: data = bget();
1397: } else {
1398: nd = 2;
1399: data = iget();
1400: }
1401: need(segindex(dotseg), nd);
1402: /*
1403: * Absolute.
1404: */
1405: if ((op&(TSYM|TPCR)) == 0) {
1406: text(data, nd);
1407: dot += nd;
1408: continue;
1409: }
1410: /*
1411: * Absolute PC rel.
1412: */
1413: if ((op&TSYM) == 0) {
1414: text(dot+data, nd);
1415: fixdot(FORMOFF, txtseg, dot+data);
1416: dot += nd;
1417: continue;
1418: }
1419: /*
1420: * Symbol based.
1421: */
1422: sp = pget();
1423: if ((sp->s_flag&S_DEF) != 0) {
1424: data += sp->s_value;
1425: /* Absolute */
1426: if ((op&TPCR)!=0 && sp->s_seg==dotseg) {
1427: text(data-(dot+nd), nd);
1428: dot += nd;
1429: continue;
1430: }
1431: /* Segment relative */
1432: text(data, nd);
1433: fixdot((op&TPCR)?FORMSRO:FORMOFF, segindex(sp->s_seg), data);
1434: dot += nd;
1435: continue;
1436: }
1437: /*
1438: * Symbol relative.
1439: */
1440: text(data, nd);
1441: fixdot((op&TPCR)?FORMSRO:FORMOFF, EXTIN|(sp->s_ref), data);
1442: dot += nd;
1443: }
1444:
1445: /*
1446: * Write SYMBOLS: and MODULES: text and fixups if DEBUG.
1447: */
1448: if (isvariant(VDEBUG)) {
1449: dbdump(); /* dump debug symbols */
1450: putbend(); /* block end */
1451: need(MODSEG, 33+1+strlen(module));
1452: for (i=1; i<=26; i++)
1453: *txtp++ = 0;
1454: text2(1); /* first line number = 1 */
1455: *txtp++ = TID; /* translator ID */
1456: #if INTEL
1457: cp = VERSINT;
1458: #else
1459: cp = VERSMWC;
1460: #endif
1461: for (i=1; i<=4; i++)
1462: *txtp++ = *cp++; /* version */
1463: txtp = setsymid(txtp, module);
1464: fixup(FORMFVA, MODSEG, 0x02, CODESEG|SEGIN, 0);
1465: fixup(FORMFVA, MODSEG, 0x0A, SYMSEG|SEGIN, 0);
1466: fixup(FORMFVA, MODSEG, 0x0E, LINESEG|SEGIN, 0);
1467: }
1468: flush();
1469:
1470: /*
1471: * Write an ITEXT block to initialize BSS if nonempty.
1472: */
1473: if (bss_size != 0) {
1474: putbyte(BITEXT); /* iterated text block */
1475: putword(seg[SBSS].s_mseek); /* offset */
1476: putword(segindex(SDATA)); /* segment */
1477: putword(bss_size); /* iteration count */
1478: putword(1); /* template length */
1479: putbyte(0); /* template */
1480: }
1481: endsec(TXTSEC);
1482: }
1483:
1484: /*
1485: * Fix the output file.
1486: */
1487: fixoutput()
1488: {
1489: register int i;
1490: long len;
1491:
1492: #ifdef vax
1493: /* On the VAX, copy the temp file to the output file. */
1494: /* This is because of problems with seeking in the output file. */
1495: #if VAXFMT
1496: vaxflush();
1497: #endif
1498: setin();
1499: outopen(1);
1500: trace("repacking");
1501: #endif
1502:
1503: /* Fix the module header. */
1504: len = oflength; /* save module length */
1505: fakeseek(mhdseek, 12); /* seek to module header */
1506: putlong(len); /* fix total module length */
1507: putword(nsegs); /* fix SEGDEFs */
1508: putword(0); /* GATDEFs */
1509: putword(npubs); /* fix PUBDEFs */
1510: putword(nexts); /* fix EXTDEFs */
1511: /* Fix the table of contents. */
1512: fakeseek(tocseek, 8*NSECS); /* seek to table of contents */
1513: for (i=0; i<NSECS; i++) {
1514: if (secloc[i] != 0L)
1515: --secloc[i]; /* location without file type byte */
1516: putlong(secloc[i]); /* fix location */
1517: putlong(seclen[i]); /* fix length */
1518: }
1519: /* Fix the SEGDEF section. */
1520: seglen[DATASEG] += bss_size; /* DATA includes text and BSS */
1521: fixsegdef(SEGDPL|SEGAXR|SEGCOM, CODESEG);
1522: fixsegdef(SEGDPL|SEGARW|SEGCOM, DATASEG);
1523: if (isvariant(VDEBUG)) {
1524: fixsegdef(SEGDPL|SEGARO|SEGDEB, MODSEG);
1525: fixsegdef(SEGDPL|SEGARO|SEGDEB, SYMSEG);
1526: fixsegdef(SEGDPL|SEGARO|SEGDEB, LINESEG);
1527: /* Fix the SYMSEG text. */
1528: fakeseek(lenseek, 2);
1529: putword(seglen[CODESEG]);
1530: }
1531: /* Seek to end. */
1532: fakeseek(len, 0);
1533: }
1534:
1535: /*
1536: * Seek to 'where' and disregard next 'ignore' bytes.
1537: * Should just be lseek(), but complicated for VAX.
1538: */
1539: fakeseek(where, ignore)
1540: long where;
1541: int ignore;
1542: {
1543: #ifdef vax
1544: register int i;
1545: static long pos = 0L;
1546:
1547: for (; pos < where; pos++)
1548: putbyte(bget()); /* copy bytes */
1549: for (i=0; i<ignore; i++)
1550: bget(); /* skip old bytes */
1551: pos += (long) ignore; /* and update position */
1552: if (where == mhdseek)
1553: checksum = 0; /* reset checksum */
1554: #else
1555: if (fseek(ofp, where, 0) != 0) /* seek to location */
1556: cfatal("seek error");
1557: #endif
1558: }
1559:
1560: /*
1561: * Fix the attribute and length words of a segment definition.
1562: */
1563: fixsegdef(attrib, seginx)
1564: int attrib, seginx;
1565: {
1566: register ADDRESS size;
1567:
1568: size = seglen[seginx];
1569: if (size == 0)
1570: attrib |= SEGEXT; /* external if empty */
1571: else
1572: --size; /* length-1 gives length */
1573: fakeseek(segseek[seginx], 4); /* seek to attribute byte */
1574: putword(attrib); /* attributes */
1575: putword(size); /* length */
1576: }
1577:
1578: /*
1579: * Write LINES text for line number.
1580: * 'lastline' is the last line for which LINES text was written.
1581: * Watch for the case where 'line' is much larger than 'lastline'.
1582: */
1583: putline(dp)
1584: struct dbgt *dp;
1585: {
1586: register int i, value, line;
1587: line = dp->d_line;
1588: value = dp->d_value;
1589: while (line > lastline) { /* need to write LINES text */
1590: i = 2 * (line - lastline); /* bytes of LINES text needed */
1591: if (i > NTXT)
1592: i = NTXT; /* cannot buffer more than NTXT */
1593: need(LINESEG, i);
1594: while (i > 0) {
1595: text2(value);
1596: i -= 2;
1597: lastline++;
1598: }
1599: }
1600: }
1601:
1602: /*
1603: * Write SYMBOLS text for a block or procedure begin.
1604: */
1605: putbbeg(dp)
1606: register struct dbgt *dp;
1607: {
1608: if (dp->d_id[0] != '{') { /* procedure block */
1609: need(SYMSEG, 10+1+strlen(dp->d_id));
1610: *txtp++ = SYMPBEG; /* procedure begin */
1611: fixsym(FORMOFF, CODESEG, dp->d_value); /* offset fixup */
1612: text2(dp->d_value); /* offset */
1613: text2(dp->d_type); /* type */
1614: *txtp++ = (isvariant(VSMALL)?0:1); /* near or far */
1615: text2(6); /* r. a. offset */
1616: text2(blklength(dp,1)); /* length */
1617: txtp = setsymid(txtp, dp->d_id); /* name */
1618: }
1619: else { /* non-procedure block */
1620: #ifdef NOABLOCKS
1621: blkcount++;
1622: #else
1623: need(SYMSEG, 6);
1624: *txtp++ = SYMBBEG; /* block begin */
1625: fixsym(FORMOFF, CODESEG, dp->d_value); /* offset fixup */
1626: text2(dp->d_value); /* offset */
1627: text2(blklength(dp, 0)); /* length */
1628: *txtp++ = 0; /* name */
1629: #endif
1630: }
1631: }
1632:
1633: /*
1634: * Return the blocklength of block dp.
1635: * Add the epilog size if epiflag.
1636: */
1637: blklength(dp, epiflag)
1638: register struct dbgt *dp;
1639: int epiflag;
1640: {
1641: register int level;
1642: register ADDRESS length;
1643: register int episize;
1644:
1645: /* Set episize to epilog length (8086: without autos) if epiflag. */
1646: episize = (epiflag) ? 4 : 0;
1647: level = dp->d_level + 1;
1648: length = dp->d_value;
1649: while ((dp = dp->d_dp) != NULL) {
1650: if (epiflag && dp->d_class == DC_AUTO && notvariant(V80186))
1651: episize = 6; /* epilog length with autos, 8086 */
1652: else if (dp->d_class == DC_LINE
1653: && dp->d_id[0] == '}'
1654: && dp->d_level == level)
1655: return ((int) (dp->d_value - length + episize));
1656: }
1657: cbotch("missing blkend");
1658: }
1659:
1660: /*
1661: * Write SYMBOLS text for block end.
1662: */
1663: putbend()
1664: {
1665: #ifdef NOABLOCKS
1666: if (blkcount > 0) {
1667: blkcount--;
1668: return;
1669: }
1670: #endif
1671: need(SYMSEG, 1);
1672: *txtp++ = SYMBEND;
1673: if (symbase == -1)
1674: symbase = 0;
1675: }
1676:
1677: /*
1678: * Write SYMBOLS text for debug symbol.
1679: */
1680: putsym(dp)
1681: register struct dbgt *dp;
1682: {
1683: register char *cp;
1684: register int n;
1685: int class = dp->d_class;
1686: if ((class == DC_AUTO) || (class == DC_PAUTO)) {
1687: /* BP-relative symbol */
1688: if (symbase != -1) {
1689: need(SYMSEG, 1);
1690: *txtp++ = SYMBPRB; /* BP-relative base */
1691: symbase = -1;
1692: }
1693: }
1694: else if (segindex(dp->d_seg) != symbase) {
1695: /* Need to change symbol segments */
1696: symbase = segindex(dp->d_seg);
1697: need(SYMSEG, 5);
1698: *txtp++ = SYMBASE; /* base */
1699: fixsym(FORMFVA, symbase, 0); /* full virt addr fixup */
1700: text2(0); /* offset */
1701: text2(symbase); /* segment */
1702: }
1703: cp = dp->d_id;
1704: n = strlen(cp);
1705: need(SYMSEG, 5+1+n);
1706: *txtp++ = SYMSYMB;
1707: text2(dp->d_value); /* offset */
1708: text2(dp->d_type); /* type */
1709: txtp = setsymid(txtp, cp); /* name */
1710: }
1711:
1712: /*
1713: * Put out a byte, updating checksum.
1714: */
1715: putbyte(b)
1716: register b;
1717: {
1718: ++oflength;
1719: checksum += b;
1720: #if VAXFMT
1721: #if TEMPBUF
1722: if (ofp == NULL) {
1723: bput(b);
1724: return;
1725: }
1726: #endif
1727: if (vaxptr >= &vaxbuf[NVDATA])
1728: vaxflush();
1729: *vaxptr++ = b;
1730: #else
1731: bput(b);
1732: #endif
1733: }
1734:
1735: /*
1736: * Put out a word.
1737: */
1738: putword(n)
1739: register int n;
1740: {
1741: putbyte(n);
1742: putbyte(n>>8);
1743: }
1744:
1745: /*
1746: * Put out a long.
1747: */
1748: putlong(n)
1749: long n;
1750: {
1751: putword((int)n);
1752: putword((int)(n>>16));
1753: }
1754:
1755: /*
1756: * Put out a block of n bytes from cp.
1757: */
1758: putblock(cp, n)
1759: register unsigned char *cp;
1760: register int n;
1761: {
1762: while (n--)
1763: putbyte(*cp++);
1764: }
1765:
1766: /*
1767: * Put out a block of n bytes from cp,
1768: * mapping lower case to upper case.
1769: */
1770: putupper(cp, n)
1771: register char *cp;
1772: register int n;
1773: {
1774: while (n--)
1775: putbyte(uppercase(*cp++));
1776: }
1777:
1778: /*
1779: * Put out n bytes of character c.
1780: */
1781: putrept(c, n)
1782: register int c;
1783: register int n;
1784: {
1785: while (n--)
1786: putbyte(c);
1787: }
1788:
1789: /*
1790: * Put out a PL/M-format name.
1791: * Warn and truncate if the name is longer than 39 characters.
1792: */
1793: putname(cp)
1794: register char *cp;
1795: {
1796: register int len;
1797: if ((len = strlen(cp)) > 39) {
1798: cwarn("symbol \"%s\" truncated to 39 characters", cp);
1799: len = 39;
1800: }
1801: putbyte(len);
1802: putupper(cp, len);
1803: }
1804:
1805: /*
1806: * Put out date and time.
1807: */
1808: putdate()
1809: {
1810: #ifdef UDI
1811: extern struct gt udigtime;
1812: putblock(udigtime.gt_date, 8);
1813: putblock(udigtime.gt_time, 8);
1814: #else /* COHERENT or VAX */
1815: #ifdef COHERENT
1816: time_t now;
1817: #else /* VAX */
1818: struct tm *localtime();
1819: long time();
1820: long now;
1821: #endif
1822: char b[17];
1823: register struct tm *tmp;
1824: time(&now);
1825: tmp = localtime(&now);
1826: sprintf (b, "%02d/%02d/%02d%02d:%02d:%02d",
1827: tmp->tm_mon+1,
1828: tmp->tm_mday,
1829: tmp->tm_year,
1830: tmp->tm_hour,
1831: tmp->tm_min,
1832: tmp->tm_sec);
1833: putblock(b, 16);
1834: #endif
1835: }
1836:
1837: /*
1838: * Put out module creator.
1839: */
1840: putcreator()
1841: {
1842: register int n;
1843: char b[40];
1844: #ifdef UDI
1845: extern char udisysid[];
1846: cstr(b, &udisysid[0]);
1847: #endif
1848: #ifdef COHERENT
1849: strcpy(b, "COHERENT");
1850: #endif
1851: #ifdef vax
1852: strcpy(b, "VAX");
1853: #endif
1854: #if INTEL
1855: strcat (b, " iC286 ");
1856: strcat (b, VERSINT);
1857: #else
1858: strcat (b, " MWC286 ");
1859: strcat (b, VERSMWC);
1860: #endif
1861: n = strlen(b);
1862: putbyte(n);
1863: putblock(b, n);
1864: putrept(' ', 40 - n);
1865: }
1866:
1867: /*
1868: * Put out a segment definition.
1869: * The attribute and length may be fixed later.
1870: * Return the location of the attribute byte.
1871: */
1872: long
1873: putsegdef(attrib, namep)
1874: int attrib;
1875: char *namep;
1876: {
1877: long l;
1878:
1879: l = oflength;
1880: ++nsegs;
1881: putword(attrib); /* attributes, may be fixed later */
1882: putrept(0, 6); /* length, dlength, LDT position */
1883: putname(namep); /* combine name */
1884: return(l);
1885: }
1886:
1887: /*
1888: * End a section.
1889: * Compute section length;
1890: * reset section location to 0 if empty.
1891: */
1892: endsec(n)
1893: register int n;
1894: {
1895: seclen[n] = oflength - secloc[n];
1896: if (seclen[n] == 0L)
1897: secloc[n] = 0L;
1898: }
1899:
1900: /*
1901: * Return OMF segment index internal name corresponding to
1902: * compiler logical segment code.
1903: */
1904: segindex(n)
1905: register int n;
1906: {
1907: return(SEGIN | ((isvariant(VSMALL)||isvariant(VRAM))?ramseg[n]
1908: : ((isvariant(VROM))?romseg[n]
1909: : nonseg[n])));
1910: }
1911:
1912: /*
1913: * Convert character to upper case.
1914: */
1915: uppercase(c)
1916: register c;
1917: {
1918: if (c < 'a' || c > 'z')
1919: return(c);
1920: return(c - 'a' + 'A');
1921: }
1922:
1923: /*
1924: * Assign a base address to a compiler logical segment.
1925: * Bump seg_size and reset segment location counter to base.
1926: * Round sizes up to even boundaries because of 80287 word alignment bug.
1927: */
1928: lseg(n)
1929: register int n;
1930: {
1931: seg[n].s_mseek = seg_size;
1932: if (((seg[n].s_dot)&1) == 1) {
1933: ++seg[n].s_dot; /* round dot up to even boundary */
1934: ++seglen[segindex(n)&~SEGIN]; /* and bump segment length */
1935: }
1936: seg_size += seg[n].s_dot;
1937: seg[n].s_dot = seg[n].s_mseek;
1938: }
1939:
1940: /*
1941: * Flush the text and fixup buffers.
1942: */
1943: flush()
1944: {
1945: register int n, sindex;
1946: if (txtp != txt) {
1947: n = txtp - txt;
1948: sindex = txtseg&~SEGIN; /* mask off segment IN */
1949: putbyte(BTEXT); /* text block */
1950: if (sindex == CODESEG || sindex == DATASEG) {
1951: putword(seg[dotseg].s_dot);
1952: seg[dotseg].s_dot += n;
1953: }
1954: else putword(seglen[sindex]); /* offset */
1955: putword(txtseg); /* segment IN */
1956: seglen[sindex] += n; /* bump seg length */
1957: putword(n); /* length */
1958: txtp = txt;
1959: while (n--)
1960: putbyte(*txtp++); /* text */
1961: txtp = txt; /* reset pointer */
1962: }
1963: if (fixp != fix) {
1964: putbyte(BFIXUP); /* fixup block */
1965: putword(fixseg); /* where-IN */
1966: n = fixp - fix;
1967: putword(n); /* length */
1968: fixp = fix;
1969: while (n--)
1970: putbyte(*fixp++); /* fixup */
1971: fixp = fix; /* reset pointer */
1972: ofixp = NULL; /* and reset ofixp */
1973: }
1974: }
1975:
1976: /*
1977: * Leave n bytes of space for text in given seg.
1978: * Flush if buffer is too full or contains text from a different segment.
1979: */
1980: need(seg, n)
1981: register int seg, n;
1982: {
1983: if (n == 0)
1984: return;
1985: if (n > NTXT)
1986: cbotch("need");
1987: seg |= SEGIN;
1988: if ((txtp+n > &txt[NTXT]) || ((seg != txtseg) && (txtp != txt)))
1989: flush();
1990: txtseg = seg;
1991: }
1992:
1993: /*
1994: * Write n (1 or 2) bytes of data as text.
1995: */
1996: text(data, n)
1997: register int data, n;
1998: {
1999: *txtp++ = data;
2000: if (n == 2)
2001: *txtp++ = data >> 8;
2002: }
2003:
2004: /*
2005: * Write 2 bytes of data as text.
2006: */
2007: text2(data)
2008: register int data;
2009: {
2010: *txtp++ = data;
2011: *txtp++ = data >> 8;
2012: }
2013:
2014: /*
2015: * Write a fixup.
2016: * Flush if buffer is too full or contains fixups on a different segment.
2017: * An offset fixup followed by a selector fixup can get kludged into
2018: * a full virtual address fixup.
2019: */
2020: fixup(format, wherein, whereoffs, whatin, whatoffs)
2021: int format;
2022: ADDRESS wherein, whereoffs, whatin, whatoffs;
2023: {
2024: register int type;
2025: static ADDRESS owhereoffs, owhatin;
2026: wherein |= SEGIN;
2027: /* Flush if necessary. */
2028: if ((fixp+7 > &fix[NFIX]) || ((wherein != fixseg) && (fixp != fix)))
2029: flush();
2030: fixseg = wherein;
2031: /* Patch offset/selector fixup pairs to full virtual address fixups. */
2032: if (format == FORMOFF) {
2033: ofixp = fixp;
2034: owhereoffs = whereoffs;
2035: owhatin = whatin;
2036: }
2037: else if ((ofixp != NULL) && (format == FORMSEL) && (whatin == owhatin)
2038: && (whereoffs == owhereoffs + 2)) {
2039: *ofixp |= FORMFVA;
2040: ofixp = NULL;
2041: return;
2042: }
2043: else ofixp == NULL;
2044: /* Determine the fixup type. */
2045: if (whatin == wherein)
2046: type = FIXISEG; /* intrasegment */
2047: else if (whatoffs == 0)
2048: type = FIXCALL; /* call */
2049: else type = FIXGEN; /* general */
2050: /* Write the fixup. */
2051: *fixp++ = format | type; /* kind */
2052: *fixp++ = whereoffs;
2053: *fixp++ = whereoffs >> 8; /* where-offset */
2054: if (type != FIXCALL) {
2055: *fixp++ = whatoffs;
2056: *fixp++ = whatoffs >> 8; /* what-offset */
2057: }
2058: if (type != FIXISEG) {
2059: *fixp++ = whatin;
2060: *fixp++ = whatin >> 8; /* what-IN */
2061: }
2062: }
2063:
2064: /*
2065: * Write a symbol fixup at the current text location in SYMSEG.
2066: */
2067: fixsym(format, whatin, whatoffs)
2068: int format;
2069: ADDRESS whatin, whatoffs;
2070: {
2071: fixup(format, SYMSEG, seglen[SYMSEG]+txtp-txt, SEGIN|whatin, whatoffs);
2072: }
2073:
2074: /*
2075: * Perform fixup at current location.
2076: */
2077: fixdot(format, whatin, whatoffs)
2078: int format;
2079: ADDRESS whatin, whatoffs;
2080: {
2081: fixup(format, segindex(dotseg), dot, whatin, whatoffs);
2082: }
2083:
2084: #if VAXFMT
2085: /*
2086: * Flush out a record on the VAX. The record is a standard,
2087: * RMS variable length record. This routine checks for no bytes
2088: * in the buffer, so it can be unconditionally called at the
2089: * end to flush the buffer out.
2090: * The record is padded out to NVDATA bytes with zeros. This
2091: * only happens on the last block; the data beyond the end
2092: * is zeroed.
2093: */
2094: vaxflush()
2095: {
2096: register int n;
2097:
2098: #if TEMPBUF
2099: if (ofp == NULL)
2100: return;
2101: #endif
2102: if ((n = vaxptr-vaxbuf) != 0) {
2103: if (fwrite(vaxbuf, n, 1, ofp) != 1
2104: || fflush(ofp) == EOF)
2105: cfatal("output write error");
2106: vaxptr = vaxbuf;
2107: }
2108: }
2109: #endif
2110:
2111: /*
2112: ** Debug information processors.
2113: */
2114:
2115: fixpatch()
2116: {
2117: register TYFIX *fp;
2118: #if INTEL
2119: register TINFO *ttp, *pttp, *tp, *ptp;
2120: #endif
2121:
2122: while ((fp = typefixp) != NULL) {
2123: #if INTEL
2124: if (fp->t_ttype >= fp->t_type) dbfatal(__LINE__);
2125: /*
2126: * This depends on NIL being at type index 1.
2127: * Excise the dummy type def.
2128: */
2129: pttp = gettype(fp->t_ttype-1);
2130: ttp = pttp->t_tp;
2131: pttp->t_tp = ttp->t_tp;
2132: /*
2133: * Excise the real type def.
2134: */
2135: ptp = gettype(fp->t_type-2);
2136: tp = ptp->t_tp;
2137: ptp->t_tp = tp->t_tp;
2138: /*
2139: * Insert the dummy and blank it.
2140: */
2141: ttp->t_tp = ptp->t_tp;
2142: ptp->t_tp = ttp;
2143: ttp->t_tflag = 0;
2144: ttp->t_length = 1;
2145: ttp->t_info[0] = OTNIL;
2146: /*
2147: * Insert the real definition.
2148: */
2149: tp->t_tp = pttp->t_tp;
2150: pttp->t_tp = tp;
2151: #endif
2152: /*
2153: * Release the memory.
2154: */
2155: typefixp = fp->t_tp;
2156: free(fp);
2157: }
2158: }
2159:
2160: static TINFO *
2161: gettype(index)
2162: {
2163: register TINFO *tp;
2164:
2165: tp = typelistp;
2166: while (--index != 0)
2167: if ((tp = tp->t_tp) == NULL)
2168: dbfatal(__LINE__);
2169: return (tp);
2170: }
2171:
2172: /*
2173: * Read debug table item(s) into memory.
2174: * These are buffered until appropriate moments.
2175: */
2176: getdlab()
2177: {
2178: register struct dbgt *dp;
2179: static int refnum = 0;
2180:
2181: dp = getdbgt();
2182: if (dp->d_class == DC_LINE || dp->d_class == DC_LAB)
2183: dp->d_ref = refnum;
2184: refnum += 1;
2185: if (dbase == NULL)
2186: dbase = dp;
2187: if (dnext != NULL)
2188: dnext->d_dp = dp;
2189: dbrpt("enter", dp);
2190: while (dp->d_dp != NULL) {
2191: dp = dp->d_dp;
2192: dbrpt("enter", dp);
2193: }
2194: dnext = dp;
2195: }
2196:
2197: /*
2198: * Read in debug item in form abbreviated by outdlab().
2199: */
2200: struct dbgt *
2201: getdbgt()
2202: {
2203: register char *cp;
2204: register struct dbgt *dp;
2205: static int level = 0;
2206: struct dbgt d;
2207: SYM *sp;
2208:
2209: d.d_level = level;
2210:
2211: /*
2212: * Read the values in.
2213: */
2214: d.d_class = bget();
2215: d.d_line = iget();
2216: d.d_value = iget();
2217: d.d_seg = bget();
2218:
2219: /*
2220: * Read name.
2221: */
2222: for (cp = id; *cp = bget(); cp += 1);
2223:
2224: /*
2225: * Read type.
2226: */
2227: d.d_type = iget();
2228:
2229: /*
2230: * Check level change.
2231: */
2232: if (d.d_class == DC_LINE) {
2233: switch (id[0]) {
2234: case '{': level += 1; break;
2235: case '}': level -= 1; break;
2236: }
2237: }
2238:
2239: /*
2240: * Find location of static internal items.
2241: */
2242: if (d.d_class == DC_SIN) {
2243: sp = llookup(d.d_value, 0);
2244: d.d_value = sp->s_value;
2245: d.d_seg = sp->s_seg;
2246: }
2247:
2248: /*
2249: * Copy into dynamic storage.
2250: */
2251: dp = (struct dbgt *)malloc(sizeof(struct dbgt) + cp - id + 1);
2252: if (dp == NULL)
2253: cnomem("getdbgt");
2254: dp->d_level = d.d_level;
2255: dp->d_class = d.d_class;
2256: dp->d_line = d.d_line;
2257: dp->d_seg = d.d_seg;
2258: if (d.d_seg < SANY)
2259: d.d_value += seg[d.d_seg].s_mseek;
2260: dp->d_value = d.d_value;
2261: dp->d_type = d.d_type;
2262: dp->d_dp = NULL;
2263: dp->d_ref = -1;
2264: while (cp >= id) {
2265: dp->d_id[cp-id] = *cp;
2266: cp -= 1;
2267: }
2268: return (dp);
2269: }
2270:
2271: /*
2272: * Read a debug relocation item and patch current 'dot'
2273: * into the appropriate debug/symbol table item.
2274: * If the debug item is '}' and level 1, then dump everything in the list.
2275: */
2276: getdloc()
2277: {
2278: register struct dbgt *dp;
2279: register int ref;
2280:
2281: ref = iget();
2282: for (dp = dbase; ; dp = dp->d_dp) {
2283: if (dp == NULL)
2284: cbotch("getdloc: %d", ref);
2285: if (dp->d_ref == ref)
2286: break;
2287: }
2288: dp->d_seg = dotseg;
2289: dp->d_value = dot;
2290:
2291: dbrpt("reloc", dp);
2292: if (dp->d_id[0] == '}' && dp->d_level == 1)
2293: dbdump();
2294: }
2295:
2296: /*
2297: * Dump all the debug symbols.
2298: */
2299: dbdump()
2300: {
2301: register struct dbgt *dp, **dpp;
2302: extern char *regnames[];
2303:
2304: dpp = &dbase;
2305: dnext = NULL;
2306: while ((dp = *dpp) != NULL) {
2307: switch (dp->d_class) {
2308: case DC_GDEF: /* Global def. */
2309: case DC_SEX: /* Static external */
2310: /* Function definitions replace initial { */
2311: if (dp->d_seg == SCODE) {
2312: /* The initial BLKDEF occurs before PROLOG
2313: * at the function entry point. Could be
2314: * moved after PROLOG if desired.
2315: * The last BLKEND occurs just
2316: * before the EPILOG, and can also be moved.
2317: */
2318: SYM *sp;
2319:
2320: sp = glookup(dp->d_id, 0);
2321: dp->d_type = sp->s_type;
2322: putline(dp);
2323: putbbeg(dp);
2324: } else
2325: putsym(dp);
2326: break;
2327: case DC_GREF: /* Global ref. */
2328: break;
2329: case DC_TYPE: /* Typedef name */
2330: case DC_STAG: /* Structure tag */
2331: case DC_UTAG: /* Union tag */
2332: case DC_ETAG: /* Enumeration tag */
2333: case DC_FILE: /* Source file name */
2334: break;
2335: case DC_AUTO: /* Auto */
2336: case DC_PAUTO: /* Parametric auto */
2337: putsym(dp);
2338: break;
2339: case DC_SIN: /* Static internal */
2340: case DC_LAB: /* Label */
2341: putsym(dp);
2342: break;
2343: case DC_REG: /* Register */
2344: case DC_PREG: /* Parametric register */
2345: #if INTEL
2346: line = dp->d_line;
2347: cwarn("variable \"%s\" is in register %s",
2348: dp->d_id, regnames[dp->d_value]);
2349: #endif
2350: break;
2351: case DC_MOE: /* Member of enumeration */
2352: break;
2353: case DC_LINE: /* Line number */
2354: switch (dp->d_id[0]) {
2355: case '{': /* Block begins */
2356: /* GDEF or SEX takes first blkdef */
2357: if (dp->d_level != 0) {
2358: putline(dp);
2359: putbbeg(dp);
2360: }
2361: break;
2362: case ';': /* Line number */
2363: putline(dp);
2364: break;
2365: case '}': /* Block ends */
2366: putbend();
2367: break;
2368: default:
2369: cbotch("bad line record (dbdump)");
2370: }
2371: break;
2372: case DC_MOS: /* Member of structure */
2373: case DC_MOU: /* Member of union */
2374: case DC_CALL: /* Function call */
2375: break;
2376: default:
2377: cbotch("bad class (dbdump)");
2378: }
2379: *dpp = dp->d_dp;
2380: free(dp);
2381: }
2382: }
2383:
2384: #if !TINY
2385: _dbrpt(p, dp)
2386: char *p;
2387: register struct dbgt *dp;
2388: {
2389: if (xflag > 5)
2390: printf("%s: %d %s %d %d %o %d\n",
2391: p,
2392: dp->d_class,
2393: dp->d_id,
2394: dp->d_ref,
2395: dp->d_level,
2396: dp->d_flag,
2397: dp->d_type,
2398: 0);
2399: }
2400:
2401: #endif
2402:
2403: /*
2404: * Splat an index leaf.
2405: */
2406: char *
2407: setindex(cp, i)
2408: register char *cp;
2409: register unsigned i;
2410: {
2411: *cp++ = OTINDEX;
2412: *cp++ = i;
2413: *cp++ = (i >> 8);
2414: return (cp);
2415: }
2416:
2417: /*
2418: * Splat a name leaf.
2419: */
2420: char *
2421: setname(bp, cp)
2422: register char *bp;
2423: register char *cp;
2424: {
2425: *bp++ = OTNAME;
2426: return(setsymid(bp, cp));
2427: }
2428:
2429: /*
2430: * Splat an unsigned numeric leaf.
2431: * This assumes that the leaf always fits in 4 bytes,
2432: * since any object the compiler knows about must fit in
2433: * 64K bytes or 64K * NBPBYTE = 512K bits.
2434: */
2435: char *
2436: setnumb(bp, numb)
2437: char *bp;
2438: unsigned long numb;
2439: {
2440: if (numb < 128)
2441: *bp++ = numb;
2442: else if (numb < 0x10000L) {
2443: *bp++ = OTUNUM2;
2444: *bp++ = numb;
2445: *bp++ = numb >> 8;
2446: }
2447: else {
2448: *bp++ = OTUNUM4;
2449: *bp++ = numb;
2450: *bp++ = numb >> 8;
2451: *bp++ = numb >> 16;
2452: *bp++ = numb >> 24;
2453: }
2454: return (bp);
2455: }
2456:
2457: /*
2458: * Splat a bit size.
2459: */
2460: char *
2461: setsize(bp, size)
2462: char *bp;
2463: long size;
2464: {
2465: lastsize = size;
2466: return (setnumb(bp, size));
2467: }
2468:
2469: /*
2470: * Copy name through bp and return updated bp.
2471: */
2472: char *
2473: setsymid(bp, cp)
2474: register char *bp;
2475: register char *cp;
2476: {
2477: register len;
2478: if ((len=strlen(cp)) > 39) {
2479: cwarn("symbol \"%s\" truncated to 39 characters", cp);
2480: len = 39;
2481: }
2482: *bp++ = len;
2483: while (len--)
2484: *bp++ = uppercase(*cp++);
2485: return (bp);
2486: }
2487:
2488: dbfatal(lineno)
2489: {
2490: cbotch("debug label format in %d", lineno);
2491: }
2492:
2493: dbmemory(lineno)
2494: {
2495: cnomem("dbmemory %d", lineno);
2496: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.