/* Target-vector operations for controlling win32 child processes, for GDB.
- Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+ Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+ 2005, 2006
Free Software Foundation, Inc.
Contributed by Cygnus Solutions, A Red Hat Company.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
/* Originally by Steve Chamberlain, sac@cygnus.com */
#include <windows.h>
#include <imagehlp.h>
#include <sys/cygwin.h>
+#include <signal.h>
#include "buildsym.h"
#include "symfile.h"
#include <unistd.h>
#include "exec.h"
#include "solist.h"
+#include "solib.h"
#include "i386-tdep.h"
#include "i387-tdep.h"
static struct target_ops win32_ops;
static struct target_so_ops win32_so_ops;
+/* The starting and ending address of the cygwin1.dll text segment. */
+static bfd_vma cygwin_load_start;
+static bfd_vma cygwin_load_end;
+
+static int have_saved_context; /* True if we've saved context from a cygwin signal. */
+static CONTEXT saved_context; /* Containes the saved context from a cygwin signal. */
+
/* If we're not using the old Cygwin header file set, define the
following which never should have been in the generic Win32 API
headers in the first place since they were our own invention... */
/* The string sent by cygwin when it processes a signal.
FIXME: This should be in a cygwin include file. */
-#define CYGWIN_SIGNAL_STRING "cygwin: signal"
+#ifndef _CYGWIN_SIGNAL_STRING
+#define _CYGWIN_SIGNAL_STRING "cYgSiGw00f"
+#endif
#define CHECK(x) check (x, __FILE__,__LINE__)
#define DEBUG_EXEC(x) if (debug_exec) printf_unfiltered x
if ((th = thread_rec (id, FALSE)))
return th;
- th = (thread_info *) xmalloc (sizeof (*th));
- memset (th, 0, sizeof (*th));
+ th = XZALLOC (thread_info);
th->id = id;
th->h = h;
th->next = thread_head.next;
if (current_thread->reload_context)
{
- thread_info *th = current_thread;
- th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
- GetThreadContext (th->h, &th->context);
- /* Copy dr values from that thread. */
- dr[0] = th->context.Dr0;
- dr[1] = th->context.Dr1;
- dr[2] = th->context.Dr2;
- dr[3] = th->context.Dr3;
- dr[6] = th->context.Dr6;
- dr[7] = th->context.Dr7;
+ if (have_saved_context)
+ {
+ /* Lie about where the program actually is stopped since cygwin has informed us that
+ we should consider the signal to have occurred at another location which is stored
+ in "saved_context. */
+ memcpy (¤t_thread->context, &saved_context, __COPY_CONTEXT_SIZE);
+ have_saved_context = 0;
+ }
+ else
+ {
+ thread_info *th = current_thread;
+ th->context.ContextFlags = CONTEXT_DEBUGGER_DR;
+ GetThreadContext (th->h, &th->context);
+ /* Copy dr values from that thread. */
+ dr[0] = th->context.Dr0;
+ dr[1] = th->context.Dr1;
+ dr[2] = th->context.Dr2;
+ dr[3] = th->context.Dr3;
+ dr[6] = th->context.Dr6;
+ dr[7] = th->context.Dr7;
+ }
current_thread->reload_context = 0;
}
struct objfile *ret;
};
-/*CGF*/
/* Maintain a linked list of "so" information. */
struct lm_info
{
DWORD load_addr;
- DWORD end_addr;
};
static struct so_list solib_start, *solib_end;
return p.ret;
}
-/* Remember the maximum DLL length for printing in info dll command. */
-static int max_dll_name_len;
+/* Get the loaded address of all sections, given that .text was loaded
+ at text_load. Assumes that all sections are subject to the same
+ relocation offset. Returns NULL if problems occur or if the
+ sections were not relocated. */
+
+static struct section_addr_info *
+get_relocated_section_addrs (bfd *abfd, CORE_ADDR text_load)
+{
+ struct section_addr_info *result = NULL;
+ int section_count = bfd_count_sections (abfd);
+ asection *text_section = bfd_get_section_by_name (abfd, ".text");
+ CORE_ADDR text_vma;
+
+ if (!text_section)
+ {
+ /* Couldn't get the .text section. Weird. */
+ }
+ else if (text_load == (text_vma = bfd_get_section_vma (abfd, text_section)))
+ {
+ /* DLL wasn't relocated. */
+ }
+ else
+ {
+ /* Figure out all sections' loaded addresses. The offset here is
+ such that taking a bfd_get_section_vma() result and adding
+ offset will give the real load address of the section. */
+
+ CORE_ADDR offset = text_load - text_vma;
+
+ struct section_table *table_start = NULL;
+ struct section_table *table_end = NULL;
+ struct section_table *iter = NULL;
+
+ build_section_table (abfd, &table_start, &table_end);
+
+ for (iter = table_start; iter < table_end; ++iter)
+ {
+ /* Relocated addresses. */
+ iter->addr += offset;
+ iter->endaddr += offset;
+ }
+
+ result = build_section_addr_info_from_section_table (table_start,
+ table_end);
+ xfree (table_start);
+ }
+
+ return result;
+}
+
+/* Add DLL symbol information. */
static void
-register_loaded_dll (const char *name, DWORD load_addr)
+solib_symbols_add (struct so_list *so, CORE_ADDR load_addr)
+{
+ struct section_addr_info *addrs = NULL;
+ static struct objfile *result = NULL;
+ char *name = so->so_name;
+ bfd *abfd = NULL;
+ char *p;
+
+ /* The symbols in a dll are offset by 0x1000, which is the
+ the offset from 0 of the first byte in an image - because
+ of the file header and the section alignment. */
+
+ if (!name || !name[0])
+ return;
+
+ abfd = bfd_openr (name, "pei-i386");
+
+ if (!abfd)
+ {
+ /* pei failed - try pe */
+ abfd = bfd_openr (name, "pe-i386");
+ }
+
+ if (abfd)
+ {
+ if (bfd_check_format (abfd, bfd_object))
+ addrs = get_relocated_section_addrs (abfd, load_addr);
+ }
+
+ if (addrs)
+ {
+ result = safe_symbol_file_add (name, 0, addrs, 0, OBJF_SHARED);
+ free_section_addr_info (addrs);
+ }
+ else
+ {
+ /* Fallback on handling just the .text section. */
+ struct cleanup *my_cleanups;
+
+ addrs = alloc_section_addr_info (1);
+ my_cleanups = make_cleanup (xfree, addrs);
+ addrs->other[0].name = ".text";
+ addrs->other[0].addr = load_addr;
+
+ result = safe_symbol_file_add (name, 0, addrs, 0, OBJF_SHARED);
+ do_cleanups (my_cleanups);
+ }
+
+ p = strchr (so->so_name, '\0') - (sizeof ("/cygwin1.dll") - 1);
+ if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0)
+ {
+ asection *text = bfd_get_section_by_name (abfd, ".text");
+ cygwin_load_start = bfd_section_vma (abfd, text);
+ cygwin_load_end = cygwin_load_start + bfd_section_size (abfd, text);
+ }
+
+ bfd_close (abfd);
+
+ so->symbols_loaded = !!result;
+ return;
+}
+
+static char *
+register_loaded_dll (const char *name, DWORD load_addr, int readsyms)
{
struct so_list *so;
- char ppath[MAX_PATH + 1];
char buf[MAX_PATH + 1];
char cwd[MAX_PATH + 1];
char *p;
GetSystemDirectory (buf, sizeof (buf));
strcat (buf, "\\ntdll.dll");
}
- cygwin_conv_to_posix_path (buf, ppath);
- so = (struct so_list *) xmalloc (sizeof (struct so_list) + strlen (ppath) + 8 + 1);
- memset (so, 0, sizeof (*so));
+ so = XZALLOC (struct so_list);
so->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info));
so->lm_info->load_addr = load_addr;
- if (VirtualQueryEx (current_process_handle, (void *) load_addr, &m,
- sizeof (m)))
- so->lm_info->end_addr = (DWORD) m.AllocationBase + m.RegionSize;
- else
- so->lm_info->end_addr = load_addr + 0x2000; /* completely arbitrary */
-
- so->next = NULL;
- strcpy (so->so_name, ppath);
+ cygwin_conv_to_posix_path (buf, so->so_name);
+ strcpy (so->so_original_name, so->so_name);
solib_end->next = so;
solib_end = so;
- len = strlen (ppath);
- if (len > max_dll_name_len)
- max_dll_name_len = len;
+ len = strlen (so->so_name);
+ if (readsyms)
+ solib_symbols_add (so, (CORE_ADDR) load_addr);
+
+ return so->so_name;
}
static char *
LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
char dll_buf[MAX_PATH + 1];
char *dll_name = NULL;
- char *p;
dll_buf[0] = dll_buf[sizeof (dll_buf) - 1] = '\0';
if (!dll_name)
return 1;
- register_loaded_dll (dll_name, (DWORD) event->lpBaseOfDll + 0x1000);
+ register_loaded_dll (dll_name, (DWORD) event->lpBaseOfDll + 0x1000, auto_solib_add);
return 1;
}
static void
win32_free_so (struct so_list *so)
{
- if (so->objfile)
- free_objfile (so->objfile);
if (so->lm_info)
xfree (so->lm_info);
}
-static struct so_list *
-win32_current_sos (void)
-{
- return solib_start.next;
-}
-
static void
win32_relocate_section_addresses (struct so_list *so,
struct section_table *sec)
return;
}
+static void
+win32_solib_create_inferior_hook (void)
+{
+ solib_add (NULL, 0, NULL, auto_solib_add);
+ return;
+}
+
static int
handle_unload_dll (void *dummy)
{
if (!so->next)
solib_end = so;
free_so (sodel);
+ solib_add (NULL, 0, NULL, auto_solib_add);
return 1;
}
+
error (_("Error: dll starting at 0x%lx not found."), (DWORD) lpBaseOfDll);
return 0;
static void
win32_clear_solib (void)
{
- struct so_list *so, *so1 = solib_start.next;
-
solib_start.next = NULL;
solib_end = &solib_start;
- max_dll_name_len = sizeof ("DLL Name") - 1;
+}
+
+static void
+win32_special_symbol_handling (void)
+{
+ return;
}
/* Load DLL symbol info. */
safe_symbol_file_add (args, from_tty, NULL, 0, OBJF_SHARED | OBJF_USERLOADED);
}
-/* List currently loaded DLLs. */
-static void
-info_dll_command (char *ignore, int from_tty)
-{
- struct so_list *so = &solib_start;
-
- if (!so->next)
- return;
-
- printf_filtered ("%*s Load Address\n", -max_dll_name_len, "DLL Name");
- while ((so = so->next) != NULL)
- printf_filtered ("%*s %08lx\n", -max_dll_name_len, so->so_name, so->lm_info->load_addr);
-
- return;
-}
-
/* Handle DEBUG_STRING output from child process.
Cygwin prepends its messages with a "cygwin:". Interpret this as
a Cygwin signal. Otherwise just print the string as a warning. */
static int
handle_output_debug_string (struct target_waitstatus *ourstatus)
{
- char *s;
- int gotasig = FALSE;
+ char *s = NULL;
+ int retval = 0;
if (!target_read_string
((CORE_ADDR) current_event.u.DebugString.lpDebugStringData, &s, 1024, 0)
|| !s || !*s)
- return gotasig;
-
- if (strncmp (s, CYGWIN_SIGNAL_STRING, sizeof (CYGWIN_SIGNAL_STRING) - 1) != 0)
+ /* nothing to do */;
+ else if (strncmp (s, _CYGWIN_SIGNAL_STRING, sizeof (_CYGWIN_SIGNAL_STRING) - 1) != 0)
{
if (strncmp (s, "cYg", 3) != 0)
warning (("%s"), s);
}
else
{
+ /* Got a cygwin signal marker. A cygwin signal is followed by the signal number
+ itself and then optionally followed by the thread id and address to saved context
+ within the DLL. If these are supplied, then the given thread is assumed to have
+ issued the signal and the context from the thread is assumed to be stored at the
+ given address in the inferior. Tell gdb to treat this like a real signal. */
char *p;
- int sig = strtol (s + sizeof (CYGWIN_SIGNAL_STRING) - 1, &p, 0);
- gotasig = target_signal_from_host (sig);
+ int sig = strtol (s + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0);
+ int gotasig = target_signal_from_host (sig);
ourstatus->value.sig = gotasig;
if (gotasig)
- ourstatus->kind = TARGET_WAITKIND_STOPPED;
+ {
+ LPCVOID x;
+ DWORD n;
+ ourstatus->kind = TARGET_WAITKIND_STOPPED;
+ retval = strtoul (p, &p, 0);
+ if (!retval)
+ retval = main_thread_id;
+ else if ((x = (LPCVOID) strtoul (p, &p, 0))
+ && ReadProcessMemory (current_process_handle, x,
+ &saved_context, __COPY_CONTEXT_SIZE, &n)
+ && n == __COPY_CONTEXT_SIZE)
+ have_saved_context = 1;
+ current_event.dwThreadId = retval;
+ }
}
- xfree (s);
- return gotasig;
+ if (s)
+ xfree (s);
+ return retval;
}
static int
DEBUG_EXCEPTION_SIMPLE ("EXCEPTION_ACCESS_VIOLATION");
ourstatus->value.sig = TARGET_SIGNAL_SEGV;
{
+ /* See if the access violation happened within the cygwin DLL itself. Cygwin uses
+ a kind of exception handling to deal with passed-in invalid addresses. gdb
+ should not treat these as real SEGVs since they will be silently handled by
+ cygwin. A real SEGV will (theoretically) be caught by cygwin later in the process
+ and will be sent as a cygwin-specific-signal. So, ignore SEGVs if they show up
+ within the text segment of the DLL itself. */
char *fn;
- if (find_pc_partial_function ((CORE_ADDR) current_event.u.Exception
- .ExceptionRecord.ExceptionAddress,
- &fn, NULL, NULL)
- && strncmp (fn, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0)
+ bfd_vma addr = (bfd_vma) current_event.u.Exception.ExceptionRecord.ExceptionAddress;
+ if ((addr >= cygwin_load_start && addr < cygwin_load_end)
+ || (find_pc_partial_function (addr, &fn, NULL, NULL)
+ && strncmp (fn, "KERNEL32!IsBad", strlen ("KERNEL32!IsBad")) == 0))
return 0;
}
break;
ourstatus->value.sig = TARGET_SIGNAL_ILL;
break;
default:
+ /* Treat unhandled first chance exceptions specially. */
if (current_event.u.Exception.dwFirstChance)
- return 0;
+ return -1;
printf_unfiltered ("gdb: unknown target exception 0x%08lx at 0x%08lx\n",
current_event.u.Exception.ExceptionRecord.ExceptionCode,
(DWORD) current_event.u.Exception.ExceptionRecord.ExceptionAddress);
res = ContinueDebugEvent (current_event.dwProcessId,
current_event.dwThreadId,
continue_status);
- continue_status = 0;
if (res)
for (th = &thread_head; (th = th->next) != NULL;)
if (((id == -1) || (id == (int) th->id)) && th->suspend_count)
return main_thread_id;
}
+static void
+win32_resume (ptid_t ptid, int step, enum target_signal sig)
+{
+ thread_info *th;
+ DWORD continue_status = DBG_CONTINUE;
+
+ int pid = PIDGET (ptid);
+
+ if (sig != TARGET_SIGNAL_0)
+ {
+ if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
+ {
+ DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
+ }
+ else if (sig == last_sig)
+ continue_status = DBG_EXCEPTION_NOT_HANDLED;
+ else
+#if 0
+/* This code does not seem to work, because
+ the kernel does probably not consider changes in the ExceptionRecord
+ structure when passing the exception to the inferior.
+ Note that this seems possible in the exception handler itself. */
+ {
+ int i;
+ for (i = 0; xlate[i].them != -1; i++)
+ if (xlate[i].us == sig)
+ {
+ current_event.u.Exception.ExceptionRecord.ExceptionCode =
+ xlate[i].them;
+ continue_status = DBG_EXCEPTION_NOT_HANDLED;
+ break;
+ }
+ if (continue_status == DBG_CONTINUE)
+ {
+ DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
+ }
+ }
+#endif
+ DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
+ last_sig));
+ }
+
+ last_sig = TARGET_SIGNAL_0;
+
+ DEBUG_EXEC (("gdb: win32_resume (pid=%d, step=%d, sig=%d);\n",
+ pid, step, sig));
+
+ /* Get context for currently selected thread */
+ th = thread_rec (current_event.dwThreadId, FALSE);
+ if (th)
+ {
+ if (step)
+ {
+ /* Single step by setting t bit */
+ win32_fetch_inferior_registers (PS_REGNUM);
+ th->context.EFlags |= FLAG_TRACE_BIT;
+ }
+
+ if (th->context.ContextFlags)
+ {
+ if (debug_registers_changed)
+ {
+ th->context.Dr0 = dr[0];
+ th->context.Dr1 = dr[1];
+ th->context.Dr2 = dr[2];
+ th->context.Dr3 = dr[3];
+ /* th->context.Dr6 = dr[6];
+ FIXME: should we set dr6 also ?? */
+ th->context.Dr7 = dr[7];
+ }
+ CHECK (SetThreadContext (th->h, &th->context));
+ th->context.ContextFlags = 0;
+ }
+ }
+
+ /* Allow continuing with the same signal that interrupted us.
+ Otherwise complain. */
+
+ win32_continue (continue_status, pid);
+}
+
/* Get the next event from the child. Return 1 if the event requires
handling by WFI (or whatever).
*/
thread_info *th;
static thread_info dummy_thread_info;
int retval = 0;
+ ptid_t ptid = {-1};
last_sig = TARGET_SIGNAL_0;
event_code = current_event.dwDebugEventCode;
ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
th = NULL;
+ have_saved_context = 0;
switch (event_code)
{
"EXCEPTION_DEBUG_EVENT"));
if (saw_create != 1)
break;
- if (handle_exception (ourstatus))
- retval = current_event.dwThreadId;
- else
- continue_status = DBG_EXCEPTION_NOT_HANDLED;
+ switch (handle_exception (ourstatus))
+ {
+ case 0:
+ continue_status = DBG_EXCEPTION_NOT_HANDLED;
+ break;
+ case 1:
+ retval = current_event.dwThreadId;
+ break;
+ case -1:
+ last_sig = 1;
+ continue_status = -1;
+ break;
+ }
break;
case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */
"OUTPUT_DEBUG_STRING_EVENT"));
if (saw_create != 1)
break;
- if (handle_output_debug_string (ourstatus))
- retval = main_thread_id;
+ retval = handle_output_debug_string (ourstatus);
break;
default:
}
if (!retval || saw_create != 1)
- CHECK (win32_continue (continue_status, -1));
+ {
+ if (continue_status == -1)
+ win32_resume (ptid, 0, 1);
+ else
+ CHECK (win32_continue (continue_status, -1));
+ }
else
{
inferior_ptid = pid_to_ptid (retval);
cygwin_internal (CW_LOCK_PINFO, 1000);
for (cpid = 0;
(pinfo = (struct external_pinfo *)
- cygwin_internal (CW_GETPINFO, cpid | CW_NEXTPID));
+ cygwin_internal (CW_GETPINFO, cpid | CW_NEXTPID));
cpid = pinfo->pid)
{
if (pinfo->dwProcessId == current_event.dwProcessId) /* Got it */
{
- cygwin_conv_to_full_posix_path (pinfo->progname, path);
- path_ptr = path;
- break;
+ cygwin_conv_to_full_posix_path (pinfo->progname, path);
+ path_ptr = path;
+ break;
}
}
cygwin_internal (CW_UNLOCK_PINFO);
- return path_ptr;
+ return path_ptr;
}
/* Print status information about what we're accessing. */
error (_("Use the \"run\" command to start a Unix child process."));
}
+/* Function called by qsort to sort environment strings. */
+static int
+env_sort (const void *a, const void *b)
+{
+ const char **p = (const char **) a;
+ const char **q = (const char **) b;
+ return strcasecmp (*p, *q);
+}
+
/* Start an inferior win32 child process and sets inferior_ptid to its pid.
EXEC_FILE is the file to run.
ALLARGS is a string containing the arguments to the program.
ENV is the environment vector to pass. Errors reported with error(). */
static void
-win32_create_inferior (char *exec_file, char *allargs, char **env,
+win32_create_inferior (char *exec_file, char *allargs, char **in_env,
int from_tty)
{
char *winenv;
strings (i.e. two nulls terminate the list). */
/* Get total size for env strings. */
- for (envlen = 0, i = 0; env[i] && *env[i]; i++)
+ for (envlen = 0, i = 0; in_env[i] && *in_env[i]; i++)
{
int j, len;
for (j = 0; conv_path_names[j]; j++)
{
len = strlen (conv_path_names[j]);
- if (strncmp (conv_path_names[j], env[i], len) == 0)
+ if (strncmp (conv_path_names[j], in_env[i], len) == 0)
{
- if (cygwin_posix_path_list_p (env[i] + len))
+ if (cygwin_posix_path_list_p (in_env[i] + len))
envlen += len
- + cygwin_posix_to_win32_path_list_buf_size (env[i] + len);
+ + cygwin_posix_to_win32_path_list_buf_size (in_env[i] + len);
else
- envlen += strlen (env[i]) + 1;
+ envlen += strlen (in_env[i]) + 1;
break;
}
}
if (conv_path_names[j] == NULL)
- envlen += strlen (env[i]) + 1;
+ envlen += strlen (in_env[i]) + 1;
}
+ size_t envsize = sizeof (in_env[0]) * (i + 1);
+ char **env = (char **) alloca (envsize);
+ memcpy (env, in_env, envsize);
+ /* Windows programs expect the environment block to be sorted. */
+ qsort (env, i, sizeof (char *), env_sort);
+
winenv = alloca (envlen + 1);
/* Copy env strings into new buffer. */
do_initial_win32_stuff (pi.dwProcessId);
/* win32_continue (DBG_CONTINUE, -1); */
- proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_0, 0);
}
static void
target_mourn_inferior (); /* or just win32_mourn_inferior? */
}
-static void
-win32_resume (ptid_t ptid, int step, enum target_signal sig)
-{
- thread_info *th;
- DWORD continue_status = DBG_CONTINUE;
-
- int pid = PIDGET (ptid);
-
- if (sig != TARGET_SIGNAL_0)
- {
- if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
- {
- DEBUG_EXCEPT(("Cannot continue with signal %d here.\n",sig));
- }
- else if (sig == last_sig)
- continue_status = DBG_EXCEPTION_NOT_HANDLED;
- else
-#if 0
-/* This code does not seem to work, because
- the kernel does probably not consider changes in the ExceptionRecord
- structure when passing the exception to the inferior.
- Note that this seems possible in the exception handler itself. */
- {
- int i;
- for (i = 0; xlate[i].them != -1; i++)
- if (xlate[i].us == sig)
- {
- current_event.u.Exception.ExceptionRecord.ExceptionCode =
- xlate[i].them;
- continue_status = DBG_EXCEPTION_NOT_HANDLED;
- break;
- }
- if (continue_status == DBG_CONTINUE)
- {
- DEBUG_EXCEPT(("Cannot continue with signal %d.\n",sig));
- }
- }
-#endif
- DEBUG_EXCEPT(("Can only continue with recieved signal %d.\n",
- last_sig));
- }
-
- last_sig = TARGET_SIGNAL_0;
-
- DEBUG_EXEC (("gdb: win32_resume (pid=%d, step=%d, sig=%d);\n",
- pid, step, sig));
-
- /* Get context for currently selected thread */
- th = thread_rec (current_event.dwThreadId, FALSE);
- if (th)
- {
- if (step)
- {
- /* Single step by setting t bit */
- win32_fetch_inferior_registers (PS_REGNUM);
- th->context.EFlags |= FLAG_TRACE_BIT;
- }
-
- if (th->context.ContextFlags)
- {
- if (debug_registers_changed)
- {
- th->context.Dr0 = dr[0];
- th->context.Dr1 = dr[1];
- th->context.Dr2 = dr[2];
- th->context.Dr3 = dr[3];
- /* th->context.Dr6 = dr[6];
- FIXME: should we set dr6 also ?? */
- th->context.Dr7 = dr[7];
- }
- CHECK (SetThreadContext (th->h, &th->context));
- th->context.ContextFlags = 0;
- }
- }
-
- /* Allow continuing with the same signal that interrupted us.
- Otherwise complain. */
-
- win32_continue (continue_status, pid);
-}
-
static void
win32_prepare_to_store (void)
{
return buf;
}
+typedef struct
+{
+ struct target_ops *target;
+ bfd_vma addr;
+} map_code_section_args;
+
+static void
+map_single_dll_code_section (bfd *abfd, asection *sect, void *obj)
+{
+ int old;
+ int update_coreops;
+ struct section_table *new_target_sect_ptr;
+
+ map_code_section_args *args = (map_code_section_args *) obj;
+ struct target_ops *target = args->target;
+ if (sect->flags & SEC_CODE)
+ {
+ update_coreops = core_ops.to_sections == target->to_sections;
+
+ if (target->to_sections)
+ {
+ old = target->to_sections_end - target->to_sections;
+ target->to_sections = (struct section_table *)
+ xrealloc ((char *) target->to_sections,
+ (sizeof (struct section_table)) * (1 + old));
+ }
+ else
+ {
+ old = 0;
+ target->to_sections = (struct section_table *)
+ xmalloc ((sizeof (struct section_table)));
+ }
+ target->to_sections_end = target->to_sections + (1 + old);
+
+ /* Update the to_sections field in the core_ops structure
+ if needed. */
+ if (update_coreops)
+ {
+ core_ops.to_sections = target->to_sections;
+ core_ops.to_sections_end = target->to_sections_end;
+ }
+ new_target_sect_ptr = target->to_sections + old;
+ new_target_sect_ptr->addr = args->addr + bfd_section_vma (abfd, sect);
+ new_target_sect_ptr->endaddr = args->addr + bfd_section_vma (abfd, sect) +
+ bfd_section_size (abfd, sect);;
+ new_target_sect_ptr->the_bfd_section = sect;
+ new_target_sect_ptr->bfd = abfd;
+ }
+}
+
+static int
+dll_code_sections_add (const char *dll_name, int base_addr, struct target_ops *target)
+{
+ bfd *dll_bfd;
+ map_code_section_args map_args;
+ asection *lowest_sect;
+ char *name;
+ if (dll_name == NULL || target == NULL)
+ return 0;
+ name = xstrdup (dll_name);
+ dll_bfd = bfd_openr (name, "pei-i386");
+ if (dll_bfd == NULL)
+ return 0;
+
+ if (bfd_check_format (dll_bfd, bfd_object))
+ {
+ lowest_sect = bfd_get_section_by_name (dll_bfd, ".text");
+ if (lowest_sect == NULL)
+ return 0;
+ map_args.target = target;
+ map_args.addr = base_addr - bfd_section_vma (dll_bfd, lowest_sect);
+
+ bfd_map_over_sections (dll_bfd, &map_single_dll_code_section, (void *) (&map_args));
+ }
+
+ return 1;
+}
+
+static void
+core_section_load_dll_symbols (bfd *abfd, asection *sect, void *obj)
+{
+ struct target_ops *target = (struct target_ops *) obj;
+
+ DWORD base_addr;
+
+ int dll_name_size;
+ struct win32_pstatus *pstatus;
+ struct so_list *so;
+ char *dll_name;
+ char *buf = NULL;
+ char *p;
+ struct objfile *objfile;
+ const char *dll_basename;
+
+ if (strncmp (sect->name, ".module", 7) != 0)
+ return;
+
+ buf = (char *) xmalloc (bfd_get_section_size (sect) + 1);
+ if (!buf)
+ {
+ printf_unfiltered ("memory allocation failed for %s\n", sect->name);
+ goto out;
+ }
+ if (!bfd_get_section_contents (abfd, sect, buf, 0, bfd_get_section_size (sect)))
+ goto out;
+
+ pstatus = (struct win32_pstatus *) buf;
+
+ memmove (&base_addr, &(pstatus->data.module_info.base_address), sizeof (base_addr));
+ dll_name_size = pstatus->data.module_info.module_name_size;
+ if (offsetof (struct win32_pstatus, data.module_info.module_name) + dll_name_size > bfd_get_section_size (sect))
+ goto out;
+
+ dll_name = pstatus->data.module_info.module_name;
+
+ if (!(dll_basename = strrchr (dll_name, '/')))
+ dll_basename = dll_name;
+ else
+ dll_basename++;
+
+ ALL_OBJFILES (objfile)
+ {
+ char *objfile_basename = strrchr (objfile->name, '/');
+
+ if (objfile_basename &&
+ strcasecmp (dll_basename, objfile_basename + 1) == 0)
+ goto out;
+ }
+
+ base_addr += 0x1000;
+ dll_name = register_loaded_dll (dll_name, base_addr, 1);
+
+ if (!dll_code_sections_add (dll_name, (DWORD) base_addr, target))
+ printf_unfiltered ("%s: Failed to map dll code sections.\n", dll_name);
+
+out:
+ if (buf)
+ xfree (buf);
+ return;
+}
+
+static struct so_list *
+win32_current_sos (void)
+{
+ struct so_list *sop;
+ struct so_list *start = NULL;
+ struct so_list *last = NULL;
+
+ if (!solib_start.next && core_bfd)
+ {
+ win32_clear_solib ();
+ bfd_map_over_sections (core_bfd, &core_section_load_dll_symbols,
+ &win32_ops);
+ }
+
+ for (sop = solib_start.next; sop; sop = sop->next)
+ {
+ struct so_list *new = XZALLOC (struct so_list);
+ strcpy (new->so_name, sop->so_name);
+ strcpy (new->so_original_name, sop->so_original_name);
+ if (!start)
+ last = start = new;
+ else
+ {
+ last->next = new;
+ last = new;
+ }
+ }
+
+ return start;
+}
+
+static void
+fetch_elf_core_registers (char *core_reg_sect,
+ unsigned core_reg_size,
+ int which,
+ CORE_ADDR reg_addr)
+{
+ int r;
+ if (core_reg_size < sizeof (CONTEXT))
+ {
+ error (_("Core file register section too small (%u bytes)."), core_reg_size);
+ return;
+ }
+ for (r = 0; r < NUM_REGS; r++)
+ regcache_raw_supply (current_regcache, r, core_reg_sect + mappings[r]);
+}
+
static void
init_win32_ops (void)
{
win32_so_ops.relocate_section_addresses = win32_relocate_section_addresses;
win32_so_ops.free_so = win32_free_so;
win32_so_ops.clear_solib = win32_clear_solib;
- win32_so_ops.solib_create_inferior_hook = NULL;
- win32_so_ops.special_symbol_handling = NULL;
+ win32_so_ops.solib_create_inferior_hook = win32_solib_create_inferior_hook;
+ win32_so_ops.special_symbol_handling = win32_special_symbol_handling;
win32_so_ops.current_sos = win32_current_sos;
win32_so_ops.open_symbol_file_object = NULL;
win32_so_ops.in_dynsym_resolve_code = NULL;
current_target_so_ops = &win32_so_ops;
}
+static void
+set_win32_aliases (char *argv0)
+{
+ add_info_alias ("dll", "sharedlibrary", 1);
+}
+
void
_initialize_win32_nat (void)
{
NULL, /* FIXME: i18n: */
&setlist, &showlist);
- add_info ("dll", info_dll_command, _("Status of loaded DLLs."));
- add_info_alias ("sharedlibrary", "dll", 1);
-
add_prefix_cmd ("w32", class_info, info_w32_command,
_("Print information specific to Win32 debugging."),
&info_w32_cmdlist, "info w32 ", 0, &infolist);
_("Display selectors infos."),
&info_w32_cmdlist);
add_target (&win32_ops);
+ deprecated_init_ui_hook = set_win32_aliases;
}
/* Hardware watchpoint support, adapted from go32-nat.c code. */
FALSE : TRUE;
}
-static void
-fetch_elf_core_registers (char *core_reg_sect,
- unsigned core_reg_size,
- int which,
- CORE_ADDR reg_addr)
-{
- int r;
- if (core_reg_size < sizeof (CONTEXT))
- {
- error (_("Core file register section too small (%u bytes)."), core_reg_size);
- return;
- }
- for (r = 0; r < NUM_REGS; r++)
- regcache_raw_supply (current_regcache, r, core_reg_sect + mappings[r]);
-}
-
static struct core_fns win32_elf_core_fns =
{
bfd_target_elf_flavour,
projects / deliverable / binutils-gdb.git / blobdiff