X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fwindows-nat.c;h=36a47f7cdbc28be0e4791a9e40795580a572166f;hb=3318ac0e53a673f9989f5e9bbaa9d1c5d536f4e5;hp=1ef38fb32b4bd8cb9d9907ba1c7d728658a9f446;hpb=d092c5a2465ece3435131ae6fef1ccb6e70986cb;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/windows-nat.c b/gdb/windows-nat.c index 1ef38fb32b..36a47f7cdb 100644 --- a/gdb/windows-nat.c +++ b/gdb/windows-nat.c @@ -1,6 +1,6 @@ /* Target-vector operations for controlling windows child processes, for GDB. - Copyright (C) 1995-2017 Free Software Foundation, Inc. + Copyright (C) 1995-2020 Free Software Foundation, Inc. Contributed by Cygnus Solutions, A Red Hat Company. @@ -42,8 +42,8 @@ #include #include #endif +#include -#include "buildsym.h" #include "filenames.h" #include "symfile.h" #include "objfiles.h" @@ -66,7 +66,9 @@ #include "x86-nat.h" #include "complaints.h" #include "inf-child.h" -#include "gdb_tilde_expand.h" +#include "gdbsupport/gdb_tilde_expand.h" +#include "gdbsupport/pathstuff.h" +#include "gdbsupport/gdb_wait.h" #define AdjustTokenPrivileges dyn_AdjustTokenPrivileges #define DebugActiveProcessStop dyn_DebugActiveProcessStop @@ -145,8 +147,10 @@ static GetConsoleFontSize_ftype *GetConsoleFontSize; 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 +#ifdef __CYGWIN__ +static CONTEXT saved_context; /* Contains the saved context from a cygwin signal. */ +#endif /* If we're not using the old Cygwin header file set, define the following which never should have been in the generic Win32 API @@ -200,10 +204,6 @@ typedef enum #define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x #define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x -static void windows_interrupt (struct target_ops *self, ptid_t); -static int windows_thread_alive (struct target_ops *, ptid_t); -static void windows_kill_inferior (struct target_ops *); - static void cygwin_set_dr (int i, CORE_ADDR addr); static void cygwin_set_dr7 (unsigned long val); static CORE_ADDR cygwin_get_dr (int i); @@ -225,7 +225,6 @@ typedef struct windows_thread_info_struct int suspended; int reload_context; CONTEXT context; - STACKFRAME sf; } windows_thread_info; @@ -237,7 +236,6 @@ static DEBUG_EVENT current_event; /* The current debug event from WaitForDebugEvent */ static HANDLE current_process_handle; /* Currently executing process */ static windows_thread_info *current_thread; /* Info on currently selected thread */ -static DWORD main_thread_id; /* Thread ID of the main thread */ /* Counts of things. */ static int exception_count = 0; @@ -246,16 +244,16 @@ static int saw_create; static int open_process_used = 0; /* User options. */ -static int new_console = 0; +static bool new_console = false; #ifdef __CYGWIN__ -static int cygwin_exceptions = 0; +static bool cygwin_exceptions = false; #endif -static int new_group = 1; -static int debug_exec = 0; /* show execution */ -static int debug_events = 0; /* show events from kernel */ -static int debug_memory = 0; /* show target memory accesses */ -static int debug_exceptions = 0; /* show target exceptions */ -static int useshell = 0; /* use shell for subprocesses */ +static bool new_group = true; +static bool debug_exec = false; /* show execution */ +static bool debug_events = false; /* show events from kernel */ +static bool debug_memory = false; /* show target memory accesses */ +static bool debug_exceptions = false; /* show target exceptions */ +static bool useshell = false; /* use shell for subprocesses */ /* This vector maps GDB's idea of a register's number into an offset in the windows exception context vector. @@ -281,25 +279,80 @@ static const int *mappings; a segment register or not. */ static segment_register_p_ftype *segment_register_p; +/* See windows_nat_target::resume to understand why this is commented + out. */ +#if 0 /* This vector maps the target's idea of an exception (extracted from the DEBUG_EVENT structure) to GDB's idea. */ struct xlate_exception { - int them; + DWORD them; enum gdb_signal us; }; -static const struct xlate_exception - xlate[] = +static const struct xlate_exception xlate[] = { {EXCEPTION_ACCESS_VIOLATION, GDB_SIGNAL_SEGV}, {STATUS_STACK_OVERFLOW, GDB_SIGNAL_SEGV}, {EXCEPTION_BREAKPOINT, GDB_SIGNAL_TRAP}, {DBG_CONTROL_C, GDB_SIGNAL_INT}, {EXCEPTION_SINGLE_STEP, GDB_SIGNAL_TRAP}, - {STATUS_FLOAT_DIVIDE_BY_ZERO, GDB_SIGNAL_FPE}, - {-1, GDB_SIGNAL_UNKNOWN}}; + {STATUS_FLOAT_DIVIDE_BY_ZERO, GDB_SIGNAL_FPE} +}; + +#endif /* 0 */ + +struct windows_nat_target final : public x86_nat_target +{ + void close () override; + + void attach (const char *, int) override; + + bool attach_no_wait () override + { return true; } + + void detach (inferior *, int) override; + + void resume (ptid_t, int , enum gdb_signal) override; + + ptid_t wait (ptid_t, struct target_waitstatus *, int) override; + + void fetch_registers (struct regcache *, int) override; + void store_registers (struct regcache *, int) override; + + enum target_xfer_status xfer_partial (enum target_object object, + const char *annex, + gdb_byte *readbuf, + const gdb_byte *writebuf, + ULONGEST offset, ULONGEST len, + ULONGEST *xfered_len) override; + + void files_info () override; + + void kill () override; + + void create_inferior (const char *, const std::string &, + char **, int) override; + + void mourn_inferior () override; + + bool thread_alive (ptid_t ptid) override; + + std::string pid_to_str (ptid_t) override; + + void interrupt () override; + + char *pid_to_exec_file (int pid) override; + + ptid_t get_ada_task_ptid (long lwp, long thread) override; + + bool get_tib_address (ptid_t ptid, CORE_ADDR *addr) override; + + const char *thread_name (struct thread_info *) override; +}; + +static windows_nat_target the_windows_nat_target; /* Set the MAPPINGS static global to OFFSETS. See the description of MAPPINGS for more details. */ @@ -371,16 +424,23 @@ thread_rec (DWORD id, int get_context) return NULL; } -/* Add a thread to the thread list. */ +/* Add a thread to the thread list. + + PTID is the ptid of the thread to be added. + H is its Windows handle. + TLB is its thread local base. + MAIN_THREAD_P should be true if the thread to be added is + the main thread, false otherwise. */ + static windows_thread_info * -windows_add_thread (ptid_t ptid, HANDLE h, void *tlb) +windows_add_thread (ptid_t ptid, HANDLE h, void *tlb, bool main_thread_p) { windows_thread_info *th; DWORD id; - gdb_assert (ptid_get_tid (ptid) != 0); + gdb_assert (ptid.tid () != 0); - id = ptid_get_tid (ptid); + id = ptid.tid (); if ((th = thread_rec (id, FALSE))) return th; @@ -391,7 +451,17 @@ windows_add_thread (ptid_t ptid, HANDLE h, void *tlb) th->thread_local_base = (CORE_ADDR) (uintptr_t) tlb; th->next = thread_head.next; thread_head.next = th; - add_thread (ptid); + + /* Add this new thread to the list of threads. + + To be consistent with what's done on other platforms, we add + the main thread silently (in reality, this thread is really + more of a process to the user than a thread). */ + if (main_thread_p) + add_thread_silent (ptid); + else + add_thread (ptid); + /* Set the debug registers for the new thread if they are used. */ if (debug_registers_used) { @@ -428,23 +498,38 @@ windows_init_thread_list (void) thread_head.next = NULL; } -/* Delete a thread from the list of threads. */ +/* Delete a thread from the list of threads. + + PTID is the ptid of the thread to be deleted. + EXIT_CODE is the thread's exit code. + MAIN_THREAD_P should be true if the thread to be deleted is + the main thread, false otherwise. */ + static void -windows_delete_thread (ptid_t ptid, DWORD exit_code) +windows_delete_thread (ptid_t ptid, DWORD exit_code, bool main_thread_p) { windows_thread_info *th; DWORD id; - gdb_assert (ptid_get_tid (ptid) != 0); + gdb_assert (ptid.tid () != 0); + + id = ptid.tid (); - id = ptid_get_tid (ptid); + /* Emit a notification about the thread being deleted. + + Note that no notification was printed when the main thread + was created, and thus, unless in verbose mode, we should be + symmetrical, and avoid that notification for the main thread + here as well. */ if (info_verbose) - printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid)); - else if (print_thread_events && id != main_thread_id) + printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid).c_str ()); + else if (print_thread_events && !main_thread_p) printf_unfiltered (_("[%s exited with code %u]\n"), - target_pid_to_str (ptid), (unsigned) exit_code); - delete_thread (ptid); + target_pid_to_str (ptid).c_str (), + (unsigned) exit_code); + + delete_thread (find_thread_ptid (ptid)); for (th = &thread_head; th->next != NULL && th->next->id != id; @@ -460,14 +545,59 @@ windows_delete_thread (ptid_t ptid, DWORD exit_code) } } +/* Fetches register number R from the given windows_thread_info, + and supplies its value to the given regcache. + + This function assumes that R is non-negative. A failed assertion + is raised if that is not true. + + This function assumes that TH->RELOAD_CONTEXT is not set, meaning + that the windows_thread_info has an up-to-date context. A failed + assertion is raised if that assumption is violated. */ + static void -do_windows_fetch_inferior_registers (struct regcache *regcache, - windows_thread_info *th, int r) +windows_fetch_one_register (struct regcache *regcache, + windows_thread_info *th, int r) { + gdb_assert (r >= 0); + gdb_assert (!th->reload_context); + char *context_offset = ((char *) &th->context) + mappings[r]; - struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct gdbarch *gdbarch = regcache->arch (); struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - long l; + + if (r == I387_FISEG_REGNUM (tdep)) + { + long l = *((long *) context_offset) & 0xffff; + regcache->raw_supply (r, (char *) &l); + } + else if (r == I387_FOP_REGNUM (tdep)) + { + long l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1); + regcache->raw_supply (r, (char *) &l); + } + else if (segment_register_p (r)) + { + /* GDB treats segment registers as 32bit registers, but they are + in fact only 16 bits long. Make sure we do not read extra + bits from our source buffer. */ + long l = *((long *) context_offset) & 0xffff; + regcache->raw_supply (r, (char *) &l); + } + else + regcache->raw_supply (r, context_offset); +} + +void +windows_nat_target::fetch_registers (struct regcache *regcache, int r) +{ + DWORD tid = regcache->ptid ().tid (); + windows_thread_info *th = thread_rec (tid, TRUE); + + /* Check if TH exists. Windows sometimes uses a non-existent + thread id in its events. */ + if (th == NULL) + return; if (th->reload_context) { @@ -503,87 +633,48 @@ do_windows_fetch_inferior_registers (struct regcache *regcache, th->reload_context = 0; } - if (r == I387_FISEG_REGNUM (tdep)) - { - l = *((long *) context_offset) & 0xffff; - regcache_raw_supply (regcache, r, (char *) &l); - } - else if (r == I387_FOP_REGNUM (tdep)) - { - l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1); - regcache_raw_supply (regcache, r, (char *) &l); - } - else if (segment_register_p (r)) - { - /* GDB treats segment registers as 32bit registers, but they are - in fact only 16 bits long. Make sure we do not read extra - bits from our source buffer. */ - l = *((long *) context_offset) & 0xffff; - regcache_raw_supply (regcache, r, (char *) &l); - } - else if (r >= 0) - regcache_raw_supply (regcache, r, context_offset); + if (r < 0) + for (r = 0; r < gdbarch_num_regs (regcache->arch()); r++) + windows_fetch_one_register (regcache, th, r); else - { - for (r = 0; r < gdbarch_num_regs (gdbarch); r++) - do_windows_fetch_inferior_registers (regcache, th, r); - } + windows_fetch_one_register (regcache, th, r); } -static void -windows_fetch_inferior_registers (struct target_ops *ops, - struct regcache *regcache, int r) -{ - DWORD pid = ptid_get_tid (regcache_get_ptid (regcache)); - windows_thread_info *th = thread_rec (pid, TRUE); +/* Collect the register number R from the given regcache, and store + its value into the corresponding area of the given thread's context. - /* Check if TH exists. Windows sometimes uses a non-existent - thread id in its events. */ - if (th != NULL) - do_windows_fetch_inferior_registers (regcache, th, r); -} + This function assumes that R is non-negative. A failed assertion + assertion is raised if that is not true. */ static void -do_windows_store_inferior_registers (const struct regcache *regcache, - windows_thread_info *th, int r) +windows_store_one_register (const struct regcache *regcache, + windows_thread_info *th, int r) { - if (r >= 0) - regcache_raw_collect (regcache, r, - ((char *) &th->context) + mappings[r]); - else - { - for (r = 0; r < gdbarch_num_regs (get_regcache_arch (regcache)); r++) - do_windows_store_inferior_registers (regcache, th, r); - } + gdb_assert (r >= 0); + + regcache->raw_collect (r, ((char *) &th->context) + mappings[r]); } /* Store a new register value into the context of the thread tied to REGCACHE. */ -static void -windows_store_inferior_registers (struct target_ops *ops, - struct regcache *regcache, int r) + +void +windows_nat_target::store_registers (struct regcache *regcache, int r) { - DWORD pid = ptid_get_tid (regcache_get_ptid (regcache)); - windows_thread_info *th = thread_rec (pid, TRUE); + DWORD tid = regcache->ptid ().tid (); + windows_thread_info *th = thread_rec (tid, TRUE); /* Check if TH exists. Windows sometimes uses a non-existent thread id in its events. */ - if (th != NULL) - do_windows_store_inferior_registers (regcache, th, r); -} + if (th == NULL) + return; -/* Encapsulate the information required in a call to - symbol_file_add_args. */ -struct safe_symbol_file_add_args -{ - char *name; - int from_tty; - struct section_addr_info *addrs; - int mainline; - int flags; - struct ui_file *err, *out; - struct objfile *ret; -}; + if (r < 0) + for (r = 0; r < gdbarch_num_regs (regcache->arch ()); r++) + windows_store_one_register (regcache, th, r); + else + windows_store_one_register (regcache, th, r); +} /* Maintain a linked list of "so" information. */ struct lm_info_windows : public lm_info_base @@ -672,7 +763,6 @@ windows_make_so (const char *name, LPVOID load_addr) if (p >= so->so_name && strcasecmp (p, "/cygwin1.dll") == 0) { asection *text = NULL; - CORE_ADDR text_vma; gdb_bfd_ref_ptr abfd (gdb_bfd_open (so->so_name, "pei-i386", -1)); @@ -690,8 +780,7 @@ windows_make_so (const char *name, LPVOID load_addr) file header and the section alignment. */ cygwin_load_start = (CORE_ADDR) (uintptr_t) ((char *) load_addr + 0x1000); - cygwin_load_end = cygwin_load_start + bfd_section_size (abfd.get (), - text); + cygwin_load_end = cygwin_load_start + bfd_section_size (text); } #endif @@ -755,8 +844,8 @@ get_image_name (HANDLE h, void *address, int unicode) do_initial_windows_stuff and windows_add_all_dlls for more info on how we handle DLL loading during that phase). */ -static int -handle_load_dll (void *dummy) +static void +handle_load_dll () { LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll; char *dll_name; @@ -769,7 +858,7 @@ handle_load_dll (void *dummy) dll_name = get_image_name (current_process_handle, event->lpImageName, event->fUnicode); if (!dll_name) - return 1; + return; solib_end->next = windows_make_so (dll_name, event->lpBaseOfDll); solib_end = solib_end->next; @@ -778,8 +867,6 @@ handle_load_dll (void *dummy) DEBUG_EVENTS (("gdb: Loading dll \"%s\" at %s.\n", solib_end->so_name, host_address_to_string (li->load_addr))); - - return 1; } static void @@ -799,8 +886,8 @@ windows_free_so (struct so_list *so) do_initial_windows_stuff and windows_add_all_dlls for more info on how we handle DLL loading during that phase). */ -static int -handle_unload_dll (void *dummy) +static void +handle_unload_dll () { LPVOID lpBaseOfDll = current_event.u.UnloadDll.lpBaseOfDll; struct so_list *so; @@ -819,7 +906,7 @@ handle_unload_dll (void *dummy) DEBUG_EVENTS (("gdb: Unloading dll \"%s\".\n", sodel->so_name)); windows_free_so (sodel); - return 1; + return; } } @@ -830,22 +917,43 @@ handle_unload_dll (void *dummy) 4 mysterious UNLOAD_DLL_DEBUG_EVENTs during the startup phase (these events are apparently caused by the WOW layer, the interface between 32bit and 64bit worlds). */ - complaint (&symfile_complaints, _("dll starting at %s not found."), + complaint (_("dll starting at %s not found."), host_address_to_string (lpBaseOfDll)); +} - return 0; +/* Call FUNC wrapped in a TRY/CATCH that swallows all GDB + exceptions. */ + +static void +catch_errors (void (*func) ()) +{ + try + { + func (); + } + catch (const gdb_exception &ex) + { + exception_print (gdb_stderr, ex); + } } /* Clear list of loaded DLLs. */ static void windows_clear_solib (void) { - solib_start.next = NULL; + struct so_list *so; + + for (so = solib_start.next; so; so = solib_start.next) + { + solib_start.next = so->next; + windows_free_so (so); + } + solib_end = &solib_start; } static void -signal_event_command (char *args, int from_tty) +signal_event_command (const char *args, int from_tty) { uintptr_t event_id = 0; char *endargs = NULL; @@ -869,25 +977,25 @@ signal_event_command (char *args, int from_tty) static int handle_output_debug_string (struct target_waitstatus *ourstatus) { - char *s = NULL; + gdb::unique_xmalloc_ptr s; int retval = 0; if (!target_read_string ((CORE_ADDR) (uintptr_t) current_event.u.DebugString.lpDebugStringData, - &s, 1024, 0) - || !s || !*s) + &s, 1024, 0) + || !s || !*(s.get ())) /* nothing to do */; - else if (!startswith (s, _CYGWIN_SIGNAL_STRING)) + else if (!startswith (s.get (), _CYGWIN_SIGNAL_STRING)) { #ifdef __CYGWIN__ - if (!startswith (s, "cYg")) + if (!startswith (s.get (), "cYg")) #endif { - char *p = strchr (s, '\0'); + char *p = strchr (s.get (), '\0'); - if (p > s && *--p == '\n') + if (p > s.get () && *--p == '\n') *p = '\0'; - warning (("%s"), s); + warning (("%s"), s.get ()); } } #ifdef __CYGWIN__ @@ -901,7 +1009,7 @@ handle_output_debug_string (struct target_waitstatus *ourstatus) 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); + int sig = strtol (s.get () + sizeof (_CYGWIN_SIGNAL_STRING) - 1, &p, 0); gdb_signal gotasig = gdb_signal_from_host (sig); ourstatus->value.sig = gotasig; @@ -913,7 +1021,7 @@ handle_output_debug_string (struct target_waitstatus *ourstatus) ourstatus->kind = TARGET_WAITKIND_STOPPED; retval = strtoul (p, &p, 0); if (!retval) - retval = main_thread_id; + retval = current_event.dwThreadId; else if ((x = (LPCVOID) (uintptr_t) strtoull (p, NULL, 0)) && ReadProcessMemory (current_process_handle, x, &saved_context, @@ -924,8 +1032,6 @@ handle_output_debug_string (struct target_waitstatus *ourstatus) } #endif - if (s) - xfree (s); return retval; } @@ -980,14 +1086,16 @@ display_selector (HANDLE thread, DWORD sel) puts_filtered ("Code (Exec/Read, Conf"); break; default: - printf_filtered ("Unknown type 0x%x",info.HighWord.Bits.Type); + printf_filtered ("Unknown type 0x%lx", + (unsigned long) info.HighWord.Bits.Type); } if ((info.HighWord.Bits.Type & 0x1) == 0) puts_filtered(", N.Acc"); puts_filtered (")\n"); if ((info.HighWord.Bits.Type & 0x10) == 0) puts_filtered("System selector "); - printf_filtered ("Priviledge level = %d. ", info.HighWord.Bits.Dpl); + printf_filtered ("Priviledge level = %ld. ", + (unsigned long) info.HighWord.Bits.Dpl); if (info.HighWord.Bits.Granularity) puts_filtered ("Page granular.\n"); else @@ -1006,7 +1114,7 @@ display_selector (HANDLE thread, DWORD sel) } static void -display_selectors (char * args, int from_tty) +display_selectors (const char * args, int from_tty) { if (!current_thread) { @@ -1179,24 +1287,23 @@ handle_exception (struct target_waitstatus *ourstatus) if (named_thread != NULL) { int thread_name_len; - char *thread_name; + gdb::unique_xmalloc_ptr thread_name; thread_name_len = target_read_string (thread_name_target, &thread_name, 1025, NULL); if (thread_name_len > 0) { - thread_name[thread_name_len - 1] = '\0'; + thread_name.get ()[thread_name_len - 1] = '\0'; xfree (named_thread->name); - named_thread->name = thread_name; + named_thread->name = thread_name.release (); } - else - xfree (thread_name); } ourstatus->value.sig = GDB_SIGNAL_TRAP; result = HANDLE_EXCEPTION_IGNORED; break; } - /* treat improperly formed exception as unknown, fallthrough */ + /* treat improperly formed exception as unknown */ + /* FALLTHROUGH */ default: /* Treat unhandled first chance exceptions specially. */ if (current_event.u.Exception.dwFirstChance) @@ -1220,7 +1327,6 @@ handle_exception (struct target_waitstatus *ourstatus) static BOOL windows_continue (DWORD continue_status, int id, int killed) { - int i; windows_thread_info *th; BOOL res; @@ -1291,24 +1397,23 @@ fake_create_process (void) (unsigned) GetLastError ()); /* We can not debug anything in that case. */ } - main_thread_id = current_event.dwThreadId; - current_thread = windows_add_thread ( - ptid_build (current_event.dwProcessId, 0, - current_event.dwThreadId), - current_event.u.CreateThread.hThread, - current_event.u.CreateThread.lpThreadLocalBase); - return main_thread_id; + current_thread + = windows_add_thread (ptid_t (current_event.dwProcessId, 0, + current_event.dwThreadId), + current_event.u.CreateThread.hThread, + current_event.u.CreateThread.lpThreadLocalBase, + true /* main_thread_p */); + return current_event.dwThreadId; } -static void -windows_resume (struct target_ops *ops, - ptid_t ptid, int step, enum gdb_signal sig) +void +windows_nat_target::resume (ptid_t ptid, int step, enum gdb_signal sig) { windows_thread_info *th; DWORD continue_status = DBG_CONTINUE; /* A specific PTID means `step only this thread id'. */ - int resume_all = ptid_equal (ptid, minus_one_ptid); + int resume_all = ptid == minus_one_ptid; /* If we're continuing all threads, it's the current inferior that should be handled specially. */ @@ -1330,12 +1435,11 @@ windows_resume (struct target_ops *ops, 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) + for (const xlate_exception &x : xlate) + if (x.us == sig) { current_event.u.Exception.ExceptionRecord.ExceptionCode - = xlate[i].them; + = x.them; continue_status = DBG_EXCEPTION_NOT_HANDLED; break; } @@ -1351,20 +1455,19 @@ windows_resume (struct target_ops *ops, last_sig = GDB_SIGNAL_0; - DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n", - ptid_get_pid (ptid), ptid_get_tid (ptid), step, sig)); + DEBUG_EXEC (("gdb: windows_resume (pid=%d, tid=0x%x, step=%d, sig=%d);\n", + ptid.pid (), (unsigned) ptid.tid (), step, sig)); /* Get context for currently selected thread. */ - th = thread_rec (ptid_get_tid (inferior_ptid), FALSE); + th = thread_rec (inferior_ptid.tid (), FALSE); if (th) { if (step) { /* Single step by setting t bit. */ struct regcache *regcache = get_current_regcache (); - struct gdbarch *gdbarch = get_regcache_arch (regcache); - windows_fetch_inferior_registers (ops, regcache, - gdbarch_ps_regnum (gdbarch)); + struct gdbarch *gdbarch = regcache->arch (); + fetch_registers (regcache, gdbarch_ps_regnum (gdbarch)); th->context.EFlags |= FLAG_TRACE_BIT; } @@ -1390,7 +1493,7 @@ windows_resume (struct target_ops *ops, if (resume_all) windows_continue (continue_status, -1, 0); else - windows_continue (continue_status, ptid_get_tid (ptid), 0); + windows_continue (continue_status, ptid.tid (), 0); } /* Ctrl-C handler used when the inferior is not run in the same console. The @@ -1468,10 +1571,11 @@ get_windows_debug_event (struct target_ops *ops, } /* Record the existence of this thread. */ thread_id = current_event.dwThreadId; - th = windows_add_thread (ptid_build (current_event.dwProcessId, 0, - current_event.dwThreadId), - current_event.u.CreateThread.hThread, - current_event.u.CreateThread.lpThreadLocalBase); + th = windows_add_thread + (ptid_t (current_event.dwProcessId, 0, current_event.dwThreadId), + current_event.u.CreateThread.hThread, + current_event.u.CreateThread.lpThreadLocalBase, + false /* main_thread_p */); break; @@ -1480,14 +1584,11 @@ get_windows_debug_event (struct target_ops *ops, (unsigned) current_event.dwProcessId, (unsigned) current_event.dwThreadId, "EXIT_THREAD_DEBUG_EVENT")); - - if (current_event.dwThreadId != main_thread_id) - { - windows_delete_thread (ptid_build (current_event.dwProcessId, 0, - current_event.dwThreadId), - current_event.u.ExitThread.dwExitCode); - th = &dummy_thread_info; - } + windows_delete_thread (ptid_t (current_event.dwProcessId, 0, + current_event.dwThreadId), + current_event.u.ExitThread.dwExitCode, + false /* main_thread_p */); + th = &dummy_thread_info; break; case CREATE_PROCESS_DEBUG_EVENT: @@ -1500,16 +1601,13 @@ get_windows_debug_event (struct target_ops *ops, break; current_process_handle = current_event.u.CreateProcessInfo.hProcess; - if (main_thread_id) - windows_delete_thread (ptid_build (current_event.dwProcessId, 0, - main_thread_id), - 0); - main_thread_id = current_event.dwThreadId; /* Add the main thread. */ - th = windows_add_thread (ptid_build (current_event.dwProcessId, 0, - current_event.dwThreadId), - current_event.u.CreateProcessInfo.hThread, - current_event.u.CreateProcessInfo.lpThreadLocalBase); + th = windows_add_thread + (ptid_t (current_event.dwProcessId, 0, + current_event.dwThreadId), + current_event.u.CreateProcessInfo.hThread, + current_event.u.CreateProcessInfo.lpThreadLocalBase, + true /* main_thread_p */); thread_id = current_event.dwThreadId; break; @@ -1527,9 +1625,27 @@ get_windows_debug_event (struct target_ops *ops, } else if (saw_create == 1) { - ourstatus->kind = TARGET_WAITKIND_EXITED; - ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode; - thread_id = main_thread_id; + windows_delete_thread (ptid_t (current_event.dwProcessId, 0, + current_event.dwThreadId), + 0, true /* main_thread_p */); + DWORD exit_status = current_event.u.ExitProcess.dwExitCode; + /* If the exit status looks like a fatal exception, but we + don't recognize the exception's code, make the original + exit status value available, to avoid losing + information. */ + int exit_signal + = WIFSIGNALED (exit_status) ? WTERMSIG (exit_status) : -1; + if (exit_signal == -1) + { + ourstatus->kind = TARGET_WAITKIND_EXITED; + ourstatus->value.integer = exit_status; + } + else + { + ourstatus->kind = TARGET_WAITKIND_SIGNALLED; + ourstatus->value.sig = gdb_signal_from_host (exit_signal); + } + thread_id = current_event.dwThreadId; } break; @@ -1541,10 +1657,10 @@ get_windows_debug_event (struct target_ops *ops, CloseHandle (current_event.u.LoadDll.hFile); if (saw_create != 1 || ! windows_initialization_done) break; - catch_errors (handle_load_dll, NULL, (char *) "", RETURN_MASK_ALL); + catch_errors (handle_load_dll); ourstatus->kind = TARGET_WAITKIND_LOADED; ourstatus->value.integer = 0; - thread_id = main_thread_id; + thread_id = current_event.dwThreadId; break; case UNLOAD_DLL_DEBUG_EVENT: @@ -1554,10 +1670,10 @@ get_windows_debug_event (struct target_ops *ops, "UNLOAD_DLL_DEBUG_EVENT")); if (saw_create != 1 || ! windows_initialization_done) break; - catch_errors (handle_unload_dll, NULL, (char *) "", RETURN_MASK_ALL); + catch_errors (handle_unload_dll); ourstatus->kind = TARGET_WAITKIND_LOADED; ourstatus->value.integer = 0; - thread_id = main_thread_id; + thread_id = current_event.dwThreadId; break; case EXCEPTION_DEBUG_EVENT: @@ -1609,8 +1725,7 @@ get_windows_debug_event (struct target_ops *ops, } else { - inferior_ptid = ptid_build (current_event.dwProcessId, 0, - thread_id); + inferior_ptid = ptid_t (current_event.dwProcessId, 0, thread_id); current_thread = th; if (!current_thread) current_thread = thread_rec (thread_id, TRUE); @@ -1621,14 +1736,12 @@ out: } /* Wait for interesting events to occur in the target process. */ -static ptid_t -windows_wait (struct target_ops *ops, - ptid_t ptid, struct target_waitstatus *ourstatus, int options) +ptid_t +windows_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus, + int options) { int pid = -1; - target_terminal::ours (); - /* We loop when we get a non-standard exception rather than return with a SPURIOUS because resume can try and step or modify things, which needs a current_thread->h. But some of these exceptions mark @@ -1666,11 +1779,11 @@ windows_wait (struct target_ops *ops, the user tries to resume the execution in the inferior. This is a classic race that we should try to fix one day. */ SetConsoleCtrlHandler (&ctrl_c_handler, TRUE); - retval = get_windows_debug_event (ops, pid, ourstatus); + retval = get_windows_debug_event (this, pid, ourstatus); SetConsoleCtrlHandler (&ctrl_c_handler, FALSE); if (retval) - return ptid_build (current_event.dwProcessId, 0, retval); + return ptid_t (current_event.dwProcessId, 0, retval); else { int detach = 0; @@ -1679,7 +1792,7 @@ windows_wait (struct target_ops *ops, detach = deprecated_ui_loop_hook (0); if (detach) - windows_kill_inferior (ops); + kill (); } } } @@ -1690,7 +1803,6 @@ windows_wait (struct target_ops *ops, static void windows_add_all_dlls (void) { - struct so_list *so; HMODULE dummy_hmodule; DWORD cb_needed; HMODULE *hmodules; @@ -1740,7 +1852,6 @@ do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching) { int i; struct inferior *inf; - struct thread_info *tp; last_sig = GDB_SIGNAL_0; event_count = 0; @@ -1770,7 +1881,7 @@ do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching) can rely on it. When attaching, we don't know about any thread id here, but that's OK --- nothing should be referencing the current thread until we report an event out of windows_wait. */ - inferior_ptid = pid_to_ptid (pid); + inferior_ptid = ptid_t (pid); target_terminal::init (); target_terminal::inferior (); @@ -1781,7 +1892,7 @@ do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching) { struct target_waitstatus status; - windows_wait (ops, minus_one_ptid, &status, 0); + ops->wait (minus_one_ptid, &status, 0); /* Note windows_wait returns TARGET_WAITKIND_SPURIOUS for thread events. */ @@ -1789,7 +1900,7 @@ do_initial_windows_stuff (struct target_ops *ops, DWORD pid, int attaching) && status.kind != TARGET_WAITKIND_SPURIOUS) break; - windows_resume (ops, minus_one_ptid, 0, GDB_SIGNAL_0); + ops->resume (minus_one_ptid, 0, GDB_SIGNAL_0); } /* Now that the inferior has been started and all DLLs have been mapped, @@ -1863,8 +1974,9 @@ out: } /* Attach to process PID, then initialize for debugging it. */ -static void -windows_attach (struct target_ops *ops, const char *args, int from_tty) + +void +windows_nat_target::attach (const char *args, int from_tty) { BOOL ok; DWORD pid; @@ -1894,35 +2006,34 @@ windows_attach (struct target_ops *ops, const char *args, int from_tty) #endif if (!ok) - error (_("Can't attach to process.")); + error (_("Can't attach to process %u (error %u)"), + (unsigned) pid, (unsigned) GetLastError ()); DebugSetProcessKillOnExit (FALSE); if (from_tty) { - char *exec_file = (char *) get_exec_file (0); + const char *exec_file = get_exec_file (0); if (exec_file) printf_unfiltered ("Attaching to program `%s', %s\n", exec_file, - target_pid_to_str (pid_to_ptid (pid))); + target_pid_to_str (ptid_t (pid)).c_str ()); else printf_unfiltered ("Attaching to %s\n", - target_pid_to_str (pid_to_ptid (pid))); - - gdb_flush (gdb_stdout); + target_pid_to_str (ptid_t (pid)).c_str ()); } - do_initial_windows_stuff (ops, pid, 1); + do_initial_windows_stuff (this, pid, 1); target_terminal::ours (); } -static void -windows_detach (struct target_ops *ops, const char *args, int from_tty) +void +windows_nat_target::detach (inferior *inf, int from_tty) { int detached = 1; ptid_t ptid = minus_one_ptid; - windows_resume (ops, ptid, 0, GDB_SIGNAL_0); + resume (ptid, 0, GDB_SIGNAL_0); if (!DebugActiveProcessStop (current_event.dwProcessId)) { @@ -1939,14 +2050,13 @@ windows_detach (struct target_ops *ops, const char *args, int from_tty) exec_file = ""; printf_unfiltered ("Detaching from program: %s, Pid %u\n", exec_file, (unsigned) current_event.dwProcessId); - gdb_flush (gdb_stdout); } x86_cleanup_dregs (); inferior_ptid = null_ptid; - detach_inferior (current_event.dwProcessId); + detach_inferior (inf); - inf_child_maybe_unpush_target (ops); + maybe_unpush_target (); } /* Try to determine the executable filename. @@ -2003,8 +2113,8 @@ windows_get_exec_module_filename (char *exe_name_ret, size_t exe_name_max_len) /* The pid_to_exec_file target_ops method for this platform. */ -static char * -windows_pid_to_exec_file (struct target_ops *self, int pid) +char * +windows_nat_target::pid_to_exec_file (int pid) { static char path[__PMAX]; #ifdef __CYGWIN__ @@ -2031,14 +2141,14 @@ windows_pid_to_exec_file (struct target_ops *self, int pid) /* Print status information about what we're accessing. */ -static void -windows_files_info (struct target_ops *ignore) +void +windows_nat_target::files_info () { struct inferior *inf = current_inferior (); printf_unfiltered ("\tUsing the running image of %s %s.\n", inf->attach_flag ? "attached" : "child", - target_pid_to_str (inferior_ptid)); + target_pid_to_str (inferior_ptid).c_str ()); } /* Modify CreateProcess parameters for use of a new separate console. @@ -2420,10 +2530,10 @@ redirect_inferior_handles (const char *cmd_orig, char *cmd, ALLARGS is a string containing the arguments to the program. ENV is the environment vector to pass. Errors reported with error(). */ -static void -windows_create_inferior (struct target_ops *ops, const char *exec_file, - const std::string &origallargs, char **in_env, - int from_tty) +void +windows_nat_target::create_inferior (const char *exec_file, + const std::string &origallargs, + char **in_env, int from_tty) { STARTUPINFO si; #ifdef __CYGWIN__ @@ -2440,16 +2550,12 @@ windows_create_inferior (struct target_ops *ops, const char *exec_file, int tty; int ostdin, ostdout, ostderr; #else /* !__CYGWIN__ */ - char real_path[__PMAX]; char shell[__PMAX]; /* Path to shell */ const char *toexec; char *args, *allargs_copy; size_t args_len, allargs_len; int fd_inp = -1, fd_out = -1, fd_err = -1; HANDLE tty = INVALID_HANDLE_VALUE; - HANDLE inf_stdin = INVALID_HANDLE_VALUE; - HANDLE inf_stdout = INVALID_HANDLE_VALUE; - HANDLE inf_stderr = INVALID_HANDLE_VALUE; bool redirected = false; char *w32env; char *temp; @@ -2507,9 +2613,7 @@ windows_create_inferior (struct target_ops *ops, const char *exec_file, } else { - sh = getenv ("SHELL"); - if (!sh) - sh = "/bin/sh"; + sh = get_shell (); if (cygwin_conv_path (CCP_POSIX_TO_WIN_W, sh, shell, __PMAX) < 0) error (_("Error starting executable via shell: %d"), errno); #ifdef __USEWIDE @@ -2610,13 +2714,13 @@ windows_create_inferior (struct target_ops *ops, const char *exec_file, if (tty >= 0) { - close (tty); + ::close (tty); dup2 (ostdin, 0); dup2 (ostdout, 1); dup2 (ostderr, 2); - close (ostdin); - close (ostdout); - close (ostderr); + ::close (ostdin); + ::close (ostdout); + ::close (ostderr); } #else /* !__CYGWIN__ */ allargs_len = strlen (allargs); @@ -2629,7 +2733,7 @@ windows_create_inferior (struct target_ops *ops, const char *exec_file, redirect_inferior_handles (allargs, allargs_copy, &fd_inp, &fd_out, &fd_err); if (errno) - warning (_("Error in redirection: %s."), strerror (errno)); + warning (_("Error in redirection: %s."), safe_strerror (errno)); else errno = e; allargs_len = strlen (allargs_copy); @@ -2741,13 +2845,13 @@ windows_create_inferior (struct target_ops *ops, const char *exec_file, else saw_create = 0; - do_initial_windows_stuff (ops, pi.dwProcessId, 0); + do_initial_windows_stuff (this, pi.dwProcessId, 0); /* windows_continue (DBG_CONTINUE, -1, 0); */ } -static void -windows_mourn_inferior (struct target_ops *ops) +void +windows_nat_target::mourn_inferior () { (void) windows_continue (DBG_CONTINUE, -1, 0); x86_cleanup_dregs(); @@ -2756,14 +2860,14 @@ windows_mourn_inferior (struct target_ops *ops) CHECK (CloseHandle (current_process_handle)); open_process_used = 0; } - inf_child_mourn_inferior (ops); + inf_child_target::mourn_inferior (); } /* Send a SIGINT to the process group. This acts just like the user typed a ^C on the controlling terminal. */ -static void -windows_interrupt (struct target_ops *self, ptid_t ptid) +void +windows_nat_target::interrupt () { DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n")); CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId)); @@ -2810,8 +2914,8 @@ windows_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf, return success ? TARGET_XFER_OK : TARGET_XFER_E_IO; } -static void -windows_kill_inferior (struct target_ops *ops) +void +windows_nat_target::kill () { CHECK (TerminateProcess (current_process_handle, 0)); @@ -2828,25 +2932,19 @@ windows_kill_inferior (struct target_ops *ops) target_mourn_inferior (inferior_ptid); /* Or just windows_mourn_inferior? */ } -static void -windows_close (struct target_ops *self) +void +windows_nat_target::close () { DEBUG_EVENTS (("gdb: windows_close, inferior_ptid=%d\n", - ptid_get_pid (inferior_ptid))); + inferior_ptid.pid ())); } /* Convert pid to printable format. */ -static const char * -windows_pid_to_str (struct target_ops *ops, ptid_t ptid) +std::string +windows_nat_target::pid_to_str (ptid_t ptid) { - static char buf[80]; - - if (ptid_get_tid (ptid) != 0) - { - snprintf (buf, sizeof (buf), "Thread %d.0x%lx", - ptid_get_pid (ptid), ptid_get_tid (ptid)); - return buf; - } + if (ptid.tid () != 0) + return string_printf ("Thread %d.0x%lx", ptid.pid (), ptid.tid ()); return normal_pid_to_str (ptid); } @@ -2894,11 +2992,11 @@ windows_xfer_shared_libraries (struct target_ops *ops, return len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF; } -static enum target_xfer_status -windows_xfer_partial (struct target_ops *ops, enum target_object object, - const char *annex, gdb_byte *readbuf, - const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, - ULONGEST *xfered_len) +enum target_xfer_status +windows_nat_target::xfer_partial (enum target_object object, + const char *annex, gdb_byte *readbuf, + const gdb_byte *writebuf, ULONGEST offset, + ULONGEST len, ULONGEST *xfered_len) { switch (object) { @@ -2906,87 +3004,59 @@ windows_xfer_partial (struct target_ops *ops, enum target_object object, return windows_xfer_memory (readbuf, writebuf, offset, len, xfered_len); case TARGET_OBJECT_LIBRARIES: - return windows_xfer_shared_libraries (ops, object, annex, readbuf, + return windows_xfer_shared_libraries (this, object, annex, readbuf, writebuf, offset, len, xfered_len); default: - return ops->beneath->to_xfer_partial (ops->beneath, object, annex, - readbuf, writebuf, offset, len, - xfered_len); + if (beneath () == NULL) + { + /* This can happen when requesting the transfer of unsupported + objects before a program has been started (and therefore + with the current_target having no target beneath). */ + return TARGET_XFER_E_IO; + } + return beneath ()->xfer_partial (object, annex, + readbuf, writebuf, offset, len, + xfered_len); } } /* Provide thread local base, i.e. Thread Information Block address. Returns 1 if ptid is found and sets *ADDR to thread_local_base. */ -static int -windows_get_tib_address (struct target_ops *self, - ptid_t ptid, CORE_ADDR *addr) +bool +windows_nat_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr) { windows_thread_info *th; - th = thread_rec (ptid_get_tid (ptid), 0); + th = thread_rec (ptid.tid (), 0); if (th == NULL) - return 0; + return false; if (addr != NULL) *addr = th->thread_local_base; - return 1; + return true; } -static ptid_t -windows_get_ada_task_ptid (struct target_ops *self, long lwp, long thread) +ptid_t +windows_nat_target::get_ada_task_ptid (long lwp, long thread) { - return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp); + return ptid_t (inferior_ptid.pid (), 0, lwp); } /* Implementation of the to_thread_name method. */ -static const char * -windows_thread_name (struct target_ops *self, struct thread_info *thr) +const char * +windows_nat_target::thread_name (struct thread_info *thr) { - return thread_rec (ptid_get_tid (thr->ptid), 0)->name; + return thread_rec (thr->ptid.tid (), 0)->name; } -static struct target_ops * -windows_target (void) -{ - struct target_ops *t = inf_child_target (); - - t->to_close = windows_close; - t->to_attach = windows_attach; - t->to_attach_no_wait = 1; - t->to_detach = windows_detach; - t->to_resume = windows_resume; - t->to_wait = windows_wait; - t->to_fetch_registers = windows_fetch_inferior_registers; - t->to_store_registers = windows_store_inferior_registers; - t->to_xfer_partial = windows_xfer_partial; - t->to_files_info = windows_files_info; - t->to_kill = windows_kill_inferior; - t->to_create_inferior = windows_create_inferior; - t->to_mourn_inferior = windows_mourn_inferior; - t->to_thread_alive = windows_thread_alive; - t->to_pid_to_str = windows_pid_to_str; - t->to_interrupt = windows_interrupt; - t->to_pid_to_exec_file = windows_pid_to_exec_file; - t->to_get_ada_task_ptid = windows_get_ada_task_ptid; - t->to_get_tib_address = windows_get_tib_address; - t->to_thread_name = windows_thread_name; - - return t; -} void _initialize_windows_nat (void) { - struct target_ops *t; - - t = windows_target (); - - x86_use_watchpoints (t); - x86_dr_low.set_control = cygwin_set_dr7; x86_dr_low.set_addr = cygwin_set_dr; x86_dr_low.get_addr = cygwin_get_dr; @@ -2997,7 +3067,7 @@ _initialize_windows_nat (void) calling x86_set_debug_register_length function in processor windows specific native file. */ - add_target (t); + add_inf_child_target (&the_windows_nat_target); #ifdef __CYGWIN__ cygwin_internal (CW_SET_DOS_FILE_WARNING, 0); @@ -3134,16 +3204,16 @@ cygwin_get_dr7 (void) /* Determine if the thread referenced by "ptid" is alive by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0 it means that the thread has died. Otherwise it is assumed to be alive. */ -static int -windows_thread_alive (struct target_ops *ops, ptid_t ptid) + +bool +windows_nat_target::thread_alive (ptid_t ptid) { int tid; - gdb_assert (ptid_get_tid (ptid) != 0); - tid = ptid_get_tid (ptid); + gdb_assert (ptid.tid () != 0); + tid = ptid.tid (); - return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0 - ? FALSE : TRUE; + return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) != WAIT_OBJECT_0; } void