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