programs/winedbg/source.c

   1 /*
   2  * File source.c - source file handling for internal debugger.
   3  *
   4  * Copyright (C) 1997, Eric Youngdale.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23
  24 #include "debugger.h"
  25
  26 struct open_file_list
  27 {
  28     char*                       path;
  29     char*                       real_path;
  30     struct open_file_list*      next;
  31     unsigned int                size;
  32     signed int                  nlines;
  33     unsigned int*               linelist;
  34 };
  35
  36 void source_show_path(void)
  37 {
  38     const char* ptr;
  39     const char* next;
  40
  41     dbg_printf("Search list:\n");
  42     for (ptr = dbg_curr_process->search_path; ptr; ptr = next)
  43     {
  44         next = strchr(ptr, ';');
  45         if (next)
  46             dbg_printf("\t%.*s\n", (int)(next++ - ptr), ptr);
  47         else
  48             dbg_printf("\t%s\n", ptr);
  49     }
  50     dbg_printf("\n");
  51 }
  52
  53 void source_add_path(const char* path)
  54 {
  55     char*       new;
  56     unsigned    size;
  57
  58     size = strlen(path) + 1;
  59     if (dbg_curr_process->search_path)
  60     {
  61         unsigned pos = strlen(dbg_curr_process->search_path) + 1;
  62         new = HeapReAlloc(GetProcessHeap(), 0, dbg_curr_process->search_path, pos + size);
  63         if (!new) return;
  64         new[pos - 1] = ';';
  65         strcpy(&new[pos], path);
  66     }
  67     else
  68     {
  69         new = HeapAlloc(GetProcessHeap(), 0, size);
  70         if (!new) return;
  71         strcpy(new, path);
  72     }
  73     dbg_curr_process->search_path = new;
  74 }
  75
  76 void source_nuke_path(struct dbg_process* p)
  77 {
  78     HeapFree(GetProcessHeap(), 0, p->search_path);
  79     p->search_path = NULL;
  80 }
  81
  82 static  void*   source_map_file(const char* name, HANDLE* hMap, unsigned* size)
  83 {
  84     HANDLE              hFile;
  85
  86     hFile = CreateFileA(name, GENERIC_READ, FILE_SHARE_READ, NULL,
  87                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  88     if (hFile == INVALID_HANDLE_VALUE) return (void*)-1;
  89     if (size != NULL && (*size = GetFileSize(hFile, NULL)) == INVALID_FILE_SIZE) {
  90         CloseHandle(hFile);
  91         return (void*)-1;
  92     }
  93     *hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
  94     CloseHandle(hFile);
  95     if (!*hMap) return (void*)-1;
  96     return MapViewOfFile(*hMap, FILE_MAP_READ, 0, 0, 0);
  97 }
  98
  99 static void     source_unmap_file(void* addr, HANDLE hMap)
 100 {
 101     UnmapViewOfFile(addr);
 102     CloseHandle(hMap);
 103 }
 104
 105 static struct open_file_list* source_search_open_file(const char* name)
 106 {
 107     struct open_file_list*      ol;
 108
 109     for (ol = dbg_curr_process->source_ofiles; ol; ol = ol->next)
 110     {
 111         if (strcmp(ol->path, name) == 0) break;
 112     }
 113     return ol;
 114 }
 115
 116 static BOOL     source_locate_file(const char* srcfile, char* path)
 117 {
 118     BOOL        found = FALSE;
 119
 120     if (GetFileAttributesA(srcfile) != INVALID_FILE_ATTRIBUTES)
 121     {
 122         strcpy(path, srcfile);
 123         found = TRUE;
 124     }
 125     else if (dbg_curr_process->search_path)
 126     {
 127         const char* spath;
 128
 129         spath = srcfile;
 130         while (!found)
 131         {
 132             while (*spath && *spath != '/' && *spath != '\\') spath++;
 133             if (!*spath) break;
 134             spath++;
 135             found = SearchPathA(dbg_curr_process->search_path, spath, NULL, MAX_PATH, path, NULL);
 136         }
 137     }
 138     return found;
 139 }
 140
 141 static struct open_file_list* source_add_file(const char* name, const char* realpath)
 142 {
 143     struct open_file_list*      ol;
 144     size_t                      sz, nlen;
 145
 146     sz = sizeof(*ol);
 147     nlen = strlen(name) + 1;
 148     if (realpath) sz += strlen(realpath) + 1;
 149     ol = HeapAlloc(GetProcessHeap(), 0, sz + nlen);
 150     if (!ol) return NULL;
 151     strcpy(ol->path = (char*)(ol + 1), name);
 152     if (realpath)
 153         strcpy(ol->real_path = ol->path + nlen, realpath);
 154     else
 155         ol->real_path = NULL;
 156     ol->next = dbg_curr_process->source_ofiles;
 157     ol->nlines = 0;
 158     ol->linelist = NULL;
 159     ol->size = 0;
 160     return dbg_curr_process->source_ofiles = ol;
 161 }
 162
 163 static int source_display(const char* sourcefile, int start, int end)
 164 {
 165     char*                       addr;
 166     int                         i;
 167     struct open_file_list*      ol;
 168     int                         nlines;
 169     const char*                 basename = NULL;
 170     char*                       pnt;
 171     int                         rtn;
 172     HANDLE                      hMap;
 173     char                        tmppath[MAX_PATH];
 174
 175     /*
 176      * First see whether we have the file open already.  If so, then
 177      * use that, otherwise we have to try and open it.
 178      */
 179     ol = source_search_open_file(sourcefile);
 180
 181     if (ol == NULL)
 182     {
 183         /*
 184          * Try again, stripping the path from the opened file.
 185          */
 186         basename = strrchr(sourcefile, '\\');
 187         if (!basename) basename = strrchr(sourcefile, '/');
 188         if (!basename) basename = sourcefile;
 189         else basename++;
 190
 191         ol = source_search_open_file(basename);
 192     }
 193
 194     if (ol == NULL)
 195     {
 196         /*
 197          * Crapola.  We need to try and open the file.
 198          */
 199         if (!source_locate_file(sourcefile, tmppath))
 200         {
 201             if (dbg_interactiveP)
 202             {
 203                 char zbuf[256];
 204
 205                 for (;;)
 206                 {
 207                     size_t      len;
 208                     /*
 209                      * Still couldn't find it.  Ask user for path to add.
 210                      */
 211                     snprintf(zbuf, sizeof(zbuf), "Enter path to file '%s' (<cr> to end search): ", sourcefile);
 212                     input_read_line(zbuf, tmppath, sizeof(tmppath));
 213                     if (!(len = strlen(tmppath))) break;
 214
 215                     /* append '/' if missing at the end */
 216                     if (tmppath[len - 1] != '/' && tmppath[len - 1] != '\\')
 217                         tmppath[len++] = '/';
 218                     strcpy(&tmppath[len], basename);
 219                     if (GetFileAttributesA(tmppath) != INVALID_FILE_ATTRIBUTES)
 220                         break;
 221                     dbg_printf("Unable to access file '%s'\n", tmppath);
 222                 }
 223             }
 224             else
 225             {
 226                 dbg_printf("Unable to access file '%s'\n", sourcefile);
 227                 tmppath[0] = '\0';
 228             }
 229
 230             if (!tmppath[0])
 231             {
 232                 /*
 233                  * OK, I guess the user doesn't really want to see it
 234                  * after all.
 235                  */
 236                 source_add_file(sourcefile, NULL);
 237                 return FALSE;
 238             }
 239         }
 240         /*
 241          * Create header for file.
 242          */
 243         ol = source_add_file(sourcefile, tmppath);
 244
 245         addr = source_map_file(tmppath, &hMap, &ol->size);
 246         if (addr == (char*)-1) return FALSE;
 247         /*
 248          * Now build up the line number mapping table.
 249          */
 250         ol->nlines = 1;
 251         pnt = addr;
 252         while (pnt < addr + ol->size)
 253         {
 254             if (*pnt++ == '\n') ol->nlines++;
 255         }
 256
 257         ol->nlines++;
 258         ol->linelist = HeapAlloc(GetProcessHeap(), 0, ol->nlines * sizeof(unsigned int));
 259
 260         nlines = 0;
 261         pnt = addr;
 262         ol->linelist[nlines++] = 0;
 263         while (pnt < addr + ol->size)
 264         {
 265             if (*pnt++ == '\n') ol->linelist[nlines++] = pnt - addr;
 266         }
 267         ol->linelist[nlines++] = pnt - addr;
 268
 269     }
 270     else
 271     {
 272         addr = source_map_file(ol->real_path, &hMap, NULL);
 273         if (addr == (char*)-1) return FALSE;
 274     }
 275     /*
 276      * All we need to do is to display the source lines here.
 277      */
 278     rtn = FALSE;
 279     for (i = start - 1; i <= end - 1; i++)
 280     {
 281         char    buffer[1024];
 282
 283         if (i < 0 || i >= ol->nlines - 1) continue;
 284
 285         rtn = TRUE;
 286         memset(&buffer, 0, sizeof(buffer));
 287         if (ol->linelist[i+1] != ol->linelist[i])
 288         {
 289             memcpy(&buffer, addr + ol->linelist[i],
 290                    (ol->linelist[i+1] - ol->linelist[i]) - 1);
 291         }
 292         dbg_printf("%d\t%s\n", i + 1, buffer);
 293     }
 294
 295     source_unmap_file(addr, hMap);
 296     return rtn;
 297 }
 298
 299 void source_list(IMAGEHLP_LINE64* src1, IMAGEHLP_LINE64* src2, int delta)
 300 {
 301     int         end;
 302     int         start;
 303     const char* sourcefile;
 304
 305     /*
 306      * We need to see what source file we need.  Hopefully we only have
 307      * one specified, otherwise we might as well punt.
 308      */
 309     if (src1 && src2 && src1->FileName && src2->FileName &&
 310         strcmp(src1->FileName, src2->FileName) != 0)
 311     {
 312         dbg_printf("Ambiguous source file specification.\n");
 313         return;
 314     }
 315
 316     sourcefile = NULL;
 317     if (src1 && src1->FileName) sourcefile = src1->FileName;
 318     if (!sourcefile && src2 && src2->FileName) sourcefile = src2->FileName;
 319     if (!sourcefile) sourcefile = dbg_curr_process->source_current_file;
 320
 321     /*
 322      * Now figure out the line number range to be listed.
 323      */
 324     start = end = -1;
 325
 326     if (src1) start = src1->LineNumber;
 327     if (src2) end   = src2->LineNumber;
 328     if (start == -1 && end == -1)
 329     {
 330         if (delta < 0)
 331         {
 332             end = dbg_curr_process->source_start_line;
 333             start = end + delta;
 334         }
 335         else
 336         {
 337             start = dbg_curr_process->source_end_line;
 338             end = start + delta;
 339         }
 340     }
 341     else if (start == -1) start = end + delta;
 342     else if (end == -1)   end = start + delta;
 343
 344     /*
 345      * Now call this function to do the dirty work.
 346      */
 347     source_display(sourcefile, start, end);
 348
 349     if (sourcefile != dbg_curr_process->source_current_file)
 350         strcpy(dbg_curr_process->source_current_file, sourcefile);
 351     dbg_curr_process->source_start_line = start;
 352     dbg_curr_process->source_end_line = end;
 353 }
 354
 355 void source_list_from_addr(const ADDRESS64* addr, int nlines)
 356 {
 357     IMAGEHLP_LINE64     il;
 358     ADDRESS64           la;
 359     DWORD               disp;
 360
 361     if (!addr)
 362     {
 363         memory_get_current_pc(&la);
 364         addr = &la;
 365     }
 366
 367     il.SizeOfStruct = sizeof(il);
 368     if (SymGetLineFromAddr64(dbg_curr_process->handle,
 369                              (DWORD_PTR)memory_to_linear_addr(addr),
 370                              &disp, &il))
 371         source_list(&il, NULL, nlines);
 372 }
 373
 374 void source_free_files(struct dbg_process* p)
 375 {
 376     struct open_file_list*      ofile;
 377     struct open_file_list*      ofile_next;
 378
 379     for (ofile = p->source_ofiles; ofile; ofile = ofile_next)
 380     {
 381         ofile_next = ofile->next;
 382         HeapFree(GetProcessHeap(), 0, ofile->linelist);
 383         HeapFree(GetProcessHeap(), 0, ofile);
 384     }
 385 }