gdb/windows-nat.c

   1 /* Target-vector operations for controlling win32 child processes, for GDB.
   2
   3    Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 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, [email protected] */
  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
 128 /* Counts of things. */
 129 static int exception_count = 0;
 130 static int event_count = 0;
 131 static int saw_create;
 132
 133 /* User options. */
 134 static int new_console = 0;
 135 static int new_group = 1;
 136 static int debug_exec = 0;              /* show execution */
 137 static int debug_events = 0;            /* show events from kernel */
 138 static int debug_memory = 0;            /* show target memory accesses */
 139 static int debug_exceptions = 0;        /* show target exceptions */
 140 static int useshell = 0;                /* use shell for subprocesses */
 141
 142 /* This vector maps GDB's idea of a register's number into an address
 143    in the win32 exception context vector.
 144
 145    It also contains the bit mask needed to load the register in question.
 146
 147    One day we could read a reg, we could inspect the context we
 148    already have loaded, if it doesn't have the bit set that we need,
 149    we read that set of registers in using GetThreadContext.  If the
 150    context already contains what we need, we just unpack it. Then to
 151    write a register, first we have to ensure that the context contains
 152    the other regs of the group, and then we copy the info in and set
 153    out bit. */
 154
 155 #define context_offset(x) ((int)&(((CONTEXT *)NULL)->x))
 156 static const int mappings[] =
 157 {
 158   context_offset (Eax),
 159   context_offset (Ecx),
 160   context_offset (Edx),
 161   context_offset (Ebx),
 162   context_offset (Esp),
 163   context_offset (Ebp),
 164   context_offset (Esi),
 165   context_offset (Edi),
 166   context_offset (Eip),
 167   context_offset (EFlags),
 168   context_offset (SegCs),
 169   context_offset (SegSs),
 170   context_offset (SegDs),
 171   context_offset (SegEs),
 172   context_offset (SegFs),
 173   context_offset (SegGs),
 174   context_offset (FloatSave.RegisterArea[0 * 10]),
 175   context_offset (FloatSave.RegisterArea[1 * 10]),
 176   context_offset (FloatSave.RegisterArea[2 * 10]),
 177   context_offset (FloatSave.RegisterArea[3 * 10]),
 178   context_offset (FloatSave.RegisterArea[4 * 10]),
 179   context_offset (FloatSave.RegisterArea[5 * 10]),
 180   context_offset (FloatSave.RegisterArea[6 * 10]),
 181   context_offset (FloatSave.RegisterArea[7 * 10]),
 182   context_offset (FloatSave.ControlWord),
 183   context_offset (FloatSave.StatusWord),
 184   context_offset (FloatSave.TagWord),
 185   context_offset (FloatSave.ErrorSelector),
 186   context_offset (FloatSave.ErrorOffset),
 187   context_offset (FloatSave.DataSelector),
 188   context_offset (FloatSave.DataOffset),
 189   context_offset (FloatSave.ErrorSelector)
 190 #ifdef HAVE_SSE_REGS
 191   /* XMM0-7 */ ,
 192   context_offset (ExtendedRegisters[10*16]),
 193   context_offset (ExtendedRegisters[11*16]),
 194   context_offset (ExtendedRegisters[12*16]),
 195   context_offset (ExtendedRegisters[13*16]),
 196   context_offset (ExtendedRegisters[14*16]),
 197   context_offset (ExtendedRegisters[15*16]),
 198   context_offset (ExtendedRegisters[16*16]),
 199   context_offset (ExtendedRegisters[17*16]),
 200   /* MXCSR */
 201   context_offset (ExtendedRegisters[24])
 202 #endif
 203 };
 204
 205 #undef context_offset
 206
 207 /* This vector maps the target's idea of an exception (extracted
 208    from the DEBUG_EVENT structure) to GDB's idea. */
 209
 210 struct xlate_exception
 211   {
 212     int them;
 213     enum target_signal us;
 214   };
 215
 216 static const struct xlate_exception
 217   xlate[] =
 218 {
 219   {EXCEPTION_ACCESS_VIOLATION, TARGET_SIGNAL_SEGV},
 220   {STATUS_STACK_OVERFLOW, TARGET_SIGNAL_SEGV},
 221   {EXCEPTION_BREAKPOINT, TARGET_SIGNAL_TRAP},
 222   {DBG_CONTROL_C, TARGET_SIGNAL_INT},
 223   {EXCEPTION_SINGLE_STEP, TARGET_SIGNAL_TRAP},
 224   {STATUS_FLOAT_DIVIDE_BY_ZERO, TARGET_SIGNAL_FPE},
 225   {-1, -1}};
 226
 227 static void
 228 check (BOOL ok, const char *file, int line)
 229 {
 230   if (!ok)
 231     printf_filtered ("error return %s:%d was %lu\n", file, line,
 232                      GetLastError ());
 233 }
 234
 235
 236 /* Find a thread record given a thread id.
 237    If get_context then also retrieve the context for this
 238    thread. */
 239 static thread_info *
 240 thread_rec (DWORD id, int get_context)
 241 {
 242   thread_info *th;
 243
 244   for (th = &thread_head; (th = th->next) != NULL;)
 245     if (th->id == id)
 246       {
 247         if (!th->suspend_count && get_context)
 248           {
 249             if (get_context > 0 && id != current_event.dwThreadId)
 250               th->suspend_count = SuspendThread (th->h) + 1;
 251             else if (get_context < 0)
 252               th->suspend_count = -1;
 253
 254             th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
 255             GetThreadContext (th->h, &th->context);
 256             if (id == current_event.dwThreadId)
 257               {
 258                 /* Copy dr values from that thread.  */
 259                 dr[0] = th->context.Dr0;
 260                 dr[1] = th->context.Dr1;
 261                 dr[2] = th->context.Dr2;
 262                 dr[3] = th->context.Dr3;
 263                 dr[6] = th->context.Dr6;
 264                 dr[7] = th->context.Dr7;
 265               }
 266           }
 267         return th;
 268       }
 269
 270   return NULL;
 271 }
 272
 273 /* Add a thread to the thread list */
 274 static thread_info *
 275 child_add_thread (DWORD id, HANDLE h)
 276 {
 277   thread_info *th;
 278
 279   if ((th = thread_rec (id, FALSE)))
 280     return th;
 281
 282   th = (thread_info *) xmalloc (sizeof (*th));
 283   memset (th, 0, sizeof (*th));
 284   th->id = id;
 285   th->h = h;
 286   th->next = thread_head.next;
 287   thread_head.next = th;
 288   add_thread (pid_to_ptid (id));
 289   /* Set the debug registers for the new thread in they are used.  */
 290   if (debug_registers_used)
 291     {
 292       /* Only change the value of the debug registers.  */
 293       th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
 294       CHECK (GetThreadContext (th->h, &th->context));
 295       th->context.Dr0 = dr[0];
 296       th->context.Dr1 = dr[1];
 297       th->context.Dr2 = dr[2];
 298       th->context.Dr3 = dr[3];
 299       /* th->context.Dr6 = dr[6];
 300       FIXME: should we set dr6 also ?? */
 301       th->context.Dr7 = dr[7];
 302       CHECK (SetThreadContext (th->h, &th->context));
 303       th->context.ContextFlags = 0;
 304     }
 305   return th;
 306 }
 307
 308 /* Clear out any old thread list and reintialize it to a
 309    pristine state. */
 310 static void
 311 child_init_thread_list (void)
 312 {
 313   thread_info *th = &thread_head;
 314
 315   DEBUG_EVENTS (("gdb: child_init_thread_list\n"));
 316   init_thread_list ();
 317   while (th->next != NULL)
 318     {
 319       thread_info *here = th->next;
 320       th->next = here->next;
 321       (void) CloseHandle (here->h);
 322       xfree (here);
 323     }
 324 }
 325
 326 /* Delete a thread from the list of threads */
 327 static void
 328 child_delete_thread (DWORD id)
 329 {
 330   thread_info *th;
 331
 332   if (info_verbose)
 333     printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id)));
 334   delete_thread (pid_to_ptid (id));
 335
 336   for (th = &thread_head;
 337        th->next != NULL && th->next->id != id;
 338        th = th->next)
 339     continue;
 340
 341   if (th->next != NULL)
 342     {
 343       thread_info *here = th->next;
 344       th->next = here->next;
 345       CloseHandle (here->h);
 346       xfree (here);
 347     }
 348 }
 349
 350 static void
 351 do_child_fetch_inferior_registers (int r)
 352 {
 353   char *context_offset = ((char *) &current_thread->context) + mappings[r];
 354   long l;
 355   if (r == FCS_REGNUM)
 356     {
 357       l = *((long *) context_offset) & 0xffff;
 358       supply_register (r, (char *) &l);
 359     }
 360   else if (r == FOP_REGNUM)
 361     {
 362       l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
 363       supply_register (r, (char *) &l);
 364     }
 365   else if (r >= 0)
 366     supply_register (r, context_offset);
 367   else
 368     {
 369       for (r = 0; r < NUM_REGS; r++)
 370         do_child_fetch_inferior_registers (r);
 371     }
 372 }
 373
 374 static void
 375 child_fetch_inferior_registers (int r)
 376 {
 377   current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
 378   do_child_fetch_inferior_registers (r);
 379 }
 380
 381 static void
 382 do_child_store_inferior_registers (int r)
 383 {
 384   if (r >= 0)
 385     regcache_collect (r, ((char *) &current_thread->context) + mappings[r]);
 386   else
 387     {
 388       for (r = 0; r < NUM_REGS; r++)
 389         do_child_store_inferior_registers (r);
 390     }
 391 }
 392
 393 /* Store a new register value into the current thread context */
 394 static void
 395 child_store_inferior_registers (int r)
 396 {
 397   current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
 398   do_child_store_inferior_registers (r);
 399 }
 400
 401 static int psapi_loaded = 0;
 402 static HMODULE psapi_module_handle = NULL;
 403 static BOOL WINAPI (*psapi_EnumProcessModules) (HANDLE, HMODULE *, DWORD, LPDWORD) = NULL;
 404 static BOOL WINAPI (*psapi_GetModuleInformation) (HANDLE, HMODULE, LPMODULEINFO, DWORD) = NULL;
 405 static DWORD WINAPI (*psapi_GetModuleFileNameExA) (HANDLE, HMODULE, LPSTR, DWORD) = NULL;
 406
 407 int
 408 psapi_get_dll_name (DWORD BaseAddress, char *dll_name_ret)
 409 {
 410   DWORD len;
 411   MODULEINFO mi;
 412   int i;
 413   HMODULE dh_buf[1];
 414   HMODULE *DllHandle = dh_buf;
 415   DWORD cbNeeded;
 416   BOOL ok;
 417
 418   if (!psapi_loaded ||
 419       psapi_EnumProcessModules == NULL ||
 420       psapi_GetModuleInformation == NULL ||
 421       psapi_GetModuleFileNameExA == NULL)
 422     {
 423       if (psapi_loaded)
 424         goto failed;
 425       psapi_loaded = 1;
 426       psapi_module_handle = LoadLibrary ("psapi.dll");
 427       if (!psapi_module_handle)
 428         {
 429           /* printf_unfiltered ("error loading psapi.dll: %u", GetLastError ()); */
 430           goto failed;
 431         }
 432       psapi_EnumProcessModules = GetProcAddress (psapi_module_handle, "EnumProcessModules");
 433       psapi_GetModuleInformation = GetProcAddress (psapi_module_handle, "GetModuleInformation");
 434       psapi_GetModuleFileNameExA = (void *) GetProcAddress (psapi_module_handle,
 435                                                     "GetModuleFileNameExA");
 436       if (psapi_EnumProcessModules == NULL ||
 437           psapi_GetModuleInformation == NULL ||
 438           psapi_GetModuleFileNameExA == NULL)
 439         goto failed;
 440     }
 441
 442   cbNeeded = 0;
 443   ok = (*psapi_EnumProcessModules) (current_process_handle,
 444                                     DllHandle,
 445                                     sizeof (HMODULE),
 446                                     &cbNeeded);
 447
 448   if (!ok || !cbNeeded)
 449     goto failed;
 450
 451   DllHandle = (HMODULE *) alloca (cbNeeded);
 452   if (!DllHandle)
 453     goto failed;
 454
 455   ok = (*psapi_EnumProcessModules) (current_process_handle,
 456                                     DllHandle,
 457                                     cbNeeded,
 458                                     &cbNeeded);
 459   if (!ok)
 460     goto failed;
 461
 462   for (i = 0; i < (int) (cbNeeded / sizeof (HMODULE)); i++)
 463     {
 464       if (!(*psapi_GetModuleInformation) (current_process_handle,
 465                                           DllHandle[i],
 466                                           &mi,
 467                                           sizeof (mi)))
 468         error ("Can't get module info");
 469
 470       len = (*psapi_GetModuleFileNameExA) (current_process_handle,
 471                                            DllHandle[i],
 472                                            dll_name_ret,
 473                                            MAX_PATH);
 474       if (len == 0)
 475         error ("Error getting dll name: %u\n", (unsigned) GetLastError ());
 476
 477       if ((DWORD) (mi.lpBaseOfDll) == BaseAddress)
 478         return 1;
 479     }
 480
 481 failed:
 482   dll_name_ret[0] = '\0';
 483   return 0;
 484 }
 485
 486 /* Encapsulate the information required in a call to
 487    symbol_file_add_args */
 488 struct safe_symbol_file_add_args
 489 {
 490   char *name;
 491   int from_tty;
 492   struct section_addr_info *addrs;
 493   int mainline;
 494   int flags;
 495   struct ui_file *err, *out;
 496   struct objfile *ret;
 497 };
 498
 499 /* Maintain a linked list of "so" information. */
 500 struct so_stuff
 501 {
 502   struct so_stuff *next;
 503   DWORD load_addr;
 504   DWORD end_addr;
 505   int loaded;
 506   struct objfile *objfile;
 507   char name[1];
 508 } solib_start, *solib_end;
 509
 510 /* Call symbol_file_add with stderr redirected.  We don't care if there
 511    are errors. */
 512 static int
 513 safe_symbol_file_add_stub (void *argv)
 514 {
 515 #define p ((struct safe_symbol_file_add_args *)argv)
 516   struct so_stuff *so = &solib_start;
 517
 518   while ((so = so->next))
 519     if (so->loaded && strcasecmp (so->name, p->name) == 0)
 520       return 0;
 521   p->ret = symbol_file_add (p->name, p->from_tty, p->addrs, p->mainline, p->flags);
 522   return !!p->ret;
 523 #undef p
 524 }
 525
 526 /* Restore gdb's stderr after calling symbol_file_add */
 527 static void
 528 safe_symbol_file_add_cleanup (void *p)
 529 {
 530 #define sp ((struct safe_symbol_file_add_args *)p)
 531   gdb_flush (gdb_stderr);
 532   gdb_flush (gdb_stdout);
 533   ui_file_delete (gdb_stderr);
 534   ui_file_delete (gdb_stdout);
 535   gdb_stderr = sp->err;
 536   gdb_stdout = sp->out;
 537 #undef sp
 538 }
 539
 540 /* symbol_file_add wrapper that prevents errors from being displayed. */
 541 static struct objfile *
 542 safe_symbol_file_add (char *name, int from_tty,
 543                       struct section_addr_info *addrs,
 544                       int mainline, int flags)
 545 {
 546   struct safe_symbol_file_add_args p;
 547   struct cleanup *cleanup;
 548
 549   cleanup = make_cleanup (safe_symbol_file_add_cleanup, &p);
 550
 551   p.err = gdb_stderr;
 552   p.out = gdb_stdout;
 553   gdb_flush (gdb_stderr);
 554   gdb_flush (gdb_stdout);
 555   gdb_stderr = ui_file_new ();
 556   gdb_stdout = ui_file_new ();
 557   p.name = name;
 558   p.from_tty = from_tty;
 559   p.addrs = addrs;
 560   p.mainline = mainline;
 561   p.flags = flags;
 562   catch_errors (safe_symbol_file_add_stub, &p, "", RETURN_MASK_ERROR);
 563
 564   do_cleanups (cleanup);
 565   return p.ret;
 566 }
 567
 568 /* Remember the maximum DLL length for printing in info dll command. */
 569 int max_dll_name_len;
 570
 571 static void
 572 register_loaded_dll (const char *name, DWORD load_addr)
 573 {
 574   struct so_stuff *so;
 575   char ppath[MAX_PATH + 1];
 576   char buf[MAX_PATH + 1];
 577   char cwd[MAX_PATH + 1];
 578   char *p;
 579   WIN32_FIND_DATA w32_fd;
 580   HANDLE h = FindFirstFile(name, &w32_fd);
 581   MEMORY_BASIC_INFORMATION m;
 582   size_t len;
 583
 584   if (h == INVALID_HANDLE_VALUE)
 585     strcpy (buf, name);
 586   else
 587     {
 588       FindClose (h);
 589       strcpy (buf, name);
 590       if (GetCurrentDirectory (MAX_PATH + 1, cwd))
 591         {
 592           p = strrchr (buf, '\\');
 593           if (p)
 594             p[1] = '\0';
 595           SetCurrentDirectory (buf);
 596           GetFullPathName (w32_fd.cFileName, MAX_PATH, buf, &p);
 597           SetCurrentDirectory (cwd);
 598         }
 599     }
 600
 601   cygwin_conv_to_posix_path (buf, ppath);
 602   so = (struct so_stuff *) xmalloc (sizeof (struct so_stuff) + strlen (ppath) + 8 + 1);
 603   so->loaded = 0;
 604   so->load_addr = load_addr;
 605   if (VirtualQueryEx (current_process_handle, (void *) load_addr, &m,
 606                       sizeof (m)))
 607     so->end_addr = (DWORD) m.AllocationBase + m.RegionSize;
 608   else
 609     so->end_addr = load_addr + 0x2000;  /* completely arbitrary */
 610
 611   so->next = NULL;
 612   so->objfile = NULL;
 613   strcpy (so->name, ppath);
 614
 615   solib_end->next = so;
 616   solib_end = so;
 617   len = strlen (ppath);
 618   if (len > max_dll_name_len)
 619     max_dll_name_len = len;
 620 }
 621
 622 char *
 623 get_image_name (HANDLE h, void *address, int unicode)
 624 {
 625   static char buf[(2 * MAX_PATH) + 1];
 626   DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
 627   char *address_ptr;
 628   int len = 0;
 629   char b[2];
 630   DWORD done;
 631
 632   /* Attempt to read the name of the dll that was detected.
 633      This is documented to work only when actively debugging
 634      a program.  It will not work for attached processes. */
 635   if (address == NULL)
 636     return NULL;
 637
 638   /* See if we could read the address of a string, and that the
 639      address isn't null. */
 640   if (!ReadProcessMemory (h, address,  &address_ptr, sizeof (address_ptr), &done)
 641       || done != sizeof (address_ptr) || !address_ptr)
 642     return NULL;
 643
 644   /* Find the length of the string */
 645   while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
 646          && (b[0] != 0 || b[size - 1] != 0) && done == size)
 647     continue;
 648
 649   if (!unicode)
 650     ReadProcessMemory (h, address_ptr, buf, len, &done);
 651   else
 652     {
 653       WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
 654       ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
 655                          &done);
 656
 657       WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, len, 0, 0);
 658     }
 659
 660   return buf;
 661 }
 662
 663 /* Wait for child to do something.  Return pid of child, or -1 in case
 664    of error; store status through argument pointer OURSTATUS.  */
 665 static int
 666 handle_load_dll (void *dummy)
 667 {
 668   LOAD_DLL_DEBUG_INFO *event = &current_event.u.LoadDll;
 669   char dll_buf[MAX_PATH + 1];
 670   char *dll_name = NULL;
 671   char *p;
 672
 673   dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
 674
 675   if (!psapi_get_dll_name ((DWORD) (event->lpBaseOfDll), dll_buf))
 676     dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
 677
 678   dll_name = dll_buf;
 679
 680   if (*dll_name == '\0')
 681     dll_name = get_image_name (current_process_handle, event->lpImageName, event->fUnicode);
 682   if (!dll_name)
 683     return 1;
 684
 685   register_loaded_dll (dll_name, (DWORD) event->lpBaseOfDll + 0x1000);
 686
 687   return 1;
 688 }
 689
 690 static int
 691 handle_unload_dll (void *dummy)
 692 {
 693   DWORD lpBaseOfDll = (DWORD) current_event.u.UnloadDll.lpBaseOfDll + 0x1000;
 694   struct so_stuff *so;
 695
 696   for (so = &solib_start; so->next != NULL; so = so->next)
 697     if (so->next->load_addr == lpBaseOfDll)
 698       {
 699         struct so_stuff *sodel = so->next;
 700         so->next = sodel->next;
 701         if (!so->next)
 702           solib_end = so;
 703         if (sodel->objfile)
 704           free_objfile (sodel->objfile);
 705         xfree(sodel);
 706         return 1;
 707       }
 708   error ("Error: dll starting at 0x%lx not found.\n", (DWORD) lpBaseOfDll);
 709
 710   return 0;
 711 }
 712
 713 char *
 714 solib_address (CORE_ADDR address)
 715 {
 716   struct so_stuff *so;
 717   for (so = &solib_start; so->next != NULL; so = so->next)
 718     if (address >= so->load_addr && address <= so->end_addr)
 719       return so->name;
 720   return NULL;
 721 }
 722
 723 /* Return name of last loaded DLL. */
 724 char *
 725 child_solib_loaded_library_pathname (int pid)
 726 {
 727   return !solib_end || !solib_end->name[0] ? NULL : solib_end->name;
 728 }
 729
 730 /* Clear list of loaded DLLs. */
 731 void
 732 child_clear_solibs (void)
 733 {
 734   struct so_stuff *so, *so1 = solib_start.next;
 735
 736   while ((so = so1) != NULL)
 737     {
 738       so1 = so->next;
 739       xfree (so);
 740     }
 741
 742   solib_start.next = NULL;
 743   solib_start.objfile = NULL;
 744   solib_end = &solib_start;
 745   max_dll_name_len = sizeof ("DLL Name") - 1;
 746 }
 747
 748 /* Get the loaded address of all sections, given that .text was loaded
 749    at text_load. Assumes that all sections are subject to the same
 750    relocation offset. Returns NULL if problems occur or if the
 751    sections were not relocated. */
 752
 753 static struct section_addr_info *
 754 get_relocated_section_addrs (bfd *abfd, CORE_ADDR text_load)
 755 {
 756   struct section_addr_info *result = NULL;
 757   int section_count = bfd_count_sections (abfd);
 758   asection *text_section = bfd_get_section_by_name (abfd, ".text");
 759   CORE_ADDR text_vma;
 760
 761   if (!text_section)
 762     {
 763       /* Couldn't get the .text section. Weird. */
 764     }
 765
 766   else if (text_load == (text_vma = bfd_get_section_vma (abfd, text_section)))
 767     {
 768       /* DLL wasn't relocated. */
 769     }
 770
 771   else
 772     {
 773       /* Figure out all sections' loaded addresses. The offset here is
 774          such that taking a bfd_get_section_vma() result and adding
 775          offset will give the real load address of the section. */
 776
 777       CORE_ADDR offset = text_load - text_vma;
 778
 779       struct section_table *table_start = NULL;
 780       struct section_table *table_end = NULL;
 781       struct section_table *iter = NULL;
 782
 783       build_section_table (abfd, &table_start, &table_end);
 784
 785       for (iter = table_start; iter < table_end; ++iter)
 786         {
 787           /* Relocated addresses. */
 788           iter->addr += offset;
 789           iter->endaddr += offset;
 790         }
 791
 792       result = build_section_addr_info_from_section_table (table_start,
 793                                                            table_end);
 794
 795       xfree (table_start);
 796     }
 797
 798   return result;
 799 }
 800
 801 /* Add DLL symbol information. */
 802 static struct objfile *
 803 solib_symbols_add (char *name, int from_tty, CORE_ADDR load_addr)
 804 {
 805   struct section_addr_info *section_addrs_ptr = NULL;
 806   static struct objfile *result = NULL;
 807   bfd *abfd = NULL;
 808
 809   /* The symbols in a dll are offset by 0x1000, which is the
 810      the offset from 0 of the first byte in an image - because
 811      of the file header and the section alignment. */
 812
 813   if (!name || !name[0])
 814     return NULL;
 815
 816   abfd = bfd_openr (name, "pei-i386");
 817
 818   if (!abfd)
 819     {
 820       /* pei failed - try pe */
 821       abfd = bfd_openr (name, "pe-i386");
 822     }
 823
 824   if (abfd)
 825     {
 826       if (bfd_check_format (abfd, bfd_object))
 827         {
 828           section_addrs_ptr = get_relocated_section_addrs (abfd, load_addr);
 829         }
 830
 831       bfd_close (abfd);
 832     }
 833
 834   if (section_addrs_ptr)
 835     {
 836       result = safe_symbol_file_add (name, from_tty, section_addrs_ptr,
 837                                      0, OBJF_SHARED);
 838
 839       free_section_addr_info (section_addrs_ptr);
 840     }
 841
 842   else
 843     {
 844       /* Fallback on handling just the .text section. */
 845       struct section_addr_info section_addrs;
 846
 847       memset (&section_addrs, 0, sizeof (section_addrs));
 848       section_addrs.other[0].name = ".text";
 849       section_addrs.other[0].addr = load_addr;
 850
 851       result = safe_symbol_file_add (name, from_tty, &section_addrs,
 852                                      0, OBJF_SHARED);
 853     }
 854
 855   return result;
 856 }
 857
 858 /* Load DLL symbol info. */
 859 void
 860 dll_symbol_command (char *args, int from_tty)
 861 {
 862   int n;
 863   dont_repeat ();
 864
 865   if (args == NULL)
 866     error ("dll-symbols requires a file name");
 867
 868   n = strlen (args);
 869   if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0)
 870     {
 871       char *newargs = (char *) alloca (n + 4 + 1);
 872       strcpy (newargs, args);
 873       strcat (newargs, ".dll");
 874       args = newargs;
 875     }
 876
 877   safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED | OBJF_USERLOADED);
 878 }
 879
 880 /* List currently loaded DLLs. */
 881 void
 882 info_dll_command (char *ignore, int from_tty)
 883 {
 884   struct so_stuff *so = &solib_start;
 885
 886   if (!so->next)
 887     return;
 888
 889   printf_filtered ("%*s  Load Address\n", -max_dll_name_len, "DLL Name");
 890   while ((so = so->next) != NULL)
 891     printf_filtered ("%*s  %08lx\n", -max_dll_name_len, so->name, so->load_addr);
 892
 893   return;
 894 }
 895
 896 /* Handle DEBUG_STRING output from child process.
 897    Cygwin prepends its messages with a "cygwin:".  Interpret this as
 898    a Cygwin signal.  Otherwise just print the string as a warning. */
 899 static int
 900 handle_output_debug_string (struct target_waitstatus *ourstatus)
 901 {
 902   char *s;
 903   int gotasig = FALSE;
 904
 905   if (!target_read_string
 906     ((CORE_ADDR) current_event.u.DebugString.lpDebugStringData, &s, 1024, 0)
 907       || !s || !*s)
 908     return gotasig;
 909
 910   if (strncmp (s, CYGWIN_SIGNAL_STRING, sizeof (CYGWIN_SIGNAL_STRING) - 1) != 0)
 911     {
 912       if (strncmp (s, "cYg", 3) != 0)
 913         warning ("%s", s);
 914     }
 915   else
 916     {
 917       char *p;
 918       int sig = strtol (s + sizeof (CYGWIN_SIGNAL_STRING) - 1, &p, 0);
 919       gotasig = target_signal_from_host (sig);
 920       ourstatus->value.sig = gotasig;
 921       if (gotasig)
 922         ourstatus->kind = TARGET_WAITKIND_STOPPED;
 923     }
 924
 925   xfree (s);
 926   return gotasig;
 927 }
 928
 929 static int
 930 display_selector (HANDLE thread, DWORD sel)
 931 {
 932   LDT_ENTRY info;
 933   if (GetThreadSelectorEntry (thread, sel, &info))
 934     {
 935       int base, limit;
 936       printf_filtered ("0x%03lx: ", sel);
 937       if (!info.HighWord.Bits.Pres)
 938         {
 939           puts_filtered ("Segment not present\n");
 940           return 0;
 941         }
 942       base = (info.HighWord.Bits.BaseHi << 24) +
 943              (info.HighWord.Bits.BaseMid << 16)
 944              + info.BaseLow;
 945       limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
 946       if (info.HighWord.Bits.Granularity)
 947         limit = (limit << 12) | 0xfff;
 948       printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
 949       if (info.HighWord.Bits.Default_Big)
 950         puts_filtered(" 32-bit ");
 951       else
 952         puts_filtered(" 16-bit ");
 953       switch ((info.HighWord.Bits.Type & 0xf) >> 1)
 954         {
 955         case 0:
 956           puts_filtered ("Data (Read-Only, Exp-up");
 957           break;
 958         case 1:
 959           puts_filtered ("Data (Read/Write, Exp-up");
 960           break;
 961         case 2:
 962           puts_filtered ("Unused segment (");
 963           break;
 964         case 3:
 965           puts_filtered ("Data (Read/Write, Exp-down");
 966           break;
 967         case 4:
 968           puts_filtered ("Code (Exec-Only, N.Conf");
 969           break;
 970         case 5:
 971           puts_filtered ("Code (Exec/Read, N.Conf");
 972           break;
 973         case 6:
 974           puts_filtered ("Code (Exec-Only, Conf");
 975           break;
 976         case 7:
 977           puts_filtered ("Code (Exec/Read, Conf");
 978           break;
 979         default:
 980           printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
 981         }
 982       if ((info.HighWord.Bits.Type & 0x1) == 0)
 983         puts_filtered(", N.Acc");
 984       puts_filtered (")\n");
 985       if ((info.HighWord.Bits.Type & 0x10) == 0)
 986         puts_filtered("System selector ");
 987       printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
 988       if (info.HighWord.Bits.Granularity)
 989         puts_filtered ("Page granular.\n");
 990       else
 991         puts_filtered ("Byte granular.\n");
 992       return 1;
 993     }
 994   else
 995     {
 996       printf_filtered ("Invalid selector 0x%lx.\n",sel);
 997       return 0;
 998     }
 999 }
