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