1 /* Copyright (c) 1980 Regents of the University of California */ 2 3 static char sccsid[] = "@(#)stab.c 1.3 09/04/80"; 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 <stab.h> 16 17 /* 18 * additional symbol definition for <stab.h> 19 * that is used by the separate compilation facility -- 20 * eventually, <stab.h> should be updated to include this 21 */ 22 23 # include "pstab.h" 24 # include "pc.h" 25 26 /* 27 * absolute value: line numbers are negative if error recovery. 28 */ 29 #define ABS( x ) ( x < 0 ? -x : x ) 30 31 /* 32 * variables 33 */ 34 stabvar( name , type , level , offset , length , line ) 35 char *name; 36 int type; 37 int level; 38 int offset; 39 int length; 40 int line; 41 { 42 43 /* 44 * for separate compilation 45 */ 46 if ( level == 1 ) { 47 putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0 48 , name , N_PC , N_PGVAR , ABS( line ) ); 49 } 50 /* 51 * for sdb 52 */ 53 if ( ! opt('g') ) { 54 return; 55 } 56 putprintf( " .stabs \"" , 1 ); 57 putprintf( NAMEFORMAT , 1 , name ); 58 if ( level == 1 ) { 59 putprintf( "\",0x%x,0,0x%x,0" , 0 , N_GSYM , type ); 60 } else { 61 putprintf( "\",0x%x,0,0x%x,0x%x" , 0 , N_LSYM , type , offset ); 62 } 63 putprintf( " .stabs \"" , 1 ); 64 putprintf( NAMEFORMAT , 1 , name ); 65 putprintf( "\",0x%x,0,0,0x%x" , 0 , N_LENG , length ); 66 67 } 68 69 70 /* 71 * parameters 72 */ 73 stabparam( name , type , offset , length ) 74 char *name; 75 int type; 76 int offset; 77 int length; 78 { 79 80 if ( ! opt('g') ) { 81 return; 82 } 83 putprintf( " .stabs \"" , 1 ); 84 putprintf( NAMEFORMAT , 1 , name ); 85 putprintf( "\",0x%x,0,0x%x,0x%x" , 0 , N_PSYM , type , offset ); 86 putprintf( " .stabs \"" , 1 ); 87 putprintf( NAMEFORMAT , 1 , name ); 88 putprintf( "\",0x%x,0,0,0x%x" , 0 , N_LENG , length ); 89 } 90 91 /* 92 * fields 93 */ 94 stabfield( name , type , offset , length ) 95 char *name; 96 int type; 97 int offset; 98 int length; 99 { 100 101 if ( ! opt('g') ) { 102 return; 103 } 104 putprintf( " .stabs \"" , 1 ); 105 putprintf( NAMEFORMAT , 1 , name ); 106 putprintf( "\",0x%x,0,0x%x,0x%x" , 0 , N_SSYM , type , offset ); 107 putprintf( " .stabs \"" , 1 ); 108 putprintf( NAMEFORMAT , 1 , name ); 109 putprintf( "\",0x%x,0,0,0x%x" , 0 , N_LENG , length ); 110 } 111 112 /* 113 * left brackets 114 */ 115 stablbrac( level ) 116 int level; 117 { 118 119 if ( ! opt('g') ) { 120 return; 121 } 122 putprintf( " .stabd 0x%x,0,0x%x" , 0 , N_LBRAC , level ); 123 } 124 125 /* 126 * right brackets 127 */ 128 stabrbrac( level ) 129 int level; 130 { 131 132 if ( ! opt('g') ) { 133 return; 134 } 135 putprintf( " .stabd 0x%x,0,0x%x" , 0 , N_RBRAC , level ); 136 } 137 138 /* 139 * functions 140 */ 141 stabfunc( name , class , line , level ) 142 char *name; 143 int class; 144 int line; 145 long level; 146 { 147 int type; 148 long i; 149 150 /* 151 * for separate compilation 152 */ 153 if ( level == 1 ) { 154 if ( class == FUNC ) { 155 putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0 156 , name , N_PC , N_PGFUNC , ABS( line ) ); 157 } else if ( class == PROC ) { 158 putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0 159 , name , N_PC , N_PGPROC , ABS( line ) ); 160 } 161 } 162 /* 163 * for sdb 164 */ 165 if ( ! opt('g') ) { 166 return; 167 } 168 putprintf( " .stabs \"" , 1 ); 169 putprintf( NAMEFORMAT , 1 , name ); 170 putprintf( "\",0x%x,0,0x%x," , 1 , N_FUN , line ); 171 for ( i = 1 ; i < level ; i++ ) { 172 putprintf( EXTFORMAT , 1 , enclosing[ i ] ); 173 } 174 putprintf( EXTFORMAT , 0 , name ); 175 } 176 177 /* 178 * source line numbers 179 */ 180 stabline( line ) 181 int line; 182 { 183 if ( ! opt('g') ) { 184 return; 185 } 186 putprintf( " .stabd 0x%x,0,0x%x" , 0 , N_SLINE , ABS( line ) ); 187 } 188 189 /* 190 * source files 191 */ 192 stabsource( filename ) 193 char *filename; 194 { 195 int label; 196 197 /* 198 * for separate compilation 199 */ 200 putprintf( " .stabs \"%s\",0x%x,0,0x%x,0" , 0 201 , filename , N_PC , N_PSO ); 202 /* 203 * for sdb 204 */ 205 if ( ! opt('g') ) { 206 return; 207 } 208 label = getlab(); 209 putprintf( " .stabs \"" , 1 ); 210 putprintf( NAMEFORMAT , 1 , filename ); 211 putprintf( "\",0x%x,0,0," , 1 , N_SO ); 212 putprintf( PREFIXFORMAT , 0 , LLABELPREFIX , label ); 213 putprintf( PREFIXFORMAT , 1 , LLABELPREFIX , label ); 214 putprintf( ":" , 0 ); 215 } 216 217 /* 218 * included files get one or more of these: 219 * one as they are entered by a #include, 220 * and one every time they are returned to by nested #includes 221 */ 222 stabinclude( filename ) 223 char *filename; 224 { 225 int label; 226 227 /* 228 * for separate compilation 229 */ 230 putprintf( " .stabs \"%s\",0x%x,0,0x%x,0" , 0 231 , filename , N_PC , N_PSOL ); 232 /* 233 * for sdb 234 */ 235 if ( ! opt('g') ) { 236 return; 237 } 238 label = getlab(); 239 putprintf( " .stabs \"" , 1 ); 240 putprintf( NAMEFORMAT , 1 , filename ); 241 putprintf( "\",0x%x,0,0," , 1 , N_SOL ); 242 putprintf( PREFIXFORMAT , 0 , LLABELPREFIX , label ); 243 putprintf( PREFIXFORMAT , 1 , LLABELPREFIX , label ); 244 putprintf( ":" , 0 ); 245 } 246 247 248 /* 249 * global Pascal symbols : 250 * labels, types, constants, and external procedure and function names: 251 * These are used by the separate compilation facility 252 * to be able to check for disjoint header files. 253 */ 254 255 /* 256 * global labels 257 */ 258 stabglabel( label , line ) 259 char *label; 260 int line; 261 { 262 263 putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0 264 , label , N_PC , N_PGLABEL , ABS( line ) ); 265 } 266 267 /* 268 * global constants 269 */ 270 stabgconst( const , line ) 271 char *const; 272 int line; 273 { 274 275 putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0 276 , const , N_PC , N_PGCONST , ABS( line ) ); 277 } 278 279 /* 280 * global types 281 */ 282 stabgtype( type , line ) 283 char *type; 284 int line; 285 { 286 287 putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0 288 , type , N_PC , N_PGTYPE , ABS( line ) ); 289 } 290 291 292 /* 293 * external functions and procedures 294 */ 295 stabefunc( name , class , line ) 296 char *name; 297 int class; 298 int line; 299 { 300 int type; 301 302 if ( class == FUNC ) { 303 type = N_PEFUNC; 304 } else if ( class == PROC ) { 305 type = N_PEPROC; 306 } else { 307 return; 308 } 309 putprintf( " .stabs \"%s\",0x%x,0,0x%x,0x%x" , 0 310 , name , N_PC , type , ABS( line ) ); 311 } 312 313 #endif PC 314