commands/mdb/gnu_sym.c

   1 /*
   2  * gnu_sym.c for mdb
   3  * copied and modified from sym.c
   4  * Support GNU Exec symbol tables
   5  */
   6
   7 #include "mdb.h"
   8
   9 #ifdef  EXTRA_SYMBOLS
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <unistd.h>
  14 #include <string.h>
  15 #include <fcntl.h>
  16 #ifdef __NBSD_LIBC
  17 #include <compat/a.out.h>
  18 #else
  19 #include <minix/a.out.h>
  20 #endif
  21 #include "proto.h"
  22
  23 #define NN_UNDF 0
  24 #define NN_ABS 2
  25 #define NN_TEXT 4
  26 #define NN_DATA 6
  27 #define NN_BSS 8
  28 #define NN_FN 15
  29 #define NN_EXT 1
  30 #define NN_TYPE 036
  31
  32 struct newnlist {
  33         union {
  34                 char *n_name;
  35                 struct newnlist *n_next;
  36                 long n_strx;
  37         } n_un;
  38         unsigned char n_type;
  39         char n_other;
  40         short n_desc;
  41         unsigned long n_value;
  42 };
  43
  44 struct symtab_s
  45 {
  46         struct newnlist *start;
  47         struct newnlist *end;
  48         unsigned int nsym;
  49 };
  50
  51 static struct symtab_s symtab;
  52
  53 static void gnu_sort(struct newnlist *array , struct newnlist *top );
  54 static int gnu_symeq(char *t , struct newnlist *sp );
  55 static int gnu_symprefix(char *t , struct newnlist *sp );
  56 static struct newnlist *gnu_sname(char *name, int is_text, int
  57         allflag);
  58 static struct newnlist *gnu_sval(off_t value, int where);
  59 static void gnu_sym(struct newnlist *sp, off_t off);
  60
  61
  62 void gnu_init( filename )
  63 char *filename;
  64 {
  65         struct exec header;
  66         unsigned int string_size;
  67         char *names;
  68         struct newnlist *p;
  69         int fd;
  70         register struct symtab_s *tp;
  71
  72         tp = &symtab;
  73         if ( (fd = open( filename, O_RDONLY)) < 0 ||
  74              read( fd, (char *) &header, sizeof header ) != sizeof header )
  75         {
  76                 do_error( "gnu_load - reading header" );
  77                 if ( fd >= 0) close( fd );
  78                 return;
  79         }
  80
  81         if ( (string_size = lseek( fd, 0, SEEK_END ) ) == -1 )
  82         {
  83                 do_error( "gnu_load - determining file size" );
  84                 close( fd );
  85                 return;
  86         }
  87
  88         string_size -= A_SYMPOS( header );
  89
  90         if ( (int) header.a_syms < 0 ||
  91                 (unsigned) header.a_syms != header.a_syms ||
  92              (tp->start = (struct newnlist *) malloc( string_size ))
  93                                 == (struct newnlist *) NULL &&
  94              header.a_syms != 0 )
  95         {
  96                 do_error( "gnu_load - allocating memory" );
  97                 close( fd );
  98                 return;
  99         }
 100
 101         if ( lseek( fd, A_SYMPOS( header ), SEEK_SET ) != A_SYMPOS( header ) )
 102         {
 103                 do_error( "gnu_load - reading header" );
 104                 close( fd );
 105                 return;
 106         }
 107
 108         if ( read( fd, (char *) tp->start, string_size ) < 0 )
 109         {
 110                 do_error( "gnu_load - reading symbols" );
 111                 close( fd );
 112                 return;
 113         }
 114         close( fd );
 115
 116         tp->nsym = (unsigned int) header.a_syms / sizeof (struct newnlist);
 117         tp->end = tp->start + tp->nsym;
 118
 119         names = (char *) tp->start + header.a_syms;
 120
 121         for ( p = tp->start; p < tp->end; p++)
 122                 if(p->n_un.n_strx)
 123                         p->n_un.n_name = names + p->n_un.n_strx;
 124                 else
 125                         p->n_un.n_name = "";
 126
 127         /* sort on value only, name search not used much and storage a problem */
 128         Printf("Sorting %d GNU symbols ....", tp->nsym );
 129         gnu_sort( tp->start, tp->end );
 130         Printf("\n");
 131 }
 132
 133
 134 long gnu_symbolvalue( name, is_text )
 135 char *name;
 136 int is_text;
 137 {
 138   register struct newnlist *sp;
 139   sp = gnu_sname(name,is_text,0);
 140   if (sp != NULL)
 141         return sp->n_value;
 142   else
 143         return 0L;
 144 }
 145
 146
 147 static struct newnlist *gnu_sname( name, is_text, allflag )
 148 char *name;
 149 int is_text;
 150 int allflag;
 151 {
 152         char *s;
 153         unsigned char sclass;
 154         int schar;
 155         char *send;
 156         register struct newnlist *sp;
 157         register struct symtab_s *tp;
 158
 159         tp = &symtab;
 160
 161         if ( allflag )
 162         {
 163                 /* find and print all matching symbols */
 164                 for ( sp = tp->start; sp < tp->end; ++sp )
 165                 {
 166                         if ( gnu_symprefix( name, sp ) )
 167                         {
 168                                 sp = sp;
 169                                 for ( s = sp->n_un.n_name, send = s + strlen(s);
 170                                       *s != 0 && s < send; ++s )
 171                                         outbyte( *s );
 172                                 for ( ; s <= send; ++s )
 173                                         outspace();
 174                                 switch( sp->n_type & NN_TYPE )
 175                                 {
 176                                         case NN_ABS: schar = 'a'; break;
 177                                         case NN_TEXT: schar = 't'; break;
 178                                         case NN_DATA: schar = 'd'; break;
 179                                         case NN_BSS: schar = 'b'; break;
 180                                         default: schar = '?'; break;
 181                                 }
 182                                 if ( (sp->n_type & NN_EXT) && schar != '?' )
 183                                         schar += 'A' - 'a';
 184                                 outbyte( schar );
 185                                 outspace();
 186                                 outh32( sp->n_value );
 187                                 outbyte('\n');
 188                         }
 189                 }
 190         }
 191         else
 192         {
 193                 /* find symbol by dumb linear search */
 194                 for ( sp = tp->start; sp < tp->end; ++sp )
 195                 {
 196                         sclass = sp->n_type & NN_TYPE;
 197                         if ( (is_text && sclass == NN_TEXT ||
 198                               !is_text && (sclass == NN_DATA ||
 199                                            sclass == NN_BSS)) &&
 200                                          gnu_symeq( name, sp ) )
 201                                 return sp;
 202                 }
 203         }
 204         return NULL;
 205 }
 206
 207 static struct newnlist *gnu_sval( value, where )
 208 off_t value;
 209 int where;
 210 {
 211         int left;
 212         int middle;
 213         int right;
 214         unsigned char sclass;
 215         register struct newnlist *sp;
 216         register struct symtab_s *tp;
 217
 218         tp = &symtab;
 219
 220         /* find last symbol with value <= desired one by binary search */
 221         for ( left = 0, right = tp->nsym - 1; left <= right; )
 222         {
 223                 middle = (left + right) / 2;
 224                 sp = tp->start + middle;
 225                 if ( value < sp->n_value )
 226                         right = middle - 1;
 227                 else
 228                         left = middle + 1;
 229         }
 230         if ( right >= 0 )
 231                 /* otherwise tp->start + right may wrap around to > tp->start !! */
 232                 for ( sp = tp->start + right; sp >= tp->start; --sp )
 233                 {
 234                         if ( !(sp->n_type & NN_EXT) ) continue;
 235                         sclass = sp->n_type & NN_TYPE;
 236                         if ( (where == CSEG && sclass == NN_TEXT) ||
 237                                                 (where != CSEG &&
 238                                 (sclass == NN_DATA || sclass == NN_BSS)) )
 239                         return sp;
 240                 }
 241         return NULL;
 242 }
 243
 244
 245 static void gnu_sym( sp, off )
 246 struct newnlist *sp;
 247 off_t off;
 248 {
 249         register char *s;
 250         char *send;
 251
 252         for ( s = sp->n_un.n_name, send = s + strlen(s); *s != 0 && s < send; ++s )
 253                 outbyte( *s );
 254         if ( (off -= sp->n_value) != 0 )
 255         {
 256                 outbyte( '+' );
 257                 printhex(off);
 258         }
 259 }
 260
 261 /* shell sort symbols on value */
 262
 263 static void gnu_sort( array, top )
 264 struct newnlist *array;
 265 struct newnlist *top;
 266 {
 267         int gap;
 268         int i;
 269         int j;
 270         register struct newnlist *left;
 271         register struct newnlist *right;
 272         struct newnlist swaptemp;
 273         int size;
 274
 275         size = top - array;
 276         /* choose gaps according to Knuth V3 p95 */
 277         for ( gap = 1, i = 4; (j = 3 * i + 1) < size; gap = i, i = j )
 278                 ;
 279         do
 280         {
 281                 for ( j = gap; j < size; ++j )
 282                         for ( i = j - gap; i >= 0; i -= gap )
 283                         {
 284                                 left = array + i;
 285                                 right = array + (i + gap);
 286                                 if ( (off_t) left->n_value <=
 287                                      right->n_value )
 288                                         break;
 289                                 swaptemp = *left;
 290                                 *left = *right;
 291                                 *right = swaptemp;
 292                         }
 293         }
 294         while ( (gap /= 3) != 0 );
 295 }
 296
 297 void gnu_symbolic( value, separator )
 298 off_t value;
 299 int separator;
 300 {
 301         register struct newnlist *sp;
 302         long off;
 303
 304         if (value < st_addr || value > end_addr) {
 305                 outstr("0x");
 306                 printhex(value);
 307                 outbyte(separator);
 308                 return;
 309         }
 310
 311         if ( (sp = gnu_sval( value, CSEG )) != NULL )
 312         {
 313                 gnu_sym( sp, value );
 314         }
 315         else if ( (sp = gnu_sval( value, DSEG )) != NULL )
 316         {
 317                 gnu_sym( sp, value );
 318         }
 319         else
 320         {
 321                 outstr("_start");
 322                 off = value - st_addr;
 323                 if ( off != 0 )
 324                 {
 325                 outbyte( '+' );
 326                 printhex(off);
 327                 }
 328         }
 329         outbyte( separator );
 330 }
 331
 332
 333 static int gnu_symeq( t, sp )
 334 register char *t;
 335 struct newnlist *sp;
 336 {
 337         return strncmp( t, sp->n_un.n_name, strlen(t) ) == 0;
 338 }
 339
 340 static int gnu_symprefix( t, sp )
 341 register char *t;
 342 struct newnlist *sp;
 343 {
 344         register char *s;
 345         char *send;
 346
 347         for ( ; *t == '_'; ++t )
 348                 ;
 349         for ( s = sp->n_un.n_name, send = s + strlen(s);
 350               s < send && *s == '_'; ++s )
 351                 ;
 352         return strncmp( s, t, send - s ) == 0;
 353 }
 354
 355
 356
 357 /* list all symbols - test for selection criteria */
 358
 359 void gnu_listsym( tchar )
 360 char tchar;
 361 {
 362         register struct symtab_s *tp;
 363         register struct newnlist *sp;
 364         char *s;
 365         char *send;
 366         char schar;
 367
 368         outbyte('\n');
 369         tp = &symtab;
 370         for ( sp = tp->start; sp < tp->end; ++sp )
 371         {
 372              switch( sp->n_type & NN_TYPE )
 373              {
 374                         case NN_ABS:    schar = 'a'; break;
 375                         case NN_TEXT:   schar = 't'; break;
 376                         case NN_DATA:   schar = 'd'; break;
 377                         case NN_BSS:    schar = 'b'; break;
 378                         default:        schar = '?'; break;
 379              }
 380
 381              if ( (sp->n_type & NN_EXT) && schar != '?' )
 382                 schar += 'A' - 'a';
 383
 384              /* check for selection */
 385              if ( tchar != '*' && schar != tchar)
 386                 continue;
 387
 388              /* print symbol type and value */
 389              outh32( sp->n_value );
 390              outspace();
 391              outbyte( schar );
 392              outbyte( '\t' );
 393              for ( s = sp->n_un.n_name, send = s + strlen(s);
 394                  *s != 0 && s < send; ++s ) outbyte( *s );
 395              outbyte('\n');
 396         }
 397 }
 398
 399 int gnu_text_symbol(value)
 400 off_t value;
 401 {
 402     struct newnlist *sp;
 403
 404     if ((sp = gnu_sval(value, CSEG)) != NULL && sp->n_value == value)
 405     {
 406         gnu_sym(sp, value);
 407         return TRUE;
 408     }
 409     else
 410         return FALSE;
 411 }
 412
 413 int gnu_finds_data(off,data_seg)
 414 off_t off;
 415 int data_seg;
 416 {
 417         struct newnlist *sp;
 418
 419         if ((sp = gnu_sval(off, data_seg)) != NULL)
 420         {
 421             gnu_sym(sp, off);
 422             return TRUE;
 423         }
 424         else
 425             return FALSE;
 426 }
 427
 428 int gnu_finds_pc(pc)
 429 off_t pc;
 430 {
 431         struct newnlist *sp;
 432
 433         if ((sp = gnu_sval(pc, CSEG)) != NULL)
 434         {
 435             gnu_sym(sp, pc);
 436             return TRUE;
 437         }
 438         else
 439             return FALSE;
 440 }
 441
 442
 443 #endif /* EXTRA_SYMBOLS */