X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbserver%2Fwin32-low.c;h=1a50141c123faf158c30a772686e805a5b43ff07;hb=353ea2d106a51cfd1680f7d351f35eb8f69c9248;hp=14afbdb914d4e9d7f1860ebf56ed7ac5a2882cb9;hpb=d763de106f7146d7b972f98c7d0113f80a65e4f5;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbserver/win32-low.c b/gdb/gdbserver/win32-low.c index 14afbdb914..1a50141c12 100644 --- a/gdb/gdbserver/win32-low.c +++ b/gdb/gdbserver/win32-low.c @@ -1,5 +1,5 @@ /* Low level interface to Windows debugging, for gdbserver. - Copyright (C) 2006-2014 Free Software Foundation, Inc. + Copyright (C) 2006-2019 Free Software Foundation, Inc. Contributed by Leo Zayas. Based on "win32-nat.c" from GDB. @@ -20,21 +20,20 @@ #include "server.h" #include "regcache.h" -#include "gdb/signals.h" #include "gdb/fileio.h" #include "mem-break.h" #include "win32-low.h" #include "gdbthread.h" #include "dll.h" #include "hostio.h" - -#include #include #include #include #include #include #include +#include "common/gdb_tilde_expand.h" +#include "common/common-inferior.h" #ifndef USE_WIN32API #include @@ -112,7 +111,7 @@ static void win32_add_all_dlls (void); /* Get the thread ID from the current selected inferior (the current thread). */ static ptid_t -current_inferior_ptid (void) +current_thread_ptid (void) { return current_ptid; } @@ -121,7 +120,7 @@ current_inferior_ptid (void) static ptid_t debug_event_ptid (DEBUG_EVENT *event) { - return ptid_build (event->dwProcessId, event->dwThreadId, 0); + return ptid_t (event->dwProcessId, event->dwThreadId, 0); } /* Get the thread context of the thread associated with TH. */ @@ -130,7 +129,7 @@ static void win32_get_thread_context (win32_thread_info *th) { memset (&th->context, 0, sizeof (CONTEXT)); - (*the_low_target.get_thread_context) (th, ¤t_event); + (*the_low_target.get_thread_context) (th); #ifdef _WIN32_WCE memcpy (&th->base_context, &th->context, sizeof (CONTEXT)); #endif @@ -154,23 +153,24 @@ win32_set_thread_context (win32_thread_info *th) it between stopping and resuming. */ if (memcmp (&th->context, &th->base_context, sizeof (CONTEXT)) != 0) #endif - (*the_low_target.set_thread_context) (th, ¤t_event); + SetThreadContext (th->h, &th->context); } -/* Find a thread record given a thread id. If GET_CONTEXT is set then - also retrieve the context for this thread. */ -static win32_thread_info * -thread_rec (ptid_t ptid, int get_context) +/* Set the thread context of the thread associated with TH. */ + +static void +win32_prepare_to_resume (win32_thread_info *th) { - struct thread_info *thread; - win32_thread_info *th; + if (the_low_target.prepare_to_resume != NULL) + (*the_low_target.prepare_to_resume) (th); +} - thread = (struct thread_info *) find_inferior_id (&all_threads, ptid); - if (thread == NULL) - return NULL; +/* See win32-low.h. */ - th = inferior_target_data (thread); - if (get_context && th->context.ContextFlags == 0) +void +win32_require_context (win32_thread_info *th) +{ + if (th->context.ContextFlags == 0) { if (!th->suspended) { @@ -186,7 +186,20 @@ thread_rec (ptid_t ptid, int get_context) win32_get_thread_context (th); } +} + +/* Find a thread record given a thread id. If GET_CONTEXT is set then + also retrieve the context for this thread. */ +static win32_thread_info * +thread_rec (ptid_t ptid, int get_context) +{ + thread_info *thread = find_thread_ptid (ptid); + if (thread == NULL) + return NULL; + win32_thread_info *th = (win32_thread_info *) thread_target_data (thread); + if (get_context) + win32_require_context (th); return th; } @@ -195,12 +208,12 @@ static win32_thread_info * child_add_thread (DWORD pid, DWORD tid, HANDLE h, void *tlb) { win32_thread_info *th; - ptid_t ptid = ptid_build (pid, tid, 0); + ptid_t ptid = ptid_t (pid, tid, 0); if ((th = thread_rec (ptid, FALSE))) return th; - th = xcalloc (1, sizeof (*th)); + th = XCNEW (win32_thread_info); th->tid = tid; th->h = h; th->thread_local_base = (CORE_ADDR) (uintptr_t) tlb; @@ -215,11 +228,11 @@ child_add_thread (DWORD pid, DWORD tid, HANDLE h, void *tlb) /* Delete a thread from the list of threads. */ static void -delete_thread_info (struct inferior_list_entry *thread) +delete_thread_info (thread_info *thread) { - win32_thread_info *th = inferior_target_data ((struct thread_info *) thread); + win32_thread_info *th = (win32_thread_info *) thread_target_data (thread); - remove_thread ((struct thread_info *) thread); + remove_thread (thread); CloseHandle (th->h); free (th); } @@ -228,15 +241,11 @@ delete_thread_info (struct inferior_list_entry *thread) static void child_delete_thread (DWORD pid, DWORD tid) { - struct inferior_list_entry *thread; - ptid_t ptid; - /* If the last thread is exiting, just return. */ - if (one_inferior_p (&all_threads)) + if (all_threads.size () == 1) return; - ptid = ptid_build (pid, tid, 0); - thread = find_inferior_id (&all_threads, ptid); + thread_info *thread = find_thread_ptid (ptid_t (pid, tid)); if (thread == NULL) return; @@ -247,20 +256,29 @@ child_delete_thread (DWORD pid, DWORD tid) if the low target has registered a corresponding function. */ static int -win32_insert_point (char type, CORE_ADDR addr, int len) +win32_supports_z_point_type (char z_type) +{ + return (the_low_target.supports_z_point_type != NULL + && the_low_target.supports_z_point_type (z_type)); +} + +static int +win32_insert_point (enum raw_bkpt_type type, CORE_ADDR addr, + int size, struct raw_breakpoint *bp) { if (the_low_target.insert_point != NULL) - return the_low_target.insert_point (type, addr, len); + return the_low_target.insert_point (type, addr, size, bp); else /* Unsupported (see target.h). */ return 1; } static int -win32_remove_point (char type, CORE_ADDR addr, int len) +win32_remove_point (enum raw_bkpt_type type, CORE_ADDR addr, + int size, struct raw_breakpoint *bp) { if (the_low_target.remove_point != NULL) - return the_low_target.remove_point (type, addr, len); + return the_low_target.remove_point (type, addr, size, bp); else /* Unsupported (see target.h). */ return 1; @@ -321,7 +339,7 @@ child_xfer_memory (CORE_ADDR memaddr, char *our, int len, static void child_init_thread_list (void) { - for_each_inferior (&all_threads, delete_thread_info); + for_each_thread (delete_thread_info); } /* Zero during the child initialization phase, and nonzero otherwise. */ @@ -404,32 +422,32 @@ do_initial_child_stuff (HANDLE proch, DWORD pid, int attached) /* Resume all artificially suspended threads if we are continuing execution. */ -static int -continue_one_thread (struct inferior_list_entry *this_thread, void *id_ptr) +static void +continue_one_thread (thread_info *thread, int thread_id) { - struct thread_info *thread = (struct thread_info *) this_thread; - int thread_id = * (int *) id_ptr; - win32_thread_info *th = inferior_target_data (thread); + win32_thread_info *th = (win32_thread_info *) thread_target_data (thread); - if ((thread_id == -1 || thread_id == th->tid) - && th->suspended) + if (thread_id == -1 || thread_id == th->tid) { - if (th->context.ContextFlags) - { - win32_set_thread_context (th); - th->context.ContextFlags = 0; - } + win32_prepare_to_resume (th); - if (ResumeThread (th->h) == (DWORD) -1) + if (th->suspended) { - DWORD err = GetLastError (); - OUTMSG (("warning: ResumeThread failed in continue_one_thread, " - "(error %d): %s\n", (int) err, strwinerror (err))); + if (th->context.ContextFlags) + { + win32_set_thread_context (th); + th->context.ContextFlags = 0; + } + + if (ResumeThread (th->h) == (DWORD) -1) + { + DWORD err = GetLastError (); + OUTMSG (("warning: ResumeThread failed in continue_one_thread, " + "(error %d): %s\n", (int) err, strwinerror (err))); + } + th->suspended = 0; } - th->suspended = 0; } - - return 0; } static BOOL @@ -437,7 +455,10 @@ child_continue (DWORD continue_status, int thread_id) { /* The inferior will only continue after the ContinueDebugEvent call. */ - find_inferior (&all_threads, continue_one_thread, &thread_id); + for_each_thread ([&] (thread_info *thread) + { + continue_one_thread (thread, thread_id); + }); faked_breakpoint = 0; if (!ContinueDebugEvent (current_event.dwProcessId, @@ -453,7 +474,7 @@ static void child_fetch_inferior_registers (struct regcache *regcache, int r) { int regno; - win32_thread_info *th = thread_rec (current_inferior_ptid (), TRUE); + win32_thread_info *th = thread_rec (current_thread_ptid (), TRUE); if (r == -1 || r > NUM_REGS) child_fetch_inferior_registers (regcache, NUM_REGS); else @@ -467,7 +488,7 @@ static void child_store_inferior_registers (struct regcache *regcache, int r) { int regno; - win32_thread_info *th = thread_rec (current_inferior_ptid (), TRUE); + win32_thread_info *th = thread_rec (current_thread_ptid (), TRUE); if (r == -1 || r == 0 || r > NUM_REGS) child_store_inferior_registers (regcache, NUM_REGS); else @@ -496,7 +517,7 @@ strwinerror (DWORD error) NULL, error, 0, /* Default language */ - (LPVOID)&msgbuf, + (LPTSTR) &msgbuf, 0, NULL); if (chars != 0) @@ -534,10 +555,11 @@ static BOOL create_process (const char *program, char *args, DWORD flags, PROCESS_INFORMATION *pi) { + const char *inferior_cwd = get_inferior_cwd (); BOOL ret; #ifdef _WIN32_WCE - wchar_t *p, *wprogram, *wargs; + wchar_t *p, *wprogram, *wargs, *wcwd = NULL; size_t argslen; wprogram = alloca ((strlen (program) + 1) * sizeof (wchar_t)); @@ -551,6 +573,20 @@ create_process (const char *program, char *args, wargs = alloca ((argslen + 1) * sizeof (wchar_t)); mbstowcs (wargs, args, argslen + 1); + if (inferior_cwd != NULL) + { + std::string expanded_infcwd = gdb_tilde_expand (inferior_cwd); + std::replace (expanded_infcwd.begin (), expanded_infcwd.end (), + '/', '\\'); + wcwd = alloca ((expanded_infcwd.size () + 1) * sizeof (wchar_t)); + if (mbstowcs (wcwd, expanded_infcwd.c_str (), + expanded_infcwd.size () + 1) == NULL) + { + error (_("\ +Could not convert the expanded inferior cwd to wide-char.")); + } + } + ret = CreateProcessW (wprogram, /* image name */ wargs, /* command line */ NULL, /* security, not supported */ @@ -558,7 +594,7 @@ create_process (const char *program, char *args, FALSE, /* inherit handles, not supported */ flags, /* start flags */ NULL, /* environment, not supported */ - NULL, /* current directory, not supported */ + wcwd, /* current directory */ NULL, /* start info, not supported */ pi); /* proc info */ #else @@ -571,7 +607,10 @@ create_process (const char *program, char *args, TRUE, /* inherit handles */ flags, /* start flags */ NULL, /* environment */ - NULL, /* current directory */ + /* current directory */ + (inferior_cwd == NULL + ? NULL + : gdb_tilde_expand (inferior_cwd).c_str()), &si, /* start info */ pi); /* proc info */ #endif @@ -580,25 +619,25 @@ create_process (const char *program, char *args, } /* Start a new process. - PROGRAM is a path to the program to execute. - ARGS is a standard NULL-terminated array of arguments, - to be passed to the inferior as ``argv''. + PROGRAM is the program name. + PROGRAM_ARGS is the vector containing the inferior's args. Returns the new PID on success, -1 on failure. Registers the new process with the process list. */ static int -win32_create_inferior (char *program, char **program_args) +win32_create_inferior (const char *program, + const std::vector &program_args) { + client_state &cs = get_client_state (); #ifndef USE_WIN32API char real_path[PATH_MAX]; char *orig_path, *new_path, *path_ptr; #endif BOOL ret; DWORD flags; - char *args; - int argslen; - int argc; PROCESS_INFORMATION pi; DWORD err; + std::string str_program_args = stringify_argv (program_args); + char *args = (char *) str_program_args.c_str (); /* win32_wait needs to know we're not attaching. */ attaching = 0; @@ -614,8 +653,8 @@ win32_create_inferior (char *program, char **program_args) if (path_ptr) { int size = cygwin_conv_path_list (CCP_POSIX_TO_WIN_A, path_ptr, NULL, 0); - orig_path = alloca (strlen (path_ptr) + 1); - new_path = alloca (size); + orig_path = (char *) alloca (strlen (path_ptr) + 1); + new_path = (char *) alloca (size); strcpy (orig_path, path_ptr); cygwin_conv_path_list (CCP_POSIX_TO_WIN_A, path_ptr, new_path, size); setenv ("PATH", new_path, 1); @@ -624,18 +663,6 @@ win32_create_inferior (char *program, char **program_args) program = real_path; #endif - argslen = 1; - for (argc = 1; program_args[argc]; argc++) - argslen += strlen (program_args[argc]) + 1; - args = alloca (argslen); - args[0] = '\0'; - for (argc = 1; program_args[argc]; argc++) - { - /* FIXME: Can we do better about quoting? How does Cygwin - handle this? */ - strcat (args, " "); - strcat (args, program_args[argc]); - } OUTMSG2 (("Command line is \"%s\"\n", args)); #ifdef CREATE_NEW_PROCESS_GROUP @@ -646,7 +673,7 @@ win32_create_inferior (char *program, char **program_args) err = GetLastError (); if (!ret && err == ERROR_FILE_NOT_FOUND) { - char *exename = alloca (strlen (program) + 5); + char *exename = (char *) alloca (strlen (program) + 5); strcat (strcpy (exename, program), ".exe"); ret = create_process (exename, args, flags, &pi); err = GetLastError (); @@ -676,6 +703,10 @@ win32_create_inferior (char *program, char **program_args) do_initial_child_stuff (pi.hProcess, pi.dwProcessId, 0); + /* Wait till we are at 1st instruction in program, return new pid + (assuming success). */ + cs.last_ptid = win32_wait (ptid_t (current_process_id), &cs.last_status, 0); + return current_process_id; } @@ -719,7 +750,7 @@ win32_attach (unsigned long pid) /* Handle OUTPUT_DEBUG_STRING_EVENT from child process. */ static void -handle_output_debug_string (struct target_waitstatus *ourstatus) +handle_output_debug_string (void) { #define READ_BUFFER_LEN 1024 CORE_ADDR addr; @@ -749,7 +780,7 @@ handle_output_debug_string (struct target_waitstatus *ourstatus) return; } - if (strncmp (s, "cYg", 3) != 0) + if (!startswith (s, "cYg")) { if (!server_waiting) { @@ -768,19 +799,15 @@ win32_clear_inferiors (void) if (current_process_handle != NULL) CloseHandle (current_process_handle); - for_each_inferior (&all_threads, delete_thread_info); + for_each_thread (delete_thread_info); clear_inferiors (); } -/* Kill all inferiors. */ +/* Implementation of target_ops::kill. */ + static int -win32_kill (int pid) +win32_kill (process_info *process) { - struct process_info *process; - - if (current_process_handle == NULL) - return -1; - TerminateProcess (current_process_handle, 0); for (;;) { @@ -791,24 +818,20 @@ win32_kill (int pid) if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT) break; else if (current_event.dwDebugEventCode == OUTPUT_DEBUG_STRING_EVENT) - { - struct target_waitstatus our_status = { 0 }; - handle_output_debug_string (&our_status); - } + handle_output_debug_string (); } win32_clear_inferiors (); - process = find_process_pid (pid); remove_process (process); return 0; } -/* Detach from inferior PID. */ +/* Implementation of target_ops::detach. */ + static int -win32_detach (int pid) +win32_detach (process_info *process) { - struct process_info *process; winapi_DebugActiveProcessStop DebugActiveProcessStop = NULL; winapi_DebugSetProcessKillOnExit DebugSetProcessKillOnExit = NULL; #ifdef _WIN32_WCE @@ -835,7 +858,6 @@ win32_detach (int pid) return -1; DebugSetProcessKillOnExit (FALSE); - process = find_process_pid (pid); remove_process (process); win32_clear_inferiors (); @@ -848,7 +870,8 @@ win32_mourn (struct process_info *process) remove_process (process); } -/* Wait for inferiors to end. */ +/* Implementation of target_ops::join. */ + static void win32_join (int pid) { @@ -864,15 +887,9 @@ win32_join (int pid) static int win32_thread_alive (ptid_t ptid) { - int res; - /* Our thread list is reliable; don't bother to poll target threads. */ - if (find_inferior_id (&all_threads, ptid) != NULL) - res = 1; - else - res = 0; - return res; + return find_thread_ptid (ptid) != NULL; } /* Resume the inferior process. RESUME_INFO describes how we want @@ -890,7 +907,7 @@ win32_resume (struct thread_resume *resume_info, size_t n) /* This handles the very limited set of resume packets that GDB can currently produce. */ - if (n == 1 && ptid_equal (resume_info[0].thread, minus_one_ptid)) + if (n == 1 && resume_info[0].thread == minus_one_ptid) tid = -1; else if (n > 1) tid = -1; @@ -899,14 +916,14 @@ win32_resume (struct thread_resume *resume_info, size_t n) the Windows resume code do the right thing for thread switching. */ tid = current_event.dwThreadId; - if (!ptid_equal (resume_info[0].thread, minus_one_ptid)) + if (resume_info[0].thread != minus_one_ptid) { - sig = resume_info[0].sig; + sig = gdb_signal_from_host (resume_info[0].sig); step = resume_info[0].kind == resume_step; } else { - sig = 0; + sig = GDB_SIGNAL_0; step = 0; } @@ -914,12 +931,14 @@ win32_resume (struct thread_resume *resume_info, size_t n) { if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT) { - OUTMSG (("Cannot continue with signal %d here.\n", sig)); + OUTMSG (("Cannot continue with signal %s here.\n", + gdb_signal_to_string (sig))); } else if (sig == last_sig) continue_status = DBG_EXCEPTION_NOT_HANDLED; else - OUTMSG (("Can only continue with recieved signal %d.\n", last_sig)); + OUTMSG (("Can only continue with received signal %s.\n", + gdb_signal_to_string (last_sig))); } last_sig = GDB_SIGNAL_0; @@ -929,6 +948,8 @@ win32_resume (struct thread_resume *resume_info, size_t n) th = thread_rec (ptid, FALSE); if (th) { + win32_prepare_to_resume (th); + if (th->context.ContextFlags) { /* Move register values from the inferior into the thread @@ -1055,7 +1076,7 @@ get_image_name (HANDLE h, void *address, int unicode) ReadProcessMemory (h, address_ptr, buf, len, &done); else { - WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR)); + WCHAR *unicode_address = XALLOCAVEC (WCHAR, len); ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR), &done); @@ -1312,10 +1333,9 @@ handle_exception (struct target_waitstatus *ourstatus) static void -suspend_one_thread (struct inferior_list_entry *entry) +suspend_one_thread (thread_info *thread) { - struct thread_info *thread = (struct thread_info *) entry; - win32_thread_info *th = inferior_target_data (thread); + win32_thread_info *th = (win32_thread_info *) thread_target_data (thread); if (!th->suspended) { @@ -1343,7 +1363,7 @@ fake_breakpoint_event (void) current_event.u.Exception.ExceptionRecord.ExceptionCode = EXCEPTION_BREAKPOINT; - for_each_inferior (&all_threads, suspend_one_thread); + for_each_thread (suspend_one_thread); } #ifdef _WIN32_WCE @@ -1453,7 +1473,7 @@ get_child_debug_event (struct target_waitstatus *ourstatus) child_delete_thread (current_event.dwProcessId, current_event.dwThreadId); - current_inferior = (struct thread_info *) all_threads.head; + current_thread = get_first_thread (); return 1; case CREATE_PROCESS_DEBUG_EVENT: @@ -1466,16 +1486,12 @@ get_child_debug_event (struct target_waitstatus *ourstatus) current_process_handle = current_event.u.CreateProcessInfo.hProcess; main_thread_id = current_event.dwThreadId; - ourstatus->kind = TARGET_WAITKIND_EXECD; - ourstatus->value.execd_pathname = "Main executable"; - /* Add the main thread. */ child_add_thread (current_event.dwProcessId, main_thread_id, current_event.u.CreateProcessInfo.hThread, current_event.u.CreateProcessInfo.lpThreadLocalBase); - ourstatus->value.related_pid = debug_event_ptid (¤t_event); #ifdef _WIN32_WCE if (!attaching) { @@ -1542,7 +1558,7 @@ get_child_debug_event (struct target_waitstatus *ourstatus) "for pid=%u tid=%x\n", (unsigned) current_event.dwProcessId, (unsigned) current_event.dwThreadId)); - handle_output_debug_string (ourstatus); + handle_output_debug_string (); break; default: @@ -1555,8 +1571,7 @@ get_child_debug_event (struct target_waitstatus *ourstatus) } ptid = debug_event_ptid (¤t_event); - current_inferior = - (struct thread_info *) find_inferior_id (&all_threads, ptid); + current_thread = find_thread_ptid (ptid); return 1; } @@ -1590,20 +1605,19 @@ win32_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options) OUTMSG2 (("Child exited with retcode = %x\n", ourstatus->value.integer)); win32_clear_inferiors (); - return pid_to_ptid (current_event.dwProcessId); + return ptid_t (current_event.dwProcessId); case TARGET_WAITKIND_STOPPED: case TARGET_WAITKIND_LOADED: OUTMSG2 (("Child Stopped with signal = %d \n", ourstatus->value.sig)); - regcache = get_thread_regcache (current_inferior, 1); + regcache = get_thread_regcache (current_thread, 1); child_fetch_inferior_registers (regcache, -1); return debug_event_ptid (¤t_event); default: OUTMSG (("Ignoring unknown internal event, %d\n", ourstatus->kind)); /* fall-through */ case TARGET_WAITKIND_SPURIOUS: - case TARGET_WAITKIND_EXECD: /* do nothing, just continue */ child_continue (DBG_CONTINUE, -1); break; @@ -1754,8 +1768,18 @@ win32_get_tib_address (ptid_t ptid, CORE_ADDR *addr) return 1; } +/* Implementation of the target_ops method "sw_breakpoint_from_kind". */ + +static const gdb_byte * +win32_sw_breakpoint_from_kind (int kind, int *size) +{ + *size = the_low_target.breakpoint_len; + return the_low_target.breakpoint; +} + static struct target_ops win32_target_ops = { win32_create_inferior, + NULL, /* post_create_inferior */ win32_attach, win32_kill, win32_detach, @@ -1773,8 +1797,14 @@ static struct target_ops win32_target_ops = { NULL, /* lookup_symbols */ win32_request_interrupt, NULL, /* read_auxv */ + win32_supports_z_point_type, win32_insert_point, win32_remove_point, + NULL, /* stopped_by_sw_breakpoint */ + NULL, /* supports_stopped_by_sw_breakpoint */ + NULL, /* stopped_by_hw_breakpoint */ + NULL, /* supports_stopped_by_hw_breakpoint */ + target_can_do_hardware_single_step, win32_stopped_by_watchpoint, win32_stopped_data_address, NULL, /* read_offsets */ @@ -1791,6 +1821,10 @@ static struct target_ops win32_target_ops = { NULL, /* async */ NULL, /* start_non_stop */ NULL, /* supports_multi_process */ + NULL, /* supports_fork_events */ + NULL, /* supports_vfork_events */ + NULL, /* supports_exec_events */ + NULL, /* handle_new_gdb_connection */ NULL, /* handle_monitor_command */ NULL, /* core_of_thread */ NULL, /* read_loadmap */ @@ -1799,7 +1833,27 @@ static struct target_ops win32_target_ops = { NULL, /* read_pc */ NULL, /* write_pc */ NULL, /* thread_stopped */ - win32_get_tib_address + win32_get_tib_address, + NULL, /* pause_all */ + NULL, /* unpause_all */ + NULL, /* stabilize_threads */ + NULL, /* install_fast_tracepoint_jump_pad */ + NULL, /* emit_ops */ + NULL, /* supports_disable_randomization */ + NULL, /* get_min_fast_tracepoint_insn_len */ + NULL, /* qxfer_libraries_svr4 */ + NULL, /* support_agent */ + NULL, /* enable_btrace */ + NULL, /* disable_btrace */ + NULL, /* read_btrace */ + NULL, /* read_btrace_conf */ + NULL, /* supports_range_stepping */ + NULL, /* pid_to_exec_file */ + NULL, /* multifs_open */ + NULL, /* multifs_unlink */ + NULL, /* multifs_readlink */ + NULL, /* breakpoint_kind_from_pc */ + win32_sw_breakpoint_from_kind, }; /* Initialize the Win32 backend. */ @@ -1807,8 +1861,5 @@ void initialize_low (void) { set_target_ops (&win32_target_ops); - if (the_low_target.breakpoint != NULL) - set_breakpoint_data (the_low_target.breakpoint, - the_low_target.breakpoint_len); the_low_target.arch_setup (); }