Attachment #4429 for bug #10645

(-)a/gdb/breakpoint.c (-11 / +43 lines)

Lines 1198-1204 update_watchpoint (struct breakpoint *b, int reparse)	Link Here

1198

		  addr = value_address (v);

1198

		  addr = value_address (v);

1199

		  len = TYPE_LENGTH (value_type (v));

1199

		  len = TYPE_LENGTH (value_type (v));

1200

		  type = hw_write;

1200

		  type = hw_write;

1201

		  if (b->type == bp_read_watchpoint)

1201

		  if (v == val_chain && value_lazy (v))

1202

		    type = hw_mmap;

1203

		  else if (b->type == bp_read_watchpoint)

1204

1202

		    type = hw_read;

1205

		    type = hw_read;

1203

		  else if (b->type == bp_access_watchpoint)

1206

		  else if (b->type == bp_access_watchpoint)

1204

		    type = hw_access;

1207

		    type = hw_access;

Lines 1472-1480 Note: automatically using hardware breakpoints for read-only addresses.\n"));	Link Here

1472

	      watchpoints.  It's not clear that it's necessary... */

1475

	      watchpoints.  It's not clear that it's necessary... */

1473

	   && bpt->owner->disposition != disp_del_at_next_stop)

1476

	   && bpt->owner->disposition != disp_del_at_next_stop)

1474

1477

1475

      val = target_insert_watchpoint (bpt->address,

1478

      if (bpt->watchpoint_type == hw_mmap)

1476

				      bpt->length,

1479

1477

				      bpt->watchpoint_type);

1480

	  struct inferior *inf = current_inferior ();

1481

1482

	  inf->trap_syscalls = 1;

1483

	  val = 0;

1484

1485

      else

1486

	val = target_insert_watchpoint (bpt->address,

1487

					bpt->length,

1488

					bpt->watchpoint_type);

1478

      bpt->inserted = (val != -1);

1489

      bpt->inserted = (val != -1);

1479

1490

1480

1491

Lines 2100-2108 remove_breakpoint_1 (struct bp_location *b, insertion_state_t is)	Link Here

2100

      struct value *n;

2111

      struct value *n;

2101

2112

2102

      b->inserted = (is == mark_inserted);

2113

      b->inserted = (is == mark_inserted);

2103

      val = target_remove_watchpoint (b->address, b->length,

2114

      if (b->watchpoint_type == hw_mmap)

2104

				      b->watchpoint_type);

2115

	val = 0;

2105

2116

      else

2117

	val = target_remove_watchpoint (b->address, b->length,

2118

					b->watchpoint_type);

2106

      /* Failure to remove any of the hardware watchpoints comes here.  */

2119

      /* Failure to remove any of the hardware watchpoints comes here.  */

2107

      if ((is == mark_uninserted) && (b->inserted))

2120

      if ((is == mark_uninserted) && (b->inserted))

2108

	warning (_("Could not remove hardware watchpoint %d."),

2121

	warning (_("Could not remove hardware watchpoint %d."),

Lines 3162-3167 watchpoints_triggered (struct target_waitstatus *ws)	Link Here

3162

  return 1;

3175

  return 1;

3163

3176

3164

3177

3178

void

3179

mmap_watchpoints_triggered (void)

3180

3181

  struct breakpoint *b;

3182

3183

  ALL_BREAKPOINTS (b)

3184

    if (b->type == bp_hardware_watchpoint)

3185

3186

	struct bp_location *loc;

3187

3188

	for (loc = b->loc; loc; loc = loc->next)

3189

	  if (loc->watchpoint_type == hw_mmap)

3190

3191

	      b->watchpoint_triggered = watch_triggered_yes;

3192

	      break;

3193

3194

3195

3196

3165

/* Possible return values for watchpoint_check (this can't be an enum

3197

/* Possible return values for watchpoint_check (this can't be an enum

3166

   because of check_errors).  */

3198

   because of check_errors).  */

3167

/* The watchpoint has been deleted.  */

3199

/* The watchpoint has been deleted.  */

Lines 7084-7090 watch_command_1 (char *arg, int accessflag, int from_tty)	Link Here

7084

  struct breakpoint *b, *scope_breakpoint = NULL;

7116

  struct breakpoint *b, *scope_breakpoint = NULL;

7085

  struct expression *exp;

7117

  struct expression *exp;

7086

  struct block *exp_valid_block;

7118

  struct block *exp_valid_block;

7087

  struct value *val, *mark;

7119

  struct value *val, *mark, *result;

7088

  struct frame_info *frame;

7120

  struct frame_info *frame;

7089

  char *exp_start = NULL;

7121

  char *exp_start = NULL;

7090

  char *exp_end = NULL;

7122

  char *exp_end = NULL;

Lines 7171-7177 watch_command_1 (char *arg, int accessflag, int from_tty)	Link Here

7171

7203

7172

  exp_valid_block = innermost_block;

7204

  exp_valid_block = innermost_block;

7173

  mark = value_mark ();

7205

  mark = value_mark ();

7174

  fetch_watchpoint_value (exp, &val, NULL, NULL);

7206

  fetch_watchpoint_value (exp, &val, &result, NULL);

7175

  if (val != NULL)

7207

  if (val != NULL)

7176

    release_value (val);

7208

    release_value (val);

7177

7209

Lines 7206-7212 watch_command_1 (char *arg, int accessflag, int from_tty)	Link Here

7206

  mem_cnt = can_use_hardware_watchpoint (val);

7238

  mem_cnt = can_use_hardware_watchpoint (val);

7207

  if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)

