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