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