7239

  if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)

7208

    error (_("Expression cannot be implemented with read/access watchpoint."));

7240

    error (_("Expression cannot be implemented with read/access watchpoint."));

7209

  if (mem_cnt != 0)

7241

  if (mem_cnt != 0 || !val)

7210

7242

7211

      i = hw_watchpoint_used_count (bp_type, &other_type_used);

7243

      i = hw_watchpoint_used_count (bp_type, &other_type_used);

7212

      target_resources_ok =

7244

      target_resources_ok =

Lines 7221-7227 watch_command_1 (char *arg, int accessflag, int from_tty)	Link Here

7221

7253

7222

  /* Change the type of breakpoint to an ordinary watchpoint if a hardware

7254

  /* Change the type of breakpoint to an ordinary watchpoint if a hardware

7223

     watchpoint could not be set.  */

7255

     watchpoint could not be set.  */

7224

  if (!mem_cnt || target_resources_ok <= 0)

7256

  if ((!mem_cnt && val) || target_resources_ok <= 0)

7225

    bp_type = bp_watchpoint;

7257

    bp_type = bp_watchpoint;

7226

7258

7227

  frame = block_innermost_frame (exp_valid_block);

7259

  frame = block_innermost_frame (exp_valid_block);

(-)a/gdb/breakpoint.h (-1 / +4 lines)

Lines 168-174 enum target_hw_bp_type	Link Here

168

    hw_write   = 0, 		/* Common  HW watchpoint */

168

    hw_write   = 0, 		/* Common  HW watchpoint */

169

    hw_read    = 1, 		/* Read    HW watchpoint */

169

    hw_read    = 1, 		/* Read    HW watchpoint */

170

    hw_access  = 2, 		/* Access  HW watchpoint */

170

    hw_access  = 2, 		/* Access  HW watchpoint */

171

    hw_execute = 3		/* Execute HW breakpoint */

171

    hw_execute = 3,		/* Execute HW breakpoint */

172

    hw_mmap    = 4		/* Memory area gets mmap(2)ed.  */

172

};

173

};

173

174

175

Lines 957-962 extern int deprecated_remove_raw_breakpoint (struct gdbarch , void );	Link Here

957

   target.  */

958

   target.  */

958

int watchpoints_triggered (struct target_waitstatus *);

959

int watchpoints_triggered (struct target_waitstatus *);

959

960

961

extern void mmap_watchpoints_triggered (void);

962

960

/* Update BUF, which is LEN bytes read from the target address MEMADDR,

963

/* Update BUF, which is LEN bytes read from the target address MEMADDR,

961

   by replacing any memory breakpoints with their shadowed contents.  */

964

   by replacing any memory breakpoints with their shadowed contents.  */

962

void breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr,

965

void breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr,

(-)a/gdb/gdb_ptrace.h (+6 lines)

Lines 92-97	Link Here

# endif

# endif

#endif

#endif

#ifndef PT_SYSCALL

# define PT_SYSCALL	24	/* Continue and stop at the next (return from)

				   syscall.  */

#endif

100

/* Not all systems support attaching and detaching.   */

101

/* Not all systems support attaching and detaching.   */

102

#ifndef PT_ATTACH

103

#ifndef PT_ATTACH

(-)a/gdb/inf-ptrace.c (-1 / +4 lines)

