![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / pcc / save|
Return to stab.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / pcc / save |
1.1 root 1: /*
2: * Symbolic debugging info interface.
3: *
4: * Here we generate pseudo-ops that cause the assembler to put
5: * symbolic debugging information into the object file.
6: */
7: #include "cpass1.h"
8: #include <sys/types.h>
9: #include <a.out.h>
10: #include "stab.h"
11:
12: static int inastruct;
13: static int inafunc;
14: static int inbegfunc;
15: static int inaparam;
16: static char strvalfmt[] = " .stabs \"%s\",0x%x,0,%d,%d\n";
17: static char strsymfmt[] = " .stabs \"%s\",0x%x,0,%d,%s\n";
18: static char nulvalfmt[] = " .stabn 0x%x,0,%d,%d\n";
19: static char nulsymfmt[] = " .stabn 0x%x,0,%d,%s\n";
20: static char dotfmt[] = " .stabd 0x%x,0,%d\n";
21:
22: extern int gdebug;
23: extern char *strcpy();
24: int stabLCSYM;
25:
26: /*
27: * Old flag, not used anymore.
28: */
29: int oldway = 0;
30:
31: /*
32: * Generate information for a newly-defined structure.
33: */
34: outstruct(szindex, paramindex)
35: int szindex, paramindex;
36: {
37: register struct symtab *p;
38: register int i;
39:
40: if (!gdebug)
41: return;
42: inastruct = 1;
43: p = STP(dimtab[szindex + 3]);
44: printf(strvalfmt, p->sname, N_BSTR, p->stype, 0);
45: outstab(STP(dimtab[szindex + 3]));
46: for( i = dimtab[szindex + 1]; dimtab[i] > 0; i++)
47: outstab(STP(dimtab[i]));
48: printf(strvalfmt, p->sname, N_ESTR, p->stype, dimtab[p->sizoff]/SZCHAR);
49: inastruct = 0;
50: }
51:
52: psline(lineno)
53: int lineno;
54: {
55: if (gdebug && !dbfile(NULL))
56: printf(dotfmt, N_SLINE, lineno);
57: }
58:
59: plcstab(level)
60: int level;
61: {
62: if (gdebug)
63: printf(dotfmt, N_LBRAC, level);
64: }
65:
66: prcstab(level)
67: int level;
68: {
69: if (gdebug)
70: printf(dotfmt, N_RBRAC, level);
71: }
72:
73: pfstab(sname)
74: char *sname;
75: {
76: register struct symtab *p;
77:
78: p = STP(lookup(sname, 0));
79: inafunc = 1;
80: inbegfunc = 1;
81: /* dbfile(exname(p->sname));*/
82: locctr(PROG);
83: printf(strsymfmt, p->sname, N_BFUN, lineno, exname(p->sname));
84: outstab(p);
85: inbegfunc = 0;
86: }
87:
88: #define BYTOFF(p) (((off = (p)->offset) < 0 ? -off : off)/SZCHAR)
89:
90: /*
91: * Generate debugging info for a parameter.
92: * The offset isn't known when it is first entered into the symbol table
93: * since the types are read later.
94: */
95: fixarg(p)
96: struct symtab *p;
97: {
98: inaparam = 1;
99: outstab(p);
100: inaparam = 0;
101: }
102:
103: static char labstr[16];
104:
105: static char *
106: maklab(val)
107: {
108: sprintf(labstr, "L%d", val);
109: return labstr;
110: }
111:
112: # ifndef OUTREGNO
113: # define OUTREGNO(p) ((p)->offset)
114: # endif
115:
116: /*
117: * Generate debugging info for a given symbol.
118: */
119: outstab(p)
120: register struct symtab *p; {
121:
122: register TWORD t;
123: register off, i;
124:
125: if (ISFTN(p->stype) && !inbegfunc)
126: return;
127: if( p->sclass > FIELD ) {
128: if (!inastruct)
129: return;
130: printf(strvalfmt, p->sname, N_SFLD,
131: ((p->sclass - FIELD)<<BTSHIFT)|p->stype, p->offset);
132: return;
133: }
134:
135: switch( p->sclass )
136: {
137: case AUTO:
138: printf(strvalfmt, p->sname, N_LSYM, p->stype, BYTOFF(p));
139: break;
140: case REGISTER:
141: if (!inafunc)
142: return;
143: if (inaparam) {
144: p->sclass = PARAM;
145: outstab(p);
146: p->sclass = REGISTER;
147: }
148: printf(strvalfmt, p->sname, N_RSYM, p->stype, OUTREGNO(p));
149: break;
150: case PARAM:
151: if (!inaparam)
152: return;
153: printf(strvalfmt, p->sname, N_PSYM, p->stype, argoff/SZCHAR);
154: break;
155: case EXTERN:
156: case EXTDEF:
157: printf(strvalfmt, p->sname, N_GSYM, p->stype, 0);
158: break;
159: case STATIC:
160: if (ISFTN(p->stype))
161: printf(strvalfmt, p->sname, N_STFUN, p->stype, 0);
162: else
163: printf(strsymfmt, p->sname,
164: stabLCSYM ? N_LCSYM : N_STSYM, p->stype,
165: p->slevel ? maklab(p->offset) : exname(p->sname));
166: break;
167: case MOS:
168: case MOU:
169: if (!inastruct)
170: return;
171: printf(strvalfmt, p->sname, N_SSYM, p->stype, BYTOFF(p));
172: break;
173: case MOE:
174: if (!inastruct)
175: return;
176: printf(strvalfmt, p->sname, N_SSYM, p->stype, p->offset);
177: return;
178: default:
179: return;
180: }
181: /* make another entry to describe structs, unions, enums */
182: switch( BTYPE(p->stype) ) {
183: case STRTY:
184: case UNIONTY:
185: case ENUMTY:
186: printf(strvalfmt, STP(dimtab[p->sizoff+3])->sname,
187: N_TYID, 0, 0);
188: }
189:
190: /* make other entries with the dimensions */
191: for( t=p->stype, i=p->dimoff; t&TMASK; t = DECREF(t) )
192: {
193: if( ISARY(t) ) printf(nulvalfmt, N_DIM, 0, dimtab[i++]);
194: }
195:
196: }
197:
198: dbfunend( lab ) /* end of a function */
199: {
200: inafunc = 0;
201: printf(dotfmt, N_EFUN, lineno);
202: }
203:
204: beg_file() /* only used in cgram.y */
205: {
206: dbfile(NULL);
207: }
208:
209: static char orgfile[100], currfile[100], prtfile[100];
210:
211: static int srcfilop = N_SO;
212:
213: static char *
214: makstr(ip)
215: register char *ip;
216: {
217: register c; register char *jp = prtfile;
218: do {
219: if ((c = *ip++) != '"')
220: *jp++ = c;
221: } while (c);
222: return prtfile;
223: }
224:
225: dbfile(pname)
226: char *pname;
227: {
228: int seg;
229: if (!strcmp(currfile, ftitle))
230: return 0;
231: strcpy(currfile, ftitle);
232: seg = locctr(PROG);
233: if (pname == NULL)
234: printf("%s:", pname = maklab(getlab()));
235: printf(strsymfmt, makstr(currfile), srcfilop, lineno, pname);
236: if (srcfilop == N_SO) { /* first file */
237: strcpy(orgfile, ftitle);
238: srcfilop = N_SOL;
239: }
240: if (seg >= 0)
241: locctr(seg);
242: return 1;
243: }
244:
245: ejsdb()
246: {
247: /* called at the end of the entire file */
248: printf("\t.text\n");
249: printf("%s:", maklab(getlab()));
250: printf(strsymfmt, makstr(orgfile), N_ESO, lineno, labstr);
251: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.