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