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