This is the mail archive of the gdb-prs@sourceware.org mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: tdep/2305: IA64: breakpoints on predicated instructions ignorepredicate


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
 
 MIAGCSqGSIb3DQEHAqCAMIACAQExCzAJBgUrDgMCGgUAMIAGCSqGSIb3DQEHAQAAoIIQFjCC
 BIowggNyoAMCAQICECf06hH0eobEbp27bqkXBwcwDQYJKoZIhvcNAQEFBQAwbzELMAkGA1UE
 BhMCU0UxFDASBgNVBAoTC0FkZFRydXN0IEFCMSYwJAYDVQQLEx1BZGRUcnVzdCBFeHRlcm5h
 bCBUVFAgTmV0d29yazEiMCAGA1UEAxMZQWRkVHJ1c3QgRXh0ZXJuYWwgQ0EgUm9vdDAeFw0w
 NTA2MDcwODA5MTBaFw0yMDA1MzAxMDQ4MzhaMIGuMQswCQYDVQQGEwJVUzELMAkGA1UECBMC
 VVQxFzAVBgNVBAcTDlNhbHQgTGFrZSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5l
 dHdvcmsxITAfBgNVBAsTGGh0dHA6Ly93d3cudXNlcnRydXN0LmNvbTE2MDQGA1UEAxMtVVRO
 LVVTRVJGaXJzdC1DbGllbnQgQXV0aGVudGljYXRpb24gYW5kIEVtYWlsMIIBIjANBgkqhkiG
 9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsjmFpPJ9q0E7YkY3rs3BYHW8OWX5ShpHornMSMxqmNVN
 NRm5pELlzkniii8efNIxB8dOtINknS4p1aJkxIW9hVE1eaROaJB7HHqkkqgX8pgV8pPMyaQy
 lbsMTzC9mKALi+VuG6JG+ni8om+rWV6lL8/K2m2qL+usobNqqrcuZzWLeeEeaYji5kbNoKXq
 vgvOdjp6Dpvq/NonWz1zHyLmSGHGTPNpsaguG7bUMSAsvIKKjqQOpdeJQ/wWWq8dcdcRWdq6
 hw2v+vPhwvCkxWeM1tZUOt4KpLoDd7NlyP0e03RiqhjKaJMeoYV+9Udly/hNVyh00jT/MLbu
 9mIwFIws6wIDAQABo4HhMIHeMB8GA1UdIwQYMBaAFK29mHo0tCb3+sQmVO8DveAky1QaMB0G
 A1UdDgQWBBSJgmd9xJ0mcABLtFBIfN49rgRufTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/
 BAUwAwEB/zB7BgNVHR8EdDByMDigNqA0hjJodHRwOi8vY3JsLmNvbW9kb2NhLmNvbS9BZGRU
 cnVzdEV4dGVybmFsQ0FSb290LmNybDA2oDSgMoYwaHR0cDovL2NybC5jb21vZG8ubmV0L0Fk
 ZFRydXN0RXh0ZXJuYWxDQVJvb3QuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQAZ2IkRbyispgCi
 54fBm5AD236hEv0e8+LwAamUVEJrmgnEoG3XkJIEA2Z5Q3H8+G+v23ZF4jcaPd3kWQR4rBz0
 g0bzes9bhHIt5UbBuhgRKfPLSXmHPLptBZ2kbWhPrXIUNqi5sf2/z3/wpGqUNVCPz4FtVbHd
 WTBK322gnGQfSXzvNrv042n0+DmPWq1LhTq3Du3Tzw1EovsEv+QvcI4l+1pUBrPQxLxtjftz
 Mizpm4QkLdZ/kXpoAlAfDj9N6cz1u2fo3BwuO/xOzf4CjuOoEwqlJkRl6RDyTVKnrtw+ymsy
 XEFs/vVdoOr/0fqbhlhtPZZH5f4ulQTCAMyOofK7MIIFwDCCBKigAwIBAgIQKuzMLqPOTPUh
 9i5Ni2ASHTANBgkqhkiG9w0BAQUFADCBrjELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcw
 FQYDVQQHEw5TYWx0IExha2UgQ2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3Jr
 MSEwHwYDVQQLExhodHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xNjA0BgNVBAMTLVVUTi1VU0VS
 Rmlyc3QtQ2xpZW50IEF1dGhlbnRpY2F0aW9uIGFuZCBFbWFpbDAeFw0wNzA3MDMwMDAwMDBa
 Fw0wODA3MDIyMzU5NTlaMIHZMTUwMwYDVQQLEyxDb21vZG8gVHJ1c3QgTmV0d29yayAtIFBF
 UlNPTkEgTk9UIFZBTElEQVRFRDFGMEQGA1UECxM9VGVybXMgYW5kIENvbmRpdGlvbnMgb2Yg
 dXNlOiBodHRwOi8vd3d3LmNvbW9kby5uZXQvcmVwb3NpdG9yeTEfMB0GA1UECxMWKGMpMjAw
 MyBDb21vZG8gTGltaXRlZDEUMBIGA1UEAxMLSm9obiBXb3JsZXkxITAfBgkqhkiG9w0BCQEW
 Empzd29ybGV5QHF3ZXN0Lm5ldDCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAvWXuFM8r
 wIoO3wGGX++zUoORO6vBjPmti6kLKMq1e0/pQgZAi+fnfzxuoE0M+3/2+33WZa0lcAehJ7rP
 eW4zrq/3DA1eFQums1tsNNeeGuJgXHWKS2jWYEP8AiX8BO/vQ31B7QybOfned0YAvSkYwpYF
 9vYWPS1gFHZOOPPZ5IkCAwEAAaOCAi8wggIrMB8GA1UdIwQYMBaAFImCZ33EnSZwAEu0UEh8
 3j2uBG59MB0GA1UdDgQWBBTwGHaIvlVptpOx8DA+XbwoUUbwUDAOBgNVHQ8BAf8EBAMCBaAw
 DAYDVR0TAQH/BAIwADAgBgNVHSUEGTAXBggrBgEFBQcDBAYLKwYBBAGyMQEDBQIwEQYJYIZI
 AYb4QgEBBAQDAgUgMEYGA1UdIAQ/MD0wOwYMKwYBBAGyMQECAQEBMCswKQYIKwYBBQUHAgEW
 HWh0dHBzOi8vc2VjdXJlLmNvbW9kby5uZXQvQ1BTMIGlBgNVHR8EgZ0wgZowTKBKoEiGRmh0
 dHA6Ly9jcmwuY29tb2RvY2EuY29tL1VUTi1VU0VSRmlyc3QtQ2xpZW50QXV0aGVudGljYXRp
 b25hbmRFbWFpbC5jcmwwSqBIoEaGRGh0dHA6Ly9jcmwuY29tb2RvLm5ldC9VVE4tVVNFUkZp
 cnN0LUNsaWVudEF1dGhlbnRpY2F0aW9uYW5kRW1haWwuY3JsMIGGBggrBgEFBQcBAQR6MHgw
 OwYIKwYBBQUHMAKGL2h0dHA6Ly9jcnQuY29tb2RvY2EuY29tL1VUTkFkZFRydXN0Q2xpZW50
 Q0EuY3J0MDkGCCsGAQUFBzAChi1odHRwOi8vY3J0LmNvbW9kby5uZXQvVVROQWRkVHJ1c3RD
 bGllbnRDQS5jcnQwHQYDVR0RBBYwFIESanN3b3JsZXlAcXdlc3QubmV0MA0GCSqGSIb3DQEB
 BQUAA4IBAQABY1YWJG7rfXnH5lXsYmAwSnnnm5zNtiGeLw31rQRTO1GctyOM2NJyA9WoXwvA
 RLt5lz25BsjDwciJ7x9Hp8BK1tUd2Q8Xay39JxYeqHsCX9EPLowsI1k8vap9F6UaAFD8Mgbz
 b5OhIecWLqOseDt9qnURNco4SnI4XUby+Z2iZjPCl/UF7mBjAUaQYAfsKVbUOWZxV+AII2m5
 h2A2TpFSAin9W8bWs3Ro8vqrjFPnNGZwp1oM9DJAlvfrCIDNGr5CWfMpZbBxMfFV/s2h/etk
 NvnrQbyDw/Gbg2XAEYJUxWj98DNBQoaCJBpvCOV8hImTzMkSRbGy7FmcblYBFt1JMIIFwDCC
 BKigAwIBAgIQKuzMLqPOTPUh9i5Ni2ASHTANBgkqhkiG9w0BAQUFADCBrjELMAkGA1UEBhMC
 VVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2UgQ2l0eTEeMBwGA1UEChMVVGhl
 IFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExhodHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20x
 NjA0BgNVBAMTLVVUTi1VU0VSRmlyc3QtQ2xpZW50IEF1dGhlbnRpY2F0aW9uIGFuZCBFbWFp
 bDAeFw0wNzA3MDMwMDAwMDBaFw0wODA3MDIyMzU5NTlaMIHZMTUwMwYDVQQLEyxDb21vZG8g
 VHJ1c3QgTmV0d29yayAtIFBFUlNPTkEgTk9UIFZBTElEQVRFRDFGMEQGA1UECxM9VGVybXMg
 YW5kIENvbmRpdGlvbnMgb2YgdXNlOiBodHRwOi8vd3d3LmNvbW9kby5uZXQvcmVwb3NpdG9y
 eTEfMB0GA1UECxMWKGMpMjAwMyBDb21vZG8gTGltaXRlZDEUMBIGA1UEAxMLSm9obiBXb3Js
 ZXkxITAfBgkqhkiG9w0BCQEWEmpzd29ybGV5QHF3ZXN0Lm5ldDCBnzANBgkqhkiG9w0BAQEF
 AAOBjQAwgYkCgYEAvWXuFM8rwIoO3wGGX++zUoORO6vBjPmti6kLKMq1e0/pQgZAi+fnfzxu
 oE0M+3/2+33WZa0lcAehJ7rPeW4zrq/3DA1eFQums1tsNNeeGuJgXHWKS2jWYEP8AiX8BO/v
 Q31B7QybOfned0YAvSkYwpYF9vYWPS1gFHZOOPPZ5IkCAwEAAaOCAi8wggIrMB8GA1UdIwQY
 MBaAFImCZ33EnSZwAEu0UEh83j2uBG59MB0GA1UdDgQWBBTwGHaIvlVptpOx8DA+XbwoUUbw
 UDAOBgNVHQ8BAf8EBAMCBaAwDAYDVR0TAQH/BAIwADAgBgNVHSUEGTAXBggrBgEFBQcDBAYL
 KwYBBAGyMQEDBQIwEQYJYIZIAYb4QgEBBAQDAgUgMEYGA1UdIAQ/MD0wOwYMKwYBBAGyMQEC
 AQEBMCswKQYIKwYBBQUHAgEWHWh0dHBzOi8vc2VjdXJlLmNvbW9kby5uZXQvQ1BTMIGlBgNV
 HR8EgZ0wgZowTKBKoEiGRmh0dHA6Ly9jcmwuY29tb2RvY2EuY29tL1VUTi1VU0VSRmlyc3Qt
 Q2xpZW50QXV0aGVudGljYXRpb25hbmRFbWFpbC5jcmwwSqBIoEaGRGh0dHA6Ly9jcmwuY29t
 b2RvLm5ldC9VVE4tVVNFUkZpcnN0LUNsaWVudEF1dGhlbnRpY2F0aW9uYW5kRW1haWwuY3Js
 MIGGBggrBgEFBQcBAQR6MHgwOwYIKwYBBQUHMAKGL2h0dHA6Ly9jcnQuY29tb2RvY2EuY29t
 L1VUTkFkZFRydXN0Q2xpZW50Q0EuY3J0MDkGCCsGAQUFBzAChi1odHRwOi8vY3J0LmNvbW9k
 by5uZXQvVVROQWRkVHJ1c3RDbGllbnRDQS5jcnQwHQYDVR0RBBYwFIESanN3b3JsZXlAcXdl
 c3QubmV0MA0GCSqGSIb3DQEBBQUAA4IBAQABY1YWJG7rfXnH5lXsYmAwSnnnm5zNtiGeLw31
 rQRTO1GctyOM2NJyA9WoXwvARLt5lz25BsjDwciJ7x9Hp8BK1tUd2Q8Xay39JxYeqHsCX9EP
 LowsI1k8vap9F6UaAFD8Mgbzb5OhIecWLqOseDt9qnURNco4SnI4XUby+Z2iZjPCl/UF7mBj
 AUaQYAfsKVbUOWZxV+AII2m5h2A2TpFSAin9W8bWs3Ro8vqrjFPnNGZwp1oM9DJAlvfrCIDN
 Gr5CWfMpZbBxMfFV/s2h/etkNvnrQbyDw/Gbg2XAEYJUxWj98DNBQoaCJBpvCOV8hImTzMkS
 RbGy7FmcblYBFt1JMYIDzzCCA8sCAQEwgcMwga4xCzAJBgNVBAYTAlVTMQswCQYDVQQIEwJV
 VDEXMBUGA1UEBxMOU2FsdCBMYWtlIENpdHkxHjAcBgNVBAoTFVRoZSBVU0VSVFJVU1QgTmV0
 d29yazEhMB8GA1UECxMYaHR0cDovL3d3dy51c2VydHJ1c3QuY29tMTYwNAYDVQQDEy1VVE4t
 VVNFUkZpcnN0LUNsaWVudCBBdXRoZW50aWNhdGlvbiBhbmQgRW1haWwCECrszC6jzkz1IfYu
 TYtgEh0wCQYFKw4DAhoFAKCCAmEwGAYJKoZIhvcNAQkDMQsGCSqGSIb3DQEHATAcBgkqhkiG
 9w0BCQUxDxcNMDcwODI5MTc1ODQxWjAjBgkqhkiG9w0BCQQxFgQUDR3SGTm2vdq5urZRMdJz
 EvsfJm0wUgYJKoZIhvcNAQkPMUUwQzAKBggqhkiG9w0DBzAOBggqhkiG9w0DAgICAIAwDQYI
 KoZIhvcNAwICAUAwBwYFKw4DAgcwDQYIKoZIhvcNAwICASgwgdQGCSsGAQQBgjcQBDGBxjCB
 wzCBrjELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2UgQ2l0
 eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExhodHRwOi8vd3d3
 LnVzZXJ0cnVzdC5jb20xNjA0BgNVBAMTLVVUTi1VU0VSRmlyc3QtQ2xpZW50IEF1dGhlbnRp
 Y2F0aW9uIGFuZCBFbWFpbAIQKuzMLqPOTPUh9i5Ni2ASHTCB1gYLKoZIhvcNAQkQAgsxgcag
 gcMwga4xCzAJBgNVBAYTAlVTMQswCQYDVQQIEwJVVDEXMBUGA1UEBxMOU2FsdCBMYWtlIENp
 dHkxHjAcBgNVBAoTFVRoZSBVU0VSVFJVU1QgTmV0d29yazEhMB8GA1UECxMYaHR0cDovL3d3
 dy51c2VydHJ1c3QuY29tMTYwNAYDVQQDEy1VVE4tVVNFUkZpcnN0LUNsaWVudCBBdXRoZW50
 aWNhdGlvbiBhbmQgRW1haWwCECrszC6jzkz1IfYuTYtgEh0wDQYJKoZIhvcNAQEBBQAEgYAW
 rn7U4udg6SXEP6eeDKaLST7YQOHMG7zMDjEcR8FhSCely0Z8B8HB+K7xoFYybDps1HBicnJD
 44PdFBiBKtf0u/5WbjbCpfNnVRHaE9/enO0wVigy1dFwFsQpdJ6YyVL1dUsEJtFYRwDxCSBc
 vdRuuqV/4RhMRRuyFc+1Esh6qwAAAAAAAA==
 --------------ms010801090506010403050404--
 


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]