gdb/win32-nat.c

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