debugger/source.c

   1 /*
   2  * File source.c - source file handling for internal debugger.
   3  *
   4  * Copyright (C) 1997, Eric Youngdale.
   5  *
   6  */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10
  11 #include <sys/mman.h>
  12 #include <fcntl.h>
  13 #include <sys/stat.h>
  14 #include <limits.h>
  15 #include <strings.h>
  16 #include <unistd.h>
  17 #include <malloc.h>
  18
  19 #include "win.h"
  20 #include "pe_image.h"
  21 #include "peexe.h"
  22 #include "debugger.h"
  23 #include "peexe.h"
  24 #include "xmalloc.h"
  25
  26 struct searchlist
  27 {
  28   char * path;
  29   struct searchlist * next;
  30 };
  31
  32
  33 struct open_filelist
  34 {
  35   char                  * path;
  36   char                  * real_path;
  37   struct open_filelist  * next;
  38   unsigned int            size;
  39   signed int              nlines;
  40   unsigned int          * linelist;
  41 };
  42
  43 static struct open_filelist * ofiles;
  44
  45 static struct searchlist * listhead;
  46 static char DEBUG_current_sourcefile[PATH_MAX];
  47 static int DEBUG_start_sourceline = -1;
  48 static int DEBUG_end_sourceline = -1;
  49
  50 void
  51 DEBUG_ShowDir()
  52 {
  53   struct searchlist * sl;
  54
  55   fprintf(stderr,"Search list :\n");
  56   for(sl = listhead; sl; sl = sl->next)
  57     {
  58       fprintf(stderr, "\t%s\n", sl->path);
  59     }
  60   fprintf(stderr, "\n");
  61 }
  62
  63 void
  64 DEBUG_AddPath(const char * path)
  65 {
  66   struct searchlist * sl;
  67
  68   sl = (struct searchlist *) xmalloc(sizeof(struct searchlist));
  69   if( sl == NULL )
  70     {
  71       return;
  72     }
  73
  74   sl->next = listhead;
  75   sl->path = xstrdup(path);
  76   listhead = sl;
  77 }
  78
  79 void
  80 DEBUG_NukePath()
  81 {
  82   struct searchlist * sl;
  83   struct searchlist * nxt;
  84
  85   for(sl = listhead; sl; sl = nxt)
  86     {
  87       nxt = sl->next;
  88       free(sl->path);
  89       free(sl);
  90     }
  91
  92   listhead = NULL;
  93 }
  94
  95 static
  96 void
  97 DEBUG_DisplaySource(char * sourcefile, int start, int end)
  98 {
  99   char                        * addr;
 100   char                          buffer[1024];
 101   int                           fd;
 102   int                           i;
 103   struct open_filelist        * ol;
 104   int                           nlines;
 105   char                        * pnt;
 106   struct searchlist           * sl;
 107   struct stat                   statbuf;
 108   int                           status;
 109   char                          tmppath[PATH_MAX];
 110
 111   /*
 112    * First see whether we have the file open already.  If so, then
 113    * use that, otherwise we have to try and open it.
 114    */
 115   for(ol = ofiles; ol; ol = ol->next)
 116     {
 117       if( strcmp(ol->path, sourcefile) == 0 )
 118         {
 119           break;
 120         }
 121     }
 122
 123   if( ol == NULL )
 124     {
 125       /*
 126        * Try again, stripping the path from the opened file.
 127        */
 128       for(ol = ofiles; ol; ol = ol->next)
 129         {
 130           pnt = strrchr(ol->path, '/');
 131           if( pnt != NULL && strcmp(pnt + 1, sourcefile) == 0 )
 132             {
 133               break;
 134             }
 135         }
 136
 137     }
 138
 139   if( ol == NULL )
 140     {
 141       /*
 142        * See if this is a DOS style name or not.
 143        */
 144       pnt = strchr(sourcefile, '\\' );
 145       if( pnt == NULL )
 146         {
 147           pnt = strchr(sourcefile, '/' );
 148           if( pnt == NULL )
 149             {
 150               pnt = sourcefile;
 151             }
 152         }
 153
 154       /*
 155        * Crapola.  We need to try and open the file.
 156        */
 157       status = stat(sourcefile, &statbuf);
 158       if( status != -1 )
 159         {
 160           strcpy(tmppath, sourcefile);
 161         }
 162       else
 163         {
 164           for(sl = listhead; sl; sl = sl->next)
 165             {
 166               strcpy(tmppath, sl->path);
 167               if( tmppath[strlen(tmppath)-1] != '/' )
 168                 {
 169                   strcat(tmppath, "/");
 170                 }
 171               /*
 172                * Now append the base file name.
 173                */
 174               strcat(tmppath, pnt);
 175
 176               status = stat(tmppath, &statbuf);
 177               if( status != -1 )
 178                 {
 179                   break;
 180                 }
 181             }
 182
 183           if( sl == NULL )
 184             {
 185               /*
 186                * Still couldn't find it.  Ask user for path to add.
 187                */
 188               fprintf(stderr,"Enter path to file %s: ", sourcefile);
 189               fgets(tmppath, sizeof(tmppath), stdin);
 190
 191               if( tmppath[strlen(tmppath)-1] == '\n' )
 192                 {
 193                   tmppath[strlen(tmppath)-1] = '\0';
 194                 }
 195
 196               if( tmppath[strlen(tmppath)-1] != '/' )
 197                 {
 198                   strcat(tmppath, "/");
 199                 }
 200               /*
 201                * Now append the base file name.
 202                */
 203               strcat(tmppath, pnt);
 204
 205               status = stat(tmppath, &statbuf);
 206               if( status == -1 )
 207                 {
 208                   /*
 209                    * OK, I guess the user doesn't really want to see it
 210                    * after all.
 211                    */
 212                   ol = (struct open_filelist *) xmalloc(sizeof(*ol));
 213                   ol->path = xstrdup(sourcefile);
 214                   ol->real_path = NULL;
 215                   ol->next = ofiles;
 216                   ol->nlines = 0;
 217                   ol->linelist = NULL;
 218                   ofiles = ol;
 219                   fprintf(stderr,"Unable to open file %s\n", tmppath);
 220                   return;
 221                 }
 222             }
 223         }
 224       /*
 225        * Create header for file.
 226        */
 227       ol = (struct open_filelist *) xmalloc(sizeof(*ol));
 228       ol->path = xstrdup(sourcefile);
 229       ol->real_path = xstrdup(tmppath);
 230       ol->next = ofiles;
 231       ol->nlines = 0;
 232       ol->linelist = NULL;
 233       ol->size = statbuf.st_size;
 234       ofiles = ol;
 235
 236       /*
 237        * Now open and map the file.
 238        */
 239       fd = open(tmppath, O_RDONLY);
 240       if( fd == -1 )
 241         {
 242           return;
 243         }
 244
 245       addr = mmap(0, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
 246       if( addr == (char *) -1 )
 247         {
 248           return;
 249         }
 250
 251       /*
 252        * Now build up the line number mapping table.
 253        */
 254       ol->nlines = 1;
 255       pnt = addr;
 256       while(pnt < addr + ol->size )
 257         {
 258           if( *pnt++ == '\n' )
 259             {
 260               ol->nlines++;
 261             }
 262         }
 263
 264       ol->nlines++;
 265       ol->linelist = (unsigned int*) xmalloc(ol->nlines * sizeof(unsigned int) );
 266
 267       nlines = 0;
 268       pnt = addr;
 269       ol->linelist[nlines++] = 0;
 270       while(pnt < addr + ol->size )
 271         {
 272           if( *pnt++ == '\n' )
 273             {
 274               ol->linelist[nlines++] = pnt - addr;
 275             }
 276         }
 277       ol->linelist[nlines++] = pnt - addr;
 278
 279     }
 280   else
 281     {
 282       /*
 283        * We know what the file is, we just need to reopen it and remap it.
 284        */
 285       fd = open(ol->real_path, O_RDONLY);
 286       if( fd == -1 )
 287         {
 288           return;
 289         }
 290
 291       addr = mmap(0, ol->size, PROT_READ, MAP_PRIVATE, fd, 0);
 292       if( addr == (char *) -1 )
 293         {
 294           return;
 295         }
 296     }
 297
 298   /*
 299    * All we need to do is to display the source lines here.
 300    */
 301   for(i=start - 1; i <= end - 1; i++)
 302     {
 303       if( i < 0 || i >= ol->nlines - 1)
 304         {
 305           continue;
 306         }
 307
 308       memset(&buffer, 0, sizeof(buffer));
 309       if( ol->linelist[i+1] != ol->linelist[i] )
 310         {
 311           memcpy(&buffer, addr + ol->linelist[i],
 312                  (ol->linelist[i+1] - ol->linelist[i]) - 1);
 313         }
 314       fprintf(stderr,"%d\t%s\n", i + 1,  buffer);
 315     }
 316
 317   munmap(addr, ol->size);
 318   close(fd);
 319
 320 }
 321
 322 void
 323 DEBUG_List(struct list_id * source1, struct list_id * source2,
 324                          int delta)
 325 {
 326   int    end;
 327   int    start;
 328   char * sourcefile;
 329
 330   /*
 331    * We need to see what source file we need.  Hopefully we only have
 332    * one specified, otherwise we might as well punt.
 333    */
 334   if( source1 != NULL
 335       && source2 != NULL
 336       && source1->sourcefile != NULL
 337       && source2->sourcefile != NULL
 338       && strcmp(source1->sourcefile, source2->sourcefile) != 0 )
 339     {
 340       fprintf(stderr, "Ambiguous source file specification.\n");
 341       return;
 342     }
 343
 344   sourcefile = NULL;
 345   if( source1 != NULL && source1->sourcefile != NULL )
 346     {
 347       sourcefile = source1->sourcefile;
 348     }
 349
 350   if( sourcefile == NULL
 351       && source2 != NULL
 352       && source2->sourcefile != NULL )
 353     {
 354       sourcefile = source2->sourcefile;
 355     }
 356
 357   if( sourcefile == NULL )
 358     {
 359       sourcefile = (char *) &DEBUG_current_sourcefile;
 360     }
 361
 362   if( sourcefile == NULL )
 363     {
 364       fprintf(stderr, "No source file specified.\n");
 365       return;
 366     }
 367
 368   /*
 369    * Now figure out the line number range to be listed.
 370    */
 371   start = -1;
 372   end = -1;
 373
 374   if( source1 != NULL )
 375     {
 376       start = source1->line;
 377     }
 378
 379   if( source2 != NULL )
 380     {
 381       end = source2->line;
 382     }
 383
 384   if( start == -1 && end == -1 )
 385     {
 386       if( delta < 0 )
 387         {
 388           end = DEBUG_start_sourceline;
 389           start = end + delta;
 390         }
 391       else
 392         {
 393           start = DEBUG_end_sourceline;
 394           end = start + delta;
 395         }
 396     }
 397   else if( start == -1 )
 398     {
 399       start = end + delta;
 400     }
 401   else if (end == -1)
 402     {
 403       end = start + delta;
 404     }
 405
 406   /*
 407    * Now call this function to do the dirty work.
 408    */
 409   DEBUG_DisplaySource(sourcefile, start, end);
 410
 411   if( sourcefile != (char *) &DEBUG_current_sourcefile )
 412     {
 413       strcpy(DEBUG_current_sourcefile, sourcefile);
 414     }
 415   DEBUG_start_sourceline = start;
 416   DEBUG_end_sourceline = end;
 417 }
 418
 419
 420
 421 #if 0
 422 main()
 423 {
 424   int i, j;
 425   DEBUG_AddPath("../../de");
 426   while(1==1)
 427     {
 428       fscanf(stdin,"%d %d", &i, &j);
 429       DEBUG_DisplaySource("dumpexe.c", i, j);
 430     }
 431   return 0;
 432 }
 433 #endif