gdb/windows-nat.c

   1 /* Target-vector operations for controlling windows child processes, for GDB.
   2
   3    Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   4    2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
   5
   6    Contributed by Cygnus Solutions, A Red Hat Company.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 /* Originally by Steve Chamberlain, sac@cygnus.com */
  24
  25 #include "defs.h"
  26 #include "frame.h"              /* required by inferior.h */
  27 #include "inferior.h"
  28 #include "target.h"
  29 #include "exceptions.h"
  30 #include "gdbcore.h"
  31 #include "command.h"
  32 #include "completer.h"
  33 #include "regcache.h"
  34 #include "top.h"
  35 #include <signal.h>
  36 #include <sys/types.h>
  37 #include <fcntl.h>
  38 #include <stdlib.h>
  39 #include <windows.h>
  40 #include <imagehlp.h>
  41 #ifdef __CYGWIN__
  42 #include <sys/cygwin.h>
  43 #endif
  44 #include <signal.h>
  45
  46 #include "buildsym.h"
  47 #include "symfile.h"
  48 #include "objfiles.h"
  49 #include "gdb_obstack.h"
  50 #include "gdb_string.h"
  51 #include "gdbthread.h"
  52 #include "gdbcmd.h"
  53 #include <sys/param.h>
  54 #include <unistd.h>
  55 #include "exec.h"
  56 #include "solist.h"
  57 #include "solib.h"
  58 #include "xml-support.h"
  59
  60 #include "i386-tdep.h"
  61 #include "i387-tdep.h"
  62
  63 #include "windows-tdep.h"
  64 #include "windows-nat.h"
  65
  66 static struct target_ops windows_ops;
  67
  68 #ifdef __CYGWIN__
  69 /* The starting and ending address of the cygwin1.dll text segment. */
  70 static CORE_ADDR cygwin_load_start;
  71 static CORE_ADDR cygwin_load_end;
  72 #endif
  73
  74 static int have_saved_context;  /* True if we've saved context from a cygwin signal. */
  75 static CONTEXT saved_context;   /* Containes the saved context from a cygwin signal. */
  76
  77 /* If we're not using the old Cygwin header file set, define the
  78    following which never should have been in the generic Win32 API
  79    headers in the first place since they were our own invention... */
  80 #ifndef _GNU_H_WINDOWS_H
  81 enum
  82   {
  83     FLAG_TRACE_BIT = 0x100,
  84     CONTEXT_DEBUGGER = (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
  85   };
  86 #endif
  87 #include <psapi.h>
  88
  89 #ifndef CONTEXT_EXTENDED_REGISTERS
  90 /* This macro is only defined on ia32.  It only makes sense on this target,
  91    so define it as zero if not already defined.  */
  92 #define CONTEXT_EXTENDED_REGISTERS 0
  93 #endif
  94
  95 #define CONTEXT_DEBUGGER_DR CONTEXT_DEBUGGER | CONTEXT_DEBUG_REGISTERS \
  96         | CONTEXT_EXTENDED_REGISTERS
  97
  98 static unsigned dr[8];
  99 static int debug_registers_changed;
 100 static int debug_registers_used;
 101 #define DR6_CLEAR_VALUE 0xffff0ff0
 102
 103 /* The string sent by cygwin when it processes a signal.
 104    FIXME: This should be in a cygwin include file. */
 105 #ifndef _CYGWIN_SIGNAL_STRING
 106 #define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
 107 #endif
 108
 109 #define CHECK(x)        check (x, __FILE__,__LINE__)
 110 #define DEBUG_EXEC(x)   if (debug_exec)         printf_unfiltered x
 111 #define DEBUG_EVENTS(x) if (debug_events)       printf_unfiltered x
 112 #define DEBUG_MEM(x)    if (debug_memory)       printf_unfiltered x
 113 #define DEBUG_EXCEPT(x) if (debug_exceptions)   printf_unfiltered x
 114
 115 static void windows_stop (ptid_t);
 116 static int windows_thread_alive (ptid_t);
 117 static void windows_kill_inferior (void);
 118
 119 static enum target_signal last_sig = TARGET_SIGNAL_0;
 120 /* Set if a signal was received from the debugged process */
 121
 122 /* Thread information structure used to track information that is
 123    not available in gdb's thread structure.  */
 124 typedef struct thread_info_struct
 125   {
 126     struct thread_info_struct *next;
 127     DWORD id;
 128     HANDLE h;
 129     char *name;
 130     int suspended;
 131     int reload_context;
 132     CONTEXT context;
 133     STACKFRAME sf;
 134   }
 135 thread_info;
 136
 137 static thread_info thread_head;
 138
 139 /* The process and thread handles for the above context. */
 140
 141 static DEBUG_EVENT current_event;       /* The current debug event from
 142                                            WaitForDebugEvent */
 143 static HANDLE current_process_handle;   /* Currently executing process */
 144 static thread_info *current_thread;     /* Info on currently selected thread */
 145 static DWORD main_thread_id;            /* Thread ID of the main thread */
 146
 147 /* Counts of things. */
 148 static int exception_count = 0;
 149 static int event_count = 0;
 150 static int saw_create;
 151 static int open_process_used = 0;
 152
 153 /* User options. */
 154 static int new_console = 0;
 155 #ifdef __CYGWIN__
 156 static int cygwin_exceptions = 0;
 157 #endif
 158 static int new_group = 1;
 159 static int debug_exec = 0;              /* show execution */
 160 static int debug_events = 0;            /* show events from kernel */
 161 static int debug_memory = 0;            /* show target memory accesses */
 162 static int debug_exceptions = 0;        /* show target exceptions */
 163 static int useshell = 0;                /* use shell for subprocesses */
 164
 165 /* This vector maps GDB's idea of a register's number into an offset
 166    in the windows exception context vector.
 167
 168    It also contains the bit mask needed to load the register in question.
 169
 170    The contents of this table can only be computed by the units
 171    that provide CPU-specific support for Windows native debugging.
 172    These units should set the table by calling
 173    windows_set_context_register_offsets.
 174
 175    One day we could read a reg, we could inspect the context we
 176    already have loaded, if it doesn't have the bit set that we need,
 177    we read that set of registers in using GetThreadContext.  If the
 178    context already contains what we need, we just unpack it. Then to
 179    write a register, first we have to ensure that the context contains
 180    the other regs of the group, and then we copy the info in and set
 181    out bit. */
 182
 183 static const int *mappings;
 184
 185 /* This vector maps the target's idea of an exception (extracted
 186    from the DEBUG_EVENT structure) to GDB's idea. */
 187
 188 struct xlate_exception
 189   {
 190     int them;
 191     enum target_signal us;
 192   };
 193
 194 static const struct xlate_exception
 195   xlate[] =
 196 {
 197   {EXCEPTION_ACCESS_VIOLATION, TARGET_SIGNAL_SEGV},
 198   {STATUS_STACK_OVERFLOW, TARGET_SIGNAL_SEGV},
 199   {EXCEPTION_BREAKPOINT, TARGET_SIGNAL_TRAP},
 200   {DBG_CONTROL_C, TARGET_SIGNAL_INT},
 201   {EXCEPTION_SINGLE_STEP, TARGET_SIGNAL_TRAP},
 202   {STATUS_FLOAT_DIVIDE_BY_ZERO, TARGET_SIGNAL_FPE},
 203   {-1, -1}};
 204
 205 /* Set the MAPPINGS static global to OFFSETS.
 206    See the description of MAPPINGS for more details.  */
 207
 208 void
 209 windows_set_context_register_offsets (const int *offsets)
 210 {
 211   mappings = offsets;
 212 }
 213
 214 static void
 215 check (BOOL ok, const char *file, int line)
 216 {
 217   if (!ok)
 218     printf_filtered ("error return %s:%d was %lu\n", file, line,
 219                      GetLastError ());
 220 }
 221
 222 /* Find a thread record given a thread id.  If GET_CONTEXT is not 0,
 223    then also retrieve the context for this thread.  If GET_CONTEXT is
 224    negative, then don't suspend the thread.  */
 225 static thread_info *
 226 thread_rec (DWORD id, int get_context)
 227 {
 228   thread_info *th;
 229
 230   for (th = &thread_head; (th = th->next) != NULL;)
 231     if (th->id == id)
 232       {
 233         if (!th->suspended && get_context)
 234           {
 235             if (get_context > 0 && id != current_event.dwThreadId)
 236               {
 237                 if (SuspendThread (th->h) == (DWORD) -1)
 238                   {
 239                     DWORD err = GetLastError ();
 240                     warning (_("SuspendThread failed. (winerr %d)"),
 241                              (int) err);
 242                     return NULL;
 243                   }
 244                 th->suspended = 1;
 245               }
 246             else if (get_context < 0)
 247               th->suspended = -1;
 248             th->reload_context = 1;
 249           }
 250         return th;
 251       }
 252
 253   return NULL;
 254 }
 255
 256 /* Add a thread to the thread list.  */
 257 static thread_info *
 258 windows_add_thread (ptid_t ptid, HANDLE h)
 259 {
 260   thread_info *th;
 261   DWORD id;
 262
 263   gdb_assert (ptid_get_tid (ptid) != 0);
 264
 265   id = ptid_get_tid (ptid);
 266
 267   if ((th = thread_rec (id, FALSE)))
 268     return th;
 269
 270   th = XZALLOC (thread_info);
 271   th->id = id;
 272   th->h = h;
 273   th->next = thread_head.next;
 274   thread_head.next = th;
 275   add_thread (ptid);
 276   /* Set the debug registers for the new thread if they are used.  */
 277   if (debug_registers_used)
 278     {
 279       /* Only change the value of the debug registers.  */
 280       th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
 281       CHECK (GetThreadContext (th->h, &th->context));
 282       th->context.Dr0 = dr[0];
 283       th->context.Dr1 = dr[1];
 284       th->context.Dr2 = dr[2];
 285       th->context.Dr3 = dr[3];
 286       th->context.Dr6 = DR6_CLEAR_VALUE;
 287       th->context.Dr7 = dr[7];
 288       CHECK (SetThreadContext (th->h, &th->context));
 289       th->context.ContextFlags = 0;
 290     }
 291   return th;
 292 }
 293
 294 /* Clear out any old thread list and reintialize it to a
 295    pristine state. */
 296 static void
 297 windows_init_thread_list (void)
 298 {
 299   thread_info *th = &thread_head;
 300
 301   DEBUG_EVENTS (("gdb: windows_init_thread_list\n"));
 302   init_thread_list ();
 303   while (th->next != NULL)
 304     {
 305       thread_info *here = th->next;
 306       th->next = here->next;
 307       xfree (here);
 308     }
 309   thread_head.next = NULL;
 310 }
 311
 312 /* Delete a thread from the list of threads */
 313 static void
 314 windows_delete_thread (ptid_t ptid)
 315 {
 316   thread_info *th;
 317   DWORD id;
 318
 319   gdb_assert (ptid_get_tid (ptid) != 0);
 320
 321   id = ptid_get_tid (ptid);
 322
 323   if (info_verbose)
 324     printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid));
 325   delete_thread (ptid);
 326
 327   for (th = &thread_head;
 328        th->next != NULL && th->next->id != id;
 329        th = th->next)
 330     continue;
 331
 332   if (th->next != NULL)
 333     {
 334       thread_info *here = th->next;
 335       th->next = here->next;
 336       xfree (here);
 337     }
 338 }
 339
 340 static void
 341 do_windows_fetch_inferior_registers (struct regcache *regcache, int r)
 342 {
 343   char *context_offset = ((char *) &current_thread->context) + mappings[r];
 344   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 345   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 346   long l;
 347
 348   if (!current_thread)
 349     return;     /* Windows sometimes uses a non-existent thread id in its
 350                    events */
 351
 352   if (current_thread->reload_context)
 353     {
 354 #ifdef __COPY_CONTEXT_SIZE
 355       if (have_saved_context)
 356         {
 357           /* Lie about where the program actually is stopped since cygwin has informed us that
 358              we should consider the signal to have occurred at another location which is stored
 359              in "saved_context. */
 360           memcpy (&current_thread->context, &saved_context, __COPY_CONTEXT_SIZE);
 361           have_saved_context = 0;
 362         }
 363       else
 364 #endif
 365         {
 366           thread_info *th = current_thread;
 367           th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
 368           GetThreadContext (th->h, &th->context);
 369           /* Copy dr values from that thread.
 370              But only if there were not modified since last stop. PR gdb/2388 */
 371           if (!debug_registers_changed)
 372             {
 373               dr[0] = th->context.Dr0;
 374               dr[1] = th->context.Dr1;
 375               dr[2] = th->context.Dr2;
 376               dr[3] = th->context.Dr3;
 377               dr[6] = th->context.Dr6;
 378               dr[7] = th->context.Dr7;
 379             }
 380         }
 381       current_thread->reload_context = 0;
 382     }
 383
 384   if (r == I387_FISEG_REGNUM (tdep))
 385     {
 386       l = *((long *) context_offset) & 0xffff;
 387       regcache_raw_supply (regcache, r, (char *) &l);
 388     }
 389   else if (r == I387_FOP_REGNUM (tdep))
 390     {
 391       l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
 392       regcache_raw_supply (regcache, r, (char *) &l);
 393     }
 394   else if (r >= 0)
 395     regcache_raw_supply (regcache, r, context_offset);
 396   else
 397     {
 398       for (r = 0; r < gdbarch_num_regs (gdbarch); r++)
 399         do_windows_fetch_inferior_registers (regcache, r);
 400     }
 401 }
 402
 403 static void
 404 windows_fetch_inferior_registers (struct regcache *regcache, int r)
 405 {
 406   current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
 407   /* Check if current_thread exists.  Windows sometimes uses a non-existent
 408      thread id in its events */
 409   if (current_thread)
 410     do_windows_fetch_inferior_registers (regcache, r);
 411 }
 412
 413 static void
 414 do_windows_store_inferior_registers (const struct regcache *regcache, int r)
 415 {
 416   if (!current_thread)
 417     /* Windows sometimes uses a non-existent thread id in its events */;
 418   else if (r >= 0)
 419     regcache_raw_collect (regcache, r,
 420                           ((char *) &current_thread->context) + mappings[r]);
 421   else
 422     {
 423       for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++)
 424         do_windows_store_inferior_registers (regcache, r);
 425     }
 426 }
 427
 428 /* Store a new register value into the current thread context */
 429 static void
 430 windows_store_inferior_registers (struct regcache *regcache, int r)
 431 {
 432   current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
 433   /* Check if current_thread exists.  Windows sometimes uses a non-existent
 434      thread id in its events */
 435   if (current_thread)
 436     do_windows_store_inferior_registers (regcache, r);
 437 }
 438
 439 static int psapi_loaded = 0;
 440 static BOOL WINAPI (*psapi_EnumProcessModules) (HANDLE, HMODULE *, DWORD,
 441                                                 LPDWORD);
 442 static BOOL WINAPI (*psapi_GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO,
 443                                                   DWORD);
 444 static DWORD WINAPI (*psapi_GetModuleFileNameExA) (HANDLE, HMODULE, LPSTR,
 445                                                    DWORD);
 446
 447 /* Get the name of a given module at at given base address.  If base_address
 448    is zero return the first loaded module (which is always the name of the
 449    executable).  */
 450 static int
 451 get_module_name (LPVOID base_address, char *dll_name_ret)
 452 {
 453   DWORD len;
 454   MODULEINFO mi;
 455   int i;
 456   HMODULE dh_buf[1];
 457   HMODULE *DllHandle = dh_buf;  /* Set to temporary storage for initial query */
 458   DWORD cbNeeded;
 459 #ifdef __CYGWIN__
 460   char pathbuf[PATH_MAX + 1];   /* Temporary storage prior to converting to
 461                                    posix form */
 462 #else
 463   char *pathbuf = dll_name_ret; /* Just copy directly to passed-in arg */
 464 #endif
 465
 466   /* If psapi_loaded < 0 either psapi.dll is not available or it does not contain
 467      the needed functions. */
 468   if (psapi_loaded <= 0)
 469     goto failed;
 470
 471   cbNeeded = 0;
 472   /* Find size of buffer needed to handle list of modules loaded in inferior */
 473   if (!psapi_EnumProcessModules (current_process_handle, DllHandle,
 474                                  sizeof (HMODULE), &cbNeeded) || !cbNeeded)
 475     goto failed;
 476
 477   /* Allocate correct amount of space for module list */
 478   DllHandle = (HMODULE *) alloca (cbNeeded);
 479   if (!DllHandle)
 480     goto failed;
 481
 482   /* Get the list of modules */
 483   if (!psapi_EnumProcessModules (current_process_handle, DllHandle, cbNeeded,
 484                                  &cbNeeded))
 485     goto failed;
 486
 487   for (i = 0; i < (int) (cbNeeded / sizeof (HMODULE)); i++)
 488     {
 489       /* Get information on this module */
 490       if (!psapi_GetModuleInformation (current_process_handle, DllHandle[i],
 491                                        &mi, sizeof (mi)))
 492         error (_("Can't get module info"));
 493
 494       if (!base_address || mi.lpBaseOfDll == base_address)
 495         {
 496           /* Try to find the name of the given module */
 497           len = psapi_GetModuleFileNameExA (current_process_handle,
 498                                             DllHandle[i], pathbuf, MAX_PATH);
 499           if (len == 0)
 500             error (_("Error getting dll name: %u."), (unsigned) GetLastError ());
 501 #ifdef __CYGWIN__
 502           /* Cygwin prefers that the path be in /x/y/z format */
 503           cygwin_conv_to_full_posix_path (pathbuf, dll_name_ret);
 504 #endif
 505           return 1;     /* success */
 506         }
 507     }
 508
 509 failed:
 510   dll_name_ret[0] = '\0';
 511   return 0;             /* failure */
 512 }
 513
 514 /* Encapsulate the information required in a call to
 515    symbol_file_add_args */
 516 struct safe_symbol_file_add_args
 517 {
 518   char *name;
 519   int from_tty;
 520   struct section_addr_info *addrs;
 521   int mainline;
 522   int flags;
 523   struct ui_file *err, *out;
 524   struct objfile *ret;
 525 };
 526
 527 /* Maintain a linked list of "so" information. */
 528 struct lm_info
 529 {
 530   LPVOID load_addr;
 531 };
 532
 533 static struct so_list solib_start, *solib_end;
 534
 535 /* Call symbol_file_add with stderr redirected.  We don't care if there
 536    are errors. */
 537 static int
 538 safe_symbol_file_add_stub (void *argv)
 539 {
 540 #define p ((struct safe_symbol_file_add_args *) argv)
 541   p->ret = symbol_file_add (p->name, p->from_tty, p->addrs, p->mainline, p->flags);
 542   return !!p->ret;
 543 #undef p
 544 }
 545
 546 /* Restore gdb's stderr after calling symbol_file_add */
 547 static void
 548 safe_symbol_file_add_cleanup (void *p)
 549 {
 550 #define sp ((struct safe_symbol_file_add_args *)p)
 551   gdb_flush (gdb_stderr);
 552   gdb_flush (gdb_stdout);
 553   ui_file_delete (gdb_stderr);
 554   ui_file_delete (gdb_stdout);
 555   gdb_stderr = sp->err;
 556   gdb_stdout = sp->out;
 557 #undef sp
 558 }
 559
 560 /* symbol_file_add wrapper that prevents errors from being displayed. */
 561 static struct objfile *
 562 safe_symbol_file_add (char *name, int from_tty,
 563                       struct section_addr_info *addrs,
 564                       int mainline, int flags)
 565 {
 566   struct safe_symbol_file_add_args p;
 567   struct cleanup *cleanup;
 568
 569   cleanup = make_cleanup (safe_symbol_file_add_cleanup, &p);
 570
 571   p.err = gdb_stderr;
 572   p.out = gdb_stdout;
 573   gdb_flush (gdb_stderr);
 574   gdb_flush (gdb_stdout);
 575   gdb_stderr = ui_file_new ();
 576   gdb_stdout = ui_file_new ();
 577   p.name = name;
 578   p.from_tty = from_tty;
 579   p.addrs = addrs;
 580   p.mainline = mainline;
 581   p.flags = flags;
 582   catch_errors (safe_symbol_file_add_stub, &p, "", RETURN_MASK_ERROR);
 583
 584   do_cleanups (cleanup);
 585   return p.ret;
 586 }
 587
 588 static struct so_list *
 589 windows_make_so (const char *name, LPVOID load_addr)
 590 {
 591   struct so_list *so;
 592   char buf[MAX_PATH + 1];
 593   char cwd[MAX_PATH + 1];
 594   char *p;
 595   WIN32_FIND_DATA w32_fd;
 596   HANDLE h = FindFirstFile(name, &w32_fd);
 597   MEMORY_BASIC_INFORMATION m;
 598
 599   if (h == INVALID_HANDLE_VALUE)
 600     strcpy (buf, name);
 601   else
 602     {
 603       FindClose (h);
 604       strcpy (buf, name);
 605       if (GetCurrentDirectory (MAX_PATH + 1, cwd))
 606         {
 607           p = strrchr (buf, '\\');
 608           if (p)
 609             p[1] = '\0';
 610           SetCurrentDirectory (buf);
 611           GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
 612           SetCurrentDirectory (cwd);
 613         }
 614     }
 615
 616   if (strcasecmp (buf, "ntdll.dll") == 0)
 617     {
 618       GetSystemDirectory (buf, sizeof (buf));
 619       strcat (buf, "\\ntdll.dll");
 620     }
 621   so = XZALLOC (struct so_list);
 622   so->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info));
 623   so->lm_info->load_addr = load_addr;
 624   strcpy (so->so_original_name, name);
 625 #ifndef __CYGWIN__
 626   strcpy (so->so_name, buf);
 627 #else
 628   cygwin_conv_to_posix_path (buf, so->so_name);
 629   /* Record cygwin1.dll .text start/end.  */
 630   p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1);
 631   if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0)
 632     {
 633       bfd *abfd;
 634       asection *text = NULL;
 635       CORE_ADDR text_vma;
 636
 637       abfd = bfd_openr (so->so_name, "pei-i386");
 638
 639       if (!abfd)
 640         return so;
 641
 642       if (bfd_check_format (abfd, bfd_object))
 643         text = bfd_get_section_by_name (abfd, ".text");
 644
 645       if (!text)
 646         {
 647           bfd_close (abfd);
 648           return so;
 649         }
 650
 651       /* The symbols in a dll are offset by 0x1000, which is the the
 652          offset from 0 of the first byte in an image - because of the
 653          file header and the section alignment. */
 654       cygwin_load_start = (CORE_ADDR) (uintptr_t) ((char *) load_addr + 0x1000);
 655       cygwin_load_end = cygwin_load_start + bfd_section_size (abfd, text);
 656
 657       bfd_close (abfd);
 658     }
 659 #endif
 660
 661   return so;
 662 }
 663
 664 static char *
 665 get_image_name (HANDLE h, void *address, int unicode)
 666 {
 667   static char buf[(2 * MAX_PATH) + 1];
 668   DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
 669   char *address_ptr;
 670   int len = 0;
 671   char b[2];
 672   SIZE_T done;
 673
 674   /* Attempt to read the name of the dll that was detected.
 675      This is documented to work only when actively debugging
 676      a program.  It will not work for attached processes. */
 677   if (address == NULL)
 678     return NULL;
 679
 680   /* See if we could read the address of a string, and that the
 681      address isn't null. */
 682   if (!ReadProcessMemory (h, address,  &address_ptr, sizeof (address_ptr), &done)
 683       || done != sizeof (address_ptr) || !address_ptr)
 684     return NULL;
 685
 686   /* Find the length of the string */
 687   while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
 688          && (b[0] != 0 || b[size - 1] != 0) && done == size)
 689     continue;
 690
 691   if (!unicode)
 692     ReadProcessMemory (h, address_ptr, buf, len, &done);
 693   else
 694     {
 695       WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
 696       ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
 697                          &done);
 698
 699       WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, len, 0, 0);
 700     }
 701
 702   return buf;
 703 }
 704
 705 /* Wait for child to do something.  Return pid of child, or -1 in case
 706    of error; store status through argument pointer OURSTATUS.  */
 707 static int
 708 handle_load_dll (void *dummy)
 709 {
 710   LOAD_DLL_DEBUG_INFO *event = &current_event.u.LoadDll;
 711   char dll_buf[MAX_PATH + 1];
 712   char *dll_name = NULL;
 713
 714   dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
 715
 716   if (!get_module_name (event->lpBaseOfDll, dll_buf))
 717     dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
 718
 719   dll_name = dll_buf;
 720
 721   if (*dll_name == '\0')
 722     dll_name = get_image_name (current_process_handle,
 723                                event->lpImageName, event->fUnicode);
 724   if (!dll_name)
 725     return 1;
 726
 727   solib_end->next = windows_make_so (dll_name, event->lpBaseOfDll);
 728   solib_end = solib_end->next;
 729
 730   DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %p.\n", solib_end->so_name,
 731                  solib_end->lm_info->load_addr));
 732
 733   return 1;
 734 }
 735
 736 static void
 737 windows_free_so (struct so_list *so)
 738 {
 739   if (so->lm_info)
 740     xfree (so->lm_info);
 741   xfree (so);
 742 }
 743
 744 static int
 745 handle_unload_dll (void *dummy)
 746 {
 747   LPVOID lpBaseOfDll = current_event.u.UnloadDll.lpBaseOfDll;
 748   struct so_list *so;
 749
 750   for (so = &solib_start; so->next != NULL; so = so->next)
 751     if (so->next->lm_info->load_addr == lpBaseOfDll)
 752       {
 753         struct so_list *sodel = so->next;
 754         so->next = sodel->next;
 755         if (!so->next)
 756           solib_end = so;
 757         DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name));
 758
 759         windows_free_so (sodel);
 760         solib_add (NULL, 0, NULL, auto_solib_add);
 761         return 1;
 762       }
 763
 764   error (_("Error: dll starting at %p not found."), lpBaseOfDll);
 765
 766   return 0;
 767 }
 768
 769 /* Clear list of loaded DLLs. */
 770 static void
 771 windows_clear_solib (void)
 772 {
 773   solib_start.next = NULL;
 774   solib_end = &solib_start;
 775 }
 776
 777 /* Load DLL symbol info. */
 778 void
 779 dll_symbol_command (char *args, int from_tty)
 780 {
 781   int n;
 782   dont_repeat ();
 783
 784   if (args == NULL)
 785     error (_("dll-symbols requires a file name"));
 786
 787   n = strlen (args);
 788   if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0)
 789     {
 790       char *newargs = (char *) alloca (n + 4 + 1);
 791       strcpy (newargs, args);
 792       strcat (newargs, ".dll");
 793       args = newargs;
 794     }
 795
 796   safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED | OBJF_USERLOADED);
 797 }
 798
 799 /* Handle DEBUG_STRING output from child process.
 800    Cygwin prepends its messages with a "cygwin:".  Interpret this as
 801    a Cygwin signal.  Otherwise just print the string as a warning. */
 802 static int
 803 handle_output_debug_string (struct target_waitstatus *ourstatus)
 804 {
 805   char *s = NULL;
 806   int retval = 0;
 807
 808   if (!target_read_string
 809         ((CORE_ADDR) (uintptr_t) current_event.u.DebugString.lpDebugStringData,
 810         &s, 1024, 0)
 811       || !s || !*s)
 812     /* nothing to do */;
 813   else if (strncmp (s, _CYGWIN_SIGNAL_STRING, sizeof (_CYGWIN_SIGNAL_STRING) - 1) != 0)
 814     {
 815 #ifdef __CYGWIN__
 816       if (strncmp (s, "cYg", 3) != 0)
 817 #endif
 818         warning (("%s"), s);
 819     }
 820 #ifdef __COPY_CONTEXT_SIZE
 821   else
 822     {
 823       /* Got a cygwin signal marker.  A cygwin signal is followed by the signal number
 824          itself and then optionally followed by the thread id and address to saved context
 825          within the DLL.  If these are supplied, then the given thread is assumed to have
 826          issued the signal and the context from the thread is assumed to be stored at the
 827          given address in the inferior.  Tell gdb to treat this like a real signal.  */
 828       char *p;
 829       int sig = strtol (s + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0);
 830       int gotasig = target_signal_from_host (sig);
 831       ourstatus->value.sig = gotasig;
 832       if (gotasig)
 833         {
 834           LPCVOID x;
 835           DWORD n;
 836           ourstatus->kind = TARGET_WAITKIND_STOPPED;
 837           retval = strtoul (p, &p, 0);
 838           if (!retval)
 839             retval = main_thread_id;
 840           else if ((x = (LPCVOID) strtoul (p, &p, 0))
 841                    && ReadProcessMemory (current_process_handle, x,
 842                                          &saved_context, __COPY_CONTEXT_SIZE, &n)
 843                    && n == __COPY_CONTEXT_SIZE)
 844             have_saved_context = 1;
 845           current_event.dwThreadId = retval;
 846         }
 847     }
 848 #endif
 849
 850   if (s)
 851     xfree (s);
 852   return retval;
 853 }
 854
 855 static int
 856 display_selector (HANDLE thread, DWORD sel)
 857 {
 858   LDT_ENTRY info;
 859   if (GetThreadSelectorEntry (thread, sel, &info))
 860     {
 861       int base, limit;
 862       printf_filtered ("0x%03lx: ", sel);
 863       if (!info.HighWord.Bits.Pres)
 864         {
 865           puts_filtered ("Segment not present\n");
 866           return 0;
 867         }
 868       base = (info.HighWord.Bits.BaseHi << 24) +
 869              (info.HighWord.Bits.BaseMid << 16)
 870              + info.BaseLow;
 871       limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
 872       if (info.HighWord.Bits.Granularity)
 873         limit = (limit << 12) | 0xfff;
 874       printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
 875       if (info.HighWord.Bits.Default_Big)
 876         puts_filtered(" 32-bit ");
 877       else
 878         puts_filtered(" 16-bit ");
 879       switch ((info.HighWord.Bits.Type & 0xf) >> 1)
 880         {
 881         case 0:
 882           puts_filtered ("Data (Read-Only, Exp-up");
 883           break;
 884         case 1:
 885           puts_filtered ("Data (Read/Write, Exp-up");
 886           break;
 887         case 2:
 888           puts_filtered ("Unused segment (");
 889           break;
 890         case 3:
 891           puts_filtered ("Data (Read/Write, Exp-down");
 892           break;
 893         case 4:
 894           puts_filtered ("Code (Exec-Only, N.Conf");
 895           break;
 896         case 5:
 897           puts_filtered ("Code (Exec/Read, N.Conf");
 898           break;
 899         case 6:
 900           puts_filtered ("Code (Exec-Only, Conf");
 901           break;
 902         case 7:
 903           puts_filtered ("Code (Exec/Read, Conf");
 904           break;
 905         default:
 906           printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
 907         }
 908       if ((info.HighWord.Bits.Type & 0x1) == 0)
 909         puts_filtered(", N.Acc");
 910       puts_filtered (")\n");
 911       if ((info.HighWord.Bits.Type & 0x10) == 0)
 912         puts_filtered("System selector ");
 913       printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
 914       if (info.HighWord.Bits.Granularity)
 915         puts_filtered ("Page granular.\n");
 916       else
 917         puts_filtered ("Byte granular.\n");
 918       return 1;
 919     }
 920   else
 921     {
 922       printf_filtered ("Invalid selector 0x%lx.\n",sel);
 923       return 0;
 924     }
 925 }
 926
 927 static void
 928 display_selectors (char * args, int from_tty)
 929 {
 930   if (!current_thread)
 931     {
 932       puts_filtered ("Impossible to display selectors now.\n");
 933       return;
 934     }
 935   if (!args)
 936     {
 937
 938       puts_filtered ("Selector $cs\n");
 939       display_selector (current_thread->h,
 940         current_thread->context.SegCs);
 941       puts_filtered ("Selector $ds\n");
 942       display_selector (current_thread->h,
 943         current_thread->context.SegDs);
 944       puts_filtered ("Selector $es\n");
 945       display_selector (current_thread->h,
 946         current_thread->context.SegEs);
 947       puts_filtered ("Selector $ss\n");
 948       display_selector (current_thread->h,
 949         current_thread->context.SegSs);
 950       puts_filtered ("Selector $fs\n");
 951       display_selector (current_thread->h,
 952         current_thread->context.SegFs);
 953       puts_filtered ("Selector $gs\n");
 954       display_selector (current_thread->h,
 955         current_thread->context.SegGs);
 956     }
 957   else
 958     {
 959       int sel;
 960       sel = parse_and_eval_long (args);
 961       printf_filtered ("Selector \"%s\"\n",args);
 962       display_selector (current_thread->h, sel);
 963     }
 964 }
 965
 966 static struct cmd_list_element *info_w32_cmdlist = NULL;
 967
 968 static void
 969 info_w32_command (char *args, int from_tty)
 970 {
 971   help_list (info_w32_cmdlist, "info w32 ", class_info, gdb_stdout);
 972 }
 973
 974
 975 #define DEBUG_EXCEPTION_SIMPLE(x)       if (debug_exceptions) \
 976   printf_unfiltered ("gdb: Target exception %s at %p\n", x, \
 977           current_event.u.Exception.ExceptionRecord.ExceptionAddress)
 978
 979 static int
 980 handle_exception (struct target_waitstatus *ourstatus)
 981 {
 982   thread_info *th;
 983   DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
 984
 985   ourstatus->kind = TARGET_WAITKIND_STOPPED;
 986
 987   /* Record the context of the current thread */
 988   th = thread_rec (current_event.dwThreadId, -1);
 989
 990   switch (code)
 991     {
 992     case EXCEPTION_ACCESS_VIOLATION:
 993       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
 994       ourstatus->value.sig = TARGET_SIGNAL_SEGV;
 995 #ifdef __CYGWIN__
 996       {
 997         /* See if the access violation happened within the cygwin DLL itself.  Cygwin uses
 998            a kind of exception handling to deal with passed-in invalid addresses. gdb
 999            should not treat these as real SEGVs since they will be silently handled by
1000            cygwin.  A real SEGV will (theoretically) be caught by cygwin later in the process
1001            and will be sent as a cygwin-specific-signal.  So, ignore SEGVs if they show up
1002            within the text segment of the DLL itself. */
1003         char *fn;
1004         CORE_ADDR addr = (CORE_ADDR) (uintptr_t) current_event.u.Exception.ExceptionRecord.ExceptionAddress;
1005         if ((!cygwin_exceptions && (addr >= cygwin_load_start && addr < cygwin_load_end))
1006             || (find_pc_partial_function (addr, &fn, NULL, NULL)
1007                 && strncmp (fn, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
1008           return 0;
1009       }
1010 #endif
1011       break;
1012     case STATUS_STACK_OVERFLOW:
1013       DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1014       ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1015       break;
1016     case STATUS_FLOAT_DENORMAL_OPERAND:
1017       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1018       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1019       break;
1020     case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1021       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1022       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1023       break;
1024     case STATUS_FLOAT_INEXACT_RESULT:
1025       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1026       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1027       break;
1028     case STATUS_FLOAT_INVALID_OPERATION:
1029       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1030       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1031       break;
1032     case STATUS_FLOAT_OVERFLOW:
1033       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1034       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1035       break;
1036     case STATUS_FLOAT_STACK_CHECK:
1037       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1038       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1039       break;
1040     case STATUS_FLOAT_UNDERFLOW:
1041       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1042       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1043       break;
1044     case STATUS_FLOAT_DIVIDE_BY_ZERO:
1045       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1046       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1047       break;
1048     case STATUS_INTEGER_DIVIDE_BY_ZERO:
1049       DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1050       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1051       break;
1052     case STATUS_INTEGER_OVERFLOW:
1053       DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1054       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1055       break;
1056     case EXCEPTION_BREAKPOINT:
1057       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1058       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1059       break;
1060     case DBG_CONTROL_C:
1061       DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1062       ourstatus->value.sig = TARGET_SIGNAL_INT;
1063       break;
1064     case DBG_CONTROL_BREAK:
1065       DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1066       ourstatus->value.sig = TARGET_SIGNAL_INT;
1067       break;
1068     case EXCEPTION_SINGLE_STEP:
1069       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1070       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1071       break;
1072     case EXCEPTION_ILLEGAL_INSTRUCTION:
1073       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1074       ourstatus->value.sig = TARGET_SIGNAL_ILL;
1075       break;
1076     case EXCEPTION_PRIV_INSTRUCTION:
1077       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1078       ourstatus->value.sig = TARGET_SIGNAL_ILL;
1079       break;
1080     case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1081       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1082       ourstatus->value.sig = TARGET_SIGNAL_ILL;
1083       break;
1084     default:
1085       /* Treat unhandled first chance exceptions specially. */
1086       if (current_event.u.Exception.dwFirstChance)
1087         return -1;
1088       printf_unfiltered ("gdb: unknown target exception 0x%08lx at %p\n",
1089                     current_event.u.Exception.ExceptionRecord.ExceptionCode,
1090                 current_event.u.Exception.ExceptionRecord.ExceptionAddress);
1091       ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
1092       break;
1093     }
1094   exception_count++;
1095   last_sig = ourstatus->value.sig;
1096   return 1;
1097 }
1098
1099 /* Resume all artificially suspended threads if we are continuing
1100    execution */
1101 static BOOL
1102 windows_continue (DWORD continue_status, int id)
1103 {
1104   int i;
1105   thread_info *th;
1106   BOOL res;
1107
1108   DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1109                   current_event.dwProcessId, current_event.dwThreadId,
1110                   continue_status == DBG_CONTINUE ?
1111                   "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1112
1113   for (th = &thread_head; (th = th->next) != NULL;)
1114     if ((id == -1 || id == (int) th->id)
1115         && th->suspended)
1116       {
1117         if (debug_registers_changed)
1118           {
1119             th->context.ContextFlags |= CONTEXT_DEBUG_REGISTERS;
1120             th->context.Dr0 = dr[0];
1121             th->context.Dr1 = dr[1];
1122             th->context.Dr2 = dr[2];
1123             th->context.Dr3 = dr[3];
1124             th->context.Dr6 = DR6_CLEAR_VALUE;
1125             th->context.Dr7 = dr[7];
1126           }
1127         if (th->context.ContextFlags)
1128           {
1129             CHECK (SetThreadContext (th->h, &th->context));
1130             th->context.ContextFlags = 0;
1131           }
1132         if (th->suspended > 0)
1133           (void) ResumeThread (th->h);
1134         th->suspended = 0;
1135       }
1136
1137   res = ContinueDebugEvent (current_event.dwProcessId,
1138                             current_event.dwThreadId,
1139                             continue_status);
1140
1141   debug_registers_changed = 0;
1142   return res;
1143 }
1144
1145 /* Called in pathological case where Windows fails to send a
1146    CREATE_PROCESS_DEBUG_EVENT after an attach.  */
1147 static DWORD
1148 fake_create_process (void)
1149 {
1150   current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
1151                                         current_event.dwProcessId);
1152   if (current_process_handle != NULL)
1153     open_process_used = 1;
1154   else
1155     {
1156       error (_("OpenProcess call failed, GetLastError = %lud\n"),
1157        GetLastError ());
1158       /*  We can not debug anything in that case.  */
1159     }
1160   main_thread_id = current_event.dwThreadId;
1161   current_thread = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1162                                                    current_event.dwThreadId),
1163                                        current_event.u.CreateThread.hThread);
1164   return main_thread_id;
1165 }
1166
1167 static void
1168 windows_resume (ptid_t ptid, int step, enum target_signal sig)
1169 {
1170   thread_info *th;
1171   DWORD continue_status = DBG_CONTINUE;
1172
1173   /* A specific PTID means `step only this thread id'.  */
1174   int resume_all = ptid_equal (ptid, minus_one_ptid);
1175
1176   /* If we're continuing all threads, it's the current inferior that
1177      should be handled specially.  */
1178   if (resume_all)
1179     ptid = inferior_ptid;
1180
1181   if (sig != TARGET_SIGNAL_0)
1182     {
1183       if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1184         {
1185           DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1186         }
1187       else if (sig == last_sig)
1188         continue_status = DBG_EXCEPTION_NOT_HANDLED;
1189       else
1190 #if 0
1191 /* This code does not seem to work, because
1192   the kernel does probably not consider changes in the ExceptionRecord
1193   structure when passing the exception to the inferior.
1194   Note that this seems possible in the exception handler itself.  */
1195         {
1196           int i;
1197           for (i = 0; xlate[i].them != -1; i++)
1198             if (xlate[i].us == sig)
1199               {
1200                 current_event.u.Exception.ExceptionRecord.ExceptionCode =
1201                   xlate[i].them;
1202                 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1203                 break;
1204               }
1205           if (continue_status == DBG_CONTINUE)
1206             {
1207               DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1208             }
1209         }
1210 #endif
1211         DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1212           last_sig));
1213     }
1214
1215   last_sig = TARGET_SIGNAL_0;
1216
1217   DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
1218                ptid_get_pid (ptid), ptid_get_tid (ptid), step, sig));
1219
1220   /* Get context for currently selected thread */
1221   th = thread_rec (ptid_get_tid (inferior_ptid), FALSE);
1222   if (th)
1223     {
1224       if (step)
1225         {
1226           /* Single step by setting t bit */
1227           windows_fetch_inferior_registers (get_current_regcache (),
1228                                           gdbarch_ps_regnum (current_gdbarch));
1229           th->context.EFlags |= FLAG_TRACE_BIT;
1230         }
1231
1232       if (th->context.ContextFlags)
1233         {
1234           if (debug_registers_changed)
1235             {
1236               th->context.Dr0 = dr[0];
1237               th->context.Dr1 = dr[1];
1238               th->context.Dr2 = dr[2];
1239               th->context.Dr3 = dr[3];
1240               th->context.Dr6 = DR6_CLEAR_VALUE;
1241               th->context.Dr7 = dr[7];
1242             }
1243           CHECK (SetThreadContext (th->h, &th->context));
1244           th->context.ContextFlags = 0;
1245         }
1246     }
1247
1248   /* Allow continuing with the same signal that interrupted us.
1249      Otherwise complain. */
1250
1251   if (resume_all)
1252     windows_continue (continue_status, -1);
1253   else
1254     windows_continue (continue_status, ptid_get_tid (ptid));
1255 }
1256
1257 /* Get the next event from the child.  Return 1 if the event requires
1258    handling by WFI (or whatever).
1259  */
1260 static int
1261 get_windows_debug_event (int pid, struct target_waitstatus *ourstatus)
1262 {
1263   BOOL debug_event;
1264   DWORD continue_status, event_code;
1265   thread_info *th;
1266   static thread_info dummy_thread_info;
1267   int retval = 0;
1268
1269   last_sig = TARGET_SIGNAL_0;
1270
1271   if (!(debug_event = WaitForDebugEvent (&current_event, 1000)))
1272     goto out;
1273
1274   event_count++;
1275   continue_status = DBG_CONTINUE;
1276
1277   event_code = current_event.dwDebugEventCode;
1278   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1279   th = NULL;
1280   have_saved_context = 0;
1281
1282   switch (event_code)
1283     {
1284     case CREATE_THREAD_DEBUG_EVENT:
1285       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1286                      (unsigned) current_event.dwProcessId,
1287                      (unsigned) current_event.dwThreadId,
1288                      "CREATE_THREAD_DEBUG_EVENT"));
1289       if (saw_create != 1)
1290         {
1291           struct inferior *inf;
1292           inf = find_inferior_pid (current_event.dwProcessId);
1293           if (!saw_create && inf->attach_flag)
1294             {
1295               /* Kludge around a Windows bug where first event is a create
1296                  thread event.  Caused when attached process does not have
1297                  a main thread. */
1298               retval = fake_create_process ();
1299               if (retval)
1300                 saw_create++;
1301             }
1302           break;
1303         }
1304       /* Record the existence of this thread */
1305       retval = current_event.dwThreadId;
1306       th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1307                                          current_event.dwThreadId),
1308                              current_event.u.CreateThread.hThread);
1309       break;
1310
1311     case EXIT_THREAD_DEBUG_EVENT:
1312       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1313                      (unsigned) current_event.dwProcessId,
1314                      (unsigned) current_event.dwThreadId,
1315                      "EXIT_THREAD_DEBUG_EVENT"));
1316       if (current_event.dwThreadId != main_thread_id)
1317         {
1318           windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1319                                            current_event.dwThreadId));
1320           th = &dummy_thread_info;
1321         }
1322       break;
1323
1324     case CREATE_PROCESS_DEBUG_EVENT:
1325       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1326                      (unsigned) current_event.dwProcessId,
1327                      (unsigned) current_event.dwThreadId,
1328                      "CREATE_PROCESS_DEBUG_EVENT"));
1329       CloseHandle (current_event.u.CreateProcessInfo.hFile);
1330       if (++saw_create != 1)
1331         break;
1332
1333       current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1334       if (main_thread_id)
1335         windows_delete_thread (ptid_build (current_event.dwProcessId, 0,
1336                                          main_thread_id));
1337       main_thread_id = current_event.dwThreadId;
1338       /* Add the main thread */
1339       th = windows_add_thread (ptid_build (current_event.dwProcessId, 0,
1340                                          current_event.dwThreadId),
1341                              current_event.u.CreateProcessInfo.hThread);
1342       retval = current_event.dwThreadId;
1343       break;
1344
1345     case EXIT_PROCESS_DEBUG_EVENT:
1346       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1347                      (unsigned) current_event.dwProcessId,
1348                      (unsigned) current_event.dwThreadId,
1349                      "EXIT_PROCESS_DEBUG_EVENT"));
1350       if (saw_create != 1)
1351         break;
1352       ourstatus->kind = TARGET_WAITKIND_EXITED;
1353       ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1354       retval = main_thread_id;
1355       break;
1356
1357     case LOAD_DLL_DEBUG_EVENT:
1358       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1359                      (unsigned) current_event.dwProcessId,
1360                      (unsigned) current_event.dwThreadId,
1361                      "LOAD_DLL_DEBUG_EVENT"));
1362       CloseHandle (current_event.u.LoadDll.hFile);
1363       if (saw_create != 1)
1364         break;
1365       catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
1366       ourstatus->kind = TARGET_WAITKIND_LOADED;
1367       ourstatus->value.integer = 0;
1368       retval = main_thread_id;
1369       break;
1370
1371     case UNLOAD_DLL_DEBUG_EVENT:
1372       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1373                      (unsigned) current_event.dwProcessId,
1374                      (unsigned) current_event.dwThreadId,
1375                      "UNLOAD_DLL_DEBUG_EVENT"));
1376       if (saw_create != 1)
1377         break;
1378       catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
1379       ourstatus->kind = TARGET_WAITKIND_LOADED;
1380       ourstatus->value.integer = 0;
1381       retval = main_thread_id;
1382       break;
1383
1384     case EXCEPTION_DEBUG_EVENT:
1385       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1386                      (unsigned) current_event.dwProcessId,
1387                      (unsigned) current_event.dwThreadId,
1388                      "EXCEPTION_DEBUG_EVENT"));
1389       if (saw_create != 1)
1390         break;
1391       switch (handle_exception (ourstatus))
1392         {
1393         case 0:
1394           continue_status = DBG_EXCEPTION_NOT_HANDLED;
1395           break;
1396         case 1:
1397           retval = current_event.dwThreadId;
1398           break;
1399         case -1:
1400           last_sig = 1;
1401           continue_status = -1;
1402           break;
1403         }
1404       break;
1405
1406     case OUTPUT_DEBUG_STRING_EVENT:     /* message from the kernel */
1407       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1408                      (unsigned) current_event.dwProcessId,
1409                      (unsigned) current_event.dwThreadId,
1410                      "OUTPUT_DEBUG_STRING_EVENT"));
1411       if (saw_create != 1)
1412         break;
1413       retval = handle_output_debug_string (ourstatus);
1414       break;
1415
1416     default:
1417       if (saw_create != 1)
1418         break;
1419       printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1420                          (DWORD) current_event.dwProcessId,
1421                          (DWORD) current_event.dwThreadId);
1422       printf_unfiltered ("                 unknown event code %ld\n",
1423                          current_event.dwDebugEventCode);
1424       break;
1425     }
1426
1427   if (!retval || saw_create != 1)
1428     {
1429       if (continue_status == -1)
1430         windows_resume (minus_one_ptid, 0, 1);
1431       else
1432         CHECK (windows_continue (continue_status, -1));
1433     }
1434   else
1435     {
1436       inferior_ptid = ptid_build (current_event.dwProcessId, 0,
1437                                   retval);
1438       current_thread = th ?: thread_rec (current_event.dwThreadId, TRUE);
1439     }
1440
1441 out:
1442   return retval;
1443 }
1444
1445 /* Wait for interesting events to occur in the target process.  */
1446 static ptid_t
1447 windows_wait (struct target_ops *ops,
1448               ptid_t ptid, struct target_waitstatus *ourstatus)
1449 {
1450   int pid = -1;
1451
1452   target_terminal_ours ();
1453
1454   /* We loop when we get a non-standard exception rather than return
1455      with a SPURIOUS because resume can try and step or modify things,
1456      which needs a current_thread->h.  But some of these exceptions mark
1457      the birth or death of threads, which mean that the current thread
1458      isn't necessarily what you think it is. */
1459
1460   while (1)
1461     {
1462       int retval;
1463
1464       /* Ignore CTRL+C signals while waiting for a debug event.
1465          FIXME: brobecker/2008-05-20: When the user presses CTRL+C while
1466          the inferior is running, both the inferior and GDB receive the
1467          associated signal.  If the inferior receives the signal first
1468          and the delay until GDB receives that signal is sufficiently long,
1469          GDB can sometimes receive the SIGINT after we have unblocked
1470          the CTRL+C handler.  This would lead to the debugger to stop
1471          prematurely while handling the new-thread event that comes
1472          with the handling of the SIGINT inside the inferior, and then
1473          stop again immediately when the user tries to resume the execution
1474          in the inferior.  This is a classic race, and it would be nice
1475          to find a better solution to that problem.  But in the meantime,
1476          the current approach already greatly mitigate this issue.  */
1477       SetConsoleCtrlHandler (NULL, TRUE);
1478       retval = get_windows_debug_event (pid, ourstatus);
1479       SetConsoleCtrlHandler (NULL, FALSE);
1480
1481       if (retval)
1482         return ptid_build (current_event.dwProcessId, 0, retval);
1483       else
1484         {
1485           int detach = 0;
1486
1487           if (deprecated_ui_loop_hook != NULL)
1488             detach = deprecated_ui_loop_hook (0);
1489
1490           if (detach)
1491             windows_kill_inferior ();
1492         }
1493     }
1494 }
1495
1496 static void
1497 do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching)
1498 {
1499   extern int stop_after_trap;
1500   int i;
1501   struct inferior *inf;
1502   struct thread_info *tp;
1503
1504   last_sig = TARGET_SIGNAL_0;
1505   event_count = 0;
1506   exception_count = 0;
1507   open_process_used = 0;
1508   debug_registers_changed = 0;
1509   debug_registers_used = 0;
1510   for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1511     dr[i] = 0;
1512 #ifdef __CYGWIN__
1513   cygwin_load_start = cygwin_load_end = 0;
1514 #endif
1515   current_event.dwProcessId = pid;
1516   memset (&current_event, 0, sizeof (current_event));
1517   push_target (ops);
1518   disable_breakpoints_in_shlibs ();
1519   windows_clear_solib ();
1520   clear_proceed_status ();
1521   init_wait_for_inferior ();
1522
1523   inf = add_inferior (pid);
1524   inf->attach_flag = attaching;
1525
1526   /* Make the new process the current inferior, so terminal handling
1527      can rely on it.  When attaching, we don't know about any thread
1528      id here, but that's OK --- nothing should be referencing the
1529      current thread until we report an event out of windows_wait.  */
1530   inferior_ptid = pid_to_ptid (pid);
1531
1532   terminal_init_inferior_with_pgrp (pid);
1533   target_terminal_inferior ();
1534
1535   inf->stop_soon = STOP_QUIETLY;
1536   while (1)
1537     {
1538       stop_after_trap = 1;
1539       wait_for_inferior (0);
1540       tp = inferior_thread ();
1541       if (tp->stop_signal != TARGET_SIGNAL_TRAP)
1542         resume (0, tp->stop_signal);
1543       else
1544         break;
1545     }
1546
1547   inf->stop_soon = NO_STOP_QUIETLY;
1548   stop_after_trap = 0;
1549   return;
1550 }
1551
1552 /* Since Windows XP, detaching from a process is supported by Windows.
1553    The following code tries loading the appropriate functions dynamically.
1554    If loading these functions succeeds use them to actually detach from
1555    the inferior process, otherwise behave as usual, pretending that
1556    detach has worked. */
1557 static BOOL WINAPI (*kernel32_DebugSetProcessKillOnExit)(BOOL);
1558 static BOOL WINAPI (*kernel32_DebugActiveProcessStop)(DWORD);
1559
1560 static int
1561 has_detach_ability (void)
1562 {
1563   static HMODULE kernel32 = NULL;
1564
1565   if (!kernel32)
1566     kernel32 = LoadLibrary ("kernel32.dll");
1567   if (kernel32)
1568     {
1569       if (!kernel32_DebugSetProcessKillOnExit)
1570         kernel32_DebugSetProcessKillOnExit =
1571           (void *) GetProcAddress (kernel32, "DebugSetProcessKillOnExit");
1572       if (!kernel32_DebugActiveProcessStop)
1573         kernel32_DebugActiveProcessStop =
1574           (void *) GetProcAddress (kernel32, "DebugActiveProcessStop");
1575       if (kernel32_DebugSetProcessKillOnExit
1576           && kernel32_DebugActiveProcessStop)
1577         return 1;
1578     }
1579   return 0;
1580 }
1581
1582 /* Try to set or remove a user privilege to the current process.  Return -1
1583    if that fails, the previous setting of that privilege otherwise.
1584
1585    This code is copied from the Cygwin source code and rearranged to allow
1586    dynamically loading of the needed symbols from advapi32 which is only
1587    available on NT/2K/XP. */
1588 static int
1589 set_process_privilege (const char *privilege, BOOL enable)
1590 {
1591   static HMODULE advapi32 = NULL;
1592   static BOOL WINAPI (*OpenProcessToken)(HANDLE, DWORD, PHANDLE);
1593   static BOOL WINAPI (*LookupPrivilegeValue)(LPCSTR, LPCSTR, PLUID);
1594   static BOOL WINAPI (*AdjustTokenPrivileges)(HANDLE, BOOL, PTOKEN_PRIVILEGES,
1595                                               DWORD, PTOKEN_PRIVILEGES, PDWORD);
1596
1597   HANDLE token_hdl = NULL;
1598   LUID restore_priv;
1599   TOKEN_PRIVILEGES new_priv, orig_priv;
1600   int ret = -1;
1601   DWORD size;
1602
1603   if (GetVersion () >= 0x80000000)  /* No security availbale on 9x/Me */
1604     return 0;
1605
1606   if (!advapi32)
1607     {
1608       if (!(advapi32 = LoadLibrary ("advapi32.dll")))
1609         goto out;
1610       if (!OpenProcessToken)
1611         OpenProcessToken =
1612           (void *) GetProcAddress (advapi32, "OpenProcessToken");
1613       if (!LookupPrivilegeValue)
1614         LookupPrivilegeValue =
1615           (void *) GetProcAddress (advapi32, "LookupPrivilegeValueA");
1616       if (!AdjustTokenPrivileges)
1617         AdjustTokenPrivileges =
1618           (void *) GetProcAddress (advapi32, "AdjustTokenPrivileges");
1619       if (!OpenProcessToken || !LookupPrivilegeValue || !AdjustTokenPrivileges)
1620         {
1621           advapi32 = NULL;
1622           goto out;
1623         }
1624     }
1625
1626   if (!OpenProcessToken (GetCurrentProcess (),
1627                          TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1628                          &token_hdl))
1629     goto out;
1630
1631   if (!LookupPrivilegeValue (NULL, privilege, &restore_priv))
1632     goto out;
1633
1634   new_priv.PrivilegeCount = 1;
1635   new_priv.Privileges[0].Luid = restore_priv;
1636   new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1637
1638   if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1639                               sizeof orig_priv, &orig_priv, &size))
1640     goto out;
1641 #if 0
1642   /* Disabled, otherwise every `attach' in an unprivileged user session
1643      would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1644      windows_attach(). */
1645   /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1646      be enabled. GetLastError () returns an correct error code, though. */
1647   if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1648     goto out;
1649 #endif
1650
1651   ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1652
1653 out:
1654   if (token_hdl)
1655     CloseHandle (token_hdl);
1656
1657   return ret;
1658 }
1659
1660 /* Attach to process PID, then initialize for debugging it.  */
1661 static void
1662 windows_attach (struct target_ops *ops, char *args, int from_tty)
1663 {
1664   BOOL ok;
1665   DWORD pid;
1666
1667   if (!args)
1668     error_no_arg (_("process-id to attach"));
1669
1670   if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1671     {
1672       printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1673       printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1674     }
1675
1676   pid = strtoul (args, 0, 0);           /* Windows pid */
1677
1678   windows_init_thread_list ();
1679   ok = DebugActiveProcess (pid);
1680   saw_create = 0;
1681
1682 #ifdef __CYGWIN__
1683   if (!ok)
1684     {
1685       /* Try fall back to Cygwin pid */
1686       pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1687
1688       if (pid > 0)
1689         ok = DebugActiveProcess (pid);
1690   }
1691 #endif
1692
1693   if (!ok)
1694     error (_("Can't attach to process."));
1695
1696   if (has_detach_ability ())
1697     kernel32_DebugSetProcessKillOnExit (FALSE);
1698
1699   if (from_tty)
1700     {
1701       char *exec_file = (char *) get_exec_file (0);
1702
1703       if (exec_file)
1704         printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1705                            target_pid_to_str (pid_to_ptid (pid)));
1706       else
1707         printf_unfiltered ("Attaching to %s\n",
1708                            target_pid_to_str (pid_to_ptid (pid)));
1709
1710       gdb_flush (gdb_stdout);
1711     }
1712
1713   do_initial_windows_stuff (ops, pid, 1);
1714   target_terminal_ours ();
1715 }
1716
1717 static void
1718 windows_detach (struct target_ops *ops, char *args, int from_tty)
1719 {
1720   int detached = 1;
1721
1722   if (has_detach_ability ())
1723     {
1724       ptid_t ptid = {-1};
1725       windows_resume (ptid, 0, TARGET_SIGNAL_0);
1726
1727       if (!kernel32_DebugActiveProcessStop (current_event.dwProcessId))
1728         {
1729           error (_("Can't detach process %lu (error %lu)"),
1730                  current_event.dwProcessId, GetLastError ());
1731           detached = 0;
1732         }
1733       kernel32_DebugSetProcessKillOnExit (FALSE);
1734     }
1735   if (detached && from_tty)
1736     {
1737       char *exec_file = get_exec_file (0);
1738       if (exec_file == 0)
1739         exec_file = "";
1740       printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file,
1741                          current_event.dwProcessId);
1742       gdb_flush (gdb_stdout);
1743     }
1744
1745   inferior_ptid = null_ptid;
1746   detach_inferior (current_event.dwProcessId);
1747
1748   unpush_target (ops);
1749 }
1750
1751 static char *
1752 windows_pid_to_exec_file (int pid)
1753 {
1754   static char path[MAX_PATH + 1];
1755
1756 #ifdef __CYGWIN__
1757   /* Try to find exe name as symlink target of /proc/<pid>/exe */
1758   int nchars;
1759   char procexe[sizeof ("/proc/4294967295/exe")];
1760   sprintf (procexe, "/proc/%u/exe", pid);
1761   nchars = readlink (procexe, path, sizeof(path));
1762   if (nchars > 0 && nchars < sizeof (path))
1763     {
1764       path[nchars] = '\0';      /* Got it */
1765       return path;
1766     }
1767 #endif
1768
1769   /* If we get here then either Cygwin is hosed, this isn't a Cygwin version
1770      of gdb, or we're trying to debug a non-Cygwin windows executable. */
1771   if (!get_module_name (0, path))
1772     path[0] = '\0';
1773
1774   return path;
1775 }
1776
1777 /* Print status information about what we're accessing.  */
1778
1779 static void
1780 windows_files_info (struct target_ops *ignore)
1781 {
1782   struct inferior *inf = current_inferior ();
1783
1784   printf_unfiltered ("\tUsing the running image of %s %s.\n",
1785                      inf->attach_flag ? "attached" : "child",
1786                      target_pid_to_str (inferior_ptid));
1787 }
1788
1789 static void
1790 windows_open (char *arg, int from_tty)
1791 {
1792   error (_("Use the \"run\" command to start a Unix child process."));
1793 }
1794
1795 /* Start an inferior windows child process and sets inferior_ptid to its pid.
1796    EXEC_FILE is the file to run.
1797    ALLARGS is a string containing the arguments to the program.
1798    ENV is the environment vector to pass.  Errors reported with error().  */
1799
1800 static void
1801 windows_create_inferior (struct target_ops *ops, char *exec_file,
1802                        char *allargs, char **in_env, int from_tty)
1803 {
1804   STARTUPINFO si;
1805   PROCESS_INFORMATION pi;
1806   BOOL ret;
1807   DWORD flags;
1808   char *args;
1809   char real_path[MAXPATHLEN];
1810   char *toexec;
1811   char shell[MAX_PATH + 1]; /* Path to shell */
1812   const char *sh;
1813   int tty;
1814   int ostdin, ostdout, ostderr;
1815   const char *inferior_io_terminal = get_inferior_io_terminal ();
1816
1817   if (!exec_file)
1818     error (_("No executable specified, use `target exec'."));
1819
1820   memset (&si, 0, sizeof (si));
1821   si.cb = sizeof (si);
1822
1823 #ifdef __CYGWIN__
1824   if (!useshell)
1825     {
1826       flags = DEBUG_ONLY_THIS_PROCESS;
1827       cygwin_conv_to_win32_path (exec_file, real_path);
1828       toexec = real_path;
1829     }
1830   else
1831     {
1832       char *newallargs;
1833       sh = getenv ("SHELL");
1834       if (!sh)
1835         sh = "/bin/sh";
1836       cygwin_conv_to_win32_path (sh, shell);
1837       newallargs = alloca (sizeof (" -c 'exec  '") + strlen (exec_file)
1838                            + strlen (allargs) + 2);
1839       sprintf (newallargs, " -c 'exec %s %s'", exec_file, allargs);
1840       allargs = newallargs;
1841       toexec = shell;
1842       flags = DEBUG_PROCESS;
1843     }
1844 #else
1845   toexec = exec_file;
1846   flags = DEBUG_ONLY_THIS_PROCESS;
1847 #endif
1848
1849   if (new_group)
1850     flags |= CREATE_NEW_PROCESS_GROUP;
1851
1852   if (new_console)
1853     flags |= CREATE_NEW_CONSOLE;
1854
1855   args = alloca (strlen (toexec) + strlen (allargs) + 2);
1856   strcpy (args, toexec);
1857   strcat (args, " ");
1858   strcat (args, allargs);
1859
1860 #ifdef __CYGWIN__
1861   /* Prepare the environment vars for CreateProcess.  */
1862   cygwin_internal (CW_SYNC_WINENV);
1863
1864   if (!inferior_io_terminal)
1865     tty = ostdin = ostdout = ostderr = -1;
1866   else
1867     {
1868       tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
1869       if (tty < 0)
1870         {
1871           print_sys_errmsg (inferior_io_terminal, errno);
1872           ostdin = ostdout = ostderr = -1;
1873         }
1874       else
1875         {
1876           ostdin = dup (0);
1877           ostdout = dup (1);
1878           ostderr = dup (2);
1879           dup2 (tty, 0);
1880           dup2 (tty, 1);
1881           dup2 (tty, 2);
1882         }
1883     }
1884 #endif
1885
1886   windows_init_thread_list ();
1887   ret = CreateProcess (0,
1888                        args,    /* command line */
1889                        NULL,    /* Security */
1890                        NULL,    /* thread */
1891                        TRUE,    /* inherit handles */
1892                        flags,   /* start flags */
1893                        NULL,    /* environment */
1894                        NULL,    /* current directory */
1895                        &si,
1896                        &pi);
1897
1898 #ifdef __CYGWIN__
1899   if (tty >= 0)
1900     {
1901       close (tty);
1902       dup2 (ostdin, 0);
1903       dup2 (ostdout, 1);
1904       dup2 (ostderr, 2);
1905       close (ostdin);
1906       close (ostdout);
1907       close (ostderr);
1908     }
1909 #endif
1910
1911   if (!ret)
1912     error (_("Error creating process %s, (error %d)."),
1913            exec_file, (unsigned) GetLastError ());
1914
1915   CloseHandle (pi.hThread);
1916   CloseHandle (pi.hProcess);
1917
1918   if (useshell && shell[0] != '\0')
1919     saw_create = -1;
1920   else
1921     saw_create = 0;
1922
1923   do_initial_windows_stuff (ops, pi.dwProcessId, 0);
1924
1925   /* windows_continue (DBG_CONTINUE, -1); */
1926 }
1927
1928 static void
1929 windows_mourn_inferior (struct target_ops *ops)
1930 {
1931   (void) windows_continue (DBG_CONTINUE, -1);
1932   i386_cleanup_dregs();
1933   if (open_process_used)
1934     {
1935       CHECK (CloseHandle (current_process_handle));
1936       open_process_used = 0;
1937     }
1938   unpush_target (ops);
1939   generic_mourn_inferior ();
1940 }
1941
1942 /* Send a SIGINT to the process group.  This acts just like the user typed a
1943    ^C on the controlling terminal. */
1944
1945 static void
1946 windows_stop (ptid_t ptid)
1947 {
1948   DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1949   CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
1950   registers_changed ();         /* refresh register state */
1951 }
1952
1953 static int
1954 windows_xfer_memory (CORE_ADDR memaddr, gdb_byte *our, int len,
1955                    int write, struct mem_attrib *mem,
1956                    struct target_ops *target)
1957 {
1958   SIZE_T done = 0;
1959   if (write)
1960     {
1961       DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1962                   len, (DWORD) (uintptr_t) memaddr));
1963       if (!WriteProcessMemory (current_process_handle,
1964                                (LPVOID) (uintptr_t) memaddr, our,
1965                                len, &done))
1966         done = 0;
1967       FlushInstructionCache (current_process_handle,
1968                              (LPCVOID) (uintptr_t) memaddr, len);
1969     }
1970   else
1971     {
1972       DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1973                   len, (DWORD) (uintptr_t) memaddr));
1974       if (!ReadProcessMemory (current_process_handle,
1975                               (LPCVOID) (uintptr_t) memaddr, our,
1976                               len, &done))
1977         done = 0;
1978     }
1979   return done;
1980 }
1981
1982 static void
1983 windows_kill_inferior (void)
1984 {
1985   CHECK (TerminateProcess (current_process_handle, 0));
1986
1987   for (;;)
1988     {
1989       if (!windows_continue (DBG_CONTINUE, -1))
1990         break;
1991       if (!WaitForDebugEvent (&current_event, INFINITE))
1992         break;
1993       if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
1994         break;
1995     }
1996
1997   target_mourn_inferior ();     /* or just windows_mourn_inferior? */
1998 }
1999
2000 static void
2001 windows_prepare_to_store (struct regcache *regcache)
2002 {
2003   /* Do nothing, since we can store individual regs */
2004 }
2005
2006 static int
2007 windows_can_run (void)
2008 {
2009   return 1;
2010 }
2011
2012 static void
2013 windows_close (int x)
2014 {
2015   DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n",
2016                 PIDGET (inferior_ptid)));
2017 }
2018
2019 /* Convert pid to printable format. */
2020 static char *
2021 windows_pid_to_str (struct target_ops *ops, ptid_t ptid)
2022 {
2023   static char buf[80];
2024
2025   if (ptid_get_tid (ptid) != 0)
2026     {
2027       snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
2028                 ptid_get_pid (ptid), ptid_get_tid (ptid));
2029       return buf;
2030     }
2031
2032   return normal_pid_to_str (ptid);
2033 }
2034
2035 static LONGEST
2036 windows_xfer_shared_libraries (struct target_ops *ops,
2037                              enum target_object object, const char *annex,
2038                              gdb_byte *readbuf, const gdb_byte *writebuf,
2039                              ULONGEST offset, LONGEST len)
2040 {
2041   struct obstack obstack;
2042   const char *buf;
2043   LONGEST len_avail;
2044   struct so_list *so;
2045
2046   if (writebuf)
2047     return -1;
2048
2049   obstack_init (&obstack);
2050   obstack_grow_str (&obstack, "<library-list>\n");
2051   for (so = solib_start.next; so; so = so->next)
2052     windows_xfer_shared_library (so->so_name, (CORE_ADDR) (uintptr_t) so->lm_info->load_addr,
2053                                  &obstack);
2054   obstack_grow_str0 (&obstack, "</library-list>\n");
2055
2056   buf = obstack_finish (&obstack);
2057   len_avail = strlen (buf);
2058   if (offset >= len_avail)
2059     return 0;
2060
2061   if (len > len_avail - offset)
2062     len = len_avail - offset;
2063   memcpy (readbuf, buf + offset, len);
2064
2065   obstack_free (&obstack, NULL);
2066   return len;
2067 }
2068
2069 static LONGEST
2070 windows_xfer_partial (struct target_ops *ops, enum target_object object,
2071                     const char *annex, gdb_byte *readbuf,
2072                     const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
2073 {
2074   switch (object)
2075     {
2076     case TARGET_OBJECT_MEMORY:
2077       if (readbuf)
2078         return (*ops->deprecated_xfer_memory) (offset, readbuf,
2079                                                len, 0/*read*/, NULL, ops);
2080       if (writebuf)
2081         return (*ops->deprecated_xfer_memory) (offset, (gdb_byte *) writebuf,
2082                                                len, 1/*write*/, NULL, ops);
2083       return -1;
2084
2085     case TARGET_OBJECT_LIBRARIES:
2086       return windows_xfer_shared_libraries (ops, object, annex, readbuf,
2087                                           writebuf, offset, len);
2088
2089     default:
2090       if (ops->beneath != NULL)
2091         return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
2092                                               readbuf, writebuf, offset, len);
2093       return -1;
2094     }
2095 }
2096
2097 static void
2098 init_windows_ops (void)
2099 {
2100   windows_ops.to_shortname = "child";
2101   windows_ops.to_longname = "Win32 child process";
2102   windows_ops.to_doc = "Win32 child process (started by the \"run\" command).";
2103   windows_ops.to_open = windows_open;
2104   windows_ops.to_close = windows_close;
2105   windows_ops.to_attach = windows_attach;
2106   windows_ops.to_attach_no_wait = 1;
2107   windows_ops.to_detach = windows_detach;
2108   windows_ops.to_resume = windows_resume;
2109   windows_ops.to_wait = windows_wait;
2110   windows_ops.to_fetch_registers = windows_fetch_inferior_registers;
2111   windows_ops.to_store_registers = windows_store_inferior_registers;
2112   windows_ops.to_prepare_to_store = windows_prepare_to_store;
2113   windows_ops.deprecated_xfer_memory = windows_xfer_memory;
2114   windows_ops.to_xfer_partial = windows_xfer_partial;
2115   windows_ops.to_files_info = windows_files_info;
2116   windows_ops.to_insert_breakpoint = memory_insert_breakpoint;
2117   windows_ops.to_remove_breakpoint = memory_remove_breakpoint;
2118   windows_ops.to_terminal_init = terminal_init_inferior;
2119   windows_ops.to_terminal_inferior = terminal_inferior;
2120   windows_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2121   windows_ops.to_terminal_ours = terminal_ours;
2122   windows_ops.to_terminal_save_ours = terminal_save_ours;
2123   windows_ops.to_terminal_info = child_terminal_info;
2124   windows_ops.to_kill = windows_kill_inferior;
2125   windows_ops.to_create_inferior = windows_create_inferior;
2126   windows_ops.to_mourn_inferior = windows_mourn_inferior;
2127   windows_ops.to_can_run = windows_can_run;
2128   windows_ops.to_thread_alive = windows_thread_alive;
2129   windows_ops.to_pid_to_str = windows_pid_to_str;
2130   windows_ops.to_stop = windows_stop;
2131   windows_ops.to_stratum = process_stratum;
2132   windows_ops.to_has_all_memory = 1;
2133   windows_ops.to_has_memory = 1;
2134   windows_ops.to_has_stack = 1;
2135   windows_ops.to_has_registers = 1;
2136   windows_ops.to_has_execution = 1;
2137   windows_ops.to_pid_to_exec_file = windows_pid_to_exec_file;
2138   i386_use_watchpoints (&windows_ops);
2139
2140   windows_ops.to_magic = OPS_MAGIC;
2141 }
2142
2143 static void
2144 set_windows_aliases (char *argv0)
2145 {
2146   add_info_alias ("dll", "sharedlibrary", 1);
2147 }
2148
2149 void
2150 _initialize_windows_nat (void)
2151 {
2152   struct cmd_list_element *c;
2153
2154   init_windows_ops ();
2155
2156   c = add_com ("dll-symbols", class_files, dll_symbol_command,
2157                _("Load dll library symbols from FILE."));
2158   set_cmd_completer (c, filename_completer);
2159
2160   add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
2161
2162 #ifdef __CYGWIN__
2163   add_setshow_boolean_cmd ("shell", class_support, &useshell, _("\
2164 Set use of shell to start subprocess."), _("\
2165 Show use of shell to start subprocess."), NULL,
2166                            NULL,
2167                            NULL, /* FIXME: i18n: */
2168                            &setlist, &showlist);
2169
2170   add_setshow_boolean_cmd ("cygwin-exceptions", class_support, &cygwin_exceptions, _("\
2171 Break when an exception is detected in the Cygwin DLL itself."), _("\
2172 Show whether gdb breaks on exceptions in the Cygwin DLL itself."), NULL,
2173                            NULL,
2174                            NULL, /* FIXME: i18n: */
2175                            &setlist, &showlist);
2176 #endif
2177
2178   add_setshow_boolean_cmd ("new-console", class_support, &new_console, _("\
2179 Set creation of new console when creating child process."), _("\
2180 Show creation of new console when creating child process."), NULL,
2181                            NULL,
2182                            NULL, /* FIXME: i18n: */
2183                            &setlist, &showlist);
2184
2185   add_setshow_boolean_cmd ("new-group", class_support, &new_group, _("\
2186 Set creation of new group when creating child process."), _("\
2187 Show creation of new group when creating child process."), NULL,
2188                            NULL,
2189                            NULL, /* FIXME: i18n: */
2190                            &setlist, &showlist);
2191
2192   add_setshow_boolean_cmd ("debugexec", class_support, &debug_exec, _("\
2193 Set whether to display execution in child process."), _("\
2194 Show whether to display execution in child process."), NULL,
2195                            NULL,
2196                            NULL, /* FIXME: i18n: */
2197                            &setlist, &showlist);
2198
2199   add_setshow_boolean_cmd ("debugevents", class_support, &debug_events, _("\
2200 Set whether to display kernel events in child process."), _("\
2201 Show whether to display kernel events in child process."), NULL,
2202                            NULL,
2203                            NULL, /* FIXME: i18n: */
2204                            &setlist, &showlist);
2205
2206   add_setshow_boolean_cmd ("debugmemory", class_support, &debug_memory, _("\
2207 Set whether to display memory accesses in child process."), _("\
2208 Show whether to display memory accesses in child process."), NULL,
2209                            NULL,
2210                            NULL, /* FIXME: i18n: */
2211                            &setlist, &showlist);
2212
2213   add_setshow_boolean_cmd ("debugexceptions", class_support,
2214                            &debug_exceptions, _("\
2215 Set whether to display kernel exceptions in child process."), _("\
2216 Show whether to display kernel exceptions in child process."), NULL,
2217                            NULL,
2218                            NULL, /* FIXME: i18n: */
2219                            &setlist, &showlist);
2220
2221   add_prefix_cmd ("w32", class_info, info_w32_command,
2222                   _("Print information specific to Win32 debugging."),
2223                   &info_w32_cmdlist, "info w32 ", 0, &infolist);
2224
2225   add_cmd ("selector", class_info, display_selectors,
2226            _("Display selectors infos."),
2227            &info_w32_cmdlist);
2228   add_target (&windows_ops);
2229   deprecated_init_ui_hook = set_windows_aliases;
2230 }
2231
2232 /* Hardware watchpoint support, adapted from go32-nat.c code.  */
2233
2234 /* Pass the address ADDR to the inferior in the I'th debug register.
2235    Here we just store the address in dr array, the registers will be
2236    actually set up when windows_continue is called.  */
2237 void
2238 cygwin_set_dr (int i, CORE_ADDR addr)
2239 {
2240   if (i < 0 || i > 3)
2241     internal_error (__FILE__, __LINE__,
2242                     _("Invalid register %d in cygwin_set_dr.\n"), i);
2243   dr[i] = (unsigned) addr;
2244   debug_registers_changed = 1;
2245   debug_registers_used = 1;
2246 }
2247
2248 /* Pass the value VAL to the inferior in the DR7 debug control
2249    register.  Here we just store the address in D_REGS, the watchpoint
2250    will be actually set up in windows_wait.  */
2251 void
2252 cygwin_set_dr7 (unsigned val)
2253 {
2254   dr[7] = val;
2255   debug_registers_changed = 1;
2256   debug_registers_used = 1;
2257 }
2258
2259 /* Get the value of the DR6 debug status register from the inferior.
2260    Here we just return the value stored in dr[6]
2261    by the last call to thread_rec for current_event.dwThreadId id.  */
2262 unsigned
2263 cygwin_get_dr6 (void)
2264 {
2265   return dr[6];
2266 }
2267
2268 /* Determine if the thread referenced by "ptid" is alive
2269    by "polling" it.  If WaitForSingleObject returns WAIT_OBJECT_0
2270    it means that the thread has died.  Otherwise it is assumed to be alive. */
2271 static int
2272 windows_thread_alive (ptid_t ptid)
2273 {
2274   int tid;
2275
2276   gdb_assert (ptid_get_tid (ptid) != 0);
2277   tid = ptid_get_tid (ptid);
2278
2279   return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
2280     FALSE : TRUE;
2281 }
2282
2283 void
2284 _initialize_check_for_gdb_ini (void)
2285 {
2286   char *homedir;
2287   if (inhibit_gdbinit)
2288     return;
2289
2290   homedir = getenv ("HOME");
2291   if (homedir)
2292     {
2293       char *p;
2294       char *oldini = (char *) alloca (strlen (homedir) +
2295                                       sizeof ("/gdb.ini"));
2296       strcpy (oldini, homedir);
2297       p = strchr (oldini, '\0');
2298       if (p > oldini && p[-1] != '/')
2299         *p++ = '/';
2300       strcpy (p, "gdb.ini");
2301       if (access (oldini, 0) == 0)
2302         {
2303           int len = strlen (oldini);
2304           char *newini = alloca (len + 1);
2305           sprintf (newini, "%.*s.gdbinit",
2306             (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2307           warning (_("obsolete '%s' found. Rename to '%s'."), oldini, newini);
2308         }
2309     }
2310 }
2311
2312 void
2313 _initialize_psapi (void)
2314 {
2315   /* Load optional functions used for retrieving filename information
2316      associated with the currently debugged process or its dlls. */
2317   if (!psapi_loaded)
2318     {
2319       HMODULE psapi_module_handle;
2320
2321       psapi_loaded = -1;
2322
2323       psapi_module_handle = LoadLibrary ("psapi.dll");
2324       if (psapi_module_handle)
2325         {
2326           psapi_EnumProcessModules = (void *) GetProcAddress (psapi_module_handle, "EnumProcessModules");
2327           psapi_GetModuleInformation = (void *) GetProcAddress (psapi_module_handle, "GetModuleInformation");
2328           psapi_GetModuleFileNameExA = (void *) GetProcAddress (psapi_module_handle, "GetModuleFileNameExA");
2329
2330           if (psapi_EnumProcessModules != NULL
2331               && psapi_GetModuleInformation != NULL
2332               && psapi_GetModuleFileNameExA != NULL)
2333             psapi_loaded = 1;
2334         }
2335     }
2336
2337   /* This will probably fail on Windows 9x/Me.  Let the user know that we're
2338      missing some functionality. */
2339   if (psapi_loaded < 0)
2340     warning(_("cannot automatically find executable file or library to read symbols.  Use \"file\" or \"dll\" command to load executable/libraries directly."));
2341 }