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