![[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 / ucb / pascal / src|
Return to stab.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ucb / pascal / src |
1.1 root 1: /* Copyright (c) 1980 Regents of the University of California */
2:
3: static char sccsid[] = "@(#)stab.c 1.9 7/26/83";
4:
5: /*
6: * procedures to put out sdb symbol table information.
7: * and stabs for separate compilation type checking.
8: * these use the new .stabs, .stabn, and .stabd directives
9: */
10:
11: #include "whoami.h"
12: #ifdef PC
13: /* and the rest of the file */
14: # include "0.h"
15: # include "objfmt.h"
16: # include "yy.h"
17: # include <stab.h>
18:
19: /*
20: * additional symbol definition for <stab.h>
21: * that is used by the separate compilation facility --
22: * eventually, <stab.h> should be updated to include this
23: */
24:
25: # include "pstab.h"
26: # include "pc.h"
27:
28: /*
29: * absolute value: line numbers are negative if error recovery.
30: */
31: #define ABS( x ) ( x < 0 ? -x : x )
32:
33: /*
34: * global variables
35: */
36: stabgvar( name , type , offset , length , line )
37: char *name;
38: int type;
39: int offset;
40: int length;
41: int line;
42: {
43:
44: /*
45: * for separate compilation
46: */
47: putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0
48: , name , N_PC , N_PGVAR , ABS( line ) );
49: /*
50: * for sdb
51: */
52: if ( ! opt('g') ) {
53: return;
54: }
55: putprintf( " .stabs \"" , 1 );
56: putprintf( NAMEFORMAT , 1 , name );
57: putprintf( "\",0x%x,0,0x%x,0" , 0 , N_GSYM , type );
58: putprintf( " .stabs \"" , 1 );
59: putprintf( NAMEFORMAT , 1 , name );
60: putprintf( "\",0x%x,0,0,0x%x" , 0 , N_LENG , length );
61: }
62:
63: /*
64: * local variables
65: */
66: stablvar( name , type , level , offset , length )
67: char *name;
68: int type;
69: int level;
70: int offset;
71: int length;
72: {
73:
74: if ( ! opt('g') ) {
75: return;
76: }
77: putprintf( " .stabs \"" , 1 );
78: putprintf( NAMEFORMAT , 1 , name );
79: putprintf( "\",0x%x,0,0x%x,0x%x" , 0 , N_LSYM , type , -offset );
80: putprintf( " .stabs \"" , 1 );
81: putprintf( NAMEFORMAT , 1 , name );
82: putprintf( "\",0x%x,0,0,0x%x" , 0 , N_LENG , length );
83: }
84:
85:
86: /*
87: * parameters
88: */
89: stabparam( name , type , offset , length )
90: char *name;
91: int type;
92: int offset;
93: int length;
94: {
95:
96: if ( ! opt('g') ) {
97: return;
98: }
99: putprintf( " .stabs \"" , 1 );
100: putprintf( NAMEFORMAT , 1 , name );
101: putprintf( "\",0x%x,0,0x%x,0x%x" , 0 , N_PSYM , type , offset );
102: putprintf( " .stabs \"" , 1 );
103: putprintf( NAMEFORMAT , 1 , name );
104: putprintf( "\",0x%x,0,0,0x%x" , 0 , N_LENG , length );
105: }
106:
107: /*
108: * fields
109: */
110: stabfield( name , type , offset , length )
111: char *name;
112: int type;
113: int offset;
114: int length;
115: {
116:
117: if ( ! opt('g') ) {
118: return;
119: }
120: putprintf( " .stabs \"" , 1 );
121: putprintf( NAMEFORMAT , 1 , name );
122: putprintf( "\",0x%x,0,0x%x,0x%x" , 0 , N_SSYM , type , offset );
123: putprintf( " .stabs \"" , 1 );
124: putprintf( NAMEFORMAT , 1 , name );
125: putprintf( "\",0x%x,0,0,0x%x" , 0 , N_LENG , length );
126: }
127:
128: /*
129: * left brackets
130: */
131: stablbrac( level )
132: int level;
133: {
134:
135: if ( ! opt('g') ) {
136: return;
137: }
138: putprintf( " .stabd 0x%x,0,0x%x" , 0 , N_LBRAC , level );
139: }
140:
141: /*
142: * right brackets
143: */
144: stabrbrac( level )
145: int level;
146: {
147:
148: if ( ! opt('g') ) {
149: return;
150: }
151: putprintf( " .stabd 0x%x,0,0x%x" , 0 , N_RBRAC , level );
152: }
153:
154: /*
155: * functions
156: */
157: stabfunc( name , typeclass , line , level )
158: char *name;
159: int typeclass;
160: int line;
161: long level;
162: {
163: int type;
164: long i;
165: char extname[ BUFSIZ ];
166:
167: /*
168: * for separate compilation
169: */
170: if ( level == 1 ) {
171: if ( typeclass == FUNC ) {
172: putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0
173: , name , N_PC , N_PGFUNC , ABS( line ) );
174: } else if ( typeclass == PROC ) {
175: putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0
176: , name , N_PC , N_PGPROC , ABS( line ) );
177: }
178: }
179: /*
180: * for sdb
181: */
182: if ( ! opt('g') ) {
183: return;
184: }
185: putprintf( " .stabs \"" , 1 );
186: putprintf( NAMEFORMAT , 1 , name );
187: sextname( extname , name , level );
188: putprintf( "\",0x%x,0,0x%x,%s" , 0 , N_FUN , line , extname );
189: }
190:
191: /*
192: * source line numbers
193: */
194: stabline( line )
195: int line;
196: {
197: if ( ! opt('g') ) {
198: return;
199: }
200: putprintf( " .stabd 0x%x,0,0x%x" , 0 , N_SLINE , ABS( line ) );
201: }
202:
203: /*
204: * source files
205: */
206: stabsource(filename)
207: char *filename;
208: {
209: int label;
210:
211: /*
212: * for separate compilation
213: */
214: putprintf(" .stabs \"%s\",0x%x,0,0x%x,0x%x", 0,
215: filename, N_PC, N_PSO, N_FLAGCHECKSUM);
216: /*
217: * for sdb
218: */
219: if ( ! opt('g') ) {
220: return;
221: }
222: label = getlab();
223: putprintf( " .stabs \"" , 1 );
224: putprintf( NAMEFORMAT , 1 , filename );
225: putprintf( "\",0x%x,0,0," , 1 , N_SO );
226: putprintf( PREFIXFORMAT , 0 , LLABELPREFIX , label );
227: putprintf( PREFIXFORMAT , 1 , LLABELPREFIX , label );
228: putprintf( ":" , 0 );
229: }
230:
231: /*
232: * included files get one or more of these:
233: * one as they are entered by a #include,
234: * and one every time they are returned to from nested #includes.
235: */
236: stabinclude(filename, firsttime)
237: char *filename;
238: bool firsttime;
239: {
240: int label;
241: long check;
242:
243: /*
244: * for separate compilation
245: */
246: if (firsttime) {
247: check = checksum(filename);
248: } else {
249: check = N_FLAGCHECKSUM;
250: }
251: putprintf(" .stabs \"%s\",0x%x,0,0x%x,0x%x", 0,
252: filename, N_PC, N_PSOL, check);
253: /*
254: * for sdb
255: */
256: if ( ! opt('g') ) {
257: return;
258: }
259: label = getlab();
260: putprintf( " .stabs \"" , 1 );
261: putprintf( NAMEFORMAT , 1 , filename );
262: putprintf( "\",0x%x,0,0," , 1 , N_SOL );
263: putprintf( PREFIXFORMAT , 0 , LLABELPREFIX , label );
264: putprintf( PREFIXFORMAT , 1 , LLABELPREFIX , label );
265: putprintf( ":" , 0 );
266: }
267:
268: /*
269: * anyone know a good checksum for ascii files?
270: * this does a rotate-left and then exclusive-or's in the character.
271: * also, it avoids returning checksums of 0.
272: * The rotate is implemented by shifting and adding back the
273: * sign bit when negative.
274: */
275: long
276: checksum(filename)
277: char *filename;
278: {
279: FILE *filep;
280: register int input;
281: register long check;
282:
283: filep = fopen(filename, "r");
284: if (filep == NULL) {
285: perror(filename);
286: pexit(DIED);
287: }
288: check = 0;
289: while ((input = getc(filep)) != EOF) {
290: if (check < 0) {
291: check <<= 1;
292: check += 1;
293: } else {
294: check <<= 1;
295: }
296: check ^= input;
297: }
298: fclose(filep);
299: if ((unsigned) check <= N_FLAGCHECKSUM) {
300: return N_FLAGCHECKSUM + 1;
301: } else {
302: return check;
303: }
304: }
305:
306: /*
307: * global Pascal symbols :
308: * labels, types, constants, and external procedure and function names:
309: * These are used by the separate compilation facility
310: * to be able to check for disjoint header files.
311: */
312:
313: /*
314: * global labels
315: */
316: stabglabel( label , line )
317: char *label;
318: int line;
319: {
320:
321: putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0
322: , label , N_PC , N_PGLABEL , ABS( line ) );
323: }
324:
325: /*
326: * global constants
327: */
328: stabgconst( const , line )
329: char *const;
330: int line;
331: {
332:
333: putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0
334: , const , N_PC , N_PGCONST , ABS( line ) );
335: }
336:
337: /*
338: * global types
339: */
340: stabgtype( type , line )
341: char *type;
342: int line;
343: {
344:
345: putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0
346: , type , N_PC , N_PGTYPE , ABS( line ) );
347: }
348:
349:
350: /*
351: * external functions and procedures
352: */
353: stabefunc( name , typeclass , line )
354: char *name;
355: int typeclass;
356: int line;
357: {
358: int type;
359:
360: if ( typeclass == FUNC ) {
361: type = N_PEFUNC;
362: } else if ( typeclass == PROC ) {
363: type = N_PEPROC;
364: } else {
365: return;
366: }
367: putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0
368: , name , N_PC , type , ABS( line ) );
369: }
370:
371: #endif PC
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.