discard_cleanups (old_chain);
}
-/* Print a message indicating what happened. Returns nonzero to
- say that only the source line should be printed after this (zero
- return means print the frame as well as the source line). */
+/* This is the normal print_it function for a bpstat. In the future,
+ much of this logic could (should?) be moved to bpstat_stop_status,
+ by having it set different print_it functions. */
-int
-bpstat_print (bs)
+static int
+print_it_normal (bs)
bpstat bs;
{
/* bs->breakpoint_at can be NULL if it was a momentary breakpoint
which has since been deleted. */
- if (bs == NULL
- || bs->breakpoint_at == NULL
+ if (bs->breakpoint_at == NULL
|| (bs->breakpoint_at->type != bp_breakpoint
&& bs->breakpoint_at->type != bp_watchpoint))
return 0;
bs->old_val = NULL;
return 1;
}
+ /* We can't deal with it. Maybe another member of the bpstat chain can. */
+ return -1;
+}
+
+/* Print a message indicating what happened. Returns nonzero to
+ say that only the source line should be printed after this (zero
+ return means print the frame as well as the source line). */
+
+int
+bpstat_print (bs)
+ bpstat bs;
+{
+ int val;
+
+ if (bs == NULL)
+ return 0;
+ val = (*bs->print_it) (bs);
+ if (val >= 0)
+ return val;
+
/* Maybe another breakpoint in the chain caused us to stop.
(Currently all watchpoints go on the bpstat whether hit or
not. That probably could (should) be changed, provided care is taken
bs->commands = NULL;
bs->momentary = b->disposition == delete;
bs->old_val = NULL;
+ bs->print_it = print_it_normal;
return bs;
}
+/* Possible return values for watchpoint_check (this can't be an enum
+ because of check_errors). */
+/* The watchpoint has been disabled. */
+#define WP_DISABLED 1
+/* The value has changed. */
+#define WP_VALUE_CHANGED 2
+/* The value has not changed. */
+#define WP_VALUE_NOT_CHANGED 3
+
+/* Check watchpoint condition. */
+static int
+watchpoint_check (p)
+ PTR p;
+{
+ bpstat bs = (bpstat) p;
+
+ int within_current_scope;
+ if (bs->breakpoint_at->exp_valid_block != NULL)
+ within_current_scope =
+ contained_in (get_selected_block (), bs->breakpoint_at->exp_valid_block);
+ else
+ within_current_scope = 1;
+
+ if (within_current_scope)
+ {
+ /* We use value_{,free_to_}mark because it could be a
+ *long* time before we return to the command level and
+ call free_all_values. */
+ /* But couldn't we just call free_all_values instead? */
+
+ value mark = value_mark ();
+ value new_val = evaluate_expression (bs->breakpoint_at->exp);
+ if (!value_equal (bs->breakpoint_at->val, new_val))
+ {
+ release_value (new_val);
+ value_free_to_mark (mark);
+ bs->old_val = bs->breakpoint_at->val;
+ bs->breakpoint_at->val = new_val;
+ /* We will stop here */
+ return WP_VALUE_CHANGED;
+ }
+ else
+ {
+ /* Nothing changed, don't do anything. */
+ value_free_to_mark (mark);
+ /* We won't stop here */
+ return WP_VALUE_NOT_CHANGED;
+ }
+ }
+ else
+ {
+ /* This seems like the only logical thing to do because
+ if we temporarily ignored the watchpoint, then when
+ we reenter the block in which it is valid it contains
+ garbage (in the case of a function, it may have two
+ garbage values, one before and one after the prologue).
+ So we can't even detect the first assignment to it and
+ watch after that (since the garbage may or may not equal
+ the first value assigned). */
+ bs->breakpoint_at->enable = disabled;
+ printf_filtered ("\
+Watchpoint %d disabled because the program has left the block in\n\
+which its expression is valid.\n", bs->breakpoint_at->number);
+ return WP_DISABLED;
+ }
+}
+
+/* This is used when everything which needs to be printed has
+ already been printed. But we still want to print the frame. */
+static int
+print_it_noop (bs)
+ bpstat bs;
+{
+ return 0;
+}
+
/* Determine whether we stopped at a breakpoint, etc, or whether we
don't understand this stop. Result is a chain of bpstat's such that:
Each element of the chain refers to a particular breakpoint or
watchpoint at which we have stopped. (We may have stopped for
- several reasons.)
+ several reasons concurrently.)
Each element of the chain has valid next, breakpoint_at,
commands, FIXME??? fields.
if (b->type == bp_watchpoint)
{
- int within_current_scope;
- if (b->exp_valid_block != NULL)
- within_current_scope =
- contained_in (get_selected_block (), b->exp_valid_block);
- else
- within_current_scope = 1;
-
- if (within_current_scope)
- {
- /* We use value_{,free_to_}mark because it could be a
- *long* time before we return to the command level and
- call free_all_values. */
-
- value mark = value_mark ();
- value new_val = evaluate_expression (b->exp);
- if (!value_equal (b->val, new_val))
- {
- release_value (new_val);
- value_free_to_mark (mark);
- bs->old_val = b->val;
- b->val = new_val;
- /* We will stop here */
- }
- else
- {
- /* Nothing changed, don't do anything. */
- value_free_to_mark (mark);
- continue;
- /* We won't stop here */
- }
- }
- else
+ static char message1[] =
+ "Error evaluating expression for watchpoint %d\n";
+ char message[sizeof (message1) + 30 /* slop */];
+ sprintf (message, message1, b->number);
+ switch (catch_errors (watchpoint_check, bs, message))
{
- /* This seems like the only logical thing to do because
- if we temporarily ignored the watchpoint, then when
- we reenter the block in which it is valid it contains
- garbage (in the case of a function, it may have two
- garbage values, one before and one after the prologue).
- So we can't even detect the first assignment to it and
- watch after that (since the garbage may or may not equal
- the first value assigned). */
- b->enable = disabled;
- printf_filtered ("\
-Watchpoint %d disabled because the program has left the block in\n\
-which its expression is valid.\n", b->number);
- /* We won't stop here */
- /* FIXME, maybe we should stop here!!! */
+ case WP_DISABLED:
+ /* We've already printed what needs to be printed. */
+ bs->print_it = print_it_noop;
+ /* Stop. */
+ break;
+ case WP_VALUE_CHANGED:
+ /* Stop. */
+ break;
+ case WP_VALUE_NOT_CHANGED:
+ /* Don't stop. */
continue;
+ default:
+ /* Can't happen. */
+ /* FALLTHROUGH */
+ case 0:
+ /* Error from catch_errors. */
+ b->enable = disabled;
+ printf_filtered ("Watchpoint %d disabled.\n", b->number);
+ /* We've already printed what needs to be printed. */
+ bs->print_it = print_it_noop;
+ /* Stop. */
+ break;
}
}
#if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
bs->commands = b->commands;
if (b->silent)
this_bp_print = 0;
- if (bs->commands && !strcmp ("silent", bs->commands->line))
+ if (bs->commands && STREQ ("silent", bs->commands->line))
{
bs->commands = bs->commands->next;
this_bp_print = 0;
if (sym)
{
fputs_filtered ("in ", stdout);
- fputs_demangled (SYMBOL_NAME (sym), stdout,
- DMGL_ANSI | DMGL_PARAMS);
+ fputs_filtered (SYMBOL_SOURCE_NAME (sym), stdout);
fputs_filtered (" at ", stdout);
}
fputs_filtered (b->symtab->filename, stdout);
m = lookup_minimal_symbol(func_name, (struct objfile *)NULL);
if (m)
- sal.pc = m->address;
+ sal.pc = SYMBOL_VALUE_ADDRESS (m);
else
return;
}
b->number = breakpoint_count;
b->type = bp_breakpoint;
b->cond = cond;
-
+
+ /* FIXME: We should add the filename if this is a static function
+ and probably if it is a line number (the line numbers could
+ have changed when we re-read symbols; possibly better to disable
+ the breakpoint in that case). */
if (addr_start)
b->addr_string = savestring (addr_start, addr_end - addr_start);
if (cond_start)
exp_valid_block = innermost_block;
val = evaluate_expression (exp);
release_value (val);
+ if (VALUE_LAZY (val))
+ value_fetch_lazy (val);
/* Now set up the breakpoint. */
b = set_raw_breakpoint (sal);
b->val = val;
b->cond = 0;
b->cond_string = NULL;
+ b->exp_string = savestring (arg, strlen (arg));
mention (b);
}
\f
for (i = 0; i < nsyms; i++)
{
sym = BLOCK_SYM (b, i);
- if (! strcmp (SYMBOL_NAME (sym), "default"))
+ if (STREQ (SYMBOL_NAME (sym), "default"))
{
if (have_default)
continue;
free ((PTR)bpt->cond_string);
if (bpt->addr_string != NULL)
free ((PTR)bpt->addr_string);
+ if (bpt->exp_string != NULL)
+ free ((PTR)bpt->exp_string);
if (xgdb_verbose && bpt->type == bp_breakpoint)
printf ("breakpoint #%d deleted\n", bpt->number);
if (b->cond_string != NULL)
{
s = b->cond_string;
+ if (b->cond)
+ free ((PTR)b->cond);
b->cond = parse_exp_1 (&s, block_for_pc (sals.sals[i].pc), 0);
}
}
free ((PTR)sals.sals);
break;
+
case bp_watchpoint:
- /* FIXME! This is the wrong thing to do.... */
- delete_breakpoint (b);
+ innermost_block = NULL;
+ /* The issue arises of what context to evaluate this in. The same
+ one as when it was set, but what does that mean when symbols have
+ been re-read? We could save the filename and functionname, but
+ if the context is more local than that, the best we could do would
+ be something like how many levels deep and which index at that
+ particular level, but that's going to be less stable than filenames
+ or functionnames. */
+ /* So for now, just use a global context. */
+ b->exp = parse_expression (b->exp_string);
+ b->exp_valid_block = innermost_block;
+ b->val = evaluate_expression (b->exp);
+ release_value (b->val);
+ if (VALUE_LAZY (b->val))
+ value_fetch_lazy (b->val);
+
+ if (b->cond_string != NULL)
+ {
+ s = b->cond_string;
+ b->cond = parse_exp_1 (&s, (struct block *)0, 0);
+ }
+ mention (b);
break;
+
default:
printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
+ /* fall through */
case bp_until:
case bp_finish:
case bp_longjmp:
/* If we have no current source symtab, and we have any breakpoints,
go through the work of making a source context. */
- if (current_source_symtab == NULL)
+ if (current_source_symtab == NULL && breakpoint_chain != 0)
{
- ALL_BREAKPOINTS (b)
- {
- select_source_symtab (NULL);
- break; /* We only care if there are any, and
- don't need to do it N times. */
- }
+ select_source_symtab (NULL);
}
ALL_BREAKPOINTS_SAFE (b, temp)
printf_filtered ("\
Cannot enable watchpoint %d because the block in which its expression\n\
is valid is not currently in scope.\n", bpt->number);
+ bpt->enable = disabled;
return;
}
bpt->val = evaluate_expression (bpt->exp);
release_value (bpt->val);
+ if (VALUE_LAZY (bpt->val))
+ value_fetch_lazy (bpt->val);
}
}
"Synonym for ``info breakpoints''.");
}
-#ifdef IBM6000_TARGET
-/* Where should this function go? It is used by AIX only. FIXME. */
+/* OK, when we call objfile_relocate, we need to relocate breakpoints
+ too. breakpoint_re_set is not a good choice--for example, if
+ addr_string contains just a line number without a file name the
+ breakpoint might get set in a different file. In general, there is
+ no need to go all the way back to the user's string (though this might
+ work if some effort were made to canonicalize it), since symtabs and
+ everything except addresses are still valid.
-/* Breakpoint address relocation used to be done in breakpoint_re_set(). That
- approach the following problem:
+ Probably the best way to solve this is to have each breakpoint save
+ the objfile and the section number that was used to set it (if set
+ by "*addr", probably it is best to use find_pc_line to get a symtab
+ and use the objfile and block_line_section for that symtab). Then
+ objfile_relocate can call fixup_breakpoints with the objfile and
+ the new_offsets, and it can relocate only the appropriate breakpoints. */
- before running the program, if a file is list, then a breakpoint is
- set (just the line number), then if we switch into another file and run
- the program, just a line number as a breakpoint address was not
- descriptive enough and breakpoint was ending up in a different file's
- similar line.
+#ifdef IBM6000_TARGET
+/* But for now, just kludge it based on the concept that before an
+ objfile is relocated the breakpoint is below 0x10000000, and afterwards
+ it is higher, so that way we only relocate each breakpoint once. */
- I don't think any other platform has this breakpoint relocation problem, so this
- is not an issue for other platforms. */
-
void
fixup_breakpoints (low, high, delta)
CORE_ADDR low;
projects / deliverable / binutils-gdb.git / blobdiff