stop_pc = read_pc_pid (ecs->ptid) - DECR_PC_AFTER_BREAK;
breakpoint_pc = read_pc_pid (ecs->ptid) - DECR_PC_AFTER_BREAK;
adjust_pc_after_break (struct execution_control_state *ecs){  CORE_ADDR stop_pc;  /* If this target does not decrement the PC after breakpoints, then     we have nothing to do.  */  if (DECR_PC_AFTER_BREAK == 0)    return;  /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP.  If     we aren't, just return.     We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not     affected by DECR_PC_AFTER_BREAK.  Other waitkinds which are implemented     by software breakpoints should be handled through the normal breakpoint     layer.          NOTE drow/2004-01-31: On some targets, breakpoints may generate     different signals (SIGILL or SIGEMT for instance), but it is less     clear where the PC is pointing afterwards.  It may not match     DECR_PC_AFTER_BREAK.  I don't know any specific target that generates     these signals at breakpoints (the code has been in GDB since at least     1992) so I can not guess how to handle them here.          In earlier versions of GDB, a target with HAVE_NONSTEPPABLE_WATCHPOINTS     would have the PC after hitting a watchpoint affected by     DECR_PC_AFTER_BREAK.  I haven't found any target with both of these set     in GDB history, and it seems unlikely to be correct, so     HAVE_NONSTEPPABLE_WATCHPOINTS is not checked here.  */  if (ecs->ws.kind != TARGET_WAITKIND_STOPPED)    return;  if (ecs->ws.value.sig != TARGET_SIGNAL_TRAP)    return;  /* Find the location where (if we've hit a breakpoint) the breakpoint would     be.  */  stop_pc = read_pc_pid (ecs->ptid) - DECR_PC_AFTER_BREAK;  /* If we're software-single-stepping, then assume this is a breakpoint.     NOTE drow/2004-01-17: This doesn't check that the PC matches, or that     we're even in the right thread.  The software-single-step code needs     some modernization.     If we're not software-single-stepping, then we first check that there     is an enabled software breakpoint at this address.  If there is, and     we weren't using hardware-single-step, then we've hit the breakpoint.     If we were using hardware-single-step, we check prev_pc; if we just     stepped over an inserted software breakpoint, then we should decrement     the PC and eventually report hitting the breakpoint.  The prev_pc check     prevents us from decrementing the PC if we just stepped over a jump     instruction and landed on the instruction after a breakpoint.     The last bit checks that we didn't hit a breakpoint in a signal handler     without an intervening stop in sigtramp, which is detected by a new     stack pointer value below any usual function calling stack adjustments.     NOTE drow/2004-01-17: I'm not sure that this is necessary.  The check     predates checking for software single step at the same time.  Also,     if we've moved into a signal handler we should have seen the     signal.  */  if ((SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p)      || (software_breakpoint_inserted_here_p (stop_pc)	  && !(currently_stepping (ecs)	       && prev_pc != stop_pc	       && !(step_range_end && INNER_THAN (read_sp (), (step_sp - 16))))))    write_pc_pid (stop_pc, ecs->ptid);}