![[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 [CSRG BSD Unix] / 42BSD / usr.bin / f77 / src / f77pass1|
Return to stab.c CVS log | Up to [CSRG BSD Unix] / 42BSD / usr.bin / f77 / src / f77pass1 |
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:
8: #include "defs.h"
9:
10: #include <sys/types.h>
11: #include <a.out.h>
12: #include <stab.h>
13:
14: #define public
15: #define private static
16: #define and &&
17: #define or ||
18: #define not !
19: #define div /
20: #define mod %
21: #define nil 0
22:
23: typedef enum { false, true } Boolean;
24:
25: static char asmline[128];
26: int len;
27: extern char *malloc();
28:
29: prstab(s, code, type, loc)
30: char *s, *loc;
31: int code, type;
32: {
33: char *locout;
34:
35: if (sdbflag) {
36: locout = (loc == nil) ? "0" : loc;
37: if (s == nil) {
38: sprintf(asmline, "\t.stabn\t0x%x,0,0x%x,%s\n", code, type, locout);
39: } else {
40: sprintf(asmline, "\t.stabs\t\"%s\",0x%x,0,0x%x,%s\n", s, code, type,
41: locout);
42: }
43: p2pass( asmline );
44: }
45: }
46:
47: filenamestab(s)
48: char *s;
49: {
50: sprintf(asmline,"\t.stabs\t\"%s\",0x%x,0,0,0\n", s, N_SO);
51: p2pass( asmline );
52: }
53:
54: linenostab(lineno)
55: int lineno;
56: {
57: sprintf(asmline,"\t.stabd\t0x%x,0,%d\n", N_SLINE, lineno);
58: p2pass( asmline );
59: }
60:
61: /*
62: * Generate information for an entry point
63: */
64:
65: public entrystab(p,class)
66: register struct Entrypoint *p;
67: int class;
68: {
69: int et;
70: Namep q;
71:
72: switch(class) {
73: case CLMAIN:
74: et=writestabtype(TYSUBR);
75: sprintf(asmline, "\t.stabs\t\"MAIN:F%2d\",0x%x,0,0,L%d\n",
76: et,N_FUN,p->entrylabel);
77: p2pass(asmline);
78: if (p->entryname) {
79: sprintf(asmline, "\t.stabs\t\"%s:F%2d\",0x%x,0,0,L%d\n",
80: nounder(XL,p->entryname->extname), et,N_FNAME,p->entrylabel);
81: p2pass(asmline);
82: }
83: break;
84:
85: case CLBLOCK: /* May need to something with block data LATER */
86: break;
87:
88: default :
89: if( (q=p->enamep) == nil) fatal("entrystab has no nameblock");
90: sprintf(asmline, "\t.stabs\t\"%s:F", varstr(VL,q->varname));
91: len = strlen(asmline);
92: /* when insufficient information is around assume TYSUBR; enddcl
93: will fill this in*/
94: if(q->vtype == TYUNKNOWN || (q->vtype == TYCHAR && q->vleng == nil) ){
95: sprintf(asmline+len, "%2d", writestabtype(TYSUBR));
96: }
97: else addtypeinfo(q);
98: len += strlen(asmline+len);
99: sprintf(asmline+len, "\",0x%x,0,0,L%d\n",N_FUN,p->entrylabel);
100: p2pass(asmline);
101: break;
102: }
103: }
104:
105: /*
106: * Generate information for a symbol table (name block ) entry.
107: */
108:
109: public namestab(sym)
110: Namep sym;
111: {
112: register Namep p;
113: char *varname, *classname;
114: Boolean ignore;
115: int vartype;
116:
117: ignore = false;
118: p = sym;
119: if(!p->vdcldone) return;
120: vartype = p->vtype;
121: varname = varstr(VL, p->varname);
122: switch (p->vclass) {
123: case CLPARAM: /* parameter (constant) */
124: classname = "c";
125: break;
126:
127: case CLVAR: /* variable */
128: case CLUNKNOWN:
129: if(p->vstg == STGARG) classname = "v";
130: else classname = "V";
131: break;
132:
133: case CLMAIN: /* main program */
134: case CLENTRY: /* secondary entry point */
135: case CLBLOCK: /* block data name*/
136: case CLPROC: /* external or function or subroutine */
137: ignore = true; /* these are put out by entrystab */
138: break;
139:
140:
141: }
142: if (not ignore) {
143: sprintf(asmline, "\t.stabs\t\"%s:%s", varname, classname);
144: len = strlen(asmline);
145: addtypeinfo(p);
146: len += strlen(asmline+len);
147: switch(p->vstg) {
148:
149: case STGUNKNOWN :
150: case STGCONST :
151: case STGEXT :
152: case STGINTR :
153: case STGSTFUNCT :
154: case STGLENG :
155: case STGNULL :
156: case STGREG :
157: case STGINIT :
158: sprintf(asmline+len,
159: "\",0x%x,0,0,0 /* don't know how to calc loc for stg %d*/ \n",
160: N_LSYM,p->vstg);
161: break;
162:
163: case STGARG :
164: sprintf(asmline+len,"\",0x%x,0,0,%d \n",
165: N_PSYM,p->vardesc.varno + ARGOFFSET );
166: break;
167:
168: case STGCOMMON :
169: sprintf(asmline+len, "\",0x%x,0,0,%d\n",
170: N_GSYM, p->voffset);
171: break;
172:
173: case STGBSS :
174: sprintf(asmline+len, "\",0x%x,0,0,v.%d\n",
175: (p->inlcomm ? N_LCSYM : N_STSYM),
176: p->vardesc.varno);
177: break;
178:
179: case STGEQUIV :
180: sprintf(asmline+len, "\",0x%x,0,0,%s + %d \n",
181: (p->inlcomm ? N_LCSYM : N_STSYM) ,
182: memname(STGEQUIV,p->vardesc.varno),(p->voffset)) ;
183: break;
184:
185: case STGAUTO :
186: sprintf(asmline+len, "\",0x%x,0,0,-%d \n",
187: N_LSYM, p->voffset);
188:
189: }
190: p2pass(asmline);
191: }
192: }
193:
194: static typenum[NTYPES]; /* has the given type already been defined ?*/
195:
196: private writestabtype(type)
197: int type;
198: {
199: char asmline[130];
200: static char *typename[NTYPES] =
201: { "unknown", "addr","integer*2", "integer", "real", "double precision",
202: "complex", "double complex", "logical", "char", "void", "error" };
203:
204: static int typerange[NTYPES] = { 0, 3, 2, 3, 4, 5, 6, 7, 3, 9, 10, 11 };
205:
206: /* compare with typesize[] in init.c */
207: static int typebounds[2] [NTYPES] ={
208: /* "unknown", "addr","integer*2", "integer", "real", "double precision", */
209: { 0 , 0 , -32768, -2147483648, 4, 8,
210: /* "complex", "double complex", "logical", "char", "void", "error" }; */
211: 8, 16, 0, 0, 0, 0 },
212: /* "unknown", "addr","integer*2", "integer", "real", "double precision", */
213: { 0 , -1, 32767, 2147483647, 0, 0,
214: /* "complex", "double complex", "logical", "char", "void", "error" }; */
215: 0, 0, 1, 127, 0, 0 }
216: };
217:
218:
219: if( type < 0 || type > NTYPES) badtype("writestabtype",type);
220:
221: if (typenum[type]) return(typenum[type]);
222: typenum[type] = type;
223: sprintf(asmline, "\t.stabs\t\"%s:t%d=r%d;%ld;%ld;\",0x%x,0,0,0 \n",
224: typename[type], type, typerange[type], typebounds[0][type],
225: typebounds[1][type], N_GSYM) ;
226: p2pass(asmline);
227: return(typenum[type]);
228: }
229:
230:
231: private getbasenum(p)
232: Namep p;
233: {
234:
235: int t;
236: t = p->vtype;
237: if( t < TYSHORT || t > TYSUBR)
238: dclerr("can't get dbx basetype information",p);
239:
240: if (p->vtype == TYCHAR || p->vdim != nil ) writestabtype(TYINT);
241: return(writestabtype(t));
242: }
243:
244: /*
245: * Generate debugging information for the given type of the given symbol.
246: */
247:
248: private addtypeinfo(sym)
249: Namep sym;
250: {
251: Namep p;
252: int i,tnum;
253: char lb[20],ub[20];
254:
255: p = sym;
256: if (p->tag != TNAME) badtag("addtypeinfo",p->tag);
257:
258: tnum = getbasenum(p);
259: if(p->vdim != (struct Dimblock *) ENULL) {
260:
261: for (i = p->vdim->ndim-1; i >=0 ; --i) {
262: if(p->vdim->dims[i].lbaddr == ENULL) {
263: sprintf(lb,"%d", p->vdim->dims[i].lb->constblock.const.ci);
264: }
265: else {
266: sprintf(lb,"T%d", p->vdim->dims[i].lbaddr->addrblock.memoffset->constblock.const.ci);
267: }
268: if(p->vdim->dims[i].ubaddr == ENULL) {
269: sprintf(ub,"%d",p->vdim->dims[i].ub->constblock.const.ci);
270: }
271: else {
272: sprintf(ub,"T%d",p->vdim->dims[i].ubaddr->addrblock.memoffset->constblock.const.ci);
273: }
274: sprintf(asmline+len, "ar%d;%s;%s;", TYINT, lb, ub);
275: len += strlen(asmline+len);
276: }
277: }
278: if (p->vtype == TYCHAR) {
279: /* character type always an array(1:?) */
280: if( ! (p->vleng ) )
281: fatalstr("missing length in addtypeinfo for character variable %s", varstr(p->varname));
282:
283: if (ISCONST(p->vleng)) sprintf(ub,"%d",p->vleng->constblock.const.ci);
284: else sprintf(ub,"A%d",p->vleng->addrblock.memno + ARGOFFSET);
285:
286: sprintf(asmline+len,"ar%d;1;%s;", TYINT, ub);
287: len += strlen(asmline+len);
288: }
289: sprintf(asmline+len, "%d",tnum);
290: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.