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 "config.h"
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11
  12 #include <sys/types.h>
  13 #ifdef HAVE_SYS_MMAN_H
  14 #include <sys/mman.h>
  15 #endif
  16 #include <fcntl.h>
  17 #include <sys/stat.h>
  18 #include <limits.h>
  19 #include <string.h>
  20 #include <unistd.h>
  21 #ifndef PATH_MAX
  22 #define PATH_MAX _MAX_PATH
  23 #endif
  24
  25 #include "debugger.h"
  26
  27 struct searchlist
  28 {
  29   char * path;
  30   struct searchlist * next;
  31 };
  32
  33
  34 struct open_filelist
  35 {
  36   char                  * path;
  37   char                  * real_path;
  38   struct open_filelist  * next;
  39   unsigned int            size;
  40   signed int              nlines;
  41   unsigned int          * linelist;
  42 };
  43
  44 static struct open_filelist * ofiles;
  45
  46 static struct searchlist * listhead;
  47 static char DEBUG_current_sourcefile[PATH_MAX];
  48 static int DEBUG_start_sourceline = -1;
  49 static int DEBUG_end_sourceline = -1;
  50
  51 void
  52 DEBUG_ShowDir(void)
  53 {
  54   struct searchlist * sl;
  55
  56   DEBUG_Printf(DBG_CHN_MESG,"Search list :\n");
  57   for(sl = listhead; sl; sl = sl->next)
  58     {
  59       DEBUG_Printf(DBG_CHN_MESG, "\t%s\n", sl->path);
  60     }
  61   DEBUG_Printf(DBG_CHN_MESG, "\n");
  62 }
  63
  64 void
  65 DEBUG_AddPath(const char * path)
  66 {
  67   struct searchlist * sl;
  68
  69   sl = (struct searchlist *) DBG_alloc(sizeof(struct searchlist));
  70   if( sl == NULL )
  71     {
  72       return;
  73     }
  74
  75   sl->next = listhead;
  76   sl->path = DBG_strdup(path);
  77   listhead = sl;
  78 }
  79
  80 void
  81 DEBUG_NukePath(void)
  82 {
  83   struct searchlist * sl;
  84   struct searchlist * nxt;
  85
  86   for(sl = listhead; sl; sl = nxt)
  87     {
  88       nxt = sl->next;
  89       DBG_free(sl->path);
  90       DBG_free(sl);
  91     }
  92
  93   listhead = NULL;
  94 }
  95
  96 static
  97 int
  98 DEBUG_DisplaySource(char * sourcefile, int start, int end)
  99 {
 100   char                        * addr;
 101   char                          buffer[1024];
 102   int                           fd;
 103   int                           i;
 104   struct open_filelist        * ol;
 105   int                           nlines;
 106   char                        * basename;
 107   char                        * pnt;
 108   int                           rtn;
 109   struct searchlist           * sl;
 110   struct stat                   statbuf;
 111   int                           status;
 112   char                          tmppath[PATH_MAX];
 113
 114   /*
 115    * First see whether we have the file open already.  If so, then
 116    * use that, otherwise we have to try and open it.
 117    */
 118   for(ol = ofiles; ol; ol = ol->next)
 119     {
 120       if( strcmp(ol->path, sourcefile) == 0 )
 121         {
 122           break;
 123         }
 124     }
 125
 126   if( ol == NULL )
 127     {
 128       /*
 129        * Try again, stripping the path from the opened file.
 130        */
 131       basename = strrchr(sourcefile, '\\' );
 132       if ( !basename )
 133           basename = strrchr(sourcefile, '/' );
 134       if ( !basename )
 135           basename = sourcefile;
 136       else
 137           basename++;
 138
 139       for(ol = ofiles; ol; ol = ol->next)
 140         {
 141           if( strcmp(ol->path, basename) == 0 )
 142             {
 143               break;
 144             }
 145         }
 146
 147     }
 148
 149   if( ol == NULL )
 150     {
 151       /*
 152        * Crapola.  We need to try and open the file.
 153        */
 154       status = stat(sourcefile, &statbuf);
 155       if( status != -1 )
 156         {
 157           strcpy(tmppath, sourcefile);
 158         }
 159       else if( (status = stat(basename, &statbuf)) != -1 )
 160         {
 161           strcpy(tmppath, basename);
 162         }
 163       else
 164         {
 165           for(sl = listhead; sl; sl = sl->next)
 166             {
 167               strcpy(tmppath, sl->path);
 168               if( tmppath[strlen(tmppath)-1] != '/' )
 169                 {
 170                   strcat(tmppath, "/");
 171                 }
 172               /*
 173                * Now append the base file name.
 174                */
 175               strcat(tmppath, basename);
 176
 177               status = stat(tmppath, &statbuf);
 178               if( status != -1 )
 179                 {
 180                   break;
 181                 }
 182             }
 183
 184           if( sl == NULL )
 185             {
 186               /*
 187                * Still couldn't find it.  Ask user for path to add.
 188                */
 189               DEBUG_Printf(DBG_CHN_MESG,"Enter path to file %s: ", sourcefile);
 190               fgets(tmppath, sizeof(tmppath), stdin);
 191
 192               if( tmppath[strlen(tmppath)-1] == '\n' )
 193                 {
 194                   tmppath[strlen(tmppath)-1] = '\0';
 195                 }
 196
 197               if( tmppath[strlen(tmppath)-1] != '/' )
 198                 {
 199                   strcat(tmppath, "/");
 200                 }
 201               /*
 202                * Now append the base file name.
 203                */
 204               strcat(tmppath, basename);
 205
 206               status = stat(tmppath, &statbuf);
 207               if( status == -1 )
 208                 {
 209                   /*
 210                    * OK, I guess the user doesn't really want to see it
 211                    * after all.
 212                    */
 213                   ol = (struct open_filelist *) DBG_alloc(sizeof(*ol));
 214                   ol->path = DBG_strdup(sourcefile);
 215                   ol->real_path = NULL;
 216                   ol->next = ofiles;
 217                   ol->nlines = 0;
 218                   ol->linelist = NULL;
 219                   ofiles = ol;
 220                   DEBUG_Printf(DBG_CHN_MESG,"Unable to open file %s\n", tmppath);
 221                   return FALSE;
 222                 }
 223             }
 224         }
 225       /*
 226        * Create header for file.
 227        */
 228       ol = (struct open_filelist *) DBG_alloc(sizeof(*ol));
 229       ol->path = DBG_strdup(sourcefile);
 230       ol->real_path = DBG_strdup(tmppath);
 231       ol->next = ofiles;
 232       ol->nlines = 0;
 233       ol->linelist = NULL;
 234       ol->size = statbuf.st_size;
 235       ofiles = ol;
 236
 237       /*
 238        * Now open and map the file.
 239        */
 240       fd = open(tmppath, O_RDONLY);
 241       if( fd == -1 )
 242         {
 243           return FALSE;
 244         }
 245
 246       addr = mmap(0, statbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
 247       if( addr == (char *) -1 )
 248         {
 249           return FALSE;
 250         }
 251
 252       /*
 253        * Now build up the line number mapping table.
 254        */
 255       ol->nlines = 1;
 256       pnt = addr;
 257       while(pnt < addr + ol->size )
 258         {
 259           if( *pnt++ == '\n' )
 260             {
 261               ol->nlines++;
 262             }
 263         }
 264
 265       ol->nlines++;
 266       ol->linelist = (unsigned int*) DBG_alloc( ol->nlines * sizeof(unsigned int) );
 267
 268       nlines = 0;
 269       pnt = addr;
 270       ol->linelist[nlines++] = 0;
 271       while(pnt < addr + ol->size )
 272         {
 273           if( *pnt++ == '\n' )
 274             {
 275               ol->linelist[nlines++] = pnt - addr;
 276             }
 277         }
 278       ol->linelist[nlines++] = pnt - addr;
 279
 280     }
 281   else
 282     {
 283       /*
 284        * We know what the file is, we just need to reopen it and remap it.
 285        */
 286       fd = open(ol->real_path, O_RDONLY);
 287       if( fd == -1 )
 288         {
 289           return FALSE;
 290         }
 291
 292       addr = mmap(0, ol->size, PROT_READ, MAP_PRIVATE, fd, 0);
 293       if( addr == (char *) -1 )
 294         {
 295           return FALSE;
 296         }
 297     }
 298
 299   /*
 300    * All we need to do is to display the source lines here.
 301    */
 302   rtn = FALSE;
 303   for(i=start - 1; i <= end - 1; i++)
 304     {
 305       if( i < 0 || i >= ol->nlines - 1)
 306         {
 307           continue;
 308         }
 309
 310       rtn = TRUE;
 311       memset(&buffer, 0, sizeof(buffer));
 312       if( ol->linelist[i+1] != ol->linelist[i] )
 313         {
 314           memcpy(&buffer, addr + ol->linelist[i],
 315                  (ol->linelist[i+1] - ol->linelist[i]) - 1);
 316         }
 317       DEBUG_Printf(DBG_CHN_MESG,"%d\t%s\n", i + 1,  buffer);
 318     }
 319
 320   munmap(addr, ol->size);
 321   close(fd);
 322
 323   return rtn;
 324
 325 }
 326
 327 void
 328 DEBUG_List(struct list_id * source1, struct list_id * source2,
 329                          int delta)
 330 {
 331   int    end;
 332   int    rtn;
 333   int    start;
 334   char * sourcefile;
 335
 336   /*
 337    * We need to see what source file we need.  Hopefully we only have
 338    * one specified, otherwise we might as well punt.
 339    */
 340   if( source1 != NULL
 341       && source2 != NULL
 342       && source1->sourcefile != NULL
 343       && source2->sourcefile != NULL
 344       && strcmp(source1->sourcefile, source2->sourcefile) != 0 )
 345     {
 346       DEBUG_Printf(DBG_CHN_MESG, "Ambiguous source file specification.\n");
 347       return;
 348     }
 349
 350   sourcefile = NULL;
 351   if( source1 != NULL && source1->sourcefile != NULL )
 352     {
 353       sourcefile = source1->sourcefile;
 354     }
 355
 356   if( sourcefile == NULL
 357       && source2 != NULL
 358       && source2->sourcefile != NULL )
 359     {
 360       sourcefile = source2->sourcefile;
 361     }
 362
 363   if( sourcefile == NULL )
 364     {
 365       sourcefile = (char *) &DEBUG_current_sourcefile;
 366     }
 367
 368   if( sourcefile == NULL )
 369     {
 370       DEBUG_Printf(DBG_CHN_MESG, "No source file specified.\n");
 371       return;
 372     }
 373
 374   /*
 375    * Now figure out the line number range to be listed.
 376    */
 377   start = -1;
 378   end = -1;
 379
 380   if( source1 != NULL )
 381     {
 382       start = source1->line;
 383     }
 384
 385   if( source2 != NULL )
 386     {
 387       end = source2->line;
 388     }
 389
 390   if( start == -1 && end == -1 )
 391     {
 392       if( delta < 0 )
 393         {
 394           end = DEBUG_start_sourceline;
 395           start = end + delta;
 396         }
 397       else
 398         {
 399           start = DEBUG_end_sourceline;
 400           end = start + delta;
 401         }
 402     }
 403   else if( start == -1 )
 404     {
 405       start = end + delta;
 406     }
 407   else if (end == -1)
 408     {
 409       end = start + delta;
 410     }
 411
 412   /*
 413    * Now call this function to do the dirty work.
 414    */
 415   rtn = DEBUG_DisplaySource(sourcefile, start, end);
 416
 417   if( sourcefile != (char *) &DEBUG_current_sourcefile )
 418     {
 419       strcpy(DEBUG_current_sourcefile, sourcefile);
 420     }
 421   DEBUG_start_sourceline = start;
 422   DEBUG_end_sourceline = end;
 423 }
 424
 425 DBG_ADDR DEBUG_LastDisassemble={0,0};
 426
 427 static int
 428 _disassemble(DBG_ADDR *addr)
 429 {
 430    char ch;
 431
 432    DEBUG_PrintAddress( addr, DEBUG_CurrThread->dbg_mode, TRUE );
 433    DEBUG_Printf(DBG_CHN_MESG,": ");
 434    if (!DEBUG_READ_MEM_VERBOSE((void*)DEBUG_ToLinear(addr), &ch, sizeof(ch))) return 0;
 435    DEBUG_Disasm( addr, TRUE );
 436    DEBUG_Printf(DBG_CHN_MESG,"\n");
 437    return 1;
 438 }
 439
 440 void
 441 _disassemble_fixaddr(DBG_VALUE *value) {
 442     DWORD seg2;
 443     struct datatype *testtype;
 444
 445     assert(value->cookie == DV_TARGET || value->cookie == DV_HOST);
 446
 447     DEBUG_FixAddress(&value->addr, DEBUG_context.SegCs);
 448
 449     if( value->type != NULL )
 450       {
 451         if( value->type == DEBUG_TypeIntConst )
 452           {
 453             /*
 454              * We know that we have the actual offset stored somewhere
 455              * else in 32-bit space.  Grab it, and we
 456              * should be all set.
 457              */
 458             seg2 = value->addr.seg;
 459             value->addr.seg = 0;
 460             value->addr.off = DEBUG_GetExprValue(value, NULL);
 461             value->addr.seg = seg2;
 462           }
 463         else
 464           {
 465             DEBUG_TypeDerefPointer(value, &testtype);
 466             if( testtype != NULL || value->type == DEBUG_TypeIntConst )
 467                 value->addr.off = DEBUG_GetExprValue(value, NULL);
 468           }
 469       }
 470     else if (!value->addr.seg && !value->addr.off)
 471     {
 472         DEBUG_Printf(DBG_CHN_MESG,"Invalid expression\n");
 473         return;
 474     }
 475 }
 476
 477 void
 478 DEBUG_Disassemble(const DBG_VALUE *xstart,const DBG_VALUE *xend,int offset)
 479 {
 480   int i;
 481   DBG_ADDR      last;
 482   DBG_VALUE     end,start;
 483
 484   if (xstart) {
 485     start = *xstart;
 486     _disassemble_fixaddr(&start);
 487   }
 488   if (xend) {
 489     end = *xend;
 490     _disassemble_fixaddr(&end);
 491   }
 492   if (!xstart && !xend) {
 493     last = DEBUG_LastDisassemble;
 494     if (!last.seg && !last.off)
 495       DEBUG_GetCurrentAddress( &last );
 496
 497     for (i=0;i<offset;i++)
 498       if (!_disassemble(&last)) break;
 499     DEBUG_LastDisassemble = last;
 500     return;
 501   }
 502   last = start.addr;
 503   if (!xend) {
 504     for (i=0;i<offset;i++)
 505       if (!_disassemble(&last)) break;
 506     DEBUG_LastDisassemble = last;
 507     return;
 508   }
 509   while (last.off <= end.addr.off)
 510     if (!_disassemble(&last)) break;
 511   DEBUG_LastDisassemble = last;
 512   return;
 513 }
 514
 515
 516
 517 #if 0
 518 main(void)
 519 {
 520   int i, j;
 521   DEBUG_AddPath("../../de");
 522   while(1==1)
 523     {
 524       fscanf(stdin,"%d %d", &i, &j);
 525       DEBUG_DisplaySource("dumpexe.c", i, j);
 526     }
 527   return 0;
 528 }
 529 #endif