Lines 346-352 inf_ptrace_resume (struct target_ops *ops,	Link Here

346

  else

346

  else

347

    request = PT_CONTINUE;

347

    request = PT_CONTINUE;

348

349

  if (step)

349

  if (step == 2)

350

    request = PT_SYSCALL;

351

  else if (step)

352

350

353

351

      /* If this system does not support PT_STEP, a higher level

354

      /* If this system does not support PT_STEP, a higher level

352

         function will have called single_step() to transmute the step

355

         function will have called single_step() to transmute the step

(-)a/gdb/inferior.h (+2 lines)

Lines 478-483 struct inferior	Link Here

478

  /* Per inferior data-pointers required by other GDB modules.  */

478

  /* Per inferior data-pointers required by other GDB modules.  */

479

  void **data;

479

  void **data;

480

  unsigned num_data;

480

  unsigned num_data;

481

482

  unsigned trap_syscalls : 1;

481

};

483

};

482

484

483

/* Keep a registry of per-inferior data-pointers required by other GDB

485

/* Keep a registry of per-inferior data-pointers required by other GDB




    }

  /* Do we need to do it the hard way, w/temp breakpoints?  */
  else if (step == 1)
    step = maybe_software_singlestep (gdbarch, pc);

  if (should_resume)


      inferior = current_inferior ();
      inferior->stop_soon = NO_STOP_QUIETLY;
      inferior->trap_syscalls = 0;
    }

  stop_after_trap = 0;

  CORE_ADDR pc;
  struct address_space *aspace;
  int oneproc = 0;
  struct inferior *inf;

  /* If we're stopped at a fork/vfork, follow the branch set by the
     "set follow-fork-mode" command; otherwise, we'll just proceed

  /* Reset to normal state.  */
  init_infwait_state ();

  inf = current_inferior ();

  /* Resume inferior.  */
  resume (oneproc || step || bpstat_should_step () ? 1 :
	  (inf->trap_syscalls ? 2 : 0),
	  tp->stop_signal);

  /* Wait for it to stop (if not standalone)
     and in any case decode why it stopped, and act accordingly.  */

  else
    stopped_by_watchpoint = watchpoints_triggered (&ecs->ws);

  if (ecs->ws.kind == TARGET_WAITKIND_STOPPED
      && ecs->ws.value.sig == TARGET_SIGNAL_TRAP)
    {
      struct inferior *inferior = current_inferior ();

      if (inferior->trap_syscalls)
	mmap_watchpoints_triggered ();
    }

  /* If necessary, step over this watchpoint.  We'll be back to display
     it in a moment.  */
  if (stopped_by_watchpoint




  return 0;
}

static const char *
step_string (int step)
{
  switch (step)
  {
    case 0:
      return "PTRACE_CONT";
    case 1:
      return "PTRACE_SINGLESTEP";
    case 2:
      return "PTRACE_SYSCALL";
    default:
      gdb_assert (0);
  }
}

static void
linux_nat_resume (struct target_ops *ops,
		  ptid_t ptid, int step, enum target_signal signo)

  if (debug_linux_nat)
    fprintf_unfiltered (gdb_stdlog,
			"LLR: %s %s, %s (resume event thread)\n",
			step_string(step),
			target_pid_to_str (ptid),
			signo ? strsignal (signo) : "0");


      if (debug_linux_nat)
	fprintf_unfiltered (gdb_stdlog,
			    "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
			    step_string(lp->step),
			    "PTRACE_SINGLESTEP" : "PTRACE_CONT",
			    target_pid_to_str (lp->ptid));

      lp->stopped = 0;

      if (debug_linux_nat)
	fprintf_unfiltered (gdb_stdlog,
			    "LLW: %s %s, 0, 0 (discard SIGINT)\n",
			    step_string(lp->step),
			    "PTRACE_SINGLESTEP" : "PTRACE_CONT",
			    target_pid_to_str (lp->ptid));

      lp->stopped = 0;

      if (debug_linux_nat)
	fprintf_unfiltered (gdb_stdlog,
			    "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
			    step_string(lp->step),
			    target_pid_to_str (lp->ptid));
      lp->stopped = 0;
      gdb_assert (lp->resumed);

	  if (debug_linux_nat)
	    fprintf_unfiltered (gdb_stdlog,
				"LLW: %s %s, %s (preempt 'handle')\n",
				step_string(lp->step),
				"PTRACE_SINGLESTEP" : "PTRACE_CONT",
				target_pid_to_str (lp->ptid),
				signo ? strsignal (signo) : "0");
	  lp->stopped = 0;
- 

Return to bug 10645