gdb/windows-nat.c

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