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