168 lines
9.0 KiB
HTML
168 lines
9.0 KiB
HTML
<html lang="en">
|
|
<head>
|
|
<title>Conditions - Debugging with GDB</title>
|
|
<meta http-equiv="Content-Type" content="text/html">
|
|
<meta name="description" content="Debugging with GDB">
|
|
<meta name="generator" content="makeinfo 4.13">
|
|
<link title="Top" rel="start" href="index.html#Top">
|
|
<link rel="up" href="Breakpoints.html#Breakpoints" title="Breakpoints">
|
|
<link rel="prev" href="Disabling.html#Disabling" title="Disabling">
|
|
<link rel="next" href="Break-Commands.html#Break-Commands" title="Break Commands">
|
|
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">
|
|
<!--
|
|
Copyright (C) 1988-2019 Free Software Foundation, Inc.
|
|
|
|
Permission is granted to copy, distribute and/or modify this document
|
|
under the terms of the GNU Free Documentation License, Version 1.3 or
|
|
any later version published by the Free Software Foundation; with the
|
|
Invariant Sections being ``Free Software'' and ``Free Software Needs
|
|
Free Documentation'', with the Front-Cover Texts being ``A GNU Manual,''
|
|
and with the Back-Cover Texts as in (a) below.
|
|
|
|
(a) The FSF's Back-Cover Text is: ``You are free to copy and modify
|
|
this GNU Manual. Buying copies from GNU Press supports the FSF in
|
|
developing GNU and promoting software freedom.''
|
|
-->
|
|
<meta http-equiv="Content-Style-Type" content="text/css">
|
|
<style type="text/css"><!--
|
|
pre.display { font-family:inherit }
|
|
pre.format { font-family:inherit }
|
|
pre.smalldisplay { font-family:inherit; font-size:smaller }
|
|
pre.smallformat { font-family:inherit; font-size:smaller }
|
|
pre.smallexample { font-size:smaller }
|
|
pre.smalllisp { font-size:smaller }
|
|
span.sc { font-variant:small-caps }
|
|
span.roman { font-family:serif; font-weight:normal; }
|
|
span.sansserif { font-family:sans-serif; font-weight:normal; }
|
|
--></style>
|
|
</head>
|
|
<body>
|
|
<div class="node">
|
|
<a name="Conditions"></a>
|
|
<p>
|
|
Next: <a rel="next" accesskey="n" href="Break-Commands.html#Break-Commands">Break Commands</a>,
|
|
Previous: <a rel="previous" accesskey="p" href="Disabling.html#Disabling">Disabling</a>,
|
|
Up: <a rel="up" accesskey="u" href="Breakpoints.html#Breakpoints">Breakpoints</a>
|
|
<hr>
|
|
</div>
|
|
|
|
<h4 class="subsection">5.1.6 Break Conditions</h4>
|
|
|
|
<p><a name="index-conditional-breakpoints-321"></a><a name="index-breakpoint-conditions-322"></a>
|
|
<!-- FIXME what is scope of break condition expr? Context where wanted? -->
|
|
<!-- in particular for a watchpoint? -->
|
|
The simplest sort of breakpoint breaks every time your program reaches a
|
|
specified place. You can also specify a <dfn>condition</dfn> for a
|
|
breakpoint. A condition is just a Boolean expression in your
|
|
programming language (see <a href="Expressions.html#Expressions">Expressions</a>). A breakpoint with
|
|
a condition evaluates the expression each time your program reaches it,
|
|
and your program stops only if the condition is <em>true</em>.
|
|
|
|
<p>This is the converse of using assertions for program validation; in that
|
|
situation, you want to stop when the assertion is violated—that is,
|
|
when the condition is false. In C, if you want to test an assertion expressed
|
|
by the condition <var>assert</var>, you should set the condition
|
|
‘<samp><span class="samp">! </span><var>assert</var></samp>’ on the appropriate breakpoint.
|
|
|
|
<p>Conditions are also accepted for watchpoints; you may not need them,
|
|
since a watchpoint is inspecting the value of an expression anyhow—but
|
|
it might be simpler, say, to just set a watchpoint on a variable name,
|
|
and specify a condition that tests whether the new value is an interesting
|
|
one.
|
|
|
|
<p>Break conditions can have side effects, and may even call functions in
|
|
your program. This can be useful, for example, to activate functions
|
|
that log program progress, or to use your own print functions to
|
|
format special data structures. The effects are completely predictable
|
|
unless there is another enabled breakpoint at the same address. (In
|
|
that case, <span class="sc">gdb</span> might see the other breakpoint first and stop your
|
|
program without checking the condition of this one.) Note that
|
|
breakpoint commands are usually more convenient and flexible than break
|
|
conditions for the
|
|
purpose of performing side effects when a breakpoint is reached
|
|
(see <a href="Break-Commands.html#Break-Commands">Breakpoint Command Lists</a>).
|
|
|
|
<p>Breakpoint conditions can also be evaluated on the target's side if
|
|
the target supports it. Instead of evaluating the conditions locally,
|
|
<span class="sc">gdb</span> encodes the expression into an agent expression
|
|
(see <a href="Agent-Expressions.html#Agent-Expressions">Agent Expressions</a>) suitable for execution on the target,
|
|
independently of <span class="sc">gdb</span>. Global variables become raw memory
|
|
locations, locals become stack accesses, and so forth.
|
|
|
|
<p>In this case, <span class="sc">gdb</span> will only be notified of a breakpoint trigger
|
|
when its condition evaluates to true. This mechanism may provide faster
|
|
response times depending on the performance characteristics of the target
|
|
since it does not need to keep <span class="sc">gdb</span> informed about
|
|
every breakpoint trigger, even those with false conditions.
|
|
|
|
<p>Break conditions can be specified when a breakpoint is set, by using
|
|
‘<samp><span class="samp">if</span></samp>’ in the arguments to the <code>break</code> command. See <a href="Set-Breaks.html#Set-Breaks">Setting Breakpoints</a>. They can also be changed at any time
|
|
with the <code>condition</code> command.
|
|
|
|
<p>You can also use the <code>if</code> keyword with the <code>watch</code> command.
|
|
The <code>catch</code> command does not recognize the <code>if</code> keyword;
|
|
<code>condition</code> is the only way to impose a further condition on a
|
|
catchpoint.
|
|
|
|
|
|
<a name="index-condition-323"></a>
|
|
<dl><dt><code>condition </code><var>bnum</var> <var>expression</var><dd>Specify <var>expression</var> as the break condition for breakpoint,
|
|
watchpoint, or catchpoint number <var>bnum</var>. After you set a condition,
|
|
breakpoint <var>bnum</var> stops your program only if the value of
|
|
<var>expression</var> is true (nonzero, in C). When you use
|
|
<code>condition</code>, <span class="sc">gdb</span> checks <var>expression</var> immediately for
|
|
syntactic correctness, and to determine whether symbols in it have
|
|
referents in the context of your breakpoint. If <var>expression</var> uses
|
|
symbols not referenced in the context of the breakpoint, <span class="sc">gdb</span>
|
|
prints an error message:
|
|
|
|
<pre class="smallexample"> No symbol "foo" in current context.
|
|
</pre>
|
|
<p class="noindent"><span class="sc">gdb</span> does
|
|
not actually evaluate <var>expression</var> at the time the <code>condition</code>
|
|
command (or a command that sets a breakpoint with a condition, like
|
|
<code>break if ...</code>) is given, however. See <a href="Expressions.html#Expressions">Expressions</a>.
|
|
|
|
<br><dt><code>condition </code><var>bnum</var><dd>Remove the condition from breakpoint number <var>bnum</var>. It becomes
|
|
an ordinary unconditional breakpoint.
|
|
</dl>
|
|
|
|
<p><a name="index-ignore-count-_0028of-breakpoint_0029-324"></a>A special case of a breakpoint condition is to stop only when the
|
|
breakpoint has been reached a certain number of times. This is so
|
|
useful that there is a special way to do it, using the <dfn>ignore
|
|
count</dfn> of the breakpoint. Every breakpoint has an ignore count, which
|
|
is an integer. Most of the time, the ignore count is zero, and
|
|
therefore has no effect. But if your program reaches a breakpoint whose
|
|
ignore count is positive, then instead of stopping, it just decrements
|
|
the ignore count by one and continues. As a result, if the ignore count
|
|
value is <var>n</var>, the breakpoint does not stop the next <var>n</var> times
|
|
your program reaches it.
|
|
|
|
|
|
<a name="index-ignore-325"></a>
|
|
<dl><dt><code>ignore </code><var>bnum</var> <var>count</var><dd>Set the ignore count of breakpoint number <var>bnum</var> to <var>count</var>.
|
|
The next <var>count</var> times the breakpoint is reached, your program's
|
|
execution does not stop; other than to decrement the ignore count, <span class="sc">gdb</span>
|
|
takes no action.
|
|
|
|
<p>To make the breakpoint stop the next time it is reached, specify
|
|
a count of zero.
|
|
|
|
<p>When you use <code>continue</code> to resume execution of your program from a
|
|
breakpoint, you can specify an ignore count directly as an argument to
|
|
<code>continue</code>, rather than using <code>ignore</code>. See <a href="Continuing-and-Stepping.html#Continuing-and-Stepping">Continuing and Stepping</a>.
|
|
|
|
<p>If a breakpoint has a positive ignore count and a condition, the
|
|
condition is not checked. Once the ignore count reaches zero,
|
|
<span class="sc">gdb</span> resumes checking the condition.
|
|
|
|
<p>You could achieve the effect of the ignore count with a condition such
|
|
as ‘<samp><span class="samp">$foo-- <= 0</span></samp>’<!-- /@w --> using a debugger convenience variable that
|
|
is decremented each time. See <a href="Convenience-Vars.html#Convenience-Vars">Convenience Variables</a>.
|
|
</dl>
|
|
|
|
<p>Ignore counts apply to breakpoints, watchpoints, and catchpoints.
|
|
|
|
</body></html>
|
|
|