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