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 "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       struct cleanup *my_cleanups;
 847
 848       section_addrs = alloc_section_addr_info (1);
 849       my_cleanups = make_cleanup (xfree, section_addrs);
 850       section_addrs.other[0].name = ".text";
 851       section_addrs.other[0].addr = load_addr;
 852
 853       result = safe_symbol_file_add (name, from_tty, &section_addrs,
 854                                      0, OBJF_SHARED);
 855       do_cleanups (my_cleanups);
 856     }
 857
 858   return result;
 859 }
 860
 861 /* Load DLL symbol info. */
 862 void
 863 dll_symbol_command (char *args, int from_tty)
 864 {
 865   int n;
 866   dont_repeat ();
 867
 868   if (args == NULL)
 869     error ("dll-symbols requires a file name");
 870
 871   n = strlen (args);
 872   if (n > 4 && strcasecmp (args + n - 4, ".dll") != 0)
 873     {
 874       char *newargs = (char *) alloca (n + 4 + 1);
 875       strcpy (newargs, args);
 876       strcat (newargs, ".dll");
 877       args = newargs;
 878     }
 879
 880   safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED | OBJF_USERLOADED);
 881 }
 882
 883 /* List currently loaded DLLs. */
 884 void
 885 info_dll_command (char *ignore, int from_tty)
 886 {
 887   struct so_stuff *so = &solib_start;
 888
 889   if (!so->next)
 890     return;
 891
 892   printf_filtered ("%*s  Load Address\n", -max_dll_name_len, "DLL Name");
 893   while ((so = so->next) != NULL)
 894     printf_filtered ("%*s  %08lx\n", -max_dll_name_len, so->name, so->load_addr);
 895
 896   return;
 897 }
 898
 899 /* Handle DEBUG_STRING output from child process.
 900    Cygwin prepends its messages with a "cygwin:".  Interpret this as
 901    a Cygwin signal.  Otherwise just print the string as a warning. */
 902 static int
 903 handle_output_debug_string (struct target_waitstatus *ourstatus)
 904 {
 905   char *s;
 906   int gotasig = FALSE;
 907
 908   if (!target_read_string
 909     ((CORE_ADDR) current_event.u.DebugString.lpDebugStringData, &s, 1024, 0)
 910       || !s || !*s)
 911     return gotasig;
 912
 913   if (strncmp (s, CYGWIN_SIGNAL_STRING, sizeof (CYGWIN_SIGNAL_STRING) - 1) != 0)
 914     {
 915       if (strncmp (s, "cYg", 3) != 0)
 916         warning ("%s", s);
 917     }
 918   else
 919     {
 920       char *p;
 921       int sig = strtol (s + sizeof (CYGWIN_SIGNAL_STRING) - 1, &p, 0);
 922       gotasig = target_signal_from_host (sig);
 923       ourstatus->value.sig = gotasig;
 924       if (gotasig)
 925         ourstatus->kind = TARGET_WAITKIND_STOPPED;
 926     }
 927
 928   xfree (s);
 929   return gotasig;
 930 }
 931
 932 static int
 933 display_selector (HANDLE thread, DWORD sel)
 934 {
 935   LDT_ENTRY info;
 936   if (GetThreadSelectorEntry (thread, sel, &info))
 937     {
 938       int base, limit;
 939       printf_filtered ("0x%03lx: ", sel);
 940       if (!info.HighWord.Bits.Pres)
 941         {
 942           puts_filtered ("Segment not present\n");
 943           return 0;
 944         }
 945       base = (info.HighWord.Bits.BaseHi << 24) +
 946              (info.HighWord.Bits.BaseMid << 16)
 947              + info.BaseLow;
 948       limit = (info.HighWord.Bits.LimitHi << 16) + info.LimitLow;
 949       if (info.HighWord.Bits.Granularity)
 950         limit = (limit << 12) | 0xfff;
 951       printf_filtered ("base=0x%08x limit=0x%08x", base, limit);
 952       if (info.HighWord.Bits.Default_Big)
 953         puts_filtered(" 32-bit ");
 954       else
 955         puts_filtered(" 16-bit ");
 956       switch ((info.HighWord.Bits.Type & 0xf) >> 1)
 957         {
 958         case 0:
 959           puts_filtered ("Data (Read-Only, Exp-up");
 960           break;
 961         case 1:
 962           puts_filtered ("Data (Read/Write, Exp-up");
 963           break;
 964         case 2:
 965           puts_filtered ("Unused segment (");
 966           break;
 967         case 3:
 968           puts_filtered ("Data (Read/Write, Exp-down");
 969           break;
 970         case 4:
 971           puts_filtered ("Code (Exec-Only, N.Conf");
 972           break;
 973         case 5:
 974           puts_filtered ("Code (Exec/Read, N.Conf");
 975           break;
 976         case 6:
 977           puts_filtered ("Code (Exec-Only, Conf");
 978           break;
 979         case 7:
 980           puts_filtered ("Code (Exec/Read, Conf");
 981           break;
 982         default:
 983           printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type);
 984         }
 985       if ((info.HighWord.Bits.Type & 0x1) == 0)
 986         puts_filtered(", N.Acc");
 987       puts_filtered (")\n");
 988       if ((info.HighWord.Bits.Type & 0x10) == 0)
 989         puts_filtered("System selector ");
 990       printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl);
 991       if (info.HighWord.Bits.Granularity)
 992         puts_filtered ("Page granular.\n");
 993       else
 994         puts_filtered ("Byte granular.\n");
 995       return 1;
 996     }
 997   else
 998     {
 999       printf_filtered ("Invalid selector 0x%lx.\n",sel);
1000       return 0;
1001     }
1002 }
1003
1004 static void
1005 display_selectors (char * args, int from_tty)
1006 {
1007   if (!current_thread)
1008     {
1009       puts_filtered ("Impossible to display selectors now.\n");
1010       return;
1011     }
1012   if (!args)
1013     {
1014
1015       puts_filtered ("Selector $cs\n");
1016       display_selector (current_thread->h,
1017         current_thread->context.SegCs);
1018       puts_filtered ("Selector $ds\n");
1019       display_selector (current_thread->h,
1020         current_thread->context.SegDs);
1021       puts_filtered ("Selector $es\n");
1022       display_selector (current_thread->h,
1023         current_thread->context.SegEs);
1024       puts_filtered ("Selector $ss\n");
1025       display_selector (current_thread->h,
1026         current_thread->context.SegSs);
1027       puts_filtered ("Selector $fs\n");
1028       display_selector (current_thread->h,
1029         current_thread->context.SegFs);
1030       puts_filtered ("Selector $gs\n");
1031       display_selector (current_thread->h,
1032         current_thread->context.SegGs);
1033     }
1034   else
1035     {
1036       int sel;
1037       sel = parse_and_eval_long (args);
1038       printf_filtered ("Selector \"%s\"\n",args);
1039       display_selector (current_thread->h, sel);
1040     }
1041 }
1042
1043 static struct cmd_list_element *info_w32_cmdlist = NULL;
1044
1045 static void
1046 info_w32_command (char *args, int from_tty)
1047 {
1048   help_list (info_w32_cmdlist, "info w32 ", class_info, gdb_stdout);
1049 }
1050
1051
1052 #define DEBUG_EXCEPTION_SIMPLE(x)       if (debug_exceptions) \
1053   printf_unfiltered ("gdb: Target exception %s at 0x%08lx\n", x, \
1054   (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress)
1055
1056 static int
1057 handle_exception (struct target_waitstatus *ourstatus)
1058 {
1059   thread_info *th;
1060   DWORD code = current_event.u.Exception.ExceptionRecord.ExceptionCode;
1061
1062   ourstatus->kind = TARGET_WAITKIND_STOPPED;
1063
1064   /* Record the context of the current thread */
1065   th = thread_rec (current_event.dwThreadId, -1);
1066
1067   switch (code)
1068     {
1069     case EXCEPTION_ACCESS_VIOLATION:
1070       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
1071       ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1072       break;
1073     case STATUS_STACK_OVERFLOW:
1074       DEBUG_EXCEPTION_SIMPLE ("STATUS_STACK_OVERFLOW");
1075       ourstatus->value.sig = TARGET_SIGNAL_SEGV;
1076       break;
1077     case STATUS_FLOAT_DENORMAL_OPERAND:
1078       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DENORMAL_OPERAND");
1079       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1080       break;
1081     case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
1082       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
1083       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1084       break;
1085     case STATUS_FLOAT_INEXACT_RESULT:
1086       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INEXACT_RESULT");
1087       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1088       break;
1089     case STATUS_FLOAT_INVALID_OPERATION:
1090       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_INVALID_OPERATION");
1091       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1092       break;
1093     case STATUS_FLOAT_OVERFLOW:
1094       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_OVERFLOW");
1095       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1096       break;
1097     case STATUS_FLOAT_STACK_CHECK:
1098       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_STACK_CHECK");
1099       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1100       break;
1101     case STATUS_FLOAT_UNDERFLOW:
1102       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_UNDERFLOW");
1103       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1104       break;
1105     case STATUS_FLOAT_DIVIDE_BY_ZERO:
1106       DEBUG_EXCEPTION_SIMPLE ("STATUS_FLOAT_DIVIDE_BY_ZERO");
1107       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1108       break;
1109     case STATUS_INTEGER_DIVIDE_BY_ZERO:
1110       DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_DIVIDE_BY_ZERO");
1111       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1112       break;
1113     case STATUS_INTEGER_OVERFLOW:
1114       DEBUG_EXCEPTION_SIMPLE ("STATUS_INTEGER_OVERFLOW");
1115       ourstatus->value.sig = TARGET_SIGNAL_FPE;
1116       break;
1117     case EXCEPTION_BREAKPOINT:
1118       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_BREAKPOINT");
1119       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1120       break;
1121     case DBG_CONTROL_C:
1122       DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_C");
1123       ourstatus->value.sig = TARGET_SIGNAL_INT;
1124       break;
1125     case DBG_CONTROL_BREAK:
1126       DEBUG_EXCEPTION_SIMPLE ("DBG_CONTROL_BREAK");
1127       ourstatus->value.sig = TARGET_SIGNAL_INT;
1128       break;
1129     case EXCEPTION_SINGLE_STEP:
1130       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_SINGLE_STEP");
1131       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
1132       break;
1133     case EXCEPTION_ILLEGAL_INSTRUCTION:
1134       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ILLEGAL_INSTRUCTION");
1135       ourstatus->value.sig = TARGET_SIGNAL_ILL;
1136       break;
1137     case EXCEPTION_PRIV_INSTRUCTION:
1138       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_PRIV_INSTRUCTION");
1139       ourstatus->value.sig = TARGET_SIGNAL_ILL;
1140       break;
1141     case EXCEPTION_NONCONTINUABLE_EXCEPTION:
1142       DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_NONCONTINUABLE_EXCEPTION");
1143       ourstatus->value.sig = TARGET_SIGNAL_ILL;
1144       break;
1145     default:
1146       if (current_event.u.Exception.dwFirstChance)
1147         return 0;
1148       printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
1149                     current_event.u.Exception.ExceptionRecord.ExceptionCode,
1150         (DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress);
1151       ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
1152       break;
1153     }
1154   exception_count++;
1155   last_sig = ourstatus->value.sig;
1156   return 1;
1157 }
1158
1159 /* Resume all artificially suspended threads if we are continuing
1160    execution */
1161 static BOOL
1162 child_continue (DWORD continue_status, int id)
1163 {
1164   int i;
1165   thread_info *th;
1166   BOOL res;
1167
1168   DEBUG_EVENTS (("ContinueDebugEvent (cpid=%ld, ctid=%ld, %s);\n",
1169                   current_event.dwProcessId, current_event.dwThreadId,
1170                   continue_status == DBG_CONTINUE ?
1171                   "DBG_CONTINUE" : "DBG_EXCEPTION_NOT_HANDLED"));
1172   res = ContinueDebugEvent (current_event.dwProcessId,
1173                             current_event.dwThreadId,
1174                             continue_status);
1175   continue_status = 0;
1176   if (res)
1177     for (th = &thread_head; (th = th->next) != NULL;)
1178       if (((id == -1) || (id == (int) th->id)) && th->suspend_count)
1179         {
1180
1181           for (i = 0; i < th->suspend_count; i++)
1182             (void) ResumeThread (th->h);
1183           th->suspend_count = 0;
1184           if (debug_registers_changed)
1185             {
1186               /* Only change the value of the debug reisters */
1187               th->context.ContextFlags = CONTEXT_DEBUG_REGISTERS;
1188               th->context.Dr0 = dr[0];
1189               th->context.Dr1 = dr[1];
1190               th->context.Dr2 = dr[2];
1191               th->context.Dr3 = dr[3];
1192               /* th->context.Dr6 = dr[6];
1193                  FIXME: should we set dr6 also ?? */
1194               th->context.Dr7 = dr[7];
1195               CHECK (SetThreadContext (th->h, &th->context));
1196               th->context.ContextFlags = 0;
1197             }
1198         }
1199
1200   debug_registers_changed = 0;
1201   return res;
1202 }
1203
1204 /* Get the next event from the child.  Return 1 if the event requires
1205    handling by WFI (or whatever).
1206  */
1207 static int
1208 get_child_debug_event (int pid, struct target_waitstatus *ourstatus)
1209 {
1210   BOOL debug_event;
1211   DWORD continue_status, event_code;
1212   thread_info *th = NULL;
1213   static thread_info dummy_thread_info;
1214   int retval = 0;
1215
1216   last_sig = TARGET_SIGNAL_0;
1217
1218   if (!(debug_event = WaitForDebugEvent (&current_event, 1000)))
1219     goto out;
1220
1221   event_count++;
1222   continue_status = DBG_CONTINUE;
1223
1224   event_code = current_event.dwDebugEventCode;
1225   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1226
1227   switch (event_code)
1228     {
1229     case CREATE_THREAD_DEBUG_EVENT:
1230       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
1231                      (unsigned) current_event.dwProcessId,
1232                      (unsigned) current_event.dwThreadId,
1233                      "CREATE_THREAD_DEBUG_EVENT"));
1234       if (saw_create != 1)
1235         break;
1236       /* Record the existence of this thread */
1237       th = child_add_thread (current_event.dwThreadId,
1238                              current_event.u.CreateThread.hThread);
1239       if (info_verbose)
1240         printf_unfiltered ("[New %s]\n",
1241                            target_pid_to_str (
1242                              pid_to_ptid (current_event.dwThreadId)));
1243       retval = current_event.dwThreadId;
1244       break;
1245
1246     case EXIT_THREAD_DEBUG_EVENT:
1247       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1248                      (unsigned) current_event.dwProcessId,
1249                      (unsigned) current_event.dwThreadId,
1250                      "EXIT_THREAD_DEBUG_EVENT"));
1251       if (saw_create != 1)
1252         break;
1253       child_delete_thread (current_event.dwThreadId);
1254       th = &dummy_thread_info;
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       main_thread_id = current_event.dwThreadId;
1271       /* Add the main thread */
1272 #if 0
1273       th = child_add_thread (current_event.dwProcessId,
1274                              current_event.u.CreateProcessInfo.hProcess);
1275 #endif
1276       th = child_add_thread (main_thread_id,
1277                              current_event.u.CreateProcessInfo.hThread);
1278       retval = ourstatus->value.related_pid = current_event.dwThreadId;
1279       break;
1280
1281     case EXIT_PROCESS_DEBUG_EVENT:
1282       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1283                      (unsigned) current_event.dwProcessId,
1284                      (unsigned) current_event.dwThreadId,
1285                      "EXIT_PROCESS_DEBUG_EVENT"));
1286       if (saw_create != 1)
1287         break;
1288       ourstatus->kind = TARGET_WAITKIND_EXITED;
1289       ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
1290       CloseHandle (current_process_handle);
1291       retval = main_thread_id;
1292       break;
1293
1294     case LOAD_DLL_DEBUG_EVENT:
1295       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1296                      (unsigned) current_event.dwProcessId,
1297                      (unsigned) current_event.dwThreadId,
1298                      "LOAD_DLL_DEBUG_EVENT"));
1299       CloseHandle (current_event.u.LoadDll.hFile);
1300       if (saw_create != 1)
1301         break;
1302       catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL);
1303       registers_changed ();     /* mark all regs invalid */
1304       ourstatus->kind = TARGET_WAITKIND_LOADED;
1305       ourstatus->value.integer = 0;
1306       retval = main_thread_id;
1307       re_enable_breakpoints_in_shlibs ();
1308       break;
1309
1310     case UNLOAD_DLL_DEBUG_EVENT:
1311       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1312                      (unsigned) current_event.dwProcessId,
1313                      (unsigned) current_event.dwThreadId,
1314                      "UNLOAD_DLL_DEBUG_EVENT"));
1315       if (saw_create != 1)
1316         break;
1317       catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL);
1318       registers_changed ();     /* mark all regs invalid */
1319       /* ourstatus->kind = TARGET_WAITKIND_UNLOADED;
1320          does not exist yet. */
1321       break;
1322
1323     case EXCEPTION_DEBUG_EVENT:
1324       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1325                      (unsigned) current_event.dwProcessId,
1326                      (unsigned) current_event.dwThreadId,
1327                      "EXCEPTION_DEBUG_EVENT"));
1328       if (saw_create != 1)
1329         break;
1330       if (handle_exception (ourstatus))
1331         retval = current_event.dwThreadId;
1332       break;
1333
1334     case OUTPUT_DEBUG_STRING_EVENT:     /* message from the kernel */
1335       DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
1336                      (unsigned) current_event.dwProcessId,
1337                      (unsigned) current_event.dwThreadId,
1338                      "OUTPUT_DEBUG_STRING_EVENT"));
1339       if (saw_create != 1)
1340         break;
1341       if (handle_output_debug_string (ourstatus))
1342         retval = main_thread_id;
1343       break;
1344
1345     default:
1346       if (saw_create != 1)
1347         break;
1348       printf_unfiltered ("gdb: kernel event for pid=%ld tid=%ld\n",
1349                          (DWORD) current_event.dwProcessId,
1350                          (DWORD) current_event.dwThreadId);
1351       printf_unfiltered ("                 unknown event code %ld\n",
1352                          current_event.dwDebugEventCode);
1353       break;
1354     }
1355
1356   if (!retval || saw_create != 1)
1357     CHECK (child_continue (continue_status, -1));
1358   else
1359     {
1360       current_thread = th ? : thread_rec (current_event.dwThreadId, TRUE);
1361       inferior_ptid = pid_to_ptid (retval);
1362     }
1363
1364 out:
1365   return retval;
1366 }
1367
1368 /* Wait for interesting events to occur in the target process. */
1369 static ptid_t
1370 child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
1371 {
1372   int pid = PIDGET (ptid);
1373
1374   /* We loop when we get a non-standard exception rather than return
1375      with a SPURIOUS because resume can try and step or modify things,
1376      which needs a current_thread->h.  But some of these exceptions mark
1377      the birth or death of threads, which mean that the current thread
1378      isn't necessarily what you think it is. */
1379
1380   while (1)
1381     {
1382       int retval = get_child_debug_event (pid, ourstatus);
1383       if (retval)
1384         return pid_to_ptid (retval);
1385       else
1386         {
1387           int detach = 0;
1388
1389           if (ui_loop_hook != NULL)
1390             detach = ui_loop_hook (0);
1391
1392           if (detach)
1393             child_kill_inferior ();
1394         }
1395     }
1396 }
1397
1398 static void
1399 do_initial_child_stuff (DWORD pid)
1400 {
1401   extern int stop_after_trap;
1402   int i;
1403
1404   last_sig = TARGET_SIGNAL_0;
1405   event_count = 0;
1406   exception_count = 0;
1407   debug_registers_changed = 0;
1408   debug_registers_used = 0;
1409   for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
1410     dr[i] = 0;
1411   current_event.dwProcessId = pid;
1412   memset (&current_event, 0, sizeof (current_event));
1413   push_target (&child_ops);
1414   child_init_thread_list ();
1415   disable_breakpoints_in_shlibs (1);
1416   child_clear_solibs ();
1417   clear_proceed_status ();
1418   init_wait_for_inferior ();
1419
1420   target_terminal_init ();
1421   target_terminal_inferior ();
1422
1423   while (1)
1424     {
1425       stop_after_trap = 1;
1426       wait_for_inferior ();
1427       if (stop_signal != TARGET_SIGNAL_TRAP)
1428         resume (0, stop_signal);
1429       else
1430         break;
1431     }
1432   stop_after_trap = 0;
1433   return;
1434 }
1435
1436 /* Since Windows XP, detaching from a process is supported by Windows.
1437    The following code tries loading the appropriate functions dynamically.
1438    If loading these functions succeeds use them to actually detach from
1439    the inferior process, otherwise behave as usual, pretending that
1440    detach has worked. */
1441 static BOOL WINAPI (*DebugSetProcessKillOnExit)(BOOL);
1442 static BOOL WINAPI (*DebugActiveProcessStop)(DWORD);
1443
1444 static int
1445 has_detach_ability (void)
1446 {
1447   static HMODULE kernel32 = NULL;
1448
1449   if (!kernel32)
1450     kernel32 = LoadLibrary ("kernel32.dll");
1451   if (kernel32)
1452     {
1453       if (!DebugSetProcessKillOnExit)
1454         DebugSetProcessKillOnExit = GetProcAddress (kernel32,
1455                                                  "DebugSetProcessKillOnExit");
1456       if (!DebugActiveProcessStop)
1457         DebugActiveProcessStop = GetProcAddress (kernel32,
1458                                                  "DebugActiveProcessStop");
1459       if (DebugSetProcessKillOnExit && DebugActiveProcessStop)
1460         return 1;
1461     }
1462   return 0;
1463 }
1464
1465 /* Try to set or remove a user privilege to the current process.  Return -1
1466    if that fails, the previous setting of that privilege otherwise.
1467
1468    This code is copied from the Cygwin source code and rearranged to allow
1469    dynamically loading of the needed symbols from advapi32 which is only
1470    available on NT/2K/XP. */
1471 static int
1472 set_process_privilege (const char *privilege, BOOL enable)
1473 {
1474   static HMODULE advapi32 = NULL;
1475   static BOOL WINAPI (*OpenProcessToken)(HANDLE, DWORD, PHANDLE);
1476   static BOOL WINAPI (*LookupPrivilegeValue)(LPCSTR, LPCSTR, PLUID);
1477   static BOOL WINAPI (*AdjustTokenPrivileges)(HANDLE, BOOL, PTOKEN_PRIVILEGES,
1478                                               DWORD, PTOKEN_PRIVILEGES, PDWORD);
1479
1480   HANDLE token_hdl = NULL;
1481   LUID restore_priv;
1482   TOKEN_PRIVILEGES new_priv, orig_priv;
1483   int ret = -1;
1484   DWORD size;
1485
1486   if (GetVersion () >= 0x80000000)  /* No security availbale on 9x/Me */
1487     return 0;
1488
1489   if (!advapi32)
1490     {
1491       if (!(advapi32 = LoadLibrary ("advapi32.dll")))
1492         goto out;
1493       if (!OpenProcessToken)
1494         OpenProcessToken = GetProcAddress (advapi32, "OpenProcessToken");
1495       if (!LookupPrivilegeValue)
1496         LookupPrivilegeValue = GetProcAddress (advapi32,
1497                                                "LookupPrivilegeValueA");
1498       if (!AdjustTokenPrivileges)
1499         AdjustTokenPrivileges = GetProcAddress (advapi32,
1500                                                 "AdjustTokenPrivileges");
1501       if (!OpenProcessToken || !LookupPrivilegeValue || !AdjustTokenPrivileges)
1502         {
1503           advapi32 = NULL;
1504           goto out;
1505         }
1506     }
1507
1508   if (!OpenProcessToken (GetCurrentProcess (),
1509                          TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
1510                          &token_hdl))
1511     goto out;
1512
1513   if (!LookupPrivilegeValue (NULL, privilege, &restore_priv))
1514     goto out;
1515
1516   new_priv.PrivilegeCount = 1;
1517   new_priv.Privileges[0].Luid = restore_priv;
1518   new_priv.Privileges[0].Attributes = enable ? SE_PRIVILEGE_ENABLED : 0;
1519
1520   if (!AdjustTokenPrivileges (token_hdl, FALSE, &new_priv,
1521                               sizeof orig_priv, &orig_priv, &size))
1522     goto out;
1523 #if 0
1524   /* Disabled, otherwise every `attach' in an unprivileged user session
1525      would raise the "Failed to get SE_DEBUG_NAME privilege" warning in
1526      child_attach(). */
1527   /* AdjustTokenPrivileges returns TRUE even if the privilege could not
1528      be enabled. GetLastError () returns an correct error code, though. */
1529   if (enable && GetLastError () == ERROR_NOT_ALL_ASSIGNED)
1530     goto out;
1531 #endif
1532
1533   ret = orig_priv.Privileges[0].Attributes == SE_PRIVILEGE_ENABLED ? 1 : 0;
1534
1535 out:
1536   if (token_hdl)
1537     CloseHandle (token_hdl);
1538
1539   return ret;
1540 }
1541
1542 /* Attach to process PID, then initialize for debugging it.  */
1543 static void
1544 child_attach (char *args, int from_tty)
1545 {
1546   BOOL ok;
1547   DWORD pid;
1548
1549   if (!args)
1550     error_no_arg ("process-id to attach");
1551
1552   if (set_process_privilege (SE_DEBUG_NAME, TRUE) < 0)
1553     {
1554       printf_unfiltered ("Warning: Failed to get SE_DEBUG_NAME privilege\n");
1555       printf_unfiltered ("This can cause attach to fail on Windows NT/2K/XP\n");
1556     }
1557
1558   pid = strtoul (args, 0, 0);           /* Windows pid */
1559
1560   ok = DebugActiveProcess (pid);
1561   saw_create = 0;
1562
1563   if (!ok)
1564     {
1565       /* Try fall back to Cygwin pid */
1566       pid = cygwin_internal (CW_CYGWIN_PID_TO_WINPID, pid);
1567
1568       if (pid > 0)
1569         ok = DebugActiveProcess (pid);
1570
1571       if (!ok)
1572         error ("Can't attach to process.");
1573     }
1574
1575   if (has_detach_ability ())
1576     {
1577       attach_flag = 1;
1578       DebugSetProcessKillOnExit (FALSE);
1579     }
1580
1581   if (from_tty)
1582     {
1583       char *exec_file = (char *) get_exec_file (0);
1584
1585       if (exec_file)
1586         printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
1587                            target_pid_to_str (pid_to_ptid (pid)));
1588       else
1589         printf_unfiltered ("Attaching to %s\n",
1590                            target_pid_to_str (pid_to_ptid (pid)));
1591
1592       gdb_flush (gdb_stdout);
1593     }
1594
1595   do_initial_child_stuff (pid);
1596   target_terminal_ours ();
1597 }
1598
1599 static void
1600 child_detach (char *args, int from_tty)
1601 {
1602   int detached = 1;
1603
1604   if (has_detach_ability ())
1605     {
1606       delete_command (NULL, 0);
1607       child_continue (DBG_CONTINUE, -1);
1608       if (!DebugActiveProcessStop (current_event.dwProcessId))
1609         {
1610           error ("Can't detach process %lu (error %lu)",
1611                  current_event.dwProcessId, GetLastError ());
1612           detached = 0;
1613         }
1614       DebugSetProcessKillOnExit (FALSE);
1615     }
1616   if (detached && from_tty)
1617     {
1618       char *exec_file = get_exec_file (0);
1619       if (exec_file == 0)
1620         exec_file = "";
1621       printf_unfiltered ("Detaching from program: %s, Pid %lu\n", exec_file,
1622                          current_event.dwProcessId);
1623       gdb_flush (gdb_stdout);
1624     }
1625   inferior_ptid = null_ptid;
1626   unpush_target (&child_ops);
1627 }
1628
1629 /* Print status information about what we're accessing.  */
1630
1631 static void
1632 child_files_info (struct target_ops *ignore)
1633 {
1634   printf_unfiltered ("\tUsing the running image of %s %s.\n",
1635       attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid));
1636 }
1637
1638 /* ARGSUSED */
1639 static void
1640 child_open (char *arg, int from_tty)
1641 {
1642   error ("Use the \"run\" command to start a Unix child process.");
1643 }
1644
1645 /* Start an inferior win32 child process and sets inferior_ptid to its pid.
1646    EXEC_FILE is the file to run.
1647    ALLARGS is a string containing the arguments to the program.
1648    ENV is the environment vector to pass.  Errors reported with error().  */
1649
1650 static void
1651 child_create_inferior (char *exec_file, char *allargs, char **env)
1652 {
1653   char *winenv;
1654   char *temp;
1655   int envlen;
1656   int i;
1657   STARTUPINFO si;
1658   PROCESS_INFORMATION pi;
1659   BOOL ret;
1660   DWORD flags;
1661   char *args;
1662   char real_path[MAXPATHLEN];
1663   char *toexec;
1664   char shell[MAX_PATH + 1]; /* Path to shell */
1665   const char *sh;
1666   int tty;
1667   int ostdin, ostdout, ostderr;
1668
1669   if (!exec_file)
1670     error ("No executable specified, use `target exec'.\n");
1671
1672   memset (&si, 0, sizeof (si));
1673   si.cb = sizeof (si);
1674
1675   if (!useshell)
1676     {
1677       flags = DEBUG_ONLY_THIS_PROCESS;
1678       cygwin_conv_to_win32_path (exec_file, real_path);
1679       toexec = real_path;
1680     }
1681   else
1682     {
1683       char *newallargs;
1684       sh = getenv ("SHELL");
1685       if (!sh)
1686         sh = "/bin/sh";
1687       cygwin_conv_to_win32_path (sh, shell);
1688       newallargs = alloca (sizeof (" -c 'exec  '") + strlen (exec_file)
1689                            + strlen (allargs) + 2);
1690       sprintf (newallargs, " -c 'exec %s %s'", exec_file, allargs);
1691       allargs = newallargs;
1692       toexec = shell;
1693       flags = DEBUG_PROCESS;
1694     }
1695
1696   if (new_group)
1697     flags |= CREATE_NEW_PROCESS_GROUP;
1698
1699   if (new_console)
1700     flags |= CREATE_NEW_CONSOLE;
1701
1702   args = alloca (strlen (toexec) + strlen (allargs) + 2);
1703   strcpy (args, toexec);
1704   strcat (args, " ");
1705   strcat (args, allargs);
1706
1707   /* Prepare the environment vars for CreateProcess.  */
1708   {
1709     /* This code used to assume all env vars were file names and would
1710        translate them all to win32 style.  That obviously doesn't work in the
1711        general case.  The current rule is that we only translate PATH.
1712        We need to handle PATH because we're about to call CreateProcess and
1713        it uses PATH to find DLL's.  Fortunately PATH has a well-defined value
1714        in both posix and win32 environments.  cygwin.dll will change it back
1715        to posix style if necessary.  */
1716
1717     static const char *conv_path_names[] =
1718     {
1719       "PATH=",
1720       0
1721     };
1722
1723     /* CreateProcess takes the environment list as a null terminated set of
1724        strings (i.e. two nulls terminate the list).  */
1725
1726     /* Get total size for env strings.  */
1727     for (envlen = 0, i = 0; env[i] && *env[i]; i++)
1728       {
1729         int j, len;
1730
1731         for (j = 0; conv_path_names[j]; j++)
1732           {
1733             len = strlen (conv_path_names[j]);
1734             if (strncmp (conv_path_names[j], env[i], len) == 0)
1735               {
1736                 if (cygwin_posix_path_list_p (env[i] + len))
1737                   envlen += len
1738                     + cygwin_posix_to_win32_path_list_buf_size (env[i] + len);
1739                 else
1740                   envlen += strlen (env[i]) + 1;
1741                 break;
1742               }
1743           }
1744         if (conv_path_names[j] == NULL)
1745           envlen += strlen (env[i]) + 1;
1746       }
1747
1748     winenv = alloca (envlen + 1);
1749
1750     /* Copy env strings into new buffer.  */
1751     for (temp = winenv, i = 0; env[i] && *env[i]; i++)
1752       {
1753         int j, len;
1754
1755         for (j = 0; conv_path_names[j]; j++)
1756           {
1757             len = strlen (conv_path_names[j]);
1758             if (strncmp (conv_path_names[j], env[i], len) == 0)
1759               {
1760                 if (cygwin_posix_path_list_p (env[i] + len))
1761                   {
1762                     memcpy (temp, env[i], len);
1763                     cygwin_posix_to_win32_path_list (env[i] + len, temp + len);
1764                   }
1765                 else
1766                   strcpy (temp, env[i]);
1767                 break;
1768               }
1769           }
1770         if (conv_path_names[j] == NULL)
1771           strcpy (temp, env[i]);
1772
1773         temp += strlen (temp) + 1;
1774       }
1775
1776     /* Final nil string to terminate new env.  */
1777     *temp = 0;
1778   }
1779
1780   if (!inferior_io_terminal)
1781     tty = ostdin = ostdout = ostderr = -1;
1782   else
1783     {
1784       tty = open (inferior_io_terminal, O_RDWR | O_NOCTTY);
1785       if (tty < 0)
1786         {
1787           print_sys_errmsg (inferior_io_terminal, errno);
1788           ostdin = ostdout = ostderr = -1;
1789         }
1790       else
1791         {
1792           ostdin = dup (0);
1793           ostdout = dup (1);
1794           ostderr = dup (2);
1795           dup2 (tty, 0);
1796           dup2 (tty, 1);
1797           dup2 (tty, 2);
1798         }
1799     }
1800
1801   ret = CreateProcess (0,
1802                        args,    /* command line */
1803                        NULL,    /* Security */
1804                        NULL,    /* thread */
1805                        TRUE,    /* inherit handles */
1806                        flags,   /* start flags */
1807                        winenv,
1808                        NULL,    /* current directory */
1809                        &si,
1810                        &pi);
1811   if (tty >= 0)
1812     {
1813       close (tty);
1814       dup2 (ostdin, 0);
1815       dup2 (ostdout, 1);
1816       dup2 (ostderr, 2);
1817       close (ostdin);
1818       close (ostdout);
1819       close (ostderr);
1820     }
1821
1822   if (!ret)
1823     error ("Error creating process %s, (error %d)\n", exec_file, (unsigned) GetLastError ());
1824
1825   CloseHandle (pi.hThread);
1826   CloseHandle (pi.hProcess);
1827
1828   if (useshell && shell[0] != '\0')
1829     saw_create = -1;
1830   else
1831     saw_create = 0;
1832
1833   do_initial_child_stuff (pi.dwProcessId);
1834
1835   /* child_continue (DBG_CONTINUE, -1); */
1836   proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_0, 0);
1837 }
1838
1839 static void
1840 child_mourn_inferior (void)
1841 {
1842   (void) child_continue (DBG_CONTINUE, -1);
1843   i386_cleanup_dregs();
1844   unpush_target (&child_ops);
1845   generic_mourn_inferior ();
1846 }
1847
1848 /* Send a SIGINT to the process group.  This acts just like the user typed a
1849    ^C on the controlling terminal. */
1850
1851 static void
1852 child_stop (void)
1853 {
1854   DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
1855   CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
1856   registers_changed ();         /* refresh register state */
1857 }
1858
1859 int
1860 child_xfer_memory (CORE_ADDR memaddr, char *our, int len,
1861                    int write, struct mem_attrib *mem,
1862                    struct target_ops *target)
1863 {
1864   DWORD done = 0;
1865   if (write)
1866     {
1867       DEBUG_MEM (("gdb: write target memory, %d bytes at 0x%08lx\n",
1868                   len, (DWORD) memaddr));
1869       if (!WriteProcessMemory (current_process_handle, (LPVOID) memaddr, our,
1870                                len, &done))
1871         done = 0;
1872       FlushInstructionCache (current_process_handle, (LPCVOID) memaddr, len);
1873     }
1874   else
1875     {
1876       DEBUG_MEM (("gdb: read target memory, %d bytes at 0x%08lx\n",
1877                   len, (DWORD) memaddr));
1878       if (!ReadProcessMemory (current_process_handle, (LPCVOID) memaddr, our,
1879                               len, &done))
1880         done = 0;
1881     }
1882   return done;
1883 }
1884
1885 void
1886 child_kill_inferior (void)
1887 {
1888   CHECK (TerminateProcess (current_process_handle, 0));
1889
1890   for (;;)
1891     {
1892       if (!child_continue (DBG_CONTINUE, -1))
1893         break;
1894       if (!WaitForDebugEvent (&current_event, INFINITE))
1895         break;
1896       if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
1897         break;
1898     }
1899
1900   CHECK (CloseHandle (current_process_handle));
1901
1902   /* this may fail in an attached process so don't check. */
1903   (void) CloseHandle (current_thread->h);
1904   target_mourn_inferior ();     /* or just child_mourn_inferior? */
1905 }
1906
1907 void
1908 child_resume (ptid_t ptid, int step, enum target_signal sig)
1909 {
1910   thread_info *th;
1911   DWORD continue_status = DBG_CONTINUE;
1912
1913   int pid = PIDGET (ptid);
1914
1915   if (sig != TARGET_SIGNAL_0)
1916     {
1917       if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
1918         {
1919           DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
1920         }
1921       else if (sig == last_sig)
1922         continue_status = DBG_EXCEPTION_NOT_HANDLED;
1923       else
1924 #if 0
1925 /* This code does not seem to work, because
1926   the kernel does probably not consider changes in the ExceptionRecord
1927   structure when passing the exception to the inferior.
1928   Note that this seems possible in the exception handler itself.  */
1929         {
1930           int i;
1931           for (i = 0; xlate[i].them != -1; i++)
1932             if (xlate[i].us == sig)
1933               {
1934                 current_event.u.Exception.ExceptionRecord.ExceptionCode =
1935                   xlate[i].them;
1936                 continue_status = DBG_EXCEPTION_NOT_HANDLED;
1937                 break;
1938               }
1939           if (continue_status == DBG_CONTINUE)
1940             {
1941               DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
1942             }
1943         }
1944 #endif
1945         DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
1946           last_sig));
1947     }
1948
1949   last_sig = TARGET_SIGNAL_0;
1950
1951   DEBUG_EXEC (("gdb: child_resume (pid=%d, step=%d, sig=%d);\n",
1952                pid, step, sig));
1953
1954   /* Get context for currently selected thread */
1955   th = thread_rec (current_event.dwThreadId, FALSE);
1956   if (th)
1957     {
1958       if (step)
1959         {
1960           /* Single step by setting t bit */
1961           child_fetch_inferior_registers (PS_REGNUM);
1962           th->context.EFlags |= FLAG_TRACE_BIT;
1963         }
1964
1965       if (th->context.ContextFlags)
1966         {
1967           if (debug_registers_changed)
1968             {
1969               th->context.Dr0 = dr[0];
1970               th->context.Dr1 = dr[1];
1971               th->context.Dr2 = dr[2];
1972               th->context.Dr3 = dr[3];
1973               /* th->context.Dr6 = dr[6];
1974                FIXME: should we set dr6 also ?? */
1975               th->context.Dr7 = dr[7];
1976             }
1977           CHECK (SetThreadContext (th->h, &th->context));
1978           th->context.ContextFlags = 0;
1979         }
1980     }
1981
1982   /* Allow continuing with the same signal that interrupted us.
1983      Otherwise complain. */
1984
1985   child_continue (continue_status, pid);
1986 }
1987
1988 static void
1989 child_prepare_to_store (void)
1990 {
1991   /* Do nothing, since we can store individual regs */
1992 }
1993
1994 static int
1995 child_can_run (void)
1996 {
1997   return 1;
1998 }
1999
2000 static void
2001 child_close (int x)
2002 {
2003   DEBUG_EVENTS (("gdb: child_close, inferior_ptid=%d\n",
2004                 PIDGET (inferior_ptid)));
2005 }
2006
2007 struct target_ops child_ops;
2008
2009 static void
2010 init_child_ops (void)
2011 {
2012   child_ops.to_shortname = "child";
2013   child_ops.to_longname = "Win32 child process";
2014   child_ops.to_doc = "Win32 child process (started by the \"run\" command).";
2015   child_ops.to_open = child_open;
2016   child_ops.to_close = child_close;
2017   child_ops.to_attach = child_attach;
2018   child_ops.to_detach = child_detach;
2019   child_ops.to_resume = child_resume;
2020   child_ops.to_wait = child_wait;
2021   child_ops.to_fetch_registers = child_fetch_inferior_registers;
2022   child_ops.to_store_registers = child_store_inferior_registers;
2023   child_ops.to_prepare_to_store = child_prepare_to_store;
2024   child_ops.to_xfer_memory = child_xfer_memory;
2025   child_ops.to_files_info = child_files_info;
2026   child_ops.to_insert_breakpoint = memory_insert_breakpoint;
2027   child_ops.to_remove_breakpoint = memory_remove_breakpoint;
2028   child_ops.to_terminal_init = terminal_init_inferior;
2029   child_ops.to_terminal_inferior = terminal_inferior;
2030   child_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2031   child_ops.to_terminal_ours = terminal_ours;
2032   child_ops.to_terminal_save_ours = terminal_save_ours;
2033   child_ops.to_terminal_info = child_terminal_info;
2034   child_ops.to_kill = child_kill_inferior;
2035   child_ops.to_create_inferior = child_create_inferior;
2036   child_ops.to_mourn_inferior = child_mourn_inferior;
2037   child_ops.to_can_run = child_can_run;
2038   child_ops.to_thread_alive = win32_child_thread_alive;
2039   child_ops.to_pid_to_str = cygwin_pid_to_str;
2040   child_ops.to_stop = child_stop;
2041   child_ops.to_stratum = process_stratum;
2042   child_ops.to_has_all_memory = 1;
2043   child_ops.to_has_memory = 1;
2044   child_ops.to_has_stack = 1;
2045   child_ops.to_has_registers = 1;
2046   child_ops.to_has_execution = 1;
2047   child_ops.to_magic = OPS_MAGIC;
2048 }
2049
2050 void
2051 _initialize_win32_nat (void)
2052 {
2053   struct cmd_list_element *c;
2054
2055   init_child_ops ();
2056
2057   c = add_com ("dll-symbols", class_files, dll_symbol_command,
2058                "Load dll library symbols from FILE.");
2059   set_cmd_completer (c, filename_completer);
2060
2061   add_com_alias ("sharedlibrary", "dll-symbols", class_alias, 1);
2062
2063   add_show_from_set (add_set_cmd ("shell", class_support, var_boolean,
2064                                   (char *) &useshell,
2065                  "Set use of shell to start subprocess.",
2066                                   &setlist),
2067                      &showlist);
2068
2069   add_show_from_set (add_set_cmd ("new-console", class_support, var_boolean,
2070                                   (char *) &new_console,
2071                  "Set creation of new console when creating child process.",
2072                                   &setlist),
2073                      &showlist);
2074
2075   add_show_from_set (add_set_cmd ("new-group", class_support, var_boolean,
2076                                   (char *) &new_group,
2077                    "Set creation of new group when creating child process.",
2078                                   &setlist),
2079                      &showlist);
2080
2081   add_show_from_set (add_set_cmd ("debugexec", class_support, var_boolean,
2082                                   (char *) &debug_exec,
2083                        "Set whether to display execution in child process.",
2084                                   &setlist),
2085                      &showlist);
2086
2087   add_show_from_set (add_set_cmd ("debugevents", class_support, var_boolean,
2088                                   (char *) &debug_events,
2089                    "Set whether to display kernel events in child process.",
2090                                   &setlist),
2091                      &showlist);
2092
2093   add_show_from_set (add_set_cmd ("debugmemory", class_support, var_boolean,
2094                                   (char *) &debug_memory,
2095                  "Set whether to display memory accesses in child process.",
2096                                   &setlist),
2097                      &showlist);
2098
2099   add_show_from_set (add_set_cmd ("debugexceptions", class_support, var_boolean,
2100                                   (char *) &debug_exceptions,
2101                "Set whether to display kernel exceptions in child process.",
2102                                   &setlist),
2103                      &showlist);
2104
2105   add_info ("dll", info_dll_command, "Status of loaded DLLs.");
2106   add_info_alias ("sharedlibrary", "dll", 1);
2107
2108   add_prefix_cmd ("w32", class_info, info_w32_command,
2109                   "Print information specific to Win32 debugging.",
2110                   &info_w32_cmdlist, "info w32 ", 0, &infolist);
2111
2112   add_cmd ("selector", class_info, display_selectors,
2113            "Display selectors infos.",
2114            &info_w32_cmdlist);
2115
2116   add_target (&child_ops);
2117 }
2118
2119 /* Hardware watchpoint support, adapted from go32-nat.c code.  */
2120
2121 /* Pass the address ADDR to the inferior in the I'th debug register.
2122    Here we just store the address in dr array, the registers will be
2123    actually set up when child_continue is called.  */
2124 void
2125 cygwin_set_dr (int i, CORE_ADDR addr)
2126 {
2127   if (i < 0 || i > 3)
2128     internal_error (__FILE__, __LINE__,
2129                     "Invalid register %d in cygwin_set_dr.\n", i);
2130   dr[i] = (unsigned) addr;
2131   debug_registers_changed = 1;
2132   debug_registers_used = 1;
2133 }
2134
2135 /* Pass the value VAL to the inferior in the DR7 debug control
2136    register.  Here we just store the address in D_REGS, the watchpoint
2137    will be actually set up in child_wait.  */
2138 void
2139 cygwin_set_dr7 (unsigned val)
2140 {
2141   dr[7] = val;
2142   debug_registers_changed = 1;
2143   debug_registers_used = 1;
2144 }
2145
2146 /* Get the value of the DR6 debug status register from the inferior.
2147    Here we just return the value stored in dr[6]
2148    by the last call to thread_rec for current_event.dwThreadId id.  */
2149 unsigned
2150 cygwin_get_dr6 (void)
2151 {
2152   return dr[6];
2153 }
2154
2155
2156 /* Determine if the thread referenced by "pid" is alive
2157    by "polling" it.  If WaitForSingleObject returns WAIT_OBJECT_0
2158    it means that the pid has died.  Otherwise it is assumed to be alive. */
2159 static int
2160 win32_child_thread_alive (ptid_t ptid)
2161 {
2162   int pid = PIDGET (ptid);
2163
2164   return WaitForSingleObject (thread_rec (pid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
2165     FALSE : TRUE;
2166 }
2167
2168 /* Convert pid to printable format. */
2169 char *
2170 cygwin_pid_to_str (ptid_t ptid)
2171 {
2172   static char buf[80];
2173   int pid = PIDGET (ptid);
2174
2175   if ((DWORD) pid == current_event.dwProcessId)
2176     sprintf (buf, "process %d", pid);
2177   else
2178     sprintf (buf, "thread %ld.0x%x", current_event.dwProcessId, pid);
2179   return buf;
2180 }
2181
2182 static int
2183 core_dll_symbols_add (char *dll_name, DWORD base_addr)
2184 {
2185   struct objfile *objfile;
2186   char *objfile_basename;
2187   const char *dll_basename;
2188
2189   if (!(dll_basename = strrchr (dll_name, '/')))
2190     dll_basename = dll_name;
2191   else
2192     dll_basename++;
2193
2194   ALL_OBJFILES (objfile)
2195   {
2196     objfile_basename = strrchr (objfile->name, '/');
2197
2198     if (objfile_basename &&
2199         strcmp (dll_basename, objfile_basename + 1) == 0)
2200       {
2201         printf_unfiltered ("%08lx:%s (symbols previously loaded)\n",
2202                            base_addr, dll_name);
2203         goto out;
2204       }
2205   }
2206
2207   register_loaded_dll (dll_name, base_addr + 0x1000);
2208   solib_symbols_add (dll_name, 0, (CORE_ADDR) base_addr + 0x1000);
2209
2210 out:
2211   return 1;
2212 }
2213
2214 typedef struct
2215 {
2216   struct target_ops *target;
2217   bfd_vma addr;
2218 }
2219 map_code_section_args;
2220
2221 static void
2222 map_single_dll_code_section (bfd * abfd, asection * sect, void *obj)
2223 {
2224   int old;
2225   int update_coreops;
2226   struct section_table *new_target_sect_ptr;
2227
2228   map_code_section_args *args = (map_code_section_args *) obj;
2229   struct target_ops *target = args->target;
2230   if (sect->flags & SEC_CODE)
2231     {
2232       update_coreops = core_ops.to_sections == target->to_sections;
2233
2234       if (target->to_sections)
2235         {
2236           old = target->to_sections_end - target->to_sections;
2237           target->to_sections = (struct section_table *)
2238             xrealloc ((char *) target->to_sections,
2239                       (sizeof (struct section_table)) * (1 + old));
2240         }
2241       else
2242         {
2243           old = 0;
2244           target->to_sections = (struct section_table *)
2245             xmalloc ((sizeof (struct section_table)));
2246         }
2247       target->to_sections_end = target->to_sections + (1 + old);
2248
2249       /* Update the to_sections field in the core_ops structure
2250          if needed.  */
2251       if (update_coreops)
2252         {
2253           core_ops.to_sections = target->to_sections;
2254           core_ops.to_sections_end = target->to_sections_end;
2255         }
2256       new_target_sect_ptr = target->to_sections + old;
2257       new_target_sect_ptr->addr = args->addr + bfd_section_vma (abfd, sect);
2258       new_target_sect_ptr->endaddr = args->addr + bfd_section_vma (abfd, sect) +
2259         bfd_section_size (abfd, sect);;
2260       new_target_sect_ptr->the_bfd_section = sect;
2261       new_target_sect_ptr->bfd = abfd;
2262     }
2263 }
2264
2265 static int
2266 dll_code_sections_add (const char *dll_name, int base_addr, struct target_ops *target)
2267 {
2268   bfd *dll_bfd;
2269   map_code_section_args map_args;
2270   asection *lowest_sect;
2271   char *name;
2272   if (dll_name == NULL || target == NULL)
2273     return 0;
2274   name = xstrdup (dll_name);
2275   dll_bfd = bfd_openr (name, "pei-i386");
2276   if (dll_bfd == NULL)
2277     return 0;
2278
2279   if (bfd_check_format (dll_bfd, bfd_object))
2280     {
2281       lowest_sect = bfd_get_section_by_name (dll_bfd, ".text");
2282       if (lowest_sect == NULL)
2283         return 0;
2284       map_args.target = target;
2285       map_args.addr = base_addr - bfd_section_vma (dll_bfd, lowest_sect);
2286
2287       bfd_map_over_sections (dll_bfd, &map_single_dll_code_section, (void *) (&map_args));
2288     }
2289
2290   return 1;
2291 }
2292
2293 static void
2294 core_section_load_dll_symbols (bfd * abfd, asection * sect, void *obj)
2295 {
2296   struct target_ops *target = (struct target_ops *) obj;
2297
2298   DWORD base_addr;
2299
2300   int dll_name_size;
2301   char *dll_name = NULL;
2302   char *buf = NULL;
2303   struct win32_pstatus *pstatus;
2304   char *p;
2305
2306   if (strncmp (sect->name, ".module", 7))
2307     return;
2308
2309   buf = (char *) xmalloc (sect->_raw_size + 1);
2310   if (!buf)
2311     {
2312       printf_unfiltered ("memory allocation failed for %s\n", sect->name);
2313       goto out;
2314     }
2315   if (!bfd_get_section_contents (abfd, sect, buf, 0, sect->_raw_size))
2316     goto out;
2317
2318   pstatus = (struct win32_pstatus *) buf;
2319
2320   memmove (&base_addr, &(pstatus->data.module_info.base_address), sizeof (base_addr));
2321   dll_name_size = pstatus->data.module_info.module_name_size;
2322   if (offsetof (struct win32_pstatus, data.module_info.module_name) + dll_name_size > sect->_raw_size)
2323       goto out;
2324
2325   dll_name = (char *) xmalloc (dll_name_size + 1);
2326   if (!dll_name)
2327     {
2328       printf_unfiltered ("memory allocation failed for %s\n", sect->name);
2329       goto out;
2330     }
2331   strncpy (dll_name, pstatus->data.module_info.module_name, dll_name_size);
2332
2333   while ((p = strchr (dll_name, '\\')))
2334     *p = '/';
2335
2336   if (!core_dll_symbols_add (dll_name, (DWORD) base_addr))
2337     printf_unfiltered ("%s: Failed to load dll symbols.\n", dll_name);
2338
2339   if (!dll_code_sections_add (dll_name, (DWORD) base_addr + 0x1000, target))
2340     printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name);
2341
2342 out:
2343   if (buf)
2344     xfree (buf);
2345   if (dll_name)
2346     xfree (dll_name);
2347   return;
2348 }
2349
2350 void
2351 child_solib_add (char *filename, int from_tty, struct target_ops *target,
2352                  int readsyms)
2353 {
2354   if (!readsyms)
2355     return;
2356   if (core_bfd)
2357     {
2358       child_clear_solibs ();
2359       bfd_map_over_sections (core_bfd, &core_section_load_dll_symbols, target);
2360     }
2361   else
2362     {
2363       if (solib_end && solib_end->name)
2364              solib_end->objfile = solib_symbols_add (solib_end->name, from_tty,
2365                                                 solib_end->load_addr);
2366     }
2367 }
2368
2369 static void
2370 fetch_elf_core_registers (char *core_reg_sect,
2371                           unsigned core_reg_size,
2372                           int which,
2373                           CORE_ADDR reg_addr)
2374 {
2375   int r;
2376   if (core_reg_size < sizeof (CONTEXT))
2377     {
2378       error ("Core file register section too small (%u bytes).", core_reg_size);
2379       return;
2380     }
2381   for (r = 0; r < NUM_REGS; r++)
2382     supply_register (r, core_reg_sect + mappings[r]);
2383 }
2384
2385 static struct core_fns win32_elf_core_fns =
2386 {
2387   bfd_target_elf_flavour,
2388   default_check_format,
2389   default_core_sniffer,
2390   fetch_elf_core_registers,
2391   NULL
2392 };
2393
2394 void
2395 _initialize_core_win32 (void)
2396 {
2397   add_core_fns (&win32_elf_core_fns);
2398 }
2399
2400 void
2401 _initialize_check_for_gdb_ini (void)
2402 {
2403   char *homedir;
2404   if (inhibit_gdbinit)
2405     return;
2406
2407   homedir = getenv ("HOME");
2408   if (homedir)
2409     {
2410       char *p;
2411       char *oldini = (char *) alloca (strlen (homedir) +
2412                                       sizeof ("/gdb.ini"));
2413       strcpy (oldini, homedir);
2414       p = strchr (oldini, '\0');
2415       if (p > oldini && p[-1] != '/')
2416         *p++ = '/';
2417       strcpy (p, "gdb.ini");
2418       if (access (oldini, 0) == 0)
2419         {
2420           int len = strlen (oldini);
2421           char *newini = alloca (len + 1);
2422           sprintf (newini, "%.*s.gdbinit",
2423             (int) (len - (sizeof ("gdb.ini") - 1)), oldini);
2424           warning ("obsolete '%s' found. Rename to '%s'.", oldini, newini);
2425         }
2426     }
2427 }