1000
1001 static void
1002 display_selectors (char * args, int from_tty)
1003 {
1004   if (!current_thread)
1005     {
1006       puts_filtered ("Impossible to display selectors now.\n");
1007       return;
1008     }
1009   if (!args)
1010     {
1011
1012       puts_filtered ("Selector $cs\n");
1013       display_selector (current_thread->h,
1014         current_thread->context.SegCs);
1015       puts_filtered ("Selector $ds\n");
1016       display_selector (current_thread->h,
1017         current_thread->context.SegDs);
1018       puts_filtered ("Selector $es\n");
1019       display_selector (current_thread->h,
1020         current_thread->context.SegEs);
1021       puts_filtered ("Selector $ss\n");
1022       display_selector (current_thread->h,
1023         current_thread->context.SegSs);
1024       puts_filtered ("Selector $fs\n");
1025       display_selector (current_thread->h,
1026         current_thread->context.SegFs);
1027       puts_filtered ("Selector $gs\n");
1028       display_selector (current_thread->h,
1029         current_thread->context.SegGs);
1030     }
1031   else
1032     {
1033       int sel;
1034       sel = parse_and_eval_long (args);
1035       printf_filtered ("Selector \"%s\"\n",args);
1036       display_selector (current_thread->h, sel);
1037     }
1038 }
1039
1040 static struct cmd_list_element *info_w32_cmdlist = NULL;
1041
1042 static void
1043 info_w32_command (char *args, int from_tty)
1044 {
1045   help_list (info_w32_cmdlist, "info w32 ", class_info, gdb_stdout);
1046 }
1047
1048
1049 #define DEBUG_EXCEPTION_SIMPLE(x)       if (debug_exceptions) \
1050   printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
1051   (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
1052
1053 static int
1054 handle_exception (struct target_waitstatus *ourstatus)
1055 {
1056   thread_info *th;
1057   DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
1058
1059   ourstatus->kind = TARGET_WAITKIND_STOPPED;
1060
1061   /* Record the context of the current thread */
1062   th = thread_rec (current_event.dwThreadId, -1);
1063
1064   switch (code)
1065     {
1066     case EXCEPTION_ACCESS_VIOLATION:
1067       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1068       ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1069       break;
1070     case STATUS_STACK_OVERFLOW:
1071       DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1072       ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1073       break;
1074     case STATUS_FLOAT_DENORMAL_OPERAND:
1075       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1076       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1077       break;
1078     case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1079       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1080       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1081       break;
1082     case STATUS_FLOAT_INEXACT_RESULT:
1083       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1084       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1085       break;
1086     case STATUS_FLOAT_INVALID_OPERATION:
1087       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1088       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1089       break;
1090     case STATUS_FLOAT_OVERFLOW:
1091       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1092       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1093       break;
1094     case STATUS_FLOAT_STACK_CHECK:
1095       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1096       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1097       break;
1098     case STATUS_FLOAT_UNDERFLOW:
1099       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1100       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1101       break;
1102     case STATUS_FLOAT_DIVIDE_BY_ZERO:
1103       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1104       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1105       break;
1106     case STATUS_INTEGER_DIVIDE_BY_ZERO:
1107       DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1108       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1109       break;
1110     case STATUS_INTEGER_OVERFLOW:
1111       DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1112       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1113       break;
1114     case EXCEPTION_BREAKPOINT:
1115       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1116       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1117       break;
1118     case DBG_CONTROL_C:
1119       DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1120       ourstatus->value.sig = TARGET_SIGNAL_INT;
1121       break;
1122     case DBG_CONTROL_BREAK:
1123       DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1124       ourstatus->value.sig = TARGET_SIGNAL_INT;
1125       break;
1126     case EXCEPTION_SINGLE_STEP:
1127       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1128       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1129       break;
1130     case EXCEPTION_ILLEGAL_INSTRUCTION:
1131       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1132       ourstatus->value.sig = TARGET_SIGNAL_ILL;
1133       break;
1134     case EXCEPTION_PRIV_INSTRUCTION:
1135       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1136       ourstatus->value.sig = TARGET_SIGNAL_ILL;
1137       break;
1138     case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1139       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1140       ourstatus->value.sig = TARGET_SIGNAL_ILL;
1141       break;
1142     default:
1143       if (current_event.u.Exception.dwFirstChance)
1144         return 0;
1145       printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1146                     current_event.u.Exception.ExceptionRecord.ExceptionCode,
1147         (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress);
1148       ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
1149       break;
1150     }
1151   exception_count++;
1152   last_sig = ourstatus->value.sig;
1153   return 1;
1154 }
1155
1156 /* Resume all artificially suspended threads if we are continuing
1157    execution */
1158 static BOOL
1159 child_continue (DWORD continue_status, int id)
1160 {
1161   int i;
1162   thread_info *th;
1163   BOOL res;
1164
1165   DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1166                   current_event.dwProcessId, current_event.dwThreadId,
1167                   continue_status == DBG_CONTINUE ?
1168                   "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1169   res = ContinueDebugEvent (current_event.dwProcessId,
1170                             current_event.dwThreadId,
1171                             continue_status);
1172   continue_status = 0;
1173   if (res)
1174     for (th = &thread_head; (th = th->next) != NULL;)
1175       if (((id == -1) || (id == (int) th->id)) && th->suspend_count)
1176         {
1177
1178           for (i = 0; i < th->suspend_count; i++)
1179             (void) ResumeThread (th->h);
1180           th->suspend_count = 0;
1181           if (debug_registers_changed)
1182             {
1183               /* Only change the value of the debug reisters */
1184               th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
1185               th->context.Dr0 = dr[0];
1186               th->context.Dr1 = dr[1];
1187               th->context.Dr2 = dr[2];
1188               th->context.Dr3 = dr[3];
1189               /* th->context.Dr6 = dr[6];
1190                  FIXME: should we set dr6 also ?? */
1191               th->context.Dr7 = dr[7];
1192               CHECK (SetThreadContext (th->h, &th->context));
1193               th->context.ContextFlags = 0;
1194             }
1195         }
1196
1197   debug_registers_changed = 0;
1198   return res;
1199 }
1200
1201 /* Get the next event from the child.  Return 1 if the event requires
1202    handling by WFI (or whatever).
1203  */
1204 static int
1205 get_child_debug_event (int pid, struct target_waitstatus *ourstatus)
1206 {
1207   BOOL debug_event;
1208   DWORD continue_status, event_code;
1209   thread_info *th = NULL;
1210   static thread_info dummy_thread_info;
1211   int retval = 0;
1212
1213   last_sig = TARGET_SIGNAL_0;
1214
1215   if (!(debug_event = WaitForDebugEvent (&current_event, 1000)))
1216     goto out;
1217
1218   event_count++;
1219   continue_status = DBG_CONTINUE;
1220
1221   event_code = current_event.dwDebugEventCode;
1222   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
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       child_delete_thread (current_event.dwThreadId);
1251       th = &dummy_thread_info;
1252       break;
1253
1254     case CREATE_PROCESS_DEBUG_EVENT:
1255       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1256                      (unsigned) current_event.dwProcessId,
1257                      (unsigned) current_event.dwThreadId,
1258                      "CREATE_PROCESS_DEBUG_EVENT"));
1259       CloseHandle (current_event.u.CreateProcessInfo.hFile);
1260       if (++saw_create != 1)
1261         {
1262           CloseHandle (current_event.u.CreateProcessInfo.hProcess);
1263           break;
1264         }
1265
1266       current_process_handle = current_event.u.CreateProcessInfo.hProcess;
1267       main_thread_id = current_event.dwThreadId;
1268       /* Add the main thread */
1269 #if 0
1270       th = child_add_thread (current_event.dwProcessId,
1271                              current_event.u.CreateProcessInfo.hProcess);
1272 #endif
1273       th = child_add_thread (main_thread_id,
1274                              current_event.u.CreateProcessInfo.hThread);
1275       retval = ourstatus->value.related_pid = current_event.dwThreadId;
1276       break;
1277
1278     case EXIT_PROCESS_DEBUG_EVENT:
1279       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1280                      (unsigned) current_event.dwProcessId,
1281                      (unsigned) current_event.dwThreadId,
1282                      "EXIT_PROCESS_DEBUG_EVENT"));
1283       if (saw_create != 1)
1284         break;
1285       ourstatus->kind = TARGET_WAITKIND_EXITED;
1286       ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1287       CloseHandle (current_process_handle);
1288       retval = main_thread_id;
1289       break;
1290
1291     case LOAD_DLL_DEBUG_EVENT:
1292       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1293                      (unsigned) current_event.dwProcessId,
1294                      (unsigned) current_event.dwThreadId,
1295                      "LOAD_DLL_DEBUG_EVENT"));
1296       CloseHandle (current_event.u.LoadDll.hFile);
1297       if (saw_create != 1)
1298         break;
1299       catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
1300       registers_changed ();     /* mark all regs invalid */
1301       ourstatus->kind = TARGET_WAITKIND_LOADED;
1302       ourstatus->value.integer = 0;
1303       retval = main_thread_id;
1304       re_enable_breakpoints_in_shlibs ();
1305       break;
1306
1307     case UNLOAD_DLL_DEBUG_EVENT:
1308       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1309                      (unsigned) current_event.dwProcessId,
1310                      (unsigned) current_event.dwThreadId,
1311                      "UNLOAD_DLL_DEBUG_EVENT"));
1312       if (saw_create != 1)
1313         break;
1314       catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
1315       registers_changed ();     /* mark all regs invalid */
1316       /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
1317          does not exist yet. */
1318       break;
1319
1320     case EXCEPTION_DEBUG_EVENT:
1321       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1322                      (unsigned) current_event.dwProcessId,
1323                      (unsigned) current_event.dwThreadId,
1324                      "EXCEPTION_DEBUG_EVENT"));
1325       if (saw_create != 1)
1326         break;
1327       if (handle_exception (ourstatus))
1328         retval = current_event.dwThreadId;
1329       break;
1330
1331     case OUTPUT_DEBUG_STRING_EVENT:     /* message from the kernel */
1332       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1333                      (unsigned) current_event.dwProcessId,
1334                      (unsigned) current_event.dwThreadId,
1335                      "OUTPUT_DEBUG_STRING_EVENT"));
1336       if (saw_create != 1)
1337         break;
1338       if (handle_output_debug_string (ourstatus))
1339         retval = main_thread_id;
1340       break;
1341
1342     default:
1343       if (saw_create != 1)
1344         break;
1345       printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1346                          (DWORD) current_event.dwProcessId,
1347                          (DWORD) current_event.dwThreadId);
1348       printf_unfiltered ("                 unknown event code %ld\n",
1349                          current_event.dwDebugEventCode);
1350       break;
1351     }
1352
1353   if (!retval || saw_create != 1)
1354     CHECK (child_continue (continue_status, -1));
1355   else
1356     {
1357       current_thread = th ? : thread_rec (current_event.dwThreadId, TRUE);
1358       inferior_ptid = pid_to_ptid (retval);
1359     }
1360
1361 out:
1362   return retval;
1363 }
1364
1365 /* Wait for interesting events to occur in the target process. */
1366 static ptid_t
1367 child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
1368 {
1369   int pid = PIDGET (ptid);
1370
1371   /* We loop when we get a non-standard exception rather than return
1372      with a SPURIOUS because resume can try and step or modify things,
1373      which needs a current_thread->h.  But some of these exceptions mark
1374      the birth or death of threads, which mean that the current thread
1375      isn't necessarily what you think it is. */
1376
1377   while (1)
1378     {
1379       int retval = get_child_debug_event (pid, ourstatus);
1380       if (retval)
1381         return pid_to_ptid (retval);
1382       else
1383         {
1384           int detach = 0;
1385
1386           if (ui_loop_hook != NULL)
1387             detach = ui_loop_hook (0);
1388
1389           if (detach)
1390             child_kill_inferior ();
1391         }
1392     }
1393 }
1394
1395 static void
1396 do_initial_child_stuff (DWORD pid)
1397 {
1398   extern int stop_after_trap;
1399   int i;
1400
1401   last_sig = TARGET_SIGNAL_0;
1402   event_count = 0;
1403   exception_count = 0;
1404   debug_registers_changed = 0;
1405   debug_registers_used = 0;
1406   for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1407     dr[i] = 0;
1408   current_event.dwProcessId = pid;
1409   memset (&current_event, 0, sizeof (current_event));
1410   push_target (&child_ops);
1411   child_init_thread_list ();
1412   disable_breakpoints_in_shlibs (1);
1413   child_clear_solibs ();
1414   clear_proceed_status ();
1415   init_wait_for_inferior ();
1416
1417   target_terminal_init ();
1418   target_terminal_inferior ();
1419
1420   while (1)
1421     {
1422       stop_after_trap = 1;
1423       wait_for_inferior ();
1424       if (stop_signal != TARGET_SIGNAL_TRAP)
1425         resume (0, stop_signal);
1426       else
1427         break;
1428     }
1429   stop_after_trap = 0;
1430   return;
1431 }
1432
1433 /* Since Windows XP, detaching from a process is supported by Windows.
1434    The following code tries loading the appropriate functions dynamically.
1435    If loading these functions succeeds use them to actually detach from
1436    the inferior process, otherwise behave as usual, pretending that
1437    detach has worked. */
1438 static BOOL WINAPI (*DebugSetProcessKillOnExit)(BOOL);
1439 static BOOL WINAPI (*DebugActiveProcessStop)(DWORD);
1440
1441 static int
1442 has_detach_ability (void)
1443 {
1444   static HMODULE kernel32 = NULL;
1445
1446   if (!kernel32)
1447     kernel32 = LoadLibrary ("kernel32.dll");
1448   if (kernel32)
1449     {
1450       if (!DebugSetProcessKillOnExit)
1451         DebugSetProcessKillOnExit = GetProcAddress (kernel32,
1452                                                  "DebugSetProcessKillOnExit");
1453       if (!DebugActiveProcessStop)
1454         DebugActiveProcessStop = GetProcAddress (kernel32,
1455                                                  "DebugActiveProcessStop");
1456       if (DebugSetProcessKillOnExit && DebugActiveProcessStop)
1457         return 1;
1458     }
1459   return 0;
1460 }
1461
1462 /* Try to set or remove a user privilege to the current process.  Return -1
1463    if that fails, the previous setting of that privilege otherwise.
1464
1465    This code is copied from the Cygwin source code and rearranged to allow
1466    dynamically loading of the needed symbols from advapi32 which is only
1467    available on NT/2K/XP. */
1468 static int
1469 set_process_privilege (const char *privilege, BOOL enable)
1470 {
1471   static HMODULE advapi32 = NULL;
1472   static BOOL WINAPI (*OpenProcessToken)(HANDLE, DWORD, PHANDLE);
1473   static BOOL WINAPI (*LookupPrivilegeValue)(LPCSTR, LPCSTR, PLUID);
1474   static BOOL WINAPI (*AdjustTokenPrivileges)(HANDLE, BOOL, PTOKEN_PRIVILEGES,
1475                                               DWORD, PTOKEN_PRIVILEGES, PDWORD);
1476
1477   HANDLE token_hdl = NULL;
1478   LUID restore_priv;
1479   TOKEN_PRIVILEGES new_priv, orig_priv;
1480   int ret = -1;
1481   DWORD size;
1482
1483   if (GetVersion () >= 0x80000000)  /* No security availbale on 9x/Me */
1484     return 0;
1485
1486   if (!advapi32)
1487     {
1488       if (!(advapi32 = LoadLibrary ("advapi32.dll")))
1489         goto out;
1490       if (!OpenProcessToken)
1491         OpenProcessToken = GetProcAddress (advapi32, "OpenProcessToken");
1492       if (!LookupPrivilegeValue)
1493         LookupPrivilegeValue = GetProcAddress (advapi32,
1494                                                "LookupPrivilegeValueA");
1495       if (!AdjustTokenPrivileges)
1496         AdjustTokenPrivileges = GetProcAddress (advapi32,
1497                                                 "AdjustTokenPrivileges");
1498       if (!OpenProcessToken || !LookupPrivilegeValue || !AdjustTokenPrivileges)
1499         {
1500           advapi32 = NULL;
1501           goto out;
1502         }
1503     }
1504
1505   if (!OpenProcessToken (GetCurrentProcess (),
1506                          TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1507                          &token_hdl))
1508     goto out;
1509
1510   if (!LookupPrivilegeValue (NULL, privilege, &restore_priv))
1511     goto out;
1512
1513   new_priv.PrivilegeCount = 1;
1514   new_priv.Privileges[0].Luid = restore_priv;
1515   new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1516
1517   if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1518                               sizeof orig_priv, &orig_priv, &size))
1519     goto out;
1520 #if 0
1521   /* Disabled, otherwise every `attach' in an unprivileged user session
1522      would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1523      child_attach(). */
1524   /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1525      be enabled. GetLastError () returns an correct error code, though. */
1526   if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1527     goto out;
1528 #endif
1529
1530   ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1531
1532 out:
1533   if (token_hdl)
1534     CloseHandle (token_hdl);
1535
1536   return ret;
1537 }
1538
1539 /* Attach to process PID, then initialize for debugging it.  */
1540 static void
1541 child_attach (char *args, int from_tty)
1542 {
1543   BOOL ok;
1544   DWORD pid;
1545
1546   if (!args)
1547     error_no_arg ("process-id to attach");
1548
1549   if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1550     {
1551       printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1552       printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1553     }
1554
1555   pid = strtoul (args, 0, 0);           /* Windows pid */
1556
1557   ok = DebugActiveProcess (pid);
1558   saw_create = 0;
1559
1560   if (!ok)
1561     {
1562       /* Try fall back to Cygwin pid */
1563       pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1564
1565       if (pid > 0)
1566         ok = DebugActiveProcess (pid);
1567
1568       if (!ok)
1569         error ("Can't attach to process.");
1570     }
1571
1572   if (has_detach_ability ())
1573     {
1574       attach_flag = 1;
1575       DebugSetProcessKillOnExit (FALSE);
1576     }
1577
1578   if (from_tty)
1579     {
1580       char *exec_file = (char *) get_exec_file (0);
1581
1582       if (exec_file)
1583         printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1584                            target_pid_to_str (pid_to_ptid (pid)));
1585       else
1586         printf_unfiltered ("Attaching to %s\n",
1587                            target_pid_to_str (pid_to_ptid (pid)));
1588
1589       gdb_flush (gdb_stdout);
1590     }
1591
1592   do_initial_child_stuff (pid);
1593   target_terminal_ours ();
1594 }
1595
1596 static void
1597 child_detach (char *args, int from_tty)
1598 {
1599   int detached = 1;
1600
1601   if (has_detach_ability ())
1602     {
1603       delete_command (NULL, 0);
1604       child_continue (DBG_CONTINUE, -1);
1605       if (!DebugActiveProcessStop (current_event.dwProcessId))
1606         {
1607           error ("Can't detach process %lu (error %lu)",
1608                  current_event.dwProcessId, GetLastError ());
1609           detached = 0;
1610         }
1611       DebugSetProcessKillOnExit (FALSE);
1612     }
1613   if (detached && from_tty)
1614     {
1615       char *exec_file = get_exec_file (0);
1616       if (exec_file == 0)
1617         exec_file = "";
1618       printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file,
1619                          current_event.dwProcessId);
1620       gdb_flush (gdb_stdout);
1621     }
1622   inferior_ptid = null_ptid;
1623   unpush_target (&child_ops);
1624 }
1625
1626 /* Print status information about what we're accessing.  */
1627
1628 static void
1629 child_files_info (struct target_ops *ignore)
1630 {
1631   printf_unfiltered ("\tUsing the running image of %s %s.\n",
1632       attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid));
1633 }
1634
1635 /* ARGSUSED */
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 }
2216 map_code_section_args;
2217
2218 static void
2219 map_single_dll_code_section (bfd * abfd, asection * sect, void *obj)
2220 {
2221   int old;
2222   int update_coreops;
2223   struct section_table *new_target_sect_ptr;
2224
2225   map_code_section_args *args = (map_code_section_args *) obj;
2226   struct target_ops *target = args->target;
2227   if (sect->flags & SEC_CODE)
2228     {
2229       update_coreops = core_ops.to_sections == target->to_sections;
2230
2231       if (target->to_sections)
2232         {
2233           old = target->to_sections_end - target->to_sections;
2234           target->to_sections = (struct section_table *)
2235             xrealloc ((char *) target->to_sections,
2236                       (sizeof (struct section_table)) * (1 + old));
2237         }
2238       else
2239         {
2240           old = 0;
2241           target->to_sections = (struct section_table *)
2242             xmalloc ((sizeof (struct section_table)));
2243         }
2244       target->to_sections_end = target->to_sections + (1 + old);
2245
2246       /* Update the to_sections field in the core_ops structure
2247          if needed.  */
2248       if (update_coreops)
2249         {
2250           core_ops.to_sections = target->to_sections;
2251           core_ops.to_sections_end = target->to_sections_end;
2252         }
2253       new_target_sect_ptr = target->to_sections + old;
2254       new_target_sect_ptr->addr = args->addr + bfd_section_vma (abfd, sect);
2255       new_target_sect_ptr->endaddr = args->addr + bfd_section_vma (abfd, sect) +
2256         bfd_section_size (abfd, sect);;
2257       new_target_sect_ptr->the_bfd_section = sect;
2258       new_target_sect_ptr->bfd = abfd;
2259     }
2260 }
2261
2262 static int
2263 dll_code_sections_add (const char *dll_name, int base_addr, struct target_ops *target)
2264 {
2265   bfd *dll_bfd;
2266   map_code_section_args map_args;
2267   asection *lowest_sect;
2268   char *name;
2269   if (dll_name == NULL || target == NULL)
2270     return 0;
2271   name = xstrdup (dll_name);
2272   dll_bfd = bfd_openr (name, "pei-i386");
2273   if (dll_bfd == NULL)
2274     return 0;
2275
2276   if (bfd_check_format (dll_bfd, bfd_object))
2277     {
2278       lowest_sect = bfd_get_section_by_name (dll_bfd, ".text");
2279       if (lowest_sect == NULL)
2280         return 0;
2281       map_args.target = target;
2282       map_args.addr = base_addr - bfd_section_vma (dll_bfd, lowest_sect);
2283
2284       bfd_map_over_sections (dll_bfd, &map_single_dll_code_section, (void *) (&map_args));
2285     }
2286
2287   return 1;
2288 }
2289
2290 static void
2291 core_section_load_dll_symbols (bfd * abfd, asection * sect, void *obj)
2292 {
2293   struct target_ops *target = (struct target_ops *) obj;
2294
2295   DWORD base_addr;
2296
2297   int dll_name_size;
2298   char *dll_name = NULL;
2299   char *buf = NULL;
2300   struct win32_pstatus *pstatus;
2301   char *p;
2302
2303   if (strncmp (sect->name, ".module", 7))
2304     return;
2305
2306   buf = (char *) xmalloc (sect->_raw_size + 1);
2307   if (!buf)
2308     {
2309       printf_unfiltered ("memory allocation failed for %s\n", sect->name);
2310       goto out;
2311     }
2312   if (!bfd_get_section_contents (abfd, sect, buf, 0, sect->_raw_size))
2313     goto out;
2314
2315   pstatus = (struct win32_pstatus *) buf;
2316
2317   memmove (&base_addr, &(pstatus->data.module_info.base_address), sizeof (base_addr));
2318   dll_name_size = pstatus->data.module_info.module_name_size;
2319   if (offsetof (struct win32_pstatus, data.module_info.module_name) + dll_name_size > sect->_raw_size)
2320       goto out;
2321
2322   dll_name = (char *) xmalloc (dll_name_size + 1);
2323   if (!dll_name)
2324     {
2325       printf_unfiltered ("memory allocation failed for %s\n", sect->name);
2326       goto out;
2327     }
2328   strncpy (dll_name, pstatus->data.module_info.module_name, dll_name_size);
2329
2330   while ((p = strchr (dll_name, '\\')))
2331     *p = '/';
2332
2333   if (!core_dll_symbols_add (dll_name, (DWORD) base_addr))
2334     printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name);
2335
2336   if (!dll_code_sections_add (dll_name, (DWORD) base_addr + 0x1000, target))
2337     printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name);
2338
2339 out:
2340   if (buf)
2341     xfree (buf);
2342   if (dll_name)
2343     xfree (dll_name);
2344   return;
2345 }
2346
2347 void
2348 child_solib_add (char *filename, int from_tty, struct target_ops *target,
2349                  int readsyms)
2350 {
2351   if (!readsyms)
2352     return;
2353   if (core_bfd)
2354     {
2355       child_clear_solibs ();
2356       bfd_map_over_sections (core_bfd, &core_section_load_dll_symbols, target);
2357     }
2358   else
2359     {
2360       if (solib_end && solib_end->name)
2361              solib_end->objfile = solib_symbols_add (solib_end->name, from_tty,
2362                                                 solib_end->load_addr);
2363     }
2364 }
2365
2366 static void
2367 fetch_elf_core_registers (char *core_reg_sect,
2368                           unsigned core_reg_size,
2369                           int which,
2370                           CORE_ADDR reg_addr)
2371 {
2372   int r;
2373   if (core_reg_size < sizeof (CONTEXT))
2374     {
2375       error ("Core file register section too small (%u bytes).", core_reg_size);
2376       return;
2377     }
2378   for (r = 0; r < NUM_REGS; r++)
2379     supply_register (r, core_reg_sect + mappings[r]);
2380 }
2381
2382 static struct core_fns win32_elf_core_fns =
2383 {
2384   bfd_target_elf_flavour,
2385   default_check_format,
2386   default_core_sniffer,
2387   fetch_elf_core_registers,
2388   NULL
2389 };
2390
2391 void
2392 _initialize_core_win32 (void)
2393 {
2394   add_core_fns (&win32_elf_core_fns);
2395 }
2396
2397 void
2398 _initialize_check_for_gdb_ini (void)
2399 {
2400   char *homedir;
2401   if (inhibit_gdbinit)
2402     return;
2403
2404   homedir = getenv ("HOME");
2405   if (homedir)
2406     {
2407       char *p;
2408       char *oldini = (char *) alloca (strlen (homedir) +
2409                                       sizeof ("/gdb.ini"));
2410       strcpy (oldini, homedir);
2411       p = strchr (oldini, '\0');
2412       if (p > oldini && p[-1] != '/')
2413         *p++ = '/';
2414       strcpy (p, "gdb.ini");
2415       if (access (oldini, 0) == 0)
2416         {
2417           int len = strlen (oldini);
2418           char *newini = alloca (len + 1);
2419           sprintf (newini, "%.*s.gdbinit",
2420             (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2421           warning ("obsolete '%s' found. Rename to '%s'.", oldini, newini);
2422         }
2423     }
2424 }