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