static int update_registers_callback (struct inferior_list_entry *entry, void *arg) { struct thread_info *thread = (struct thread_info *) entry; struct lwp_info *lwp = get_thread_lwp (thread); struct update_registers_data *data = (struct update_registers_data *) arg; /* Only update the threads of the current process. */ if (pid_of (thread) == pid_of (current_thread)) { /* The actual update is done later just before resuming the lwp, we just mark that the registers need updating. */ if (data->watch) lwp->arch_private->wpts_changed[data->i] = 1; else lwp->arch_private->bpts_changed[data->i] = 1; /* If the lwp isn't stopped, force it to momentarily pause, so we can update its breakpoint registers. */ if (!lwp->stopped) linux_stop_lwp (lwp); } return 0; }
static void update_registers_callback (thread_info *thread, int watch, int i) { struct lwp_info *lwp = get_thread_lwp (thread); /* The actual update is done later just before resuming the lwp, we just mark that the registers need updating. */ if (watch) lwp->arch_private->wpts_changed[i] = 1; else lwp->arch_private->bpts_changed[i] = 1; /* If the lwp isn't stopped, force it to momentarily pause, so we can update its breakpoint registers. */ if (!lwp->stopped) linux_stop_lwp (lwp); }
static int update_debug_registers_callback (struct lwp_info *lwp, void *arg) { if (lwp->arch_private == NULL) lwp->arch_private = XCNEW (struct arch_lwp_info); /* The actual update is done later just before resuming the lwp, we just mark that the registers need updating. */ lwp->arch_private->debug_registers_changed = 1; /* If the lwp isn't stopped, force it to momentarily pause, so we can update its debug registers. */ if (!lwp->stopped) linux_stop_lwp (lwp); /* Continue the iteration. */ return 0; }
static int debug_reg_change_callback (struct inferior_list_entry *entry, void *ptr) { struct thread_info *thread = (struct thread_info *) entry; struct lwp_info *lwp = get_thread_lwp (thread); struct aarch64_dr_update_callback_param *param_p = (struct aarch64_dr_update_callback_param *) ptr; int pid = param_p->pid; int idx = param_p->idx; int is_watchpoint = param_p->is_watchpoint; struct arch_lwp_info *info = lwp->arch_private; dr_changed_t *dr_changed_ptr; dr_changed_t dr_changed; if (show_debug_regs) { fprintf (stderr, "debug_reg_change_callback: \n\tOn entry:\n"); fprintf (stderr, "\tpid%d, tid: %ld, dr_changed_bp=0x%llx, " "dr_changed_wp=0x%llx\n", pid, lwpid_of (thread), info->dr_changed_bp, info->dr_changed_wp); } dr_changed_ptr = is_watchpoint ? &info->dr_changed_wp : &info->dr_changed_bp; dr_changed = *dr_changed_ptr; /* Only update the threads of this process. */ if (pid_of (thread) == pid) { gdb_assert (idx >= 0 && (idx <= (is_watchpoint ? aarch64_num_wp_regs : aarch64_num_bp_regs))); /* The following assertion is not right, as there can be changes that have not been made to the hardware debug registers before new changes overwrite the old ones. This can happen, for instance, when the breakpoint/watchpoint hit one of the threads and the user enters continue; then what happens is: 1) all breakpoints/watchpoints are removed for all threads; 2) a single step is carried out for the thread that was hit; 3) all of the points are inserted again for all threads; 4) all threads are resumed. The 2nd step will only affect the one thread in which the bp/wp was hit, which means only that one thread is resumed; remember that the actual updating only happen in aarch64_linux_prepare_to_resume, so other threads remain stopped during the removal and insertion of bp/wp. Therefore for those threads, the change of insertion of the bp/wp overwrites that of the earlier removals. (The situation may be different when bp/wp is steppable, or in the non-stop mode.) */ /* gdb_assert (DR_N_HAS_CHANGED (dr_changed, idx) == 0); */ /* The actual update is done later just before resuming the lwp, we just mark that one register pair needs updating. */ DR_MARK_N_CHANGED (dr_changed, idx); *dr_changed_ptr = dr_changed; /* If the lwp isn't stopped, force it to momentarily pause, so we can update its debug registers. */ if (!lwp->stopped) linux_stop_lwp (lwp); } if (show_debug_regs) { fprintf (stderr, "\tOn exit:\n\tpid%d, tid: %ld, dr_changed_bp=0x%llx, " "dr_changed_wp=0x%llx\n", pid, lwpid_of (thread), info->dr_changed_bp, info->dr_changed_wp); } return 0; }