![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to outcsd.sav 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 outcsd.sav CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n2 / i8086 |
1.1 root 1: /*
2: * This file writes writes Intel iAPX-86 OMF with csd debugging information.
3: * Based on outomf.c, but with MWC CSD-format debug info (as in outrel.c)
4: * instead of Intel format.
5: * The 'out...' routines write to a temporary file during code assembly.
6: * At the end of assembly, 'copycode' uses the 'put...' routines
7: * to write the object file.
8: * This is necessary: SEGDEF records must be written before
9: * LEDATA and FIXUPP records, but each SEGDEF includes the size
10: * of the segment in bytes.
11: * However, the size of the DEBUG segment is fixed up ex post facto.
12: */
13:
14: /*
15: * Reference: "8086 Relocatable Object Formats,"
16: * Intel 121748-001 (C) Intel 1981.
17: */
18:
19: #ifdef vax
20: #include "INC$LIB:cc2.h"
21: #include "INC$LIB:debug.h"
22: #else
23: #include "cc2.h"
24: #include "debug.h"
25: #endif
26:
27: #define NTXT 256 /* Text buffer size */
28: #define NREL 256 /* Relocation buffer size */
29:
30: #ifndef __LINE__
31: #define __LINE__ 0
32: #endif
33:
34: #if !TINY
35: #define dbrpt(x,y) _dbrpt(x,y)
36: #else
37: #define dbrpt(x,y) /* _dbrpt(x,y) */
38: #endif
39:
40: /*
41: * Scratch file opcodes.
42: * Flags are or'ed in to TBYTE and TWORD opcodes only.
43: */
44: #define TTYPE 0x07 /* Type */
45: #define TPCR 0x08 /* PC rel flag */
46: #define TSYM 0x10 /* Symbol based flag */
47:
48: #define TEND 0x00 /* End marker */
49: #define TENTER 0x01 /* Enter new area */
50: #define TBYTE 0x02 /* Byte data */
51: #define TWORD 0x03 /* Word data */
52: #define TCODE 0x04 /* Code segment base */
53: #define TDATA 0x05 /* Data segment base */
54: #define TBASE 0x06 /* External segment base */
55: #define TDLAB 0x07 /* Debug label */
56: #define TDLOC 0x08 /* 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 0xE0 /* 8087 flags */
67: #define TWT 0x20 /* M:_WT */
68: #define TWST 0x40 /* M:_WST */
69: #define TWES 0x60 /* M:_WES */
70: #define TWCS 0x80 /* M:_WCS */
71: #define TWSS 0xA0 /* M:_WSS */
72: #define TWDS 0xC0 /* M:_WDS */
73: #endif
74:
75: /*
76: * OMF types.
77: */
78: #define THEADR 0x80 /* Translator module header */
79: #define COMENT 0x88 /* Comment */
80: #define MODEND 0x8A /* Module end */
81: #define EXTDEF 0x8C /* External definition (reference) */
82: #define TYPDEF 0x8E /* Type definition */
83: #define PUBDEF 0x90 /* Public definition (definition) */
84: #define LNAMES 0x96 /* List of names */
85: #define SEGDEF 0x98 /* Segment definition */
86: #define GRPDEF 0x9A /* Group definition */
87: #define FIXUPP 0x9C /* Fixups */
88: #define LEDATA 0xA0 /* Enumerated data */
89: #define LIDATA 0xA2 /* Iterated data */
90:
91: /*
92: * Some OMF fields and flags.
93: */
94: #define BYTE (0x01<<5) /* Byte alignment */
95: #define PARA (0x03<<5) /* Paragraph alignment */
96: #define BIG 0x02 /* 64k */
97: #define CCON (0x02<<2) /* C field, concatenate */
98: #define CMEM (0x01<<2) /* C field, memory */
99: #define CSTACK (0x05<<2) /* C field, stack */
100:
101: #define LOCAT 0x80 /* Locat flag bit */
102: #define M 0x40 /* M bit; 0=self rel, 1=seg rel */
103: #define LOBYTE (0x00<<2) /* Locat */
104: #define OFFSET (0x01<<2) /* Locat */
105: #define BASE (0x02<<2) /* Locat */
106: #define POINTER (0x03<<2) /* Locat */
107: #define HIBYTE (0x04<<2) /* Locat */
108:
109: #define SECWAY 0x04 /* Secondary way */
110: #define FD8087 0x36 /* FIXDAT for 8087 fixup */
111: #define FSI (0<<4) /* Frame segment index */
112: #define FGI (1<<4) /* Frame group index */
113: #define FEI (2<<4) /* Frame external index */
114: #define FFN (3<<4) /* Frame frame number */
115: #define FLSEG (4<<4) /* Frame of LSEG */
116: #define FTARGET (5<<4) /* Frame of TARGET object */
117: #define FNONE (6<<4) /* No frame */
118: #define TSI 0 /* Target: segment index */
119: #define TGI 1 /* Target: group index */
120: #define TEI 2 /* Target: external index */
121: #define TFN 3 /* Target: frame */
122: #define F 0x80 /* Frame thread used */
123: #define T 0x08 /* Target thread used */
124: #define FT0 0x00 /* 0 */
125: #define FT1 0x10 /* 1 */
126:
127: #define VCSD (isvariant(VTYPES)||isvariant(VDSYMB))
128:
129: /*
130: * Structure to contain debug items on this pass.
131: * Debug items are kept in a linked list rooted at 'dbase',
132: * with 'dnext' pointing at the most recent item.
133: */
134: struct dbgt {
135: struct dbgt *d_dp; /* Link */
136: int d_ref; /* Index number */
137: unsigned char d_class; /* Storage class */
138: unsigned char d_flag; /* Flags */
139: unsigned char d_level; /* Bracket level */
140: unsigned char d_seg; /* Reloc-style segment */
141: unsigned char d_cseg; /* C Segment */
142: ADDRESS d_value; /* Offset in segment */
143: int d_size; /* Size of d_data */
144: char d_data[]; /* Name and type */
145: };
146: /* Flag bits. */
147: #define D_GBL 1
148: #define D_LCL 2
149: #define D_TAG 4
150: #define D_NAM 8
151: #define D_LAB 16
152: #define D_ENU 32
153:
154: /*
155: * Globals for output writer.
156: */
157: static int checksum; /* For putrecord and putbyte */
158: static char txt[NTXT+5]; /* Text buffer */
159: static char rel[NREL]; /* Relocation buffer */
160: static ADDRESS code_size; /* Size of CODE */
161: static ADDRESS data_size; /* Size of DATA */
162: static ADDRESS const_size; /* Size of CONST */
163: static ADDRESS bss_size; /* Size of BSS */
164: static char *txtp = txt; /* Text pointer */
165: static char *relp = rel; /* Relocation pointer */
166: static struct dbgt *dbase; /* Root debug list item */
167: static struct dbgt *dnext; /* Last debug list item */
168: static int level = 0; /* Debug brace level */
169: static int dline = 0; /* Most recent line number entry */
170:
171: #if EMUFIXUPS
172: static int has8087; /* Has 8087 code flag */
173: static SYM *wsp[6]; /* Links to emulator symbols */
174: #endif
175:
176: #if VAXFMT
177: /*
178: * The Intel cross software packs the OMF
179: * data into 512 byte blocks as 510 byte variable length
180: * records, with the last record short.
181: */
182: #define NVDATA 510 /* Blocksize - 2 */
183: static char vaxbuf[NVDATA]; /* Buffer */
184: static char *vaxptr = vaxbuf; /* Pointer */
185: #endif
186:
187: /*
188: * Function declarations.
189: */
190: extern char *calloc();
191: extern long ftell();
192: extern struct dbgt *getdbgt();
193: extern char *getmembs();
194: extern char *malloc();
195: extern struct dbgt *newdbgt();
196: extern long putsegdef();
197: extern char *setindex();
198: extern char *setsymid();
199: extern char *strcpy();
200:
201: /*
202: * These tables are indexed by a compiler segment name (SCODE et al)
203: * to get an OMF segment index.
204: * These tables understand the way the SSTRN segment moves
205: * around when the ROM option is given, and
206: * are dependent on the order of the calls to putsegdef() in copycode().
207: */
208: static char lnonseg[] = {
209: 1, /* SCODE => module_CODE */
210: 1, /* SLINK => module_CODE */
211: 1, /* SPURE => module_CODE */
212: 2, /* SSTRN => module_DATA */
213: 2, /* SDATA => module_DATA */
214: 2 /* SBSS => module_DATA */
215: };
216:
217: static char lromseg[] = {
218: 1, /* SCODE => module_CODE */
219: 1, /* SLINK => module_CODE */
220: 1, /* SPURE => module_CODE */
221: 1, /* SSTRN => module_CODE */
222: 2, /* SDATA => module_DATA */
223: 2 /* SBSS => module_DATA */
224: };
225:
226: static char lramseg[] = {
227: 1, /* SCODE => module_CODE */
228: 1, /* SLINK => module_CODE */
229: 2, /* SPURE => module_DATA */
230: 2, /* SSTRN => module_DATA */
231: 2, /* SDATA => module_DATA */
232: 2 /* SBSS => module_DATA */
233: };
234:
235: static char snonseg[] = {
236: 1, /* SCODE => CODE */
237: 1, /* SLINK => CODE */
238: 2, /* SPURE => CONST */
239: 3, /* SSTRN => DATA */
240: 3, /* SDATA => DATA */
241: 3 /* SBSS => DATA */
242: };
243:
244: static char sromseg[] = {
245: 1, /* SCODE => CODE */
246: 1, /* SLINK => CODE */
247: 2, /* SPURE => CONST */
248: 2, /* SSTRN => CONST */
249: 3, /* SDATA => DATA */
250: 3 /* SDATA => DATA */
251: };
252:
253: static char sramseg[] = {
254: 1, /* SCODE => CODE */
255: 1, /* SLINK => CODE */
256: 3, /* SPURE => DATA */
257: 3, /* SSTRN => DATA */
258: 3, /* SDATA => DATA */
259: 3 /* SDATA => DATA */
260: };
261:
262: /*
263: * Same game, but for group index codes.
264: * This is used only in SMALL model.
265: */
266: static char grpindex[] = {
267: 1, /* SCODE => CGROUP */
268: 1, /* SLINK => CGROUP */
269: 2, /* SPURE => DGROUP */
270: 2, /* SSTRN => DGROUP */
271: 2, /* SDATA => DGROUP */
272: 2 /* SBSS => DGROUP */
273: };
274:
275: /*
276: * Some prefabricated OMF items.
277: * These are just blasted out via calls to putrecord().
278: */
279: static char lthred[] = { 0x40, 1, /* module_CODE */
280: 0x41, 2 }; /* module_DATA */
281: static char gdef1[] = { 7, 0xFF, 1 };
282: static char gdef2[] = { 8, 0xFF, 2, 0xFF, 3, 0xFF, 4, 0xFF, 5 };
283: static char sthred[] = { 0x00, 1, /* Code */
284: 0x01, 2, /* Const */
285: 0x02, 3, /* Data */
286: 0x44, 1, /* Frame -> CGROUP */
287: 0x45, 2 /* Frame -> DGROUP */
288: };
289: static char typdef[] = { 0, 0, 0x80 };
290: static char modend[] = { 0x00 };
291:
292: /*
293: ** First pass routines.
294: ** Output items to the temporary file.
295: */
296: /*
297: * Initialize the code writer.
298: */
299: outinit()
300: {
301: #if MONOLITHIC
302: #if EMUFIXUPS
303: register int i;
304:
305: has8087 = 0;
306: for (i=0; i<6; ++i)
307: wsp[i] = NULL;
308: #endif
309: txtp = &txt[0];
310: relp = &rel[0];
311: dbase = dnext = NULL;
312: #if VAXFMT
313: vaxptr = &vaxbuf[0];
314: #endif
315: #endif
316: }
317:
318: /*
319: * Output a segment switch.
320: */
321: outseg(s)
322: {
323: bput(TENTER);
324: bput(s);
325: }
326:
327: /*
328: * Output an absolute byte.
329: */
330: outab(b)
331: {
332: bput(TBYTE);
333: bput(b);
334: ++dot;
335: }
336:
337: /*
338: * Output an absolute word.
339: */
340: outaw(w)
341: {
342: bput(TWORD);
343: iput(w);
344: dot += 2;
345: }
346:
347: /*
348: * Output a full byte.
349: */
350: outxb(sp, b, pcrf)
351: register SYM *sp;
352: {
353: register opcode;
354:
355: opcode = TBYTE;
356: if (sp != NULL)
357: opcode |= TSYM;
358: if (pcrf)
359: opcode |= TPCR;
360: bput(opcode);
361: bput(b);
362: if (sp != NULL)
363: pput(sp);
364: ++dot;
365: }
366:
367: /*
368: * Output a full word.
369: */
370: outxw(sp, w, pcrf)
371: register SYM *sp;
372: {
373: register opcode;
374:
375: opcode = TWORD;
376: if (sp != NULL)
377: opcode |= TSYM;
378: if (pcrf)
379: opcode |= TPCR;
380: bput(opcode);
381: iput(w);
382: if (sp != NULL)
383: pput(sp);
384: dot += 2;
385: }
386:
387: #if EMUFIXUPS
388: /*
389: * Output a one byte opcode for the 8087.
390: */
391: outfb(b)
392: {
393: has8087 = 1;
394: bput(TBYTE|TWT);
395: bput(b);
396: ++dot;
397: }
398:
399: /*
400: * Output a two byte opcode for the 8087.
401: */
402: outfw(w, prefix)
403: {
404: has8087 = 1;
405: bput(TWORD|((prefix>>3)+TWST));
406: iput(w);
407: dot += 2;
408: }
409: #endif
410:
411: #if 0
412: /*
413: * Because the compiler now generates LARGE model code with links,
414: * the following routines are currently unused.
415: * They are retained for future reference.
416: */
417: /*
418: * Output a 1 word object containing
419: * the base address of the current code segment.
420: */
421: outcb()
422: {
423: bput(TCODE);
424: dot += 2;
425: }
426:
427: /*
428: * Output a 1 word object containing
429: * the base address of the current data segment.
430: */
431: outdb()
432: {
433: bput(TDATA);
434: dot += 2;
435: }
436: #endif
437:
438: /*
439: * Output a 1 word object containing
440: * the base address of the external symbol pointed to by 'sp'.
441: */
442: outsb(sp)
443: SYM *sp;
444: {
445: bput(TBASE);
446: pput(sp);
447: dot += 2;
448: }
449:
450: /*
451: * Copy a dlabel record from ifp to ofp.
452: * Flag the symbol table entry if appropriate.
453: * Recursive for DX_MEMBS member lists.
454: */
455: outdlab(l,class)
456: {
457: register int val;
458: register SYM *sp;
459: int n;
460:
461: if (l == 0)
462: bput(TDLAB);
463: bput(class);
464:
465: /* Get line number. */
466: iput(iget());
467:
468: /* Get value */
469: if (class < DC_AUTO)
470: ;
471: else if (class < DC_MOS)
472: iput(val = iget());
473: else {
474: bput(bget());
475: bput(bget());
476: iput(iget());
477: }
478:
479: /* Get name */
480: sget(id, NCSYMB);
481:
482: /* Check for symbol table entry */
483: if (class==DC_GDEF || class==DC_SEX || class==DC_GREF) {
484: sp = glookup(id, 0);
485: sp->s_flag |= S_PUT;
486: } else if (class==DC_SIN) {
487: sp = llookup(val, 0);
488: sp->s_flag |= S_PUT;
489: }
490:
491: /* Put name */
492: sput(id);
493:
494: /* Get type */
495: for (;;) {
496: switch (bput(bget())) {
497: case DT_NONE:
498: case DT_CHAR:
499: case DT_UCHAR:
500: case DT_SHORT:
501: case DT_USHORT:
502: case DT_INT:
503: case DT_UINT:
504: case DT_LONG:
505: case DT_ULONG:
506: case DT_FLOAT:
507: case DT_DOUBLE:
508: case DT_VOID:
509: iput(iget());
510: break;
511: case DT_STRUCT:
512: case DT_UNION:
513: case DT_ENUM:
514: case DD_PTR:
515: case DD_FUNC:
516: case DD_ARRAY:
517: iput(iget());
518: continue;
519: break;
520: case DX_MEMBS:
521: bput(n = iget());
522: for ( ; n > 0; n-=1) {
523: outdlab(1, bget());
524: }
525: break;
526: case DX_NAME:
527: iget();
528: sget(id, NCSYMB);
529: sput(id);
530: break;
531: default:
532: cbotch("outdlab: %d", n);
533: }
534: break;
535: }
536: }
537:
538: #if 0 /* This routine is apparently unused. */
539: /*
540: * Output a debug line record.
541: */
542: outdlin(op)
543: {
544: bput(TDLAB);
545: bput(DC_LINE);
546: iput(line);
547: bput(op);
548: bput(0);
549: bput(DT_NONE);
550: iput(0);
551: }
552: #endif
553:
554: /*
555: * Output a debug relocation record.
556: * This 'n' is an index into the list of debug records written.
557: */
558: outdloc(n)
559: {
560: bput(TDLOC);
561: iput(n);
562: }
563:
564: /*
565: * Finish up the code.
566: * Some old outrel.c code is retained below for reference.
567: */
568: outdone()
569: {
570: #if 0
571: register SYM *sp;
572: register int i;
573: #endif
574:
575: if (isvariant(VASM))
576: return;
577:
578: #if 0
579: /*
580: * Make dlabel items for internally generated symbols.
581: */
582: for (i = 0; i < NSHASH; i++) {
583: for (sp = hash2[i]; sp != NULL; sp = sp->s_fp) {
584: if (((sp->s_flag&S_GBL) != 0 || (sp->s_flag&S_DEF) == 0)
585: && ((sp->s_flag&S_PUT) == 0)) {
586: bput(TDLAB);
587: bput(DC_GREF);
588: iput(0);
589: sput(sp->s_id);
590: bput(DT_NONE);
591: iput(0);
592: }
593: }
594: }
595: #endif
596:
597: #if EMUFIXUPS
598: /*
599: * Put magic names into the symbol table
600: * if any 8087 code was generated.
601: */
602: if (has8087) {
603: wsp[0] = glookup("M:_WT", 0);
604: wsp[1] = glookup("M:_WST", 0);
605: wsp[2] = glookup("M:_WES", 0);
606: wsp[3] = glookup("M:_WCS", 0);
607: wsp[4] = glookup("M:_WSS", 0);
608: wsp[5] = glookup("M:_WDS", 0);
609: }
610: #endif
611: bput(TEND);
612: }
613:
614: /*
615: ** Second pass routines.
616: ** Read the temporary file and write the output.
617: */
618: /*
619: * Finish up.
620: * Figure out the sizes and final values of everything.
621: * Copy the code from the scratch file back to the output file.
622: */
623: copycode()
624: {
625: register int op;
626: register SYM *sp;
627: register int i;
628: register ADDRESS v;
629: int fixup;
630: int nd;
631: int nr;
632: int data;
633: char coment[30];
634: long debugdef;
635:
636: /*
637: * Assign base addresses to the compiler's logical segments, based on
638: * the compilation model and the settings of the VROM and VRAM flags.
639: */
640: seg[SCODE].s_mseek = 0;
641: v = rup(seg[SCODE].s_dot);
642: seg[SLINK].s_mseek = v;
643: v += rup(seg[SLINK].s_dot);
644: if ((isvariant(VSMALL)) || (isvariant(VRAM))) {
645: code_size = v;
646: v = 0;
647: }
648: seg[SPURE].s_mseek = v;
649: v += rup(seg[SPURE].s_dot);
650: if (notvariant(VROM) && notvariant(VRAM)) {
651: if (isvariant(VSMALL))
652: const_size = v;
653: else
654: code_size = v;
655: v = 0;
656: }
657: seg[SSTRN].s_mseek = v;
658: v += rup(seg[SSTRN].s_dot);
659: if (isvariant(VROM)) {
660: if (isvariant(VSMALL))
661: const_size = v;
662: else
663: code_size = v;
664: v = 0;
665: }
666: seg[SDATA].s_mseek = v;
667: v += rup(seg[SDATA].s_dot);
668: seg[SBSS].s_mseek = v;
669: bss_size = rup(seg[SBSS].s_dot);
670: data_size = v + bss_size;
671:
672: /*
673: * Put out the preamble.
674: */
675: puttheadr(); /* THEADR */
676: coment[0] = coment[1] = '\0';
677: sprintf(&coment[2], "%s %s %s %s",
678: #ifdef vax
679: "VAX",
680: #else
681: #ifdef UDI
682: "UDI",
683: #else
684: #ifdef MSDOS
685: "MS-DOS",
686: #else
687: "COHERENT",
688: #endif
689: #endif
690: #endif
691: "MWC86", VERSMWC,
692: (isvariant(VSMALL)) ? "SMALL" : "LARGE");
693: putrecord(COMENT, coment, strlen(&coment[2])+2); /* COMENT */
694: putlnames(); /* LNAMES */
695: if (isvariant(VLARGE)) {
696: putsegdef(PARA|CCON, code_size, 2, 4); /* [1] */
697: putsegdef(PARA|CCON, data_size, 3, 5); /* [2] */
698: if (VCSD)
699: debugdef = putsegdef(BYTE|CCON, 0, 7, 6); /* [3] */
700: } else {
701: putsegdef(BYTE|CCON, code_size, 2, 2); /* [1] */
702: putsegdef(BYTE|CCON, const_size, 4, 4); /* [2] */
703: putsegdef(BYTE|CCON, data_size, 3, 3); /* [3] */
704: putsegdef(PARA|CSTACK, 0, 5, 5); /* [4] */
705: putsegdef(PARA|CMEM, 0, 6, 6); /* [5] */
706: if (VCSD)
707: debugdef = putsegdef(BYTE|CCON, 0, 10, 9); /* [6] */
708: putrecord(GRPDEF, gdef1, sizeof(gdef1)); /* [1] */
709: putrecord(GRPDEF, gdef2, sizeof(gdef2)); /* [2] */
710: }
711: putrecord(TYPDEF, typdef, sizeof(typdef)); /* TYPDEF */
712: if (isvariant(VLARGE))
713: putrecord(FIXUPP, lthred, sizeof(lthred));
714: else
715: putrecord(FIXUPP, sthred, sizeof(sthred)); /* Threads */
716: putsymdef(); /* PUBDEF, EXTDEF */
717:
718: /*
719: * Copy out code.
720: */
721: for (i=0; i<NSEG; ++i)
722: seg[i].s_dot = seg[i].s_mseek;
723: dotseg = SCODE;
724: dot = seg[SCODE].s_dot;
725: while ((op = bget()) != TEND) {
726: switch (op) {
727:
728: case TENTER:
729: notenuf();
730: enter(bget());
731: continue;
732: case TDLAB:
733: getdlab();
734: continue;
735: case TDLOC:
736: getdloc();
737: continue;
738: #if 0
739: /* See comment on outcb()/outdb() above. */
740: case TCODE:
741: case TDATA:
742: if (isvariant(VSMALL))
743: cbotch("code:data");
744: enuf(2, 4);
745: fixup = txtp - (txt+3);
746: *txtp++ = 0;
747: *txtp++ = 0;
748: *relp++ = LOCAT|M|BASE|(fixup>>8);
749: *relp++ = fixup;
750: *relp++ = FTARGET|SECWAY|TSI;
751: *relp++ = (op==TCODE) ? 1 : 2;
752: dot += 2;
753: continue;
754: #endif
755: case TBASE:
756: if (isvariant(VSMALL))
757: cbotch("base");
758: sp = pget();
759: if ((sp->s_flag&S_DEF) != 0) {
760: enuf(2, 4);
761: fixup = txtp - (txt+3);
762: *txtp++ = 0;
763: *txtp++ = 0;
764: *relp++ = LOCAT|M|BASE|(fixup>>8);
765: *relp++ = fixup;
766: *relp++ = FTARGET|SECWAY|TSI;
767: *relp++ = getsegindex(sp->s_seg);
768: dot += 2;
769: continue;
770: }
771: nr = 4;
772: if (sp->s_ref >= 128)
773: ++nr;
774: enuf(2, nr);
775: fixup = txtp - (txt+3);
776: *txtp++ = 0;
777: *txtp++ = 0;
778: *relp++ = LOCAT|M|BASE|(fixup>>8);
779: *relp++ = fixup;
780: *relp++ = FTARGET|SECWAY|TEI;
781: relp = setindex(relp, sp->s_ref);
782: dot += 2;
783: continue;
784: }
785: if ((op&TTYPE) == TBYTE) {
786: nd = 1;
787: data = bget();
788: } else {
789: nd = 2;
790: data = iget();
791: }
792: #if EMUFIXUPS
793: /*
794: * 8087 opcodes.
795: * Apply magic relocation for the emulator.
796: */
797: if ((op&T8087) != 0) {
798: sp = wsp[((op&T8087)-TWT)>>5];
799: nr = 6;
800: if (sp->s_ref >= 128)
801: ++nr;
802: enuf(nd, nr);
803: fixup = txtp - (txt+3);
804: *txtp++ = data;
805: if (nd != 1) {
806: *txtp++ = data >> 8;
807: fixup |= OFFSET << 8; /* Locat */
808: }
809: fixup |= M << 8; /* Seg rel */
810: *relp++ = (fixup>>8) | LOCAT; /* Not thread */
811: *relp++ = fixup;
812: *relp++ = FD8087; /* Symbol based */
813: *relp++ = 0; /* Frame # */
814: *relp++ = 0;
815: relp = setindex(relp, sp->s_ref);
816: dot += nd;
817: continue;
818: }
819: #endif
820: /*
821: * Absolute.
822: */
823: if ((op&(TSYM|TPCR)) == 0) {
824: enuf(nd, 0);
825: *txtp++ = data;
826: if (nd != 1)
827: *txtp++ = data >> 8;
828: dot += nd;
829: continue;
830: }
831: /*
832: * Absolute PC rel.
833: */
834: if ((op&TSYM) == 0) {
835: enuf(nd, 6);
836: fixup = txtp - (txt+3);
837: *txtp++ = 0;
838: if (nd != 1) {
839: *txtp++ = 0;
840: fixup |= OFFSET << 8;
841: }
842: *relp++ = (fixup>>8) | LOCAT; /* Not thread */
843: *relp++ = fixup;
844: *relp++ = FTARGET|TFN; /* Absolute frame */
845: *relp++ = 0; /* Frame number */
846: *relp++ = data; /* Disp */
847: *relp++ = data >> 8;
848: dot += nd;
849: continue;
850: }
851: /*
852: * Symbol based.
853: * I would like to always do this
854: * in the primary way. However, LINK-86
855: * doesn't do 3 byte offsets, so I cannot
856: * do a negative one.
857: */
858: sp = pget();
859: if ((sp->s_flag&S_DEF) != 0) {
860: data += sp->s_value;
861: /* Absolute */
862: if ((op&TPCR)!=0 && sp->s_seg==dotseg) {
863: enuf(nd, 0);
864: data -= dot+nd;
865: *txtp++ = data;
866: if (nd != 1)
867: *txtp++ = data >> 8;
868: dot += nd;
869: continue;
870: }
871: /* Segment relative */
872: enuf(nd, 6);
873: fixup = txtp - (txt+3);
874: *txtp++ = 0;
875: if (nd != 1) {
876: *txtp++ = 0;
877: fixup |= OFFSET << 8; /* Loc */
878: }
879: if ((op&TPCR) == 0)
880: fixup |= M << 8; /* Seg rel */
881: *relp++ = (fixup>>8) | LOCAT; /* Not thread */
882: *relp++ = fixup;
883: fixup = F|FT0|TSI; /* F code, seg ind */
884: if (getsegindex(sp->s_seg) != 1)
885: fixup |= FT1; /* F data */
886: *relp++ = fixup;
887: *relp++ = getsegindex(sp->s_seg);
888: *relp++ = data; /* Disp */
889: *relp++ = data >> 8;
890: dot += nd;
891: continue;
892: }
893: /*
894: * Symbol relative.
895: */
896: nr = 4;
897: if (sp->s_ref >= 128) /* Two byte index */
898: ++nr;
899: enuf(nd, nr);
900: fixup = txtp - (txt+3);
901: *txtp++ = data;
902: if (nd != 1) {
903: *txtp++ = data >> 8;
904: fixup |= OFFSET << 8; /* Loc */
905: }
906: if ((op&TPCR) == 0)
907: fixup |= M << 8; /* Seg rel */
908: *relp++ = LOCAT|(fixup>>8); /* Not THREAD */
909: *relp++ = fixup;
910: *relp++ = FTARGET|SECWAY|TEI; /* Fix dat */
911: relp = setindex(relp, sp->s_ref);
912: dot += nd;
913: }
914: if (isvariant(VLINES))
915: outbrace('}');
916: if (notvariant(VLIB))
917: dump();
918: if (VCSD)
919: oglobals(); /* Dump globals */
920: enter(SDATA); /* flush */
921: /*
922: * If the size of the SBSS segment is nonzero,
923: * use an LIDATA item to get it zeroed when the program is run.
924: */
925: if (bss_size != 0) {
926: txtp = &txt[0];
927: *txtp++ = (isvariant(VSMALL)) ? 3 : 2; /* DATA */
928: *txtp++ = seg[SBSS].s_mseek; /* Offset */
929: *txtp++ = seg[SBSS].s_mseek >> 8;
930: *txtp++ = bss_size; /* Length of loop */
931: *txtp++ = bss_size >> 8;
932: *txtp++ = 0;
933: *txtp++ = 0;
934: *txtp++ = 1;
935: *txtp++ = 0;
936: putrecord(LIDATA, txt, 9); /* LIDATA */
937: }
938: putrecord(MODEND, modend, sizeof(modend)); /* MODEND */
939: #if VAXFMT
940: vaxflush();
941: #endif
942: if (VCSD) {
943: if (fseek(ofp, debugdef, 0) == -1)
944: cbotch("fixsegdef seek failed");
945: if (isvariant(VLARGE))
946: putsegdef(BYTE|CCON, seg[SDBG].s_dot, 7, 6);
947: else
948: putsegdef(BYTE|CCON, seg[SDBG].s_dot, 10, 9);
949: }
950: }
951:
952: /*
953: ** Header writing routines.
954: */
955: /*
956: * Put out a THEADR item.
957: * The name is just the module name that the compiler has been keeping.
958: * It must be mapped into upper case before writing it to the file.
959: */
960: puttheadr()
961: {
962: register char *p1, *p2;
963: register c;
964: char b[40];
965:
966: p1 = module;
967: p2 = &b[0];
968: *p2++ = strlen(p1);
969: while ((c = *p1++) != '\0') {
970: #if 0
971: if (c>='a' && c<='z')
972: c -= 'a'-'A';
973: #endif
974: *p2++ = c;
975: }
976: putrecord(THEADR, b, p2-b);
977: }
978:
979: /*
980: * Write the list of names record.
981: * For SMALL model, write the standard 'lnames' record:
982: * [1] ""
983: * [2] "CODE"
984: * [3] "DATA"
985: * [4] "CONST"
986: * [5] "STACK"
987: * [6] "MEMORY"
988: * [7] "CGROUP"
989: * [8] "DGROUP"
990: * [9] "DEBUG" (if -VCSD)
991: * [10] "module_DEBUG" (if -VCSD)
992: * For LARGE model, the names are:
993: * [1] ""
994: * [2] "module_CODE"
995: * [3] "module_DATA"
996: * [4] "CODE"
997: * [5] "DATA"
998: * [6] "DEBUG" (if -VCSD)
999: * [7] "module_DEBUG" (if -VCSD)
1000: */
1001: putlnames()
1002: {
1003: register char *p1;
1004: char *movelname();
1005: char b[1 + 1+40+5 + 1+40+5 + 1+4 + 1+4 + 1+5 + 1+40+6];
1006:
1007: p1 = &b[0];
1008: *p1++ = 0; /* "" */
1009: if (isvariant(VSMALL)) {
1010: p1 = movelname(p1, "CODE", 0);
1011: p1 = movelname(p1, "DATA", 0);
1012: p1 = movelname(p1, "CONST", 0);
1013: p1 = movelname(p1, "STACK", 0);
1014: p1 = movelname(p1, "MEMORY", 0);
1015: p1 = movelname(p1, "CGROUP", 0);
1016: p1 = movelname(p1, "DGROUP", 0);
1017: } else {
1018: p1 = movelname(p1, "CODE", 1);
1019: p1 = movelname(p1, "DATA", 1);
1020: p1 = movelname(p1, "CODE", 0);
1021: p1 = movelname(p1, "DATA", 0);
1022: }
1023: if (VCSD) {
1024: p1 = movelname(p1, "DEBUG", 0);
1025: p1 = movelname(p1, "DEBUG", 1);
1026: }
1027: putrecord(LNAMES, b, p1-b);
1028: }
1029:
1030: /*
1031: * If flag==0, move p2 to the supplied buffer p1.
1032: * If flag==1, move module_p2 to p1.
1033: * Used by putlnames().
1034: */
1035: char *
1036: movelname(p1, p2, flag)
1037: register char *p1;
1038: char *p2;
1039: {
1040: register char *p3;
1041: register c;
1042:
1043: p3 = module;
1044: if (flag) {
1045: *p1++ = strlen(p3) + 1 + strlen(p2); /* length of "module_p2" */
1046: while ((c = *p3++) != '\0') { /* copy module name */
1047: #if 0
1048: if (c>='a' && c<='z')
1049: c -= 'a'-'A';
1050: #endif
1051: *p1++ = c;
1052: }
1053: *p1++ = '_'; /* append '_' */
1054: } else
1055: *p1++ = strlen(p2);
1056: p3 = p2;
1057: while ((c = *p3++) != '\0') /* copy p2 */
1058: *p1++ = c;
1059: return (p1);
1060: }
1061:
1062: /*
1063: * This routine formats and outputs a SEGDEF item.
1064: * There is no checking for BIG segments (segments that are 64k in size).
1065: * The overlay index points to a null name.
1066: * Return the location of the first byte of the record.
1067: */
1068: long
1069: putsegdef(flag, size, segi, classi)
1070: {
1071: long l;
1072: register char *bp;
1073: char b[6];
1074:
1075: l = ftell(ofp);
1076: bp = &b[0];
1077: *bp++ = flag;
1078: *bp++ = size;
1079: *bp++ = size >> 8;
1080: *bp++ = segi;
1081: *bp++ = classi;
1082: *bp++ = 1;
1083: putrecord(SEGDEF, b, 6);
1084: return(l);
1085: }
1086:
1087: /*
1088: * Sweep through the symbol table:
1089: * 1) Make symbols LSEG relative.
1090: * 2) Assign reference numbers.
1091: * 3) Output EXTDEF or PUBDEF.
1092: */
1093: putsymdef()
1094: {
1095: register SYM *sp;
1096: register int refnum;
1097: register int i;
1098:
1099: refnum = 1;
1100: for (i=0; i<NSHASH; ++i) {
1101: for (sp = hash2[i]; sp != NULL; sp = sp->s_fp ) {
1102: if ((sp->s_flag&S_DEF) != 0)
1103: sp->s_value += seg[sp->s_seg].s_mseek;
1104: if ((sp->s_flag&S_GBL)!=0 || (sp->s_flag&S_DEF)==0) {
1105: sp->s_ref = 0;
1106: if ((sp->s_flag&S_DEF) != 0) {
1107: putpubdef(sp);
1108: } else {
1109: sp->s_ref = refnum++;
1110: putextdef(sp);
1111: }
1112: }
1113: }
1114: }
1115: }
1116:
1117: /*
1118: * Put out a PUBDEF item for symbol 'sp'.
1119: * All defs are tagged with the group
1120: * so that a FTARGET,EI fixup can determine the correct frame.
1121: */
1122: putpubdef(sp)
1123: register SYM *sp;
1124: {
1125: register char *bp;
1126: char b[1+1+40+2+1];
1127:
1128: bp = &b[0];
1129: *bp++ = getgrpindex(sp->s_seg);
1130: *bp++ = getsegindex(sp->s_seg);
1131: bp = setsymid(bp, sp->s_id);
1132: *bp++ = sp->s_value;
1133: *bp++ = sp->s_value >> 8;
1134: *bp++ = 1;
1135: putrecord(PUBDEF, b, bp-b);
1136: }
1137:
1138: /*
1139: * Put out an EXTDEF item for symbol 'sp'.
1140: */
1141: putextdef(sp)
1142: register SYM *sp;
1143: {
1144: register char *bp;
1145: char b[40+2];
1146:
1147: bp = setsymid(b, sp->s_id);
1148: *bp++ = 1;
1149: putrecord(EXTDEF, b, bp-b);
1150: }
1151:
1152: /*
1153: * Translate compiler segment codes
1154: * to OMF segment index value, using tables.
1155: * The table is selected by the model and the
1156: * setting of the VROM and VRAM variants.
1157: */
1158: getsegindex(s)
1159: register int s;
1160: {
1161: if (s > SBSS) {
1162: if (s == SDBG)
1163: return(isvariant(VSMALL) ? 6 : 3);
1164: else
1165: cbotch("getsegindex, seg=%d", s);
1166: }
1167: if (isvariant(VSMALL))
1168: return( (isvariant(VRAM)) ? sramseg[s]
1169: : (notvariant(VROM)) ? snonseg[s]
1170: : sromseg[s]);
1171: else
1172: return( (isvariant(VRAM)) ? lramseg[s]
1173: : (notvariant(VROM)) ? lnonseg[s]
1174: : lromseg[s]);
1175: }
1176:
1177: /*
1178: * Like getsegindex(), but returns a reloc-type segment name for CSD.
1179: */
1180: segindex(s) register int s;
1181: {
1182: register int seg;
1183:
1184: seg = getsegindex(s); /* Map to output segment */
1185: if (isvariant(VSMALL)) {
1186: if (seg == 1)
1187: return(PURCODE);
1188: else if (seg == 2 || seg == 3)
1189: return(PURDATA);
1190: } else {
1191: if (seg == 1)
1192: return(PURCODE);
1193: else if (seg == 2)
1194: return(PURDATA);
1195: }
1196: cbotch("segindex, s=%x, seg=%x\n", s, seg);
1197: }
1198:
1199: /*
1200: * Translate compiler segment codes
1201: * to OMF group index value, using table and model.
1202: */
1203: getgrpindex(s)
1204: register int s;
1205: {
1206: return (isvariant(VSMALL) ? grpindex[s] : 0);
1207: }
1208:
1209: /*
1210: ** Debug information processors.
1211: */
1212: /*
1213: * Read debug table item(s) into memory.
1214: */
1215: getdlab()
1216: {
1217: register struct dbgt *dp;
1218: static int refnum = 0;
1219:
1220: dp = getdbgt();
1221:
1222: /* This should be done in cc0 */
1223:
1224: if (isvariant(VLIB)) {
1225: switch (dp->d_class) {
1226: case DC_TYPE:
1227: case DC_STAG:
1228: case DC_UTAG:
1229: case DC_ETAG:
1230: return;
1231: }
1232: }
1233: if (dp->d_class == DC_LINE || dp->d_class == DC_LAB)
1234: dp->d_ref = refnum;
1235:
1236: refnum += 1;
1237: if (dbase == NULL)
1238: dbase = dp;
1239: if (dnext != NULL)
1240: dnext->d_dp = dp;
1241: dbrpt("enter", dp);
1242: while (dp->d_dp != NULL) {
1243: dp = dp->d_dp;
1244: dbrpt("enter", dp);
1245: }
1246: dnext = dp;
1247: if (dp->d_class == DC_FILE)
1248: outbrace('{');
1249: }
1250:
1251: /*
1252: * Read in debug items translating into loader type syntax.
1253: * Member definitions are fetched recursively.
1254: * If a tag or type definition, the member definitions are appended to the
1255: * node surrounded by "{" and "}" nodes.
1256: * If not a tag definition, the member definitions are discarded.
1257: * In either case, the member types are appended to the type of the
1258: * parent node.
1259: */
1260: #define DSZ 512
1261: struct dbgt *
1262: getdbgt()
1263: {
1264: register int n;
1265: register char *dptr;
1266: struct dbgt d;
1267: char data[DSZ];
1268: int value, width, offs;
1269: int typet, subt, membs;
1270: char *sdp;
1271:
1272: d.d_dp = NULL;
1273: d.d_ref = -1;
1274: d.d_flag = D_LCL;
1275: d.d_level = level;
1276: d.d_seg = LASTSEG;
1277: d.d_cseg = 0;
1278: d.d_value = 0;
1279: d.d_size = 0;
1280: width = membs = 0;
1281:
1282: /*
1283: * Loop to read entire record:
1284: * class, optional value, name, type.
1285: */
1286: dptr = data;
1287: for (typet = 0; ; typet += 1) {
1288:
1289: if (dptr >= data+DSZ) {
1290: dbrpt("1", &d);
1291: cbotch("getdbgt buffer");
1292: }
1293:
1294: n = bget();
1295: if (n < DX_MEMBS)
1296: value = iget() * NBPBYTE;
1297: else if (n < DC_SEX)
1298: ;
1299: else {
1300: dline = iget();
1301: if (n < DC_AUTO)
1302: ;
1303: else if (n < DC_MOS)
1304: value = iget();
1305: else {
1306: width = bget();
1307: offs = bget();
1308: value = iget();
1309: }
1310: }
1311: subt = 0;
1312:
1313: switch (n) {
1314:
1315: /*
1316: * Classes: fetch values and set flags.
1317: */
1318: case DC_SEX:
1319: d.d_flag |= D_NAM;
1320: goto setclass;
1321:
1322: case DC_GDEF:
1323: case DC_GREF:
1324: d.d_flag = D_GBL|D_NAM;
1325: goto setclass;
1326:
1327: case DC_ETAG:
1328: d.d_flag |= D_ENU;
1329: strcpy(dptr, "enum ");
1330: dptr += 5;
1331: goto tag;
1332: case DC_STAG:
1333: strcpy(dptr, "struct ");
1334: dptr += 7;
1335: goto tag;
1336: case DC_UTAG:
1337: strcpy(dptr, "union ");
1338: dptr += 6;
1339: case DC_TYPE:
1340: tag:
1341: d.d_flag = (level == 0) ? D_TAG|D_GBL
1342: : D_TAG|D_LCL;
1343: d.d_seg = TYPESYM;
1344: goto setclass;
1345:
1346: case DC_FILE:
1347: d.d_seg = PURCODE;
1348: goto setclass;
1349:
1350: case DC_AUTO:
1351: d.d_seg = L_STACK;
1352: d.d_value = value;
1353: goto setclass;
1354:
1355: case DC_SIN:
1356: d.d_flag |= D_LAB;
1357: goto setclass;
1358:
1359: case DC_LAB:
1360: goto setclass;
1361:
1362: case DC_REG:
1363: d.d_seg = L_REG;
1364: d.d_value = value;
1365: goto setclass;
1366:
1367: case DC_PREG:
1368: if (level == 0) {
1369: level++;
1370: outbrace('{');
1371: }
1372: d.d_seg = L_REG;
1373: d.d_value = value;
1374: goto setclass;
1375:
1376: case DC_MOE:
1377: d.d_seg = ABSLUTE;
1378: d.d_value = value;
1379: goto setclass;
1380:
1381: case DC_PAUTO:
1382: if (level == 0) {
1383: level++;
1384: outbrace('{');
1385: }
1386: d.d_seg = P_STACK;
1387: d.d_value = value;
1388: goto setclass;
1389:
1390: case DC_LINE:
1391: goto setclass;
1392:
1393: case DC_MOS:
1394: case DC_MOU:
1395: d.d_seg = FLD_OFF;
1396: d.d_value = value * NBPBYTE + offs;
1397: goto setclass;
1398:
1399: /*
1400: * Set the class field, read the name;
1401: * Lookup globals and statics.
1402: */
1403: setclass:
1404: d.d_class = n;
1405: while (*dptr++ = bget())
1406: ;
1407: if ((d.d_flag&(D_NAM|D_LAB)) != 0) {
1408: register SYM *sp;
1409:
1410: if ((d.d_flag&D_NAM) != 0)
1411: sp = glookup(data, 0);
1412: else
1413: sp = llookup(value, 0);
1414: if ((sp->s_flag&S_DEF) != 0) {
1415: d.d_cseg = sp->s_seg;
1416: d.d_seg = segindex(sp->s_seg);
1417: d.d_value = sp->s_value;
1418: }
1419: #if COMMON
1420: else if (sp->s_value != 0) {
1421: d.d_seg = BLDATA|Cb;
1422: d.d_value = sp->s_value;
1423: }
1424: #endif
1425: if ((d.d_flag&D_GBL) != 0)
1426: d.d_ref = sp->s_ref;
1427: }
1428: continue;
1429:
1430: /*
1431: * Types: write type and prepare for trailing data.
1432: * For files and lines, write a phony type.
1433: */
1434: case DT_NONE:
1435: if (d.d_class == DC_FILE) {
1436: register char *p;
1437:
1438: *dptr++ = STRINGt;
1439: p = "source file";
1440: while (*dptr++ = *p++)
1441: ;
1442: }
1443: if (d.d_class == DC_LINE) {
1444: *dptr++ = 6; /* Line */
1445: *dptr++ = dline;
1446: *dptr++ = dline >> 8;
1447: *dptr++ = 0; /* Column */
1448: *dptr++ = 0; /* Flag */
1449: *dptr++ = 0; /* Saved instruction */
1450: *dptr++ = 0;
1451: }
1452: break;
1453:
1454: case DT_CHAR:
1455: case DT_SHORT:
1456: case DT_INT:
1457: case DT_LONG:
1458: n = Integer;
1459: goto getwidth;
1460:
1461: case DT_UCHAR:
1462: case DT_USHORT:
1463: case DT_UINT:
1464: case DT_ULONG:
1465: n = Natural;
1466: goto getwidth;
1467:
1468: case DT_FLOAT:
1469: case DT_DOUBLE:
1470: n = Rational;
1471: goto settype;
1472:
1473: case DT_VOID:
1474: n = Void;
1475: goto settype;
1476:
1477: case DT_STRUCT:
1478: membs = n;
1479: n = Record;
1480: sdp = dptr;
1481: goto settype;
1482:
1483: case DT_UNION:
1484: membs = n;
1485: n = Union;
1486: sdp = dptr;
1487: goto settype;
1488:
1489: case DT_ENUM:
1490: d.d_flag |= D_ENU;
1491: membs = n;
1492: n = Natural;
1493: sdp = dptr;
1494: goto settype;
1495:
1496: getwidth:
1497: if (width)
1498: value = width;
1499:
1500: settype:
1501: *dptr++ = 1;
1502: *dptr++ = n;
1503: if (n != Void) {
1504: if (value == 0)
1505: *dptr++ = ANYt;
1506: else if (value <= 0377) {
1507: *dptr++ = 1;
1508: *dptr++ = value;
1509: } else {
1510: *dptr++ = 2;
1511: *dptr++ = value;
1512: *dptr++ = value >> 8;
1513: }
1514: }
1515: if (subt) {
1516: *dptr++ = TYPEt;
1517: continue;
1518: }
1519: if (membs) {
1520: --typet;
1521: continue;
1522: }
1523: break;
1524:
1525: /*
1526: * Dimensions: as for types, but flag for subtypes.
1527: */
1528: case DD_PTR:
1529: n = Pointer;
1530: ++subt;
1531: goto settype;
1532:
1533: case DD_FUNC:
1534: n = Proc;
1535: ++subt;
1536: goto settype;
1537:
1538: case DD_ARRAY:
1539: n = Array;
1540: ++subt;
1541: goto settype;
1542:
1543: /*
1544: * Trailing struct/union/enum data.
1545: */
1546: case DX_NAME:
1547: dptr = sdp;
1548: *dptr++ = STRINGt;
1549: switch (membs) {
1550: case DT_STRUCT:
1551: strcpy(dptr, "struct ");
1552: dptr += 7;
1553: break;
1554: case DT_UNION:
1555: strcpy(dptr, "union ");
1556: dptr += 6;
1557: break;
1558: case DT_ENUM:
1559: strcpy(dptr, "enum ");
1560: dptr += 5;
1561: }
1562: while (*dptr++ = bget())
1563: ;
1564: membs = 0;
1565: break;
1566:
1567: case DX_MEMBS:
1568: level += 1;
1569: dptr = getmembs(&d, data, dptr);
1570: level -= 1;
1571: membs = 0;
1572: break;
1573:
1574: default:
1575: cbotch("getdbgt: %d", n);
1576: }
1577: /*
1578: * Terminate types.
1579: */
1580: if (dptr + typet >= data + DSZ) {
1581: dbrpt("2", &d);
1582: cbotch("getdbgt buffer");
1583: }
1584: while (--typet >= 0)
1585: *dptr++ = 0;
1586: break;
1587: }
1588:
1589: /*
1590: * Check level change.
1591: */
1592: if (data[0] == '{') {
1593: if (level++ == 0) {
1594: d.d_level = level++;
1595: outbrace('{');
1596: }
1597: }
1598: else if (data[0] == '}')
1599: level -= 1;
1600:
1601: /*
1602: * Copy into dynamic storage.
1603: */
1604: d.d_size = dptr - data;
1605: return (newdbgt(&d, data));
1606: }
1607:
1608: /*
1609: * Enter a new output segment.
1610: */
1611: enter(newseg)
1612: register int newseg;
1613: {
1614: if (dotseg == newseg)
1615: return; /* already in newseg */
1616: notenuf(); /* flush */
1617: seg[dotseg].s_dot = dot; /* save current dot */
1618: dotseg = newseg; /* reset dotseg */
1619: dot = seg[dotseg].s_dot; /* and dot */
1620: }
1621:
1622: /*
1623: * Read a debug relocation item and patch current 'dot'
1624: * into the appropriate debug/symbol table item.
1625: * If the debug item is '}' and level 2, then dump the batch of locals.
1626: * If the debug item is '}' and level 1, then dump the type definitions.
1627: */
1628: getdloc()
1629: {
1630: register struct dbgt *dp;
1631: register int ref;
1632:
1633: ref = iget();
1634: for (dp = dbase; ; dp = dp->d_dp) {
1635: if (dp == NULL)
1636: cbotch("getdloc: %d", ref);
1637: if ((dp->d_flag&D_GBL) != 0)
1638: continue;
1639: if (dp->d_ref == ref)
1640: break;
1641: }
1642: dp->d_cseg = dotseg;
1643: dp->d_seg = segindex(dotseg);
1644: dp->d_value = dot;
1645:
1646: dbrpt("reloc", dp);
1647: if (dp->d_data[0] == '}' && dp->d_level <= 2) {
1648: outbrace('}');
1649: level--;
1650: dump();
1651: }
1652: }
1653:
1654: /*
1655: * Dump the locals and type definitions.
1656: */
1657: dump()
1658: {
1659: register struct dbgt *dp, **dpp;
1660: int saveseg;
1661:
1662: saveseg = dotseg;
1663: enter(SDBG);
1664: dpp = &dbase;
1665: dnext = NULL;
1666: while ((dp = *dpp) != NULL) {
1667: if ((dp->d_flag&D_LCL) != 0) {
1668: dbrpt("write", dp);
1669: osymbol(dp, -1);
1670: dp->d_flag &= ~D_LCL;
1671: }
1672: if ((dp->d_flag&D_GBL) == 0) {
1673: dbrpt("free", dp);
1674: *dpp = dp->d_dp;
1675: free(dp);
1676: } else {
1677: dbrpt("save", dp);
1678: dnext = dp;
1679: dpp = &dp->d_dp;
1680: }
1681: }
1682: enter(saveseg);
1683: }
1684:
1685: /*
1686: * Write out global symbol definitions and references.
1687: */
1688: oglobals()
1689: {
1690: register struct dbgt *dp, *dp1;
1691:
1692: enter(SDBG);
1693: for (dp = dbase; dp != NULL; dp = dp1) {
1694: dp1 = dp->d_dp;
1695: dbrpt("write", dp);
1696: if (dp->d_seg == TYPESYM || dp->d_seg == ABSLUTE)
1697: osymbol(dp, 0);
1698: else
1699: osymbol(dp, dp->d_ref);
1700: dbrpt("free", dp);
1701: free(dp);
1702: }
1703: notenuf();
1704: }
1705:
1706: /*
1707: * Write out a symbol to the symbol or debug table.
1708: * TYPESYM and ABSLUTE symbols have refnum 0.
1709: * Debug table symbols have negative refnums and may require relocation.
1710: */
1711: osymbol(dp, refnum)
1712: register struct dbgt *dp;
1713: {
1714: register char *cp;
1715: unsigned char seg;
1716: int nd, nr, fixup, fixseg;
1717:
1718: /* Write scope/refnum or seg/value+relocation expression */
1719: seg = dp->d_seg;
1720: nd = 5 + dp->d_size;
1721: nr = 0;
1722: #if 0
1723: printf("osymbol(%s, %x) seg=%x cseg=%x nd=%x\n", dp->d_data, refnum, seg,
1724: dp->d_cseg, nd);
1725: #endif
1726: if (refnum >= 0) {
1727: if (seg == LASTSEG) {
1728: for (cp=dp->d_data; *cp++; )
1729: ; /* skip the name */
1730: seg = (*cp++ == 1 && *cp++ == Proc) ? PURCODE : PURDATA;
1731: fixseg = -1; /* external fixup */
1732: } else
1733: fixseg = getsegindex(dp->d_cseg);
1734: if (seg != TYPESYM && seg != ABSLUTE)
1735: nr = (isvariant(VLARGE)) ? 10 : 6;
1736: } else if (refnum < 0) {
1737: if (seg < SUMMARY && seg != TYPESYM && seg != ABSLUTE) {
1738: nr = (isvariant(VLARGE)) ? 10 : 6;
1739: fixseg = getsegindex(dp->d_cseg);
1740: }
1741: else
1742: fixseg = 1; /* CODE */
1743: }
1744: enuf(nd, nr);
1745: dot += nd; /* bump dot */
1746: *txtp++ = seg; /* reloc-style segment */
1747: if (fixseg == -1) { /* extern fixup */
1748: if (isvariant(VLARGE)) {
1749: fixup = txtp - (txt+3);
1750: *relp++ = LOCAT|M|BASE|(fixup>>8);
1751: *relp++ = fixup;
1752: *relp++ = FTARGET|SECWAY|TEI;
1753: relp = setindex(relp, refnum);
1754: }
1755: *txtp++ = 0;
1756: *txtp++ = 0;
1757: fixup = txtp - (txt+3);
1758: *relp++ = LOCAT|M|OFFSET|(fixup>>8);
1759: *relp++ = fixup;
1760: *relp++ = FTARGET|SECWAY|TEI;
1761: relp = setindex(relp, refnum);
1762: *txtp++ = 0;
1763: *txtp++ = 0;
1764: } else {
1765: if (nr != 0 && isvariant(VLARGE)) { /* segment fixup */
1766: fixup = txtp - (txt+3);
1767: *relp++ = LOCAT|M|BASE|(fixup>>8);
1768: *relp++ = fixup;
1769: *relp++ = FTARGET|SECWAY|TSI;
1770: *relp++ = fixseg;
1771: }
1772: *txtp++ = 0;
1773: *txtp++ = 0; /* segment text */
1774: if (nr != 0) { /* offset text and fixup */
1775: fixup = txtp - (txt+3);
1776: *relp++ = LOCAT|M|OFFSET|(fixup>>8);
1777: *relp++ = fixup;
1778: if (fixseg == 1)
1779: *relp++ = F|FT0|TSI; /* fixup F code, seg index */
1780: else
1781: *relp++ = F|FT1|TSI; /* fixup F data, seg index */
1782: *relp++ = fixseg;
1783: *relp++ = dp->d_value;
1784: *relp++ = dp->d_value >> 8;
1785: *txtp++ = 0;
1786: *txtp++ = 0;
1787: } else {
1788: *txtp++ = dp->d_value;
1789: *txtp++ = dp->d_value >> 8; /* nonrelocated offset */
1790: }
1791: }
1792:
1793: /* Write name */
1794: cp = dp->d_data;
1795: nd = dp->d_size;
1796: do {
1797: *txtp++ = *cp;
1798: --nd;
1799: } while (*cp++);
1800:
1801: /* Type */
1802: while (--nd >= 0)
1803: *txtp++ = *cp++; /* type */
1804: }
1805:
1806: /*
1807: * Read a list of members of a union/struct/enum.
1808: * If struct/union, append member types to caller's buffer.
1809: * If making a debug table:
1810: * If struct/union tag definition, bracket member definitions.
1811: * If enum tag, make member type into "enum tag".
1812: */
1813: char *
1814: getmembs(dp0, bb, bp)
1815: struct dbgt *dp0;
1816: char *bb;
1817: register char *bp;
1818: {
1819: int nmembs, n, istag, isenu, isgbl, isdbg;
1820: char *sbp;
1821: register struct dbgt *dp;
1822: struct dbgt **dpp;
1823: register char *p;
1824: static struct dbgt dbrace = {
1825: NULL, /* d_dp */
1826: -1, /* d_ref */
1827: DT_NONE, /* d_class */
1828: D_LCL, /* d_flag */
1829: 0, /* d_level */
1830: TYPESYM, /* d_seg */
1831: 0, /* d_cseg */
1832: 0, /* d_value */
1833: 3 /* d_size */
1834: };
1835:
1836: dp = dp0;
1837: nmembs = bget();
1838: istag = (dp->d_flag&D_TAG) != 0;
1839: isenu = (dp->d_flag&D_ENU) != 0;
1840: isgbl = (dp->d_flag&D_GBL) != 0;
1841: isdbg = VCSD;
1842: if (isenu) {
1843: sbp = bp;
1844: isenu = strlen(bb) + 1 + 1;
1845: }
1846: if ( ! isenu) {
1847: #if DO_STRUCT_TYPE
1848: /* Note that this blows up for nmembs > 255 anyway */
1849: *bp++ = 1;
1850: *bp++ = nmembs;
1851: #else
1852: *bp++ = 1;
1853: *bp++ = 1;
1854: *bp++ = ANYt;
1855: #endif
1856: dpp = &dp->d_dp;
1857: dp = *dpp = newdbgt(&dbrace, "{\0\0");
1858: if (isgbl)
1859: dp->d_flag ^= D_GBL|D_LCL;
1860: }
1861: dpp = &dp->d_dp;
1862: while (--nmembs >= 0) {
1863: /* Note that dp could be a tagless structure, ie a list */
1864: dp = *dpp = getdbgt();
1865: if (isgbl)
1866: dp->d_flag ^= D_GBL|D_LCL;
1867: n = dp->d_size;
1868: p = dp->d_data;
1869: if (isenu && istag && isdbg) {
1870: /* Enumerators eschew member lists */
1871: dp->d_size += isenu;
1872: dp = newdbgt(dp, dp->d_data);
1873: bp = dp->d_data;
1874: while (*bp++)
1875: ;
1876: *bp++ = STRINGt;
1877: p = bb;
1878: while (*bp++ = *p++)
1879: ;
1880: *bp++ = 0;
1881: free(*dpp);
1882: *dpp = dp;
1883: bp = sbp;
1884: }
1885: #if DO_STRUCT_TYPE
1886: if ( ! isenu) {
1887: do {
1888: --n;
1889: } while (*p++);
1890: *bp++ = TYPEt;
1891: if (bp + n >= bb + DSZ) {
1892: dbrpt("3", dp);
1893: cbotch("getdbgt buffer");
1894: }
1895: do {
1896: *bp++ = *p++;
1897: } while (--n > 0);
1898: }
1899: #endif
1900: if (istag && isdbg)
1901: dpp = &dp->d_dp;
1902: else
1903: free(*dpp);
1904: }
1905: if ( ! isenu) {
1906: dp = *dpp = newdbgt(&dbrace, "}\0\0");
1907: dpp = &dp->d_dp;
1908: if (isgbl)
1909: dp->d_flag ^= D_GBL|D_LCL;
1910: }
1911: *dpp = NULL;
1912: return (bp);
1913: }
1914:
1915: struct dbgt *
1916: newdbgt(dp, cp)
1917: struct dbgt *dp;
1918: register char *cp;
1919: {
1920: register struct dbgt *ndp;
1921: register char *ncp;
1922: register int n;
1923:
1924: n = dp->d_size;
1925: if ((ndp = (struct dbgt *)malloc(sizeof(struct dbgt) + n)) == NULL)
1926: cnomem("newdbgt");
1927: *ndp = *dp;
1928: for (ncp = ndp->d_data; --n >= 0; *ncp++ = *cp++)
1929: ;
1930: return (ndp);
1931: }
1932:
1933: /*
1934: * Output a debug brace.
1935: */
1936: outbrace(c)
1937: int c;
1938: {
1939: struct dbgt *dp;
1940:
1941: if ((dp = (struct dbgt *)calloc(1, sizeof(struct dbgt) + 10)) == NULL)
1942: cnomem("outbrace");
1943: dp->d_class = DC_LINE;
1944: dp->d_flag = D_LCL;
1945: dp->d_seg = segindex(SCODE);
1946: dp->d_value = ( dotseg == SCODE ? dot : seg[SCODE].s_dot);
1947: dp->d_size = 10;
1948: dp->d_data[0] = c;
1949: *(dp->d_data + 2) = 6;
1950: *(dp->d_data + 3) = dline;
1951: *(dp->d_data + 4) = dline >> 8;
1952: if (dnext != NULL)
1953: dnext->d_dp = dp;
1954: dnext = dp;
1955: }
1956:
1957: #if !TINY
1958: _dbrpt(p, dp)
1959: char *p;
1960: register struct dbgt *dp;
1961: {
1962: if (xflag > 5)
1963: printf("%5s: %-10s %2x %2d %2x %2x %2x %2x %04x %2x\n",
1964: p,
1965: dp->d_data,
1966: dp->d_class,
1967: dp->d_ref,
1968: dp->d_flag,
1969: dp->d_level,
1970: dp->d_seg,
1971: dp->d_cseg,
1972: dp->d_value,
1973: dp->d_size
1974: );
1975: }
1976:
1977: #endif
1978:
1979: /*
1980: ** Low level record formatting.
1981: */
1982: /*
1983: * Put OMF index i at cp and return updated cp.
1984: */
1985: char *
1986: setindex(cp, i)
1987: register char *cp;
1988: register unsigned i;
1989: {
1990: if (i >= 128)
1991: *cp++ = (i >> 8) | 0x80;
1992: *cp++ = i;
1993: return (cp);
1994: }
1995:
1996: /*
1997: * This routine takes the name pointed to by 'cp' and
1998: * moves it into an OMF record. The 'bp' argument
1999: * is the OMF buffer pointer. The updated value
2000: * of 'bp' is returned.
2001: */
2002: char *
2003: setsymid(bp, cp)
2004: register char *bp;
2005: register char *cp;
2006: {
2007: register c, n;
2008:
2009: if ((n=strlen(cp)) > 39) {
2010: cwarn("symbol \"%s\" truncated to 39 characters", cp);
2011: n = 39;
2012: }
2013: *bp++ = n;
2014: while (n--) {
2015: #if 0
2016: if ((c = *cp++)>='a' && c<='z')
2017: c -= 'a'-'A';
2018: *bp++ = c;
2019: #else
2020: *bp++ = *cp++;
2021: #endif
2022: }
2023: return (bp);
2024: }
2025:
2026: /*
2027: * Put a record.
2028: * The 'type' argument is the record type.
2029: * The body of the record starts at 'p' and is
2030: * 'n' bytes long. The checksum is added.
2031: */
2032: putrecord(type, p, n)
2033: register char *p;
2034: register n;
2035: {
2036: checksum = 0;
2037: putbyte(type);
2038: putbyte(n+1); /* +1 for the checksum */
2039: putbyte((n+1)>>8);
2040: while(n--)
2041: putbyte(*p++);
2042: putbyte(-checksum);
2043: }
2044:
2045: putbyte(b)
2046: register b;
2047: {
2048: #if VAXFMT
2049: if (vaxptr >= &vaxbuf[NVDATA]) {
2050: vaxflush();
2051: vaxptr = vaxbuf;
2052: }
2053: *vaxptr++ = b;
2054: #else
2055: bput(b);
2056: #endif
2057: checksum += b;
2058: }
2059:
2060: /*
2061: ** Output buffering.
2062: */
2063: /*
2064: * This routine checks to see if
2065: * there is enough room in the text and relocation
2066: * buffers to hold 'nt' bytes of text and 'nr' bytes of
2067: * relocation.
2068: */
2069: enuf(nt, nr)
2070: {
2071: if (txtp+nt>&txt[NTXT] || relp+nr>&rel[NREL])
2072: notenuf();
2073: if (txtp == txt) {
2074: *txtp++ = getsegindex(dotseg);
2075: *txtp++ = dot;
2076: *txtp++ = dot >> 8;
2077: }
2078: }
2079:
2080: /*
2081: * Flush the buffer.
2082: */
2083: notenuf()
2084: {
2085: register n;
2086:
2087: if ((n = txtp-txt) > 3) {
2088: putrecord(LEDATA, txt, n);
2089: if ((n = relp-rel) != 0) {
2090: putrecord(FIXUPP, rel, n);
2091: relp = rel;
2092: }
2093: }
2094: txtp = txt;
2095: }
2096:
2097: /*
2098: * Round up to the next word.
2099: */
2100: rup(a)
2101: ADDRESS a;
2102: {
2103: return ((a+01)&~01);
2104: }
2105:
2106: #if VAXFMT
2107: /*
2108: * Flush out a record on the VAX. The record is a standard,
2109: * RMS variable length record. This routine checks for no bytes
2110: * in the buffer, so it can be unconditionally called at the
2111: * end to flush the buffer out.
2112: * The record is padded out to NVDATA bytes with zeros. This
2113: * only happens on the last block; the data beyond the end
2114: * is zeroed.
2115: */
2116: vaxflush()
2117: {
2118: register int n;
2119:
2120: if ((n = vaxptr-vaxbuf) != 0) {
2121: if (fwrite(vaxbuf, n, 1, ofp) != 1
2122: || fflush(ofp) == EOF)
2123: cfatal("output write error");
2124: }
2125: }
2126: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.