This is the mail archive of the
gdb-prs@sourceware.org
mailing list for the GDB project.
Re: tdep/2305: IA64: breakpoints on predicated instructions ignorepredicate
- From: "John S. Worley" <jsworley at qwest dot net>
- To: nobody at sources dot redhat dot com
- Cc: gdb-prs at sources dot redhat dot com,
- Date: 29 Aug 2007 18:08:01 -0000
- Subject: Re: tdep/2305: IA64: breakpoints on predicated instructions ignorepredicate
- Reply-to: "John S. Worley" <jsworley at qwest dot net>
The following reply was made to PR tdep/2305; it has been noted by GNATS.
From: "John S. Worley" <jsworley@qwest.net>
To: Daniel Jacobowitz <drow@false.org>
Cc: gdb-gnats@sources.redhat.com
Subject: Re: tdep/2305: IA64: breakpoints on predicated instructions ignore
predicate
Date: Wed, 29 Aug 2007 11:58:41 -0600
This is a cryptographically signed message in MIME format.
--------------ms010801090506010403050404
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: 7bit
Daniel -
Thanks for the reply. I don't agree that using conditional
breakpoints is equivalent,
at least from a performance standpoint. If it takes hours to encounter
the boundary or
error condition, breaking every time through the loop, even when GDB
continues,
will increase that by several orders of magnitude, especially in a
remote debugging situation,
where the cost of taking a breakpoint is magnified many times.
In terms of "generally expected" behavior, I don't agree with your
example: in this case,
you can and should set the breakpoint on the instruction with computes
the 'a == b'
predicate. I'm willing to accept that there may be some obscure scenario
where honoring
the predicate is incorrect, but I can't think of any. As a counter
example, consider the code
that brought this issue to my attention:
if (ptr != NULL) {
*ptr = 0;
}
which any reasonable compiler would optimize as:
cmp.ne pX, pY = r0, rPTR ;;
(pX) st4 [ rPTR ] = r0
in parallel with other independent instructions. Setting a
breakpoint at the assignment statement
in GDB will break every time through the code, even when ptr == NULL,
which is certainly *NOT
*the expected (or reasonable) behavior. It is also unreasonable to
require the programmer, who may
not be IA64 savvy, to have to disassemble the code to see if the
instruction replaced is predicated.
As IA64 compilers, both GNU and non-GNU, improve, there are going to
be more and
more conditions like this one. It is already the case for hand assembly,
where multiple complex
computations, each with it's own predicate(s), can be woven together in
parallel. Just placing
an unqualified break instruction is not correct behavior now, and will
only become increasingly
incorrect in the future.
Regards,
John Worley
jsworley@qwest.net
--------------ms010801090506010403050404
Content-Type: application/x-pkcs7-signature; name="smime.p7s"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="smime.p7s"
Content-Description: S/MIME Cryptographic Signature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--------------ms010801090506010403050404--