gdb/windows-nat.c

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