public inbox for git-commits@fedoraproject.org
help / color / mirror / Atom feed
* [rpms/gcc] rhel-f41-base: 4.8.2-15
@ 2026-06-29 12:26 Jakub Jelinek
0 siblings, 0 replies; only message in thread
From: Jakub Jelinek @ 2026-06-29 12:26 UTC (permalink / raw)
To: git-commits
A new commit has been pushed.
Repo : rpms/gcc
Branch : rhel-f41-base
Commit : 39b12a1a1bbfcd2ab70cecb4221db2b49cb913cf
Author : Jakub Jelinek <jakub@redhat.com>
Date : 2014-02-20T21:22:24+01:00
Stats : +1420/-4 in 4 file(s)
URL : https://src.fedoraproject.org/rpms/gcc/c/39b12a1a1bbfcd2ab70cecb4221db2b49cb913cf?branch=rhel-f41-base
Log:
4.8.2-15
---
diff --git a/gcc.spec b/gcc.spec
index b66efcc..2fa1ce1 100644
--- a/gcc.spec
+++ b/gcc.spec
@@ -3,7 +3,7 @@
%global gcc_version 4.8.2
# Note, gcc_release must be integer, if you want to add suffixes to
# %{release}, append them after %{gcc_release} on Release: line.
-%global gcc_release 14
+%global gcc_release 15
%global _unpackaged_files_terminate_build 0
%global _performance_build 1
%global multilib_64_archs sparc64 ppc64 ppc64p7 s390x x86_64
@@ -49,6 +49,11 @@
%endif
%global build_cloog 1
%global build_libstdcxx_docs 1
+%ifarch %{ix86} x86_64 ppc ppc64 ppc64p7 s390 s390x %{arm} aarch64
+%global attr_ifunc 1
+%else
+%global attr_ifunc 0
+%endif
# If you don't have already a usable gcc-java and libgcj for your arch,
# do on some arch which has it rpmbuild -bc --with java_tar gcc.spec
# which creates libjava-classes-%{version}-%{release}.tar.bz2
@@ -198,7 +203,10 @@ Patch13: gcc48-pr56564.patch
Patch14: gcc48-pr56493.patch
Patch15: gcc48-color-auto.patch
Patch16: gcc48-pr28865.patch
-Patch17: gcc48-pr60010.patch
+Patch17: gcc48-libgo-p224.patch
+Patch18: gcc48-pr60137.patch
+Patch19: gcc48-pr60010.patch
+Patch20: gcc48-pr60046.patch
Patch1000: fastjar-0.97-segfault.patch
Patch1001: fastjar-0.97-len1.patch
@@ -759,7 +767,11 @@ package or when debugging this package.
%patch15 -p0 -b .color-auto~
%endif
%patch16 -p0 -b .pr28865~
-%patch17 -p0 -b .pr60010~
+%patch17 -p0 -b .libgo-p224~
+rm -f libgo/go/crypto/elliptic/p224{,_test}.go
+%patch18 -p0 -b .pr60137~
+%patch19 -p0 -b .pr60010~
+%patch20 -p0 -b .pr60046~
%if 0%{?_enable_debug_packages}
cat > split-debuginfo.sh <<\EOF
@@ -1042,6 +1054,11 @@ CC="$CC" CFLAGS="$OPT_FLAGS" \
%else
--without-isl --without-cloog \
%endif
+%if 0%{?fedora} >= 21 || 0%{?rhel} >= 7
+%if %{attr_ifunc}
+ --enable-gnu-indirect-function \
+%endif
+%endif
%ifarch %{arm}
--disable-sjlj-exceptions \
%endif
@@ -3027,8 +3044,16 @@ fi
%{_prefix}/libexec/gcc/%{gcc_target_platform}/%{gcc_version}/plugin
%changelog
-* Fri Jan 31 2014 Kyle McMartin <kyle@redhat.com> 4.8.2-14
+* Thu Feb 20 2014 Jakub Jelinek <jakub@redhat.com> 4.8.2-15
+- fix exception spec instantiation ICE (#1067398, PR c++/60046)
- fix pch on aarch64 (#1058991, PR pch/60010)
+- configure with --enable-gnu-indirect-function on architectures
+ and distros that support it and don't support it by default
+ yet (#1067245)
+
+* Wed Feb 19 2014 Jakub Jelinek <jakub@redhat.com> 4.8.2-14
+- remove libgo P.224 elliptic curve (#1066539)
+- fix -mcpu=power8 ICE (#1064242, PR target/60137)
* Tue Jan 21 2014 Jakub Jelinek <jakub@redhat.com> 4.8.2-13
- when removing -Wall from CXXFLAGS, if -Werror=format-security
diff --git a/gcc48-libgo-p224.patch b/gcc48-libgo-p224.patch
new file mode 100644
index 0000000..50461bc
--- /dev/null
+++ b/gcc48-libgo-p224.patch
@@ -0,0 +1,1302 @@
+--- libgo/Makefile.am.jj 2013-12-12 19:01:49.000000000 +0100
++++ libgo/Makefile.am 2014-02-18 17:31:54.798484657 +0100
+@@ -1109,8 +1109,7 @@ go_crypto_dsa_files = \
+ go_crypto_ecdsa_files = \
+ go/crypto/ecdsa/ecdsa.go
+ go_crypto_elliptic_files = \
+- go/crypto/elliptic/elliptic.go \
+- go/crypto/elliptic/p224.go
++ go/crypto/elliptic/elliptic.go
+ go_crypto_hmac_files = \
+ go/crypto/hmac/hmac.go
+ go_crypto_md5_files = \
+--- libgo/Makefile.in.jj 2013-12-12 19:01:49.000000000 +0100
++++ libgo/Makefile.in 2014-02-18 17:32:11.350389191 +0100
+@@ -1274,8 +1274,7 @@ go_crypto_ecdsa_files = \
+ go/crypto/ecdsa/ecdsa.go
+
+ go_crypto_elliptic_files = \
+- go/crypto/elliptic/elliptic.go \
+- go/crypto/elliptic/p224.go
++ go/crypto/elliptic/elliptic.go
+
+ go_crypto_hmac_files = \
+ go/crypto/hmac/hmac.go
+--- libgo/go/crypto/elliptic/elliptic.go.jj 2012-12-13 11:32:02.640039537 +0100
++++ libgo/go/crypto/elliptic/elliptic.go 2014-02-18 17:28:22.909692022 +0100
+@@ -327,7 +327,6 @@ var p384 *CurveParams
+ var p521 *CurveParams
+
+ func initAll() {
+- initP224()
+ initP256()
+ initP384()
+ initP521()
+--- libgo/go/crypto/elliptic/elliptic_test.go.jj 2012-12-13 11:32:02.640039537 +0100
++++ libgo/go/crypto/elliptic/elliptic_test.go 2014-02-18 17:31:04.052774265 +0100
+@@ -5,329 +5,14 @@
+ package elliptic
+
+ import (
+- "crypto/rand"
+- "encoding/hex"
+- "fmt"
+- "math/big"
+ "testing"
+ )
+
+-func TestOnCurve(t *testing.T) {
+- p224 := P224()
+- if !p224.IsOnCurve(p224.Params().Gx, p224.Params().Gy) {
+- t.Errorf("FAIL")
+- }
+-}
+-
+-type baseMultTest struct {
+- k string
+- x, y string
+-}
+-
+-var p224BaseMultTests = []baseMultTest{
+- {
+- "1",
+- "b70e0cbd6bb4bf7f321390b94a03c1d356c21122343280d6115c1d21",
+- "bd376388b5f723fb4c22dfe6cd4375a05a07476444d5819985007e34",
+- },
+- {
+- "2",
+- "706a46dc76dcb76798e60e6d89474788d16dc18032d268fd1a704fa6",
+- "1c2b76a7bc25e7702a704fa986892849fca629487acf3709d2e4e8bb",
+- },
+- {
+- "3",
+- "df1b1d66a551d0d31eff822558b9d2cc75c2180279fe0d08fd896d04",
+- "a3f7f03cadd0be444c0aa56830130ddf77d317344e1af3591981a925",
+- },
+- {
+- "4",
+- "ae99feebb5d26945b54892092a8aee02912930fa41cd114e40447301",
+- "482580a0ec5bc47e88bc8c378632cd196cb3fa058a7114eb03054c9",
+- },
+- {
+- "5",
+- "31c49ae75bce7807cdff22055d94ee9021fedbb5ab51c57526f011aa",
+- "27e8bff1745635ec5ba0c9f1c2ede15414c6507d29ffe37e790a079b",
+- },
+- {
+- "6",
+- "1f2483f82572251fca975fea40db821df8ad82a3c002ee6c57112408",
+- "89faf0ccb750d99b553c574fad7ecfb0438586eb3952af5b4b153c7e",
+- },
+- {
+- "7",
+- "db2f6be630e246a5cf7d99b85194b123d487e2d466b94b24a03c3e28",
+- "f3a30085497f2f611ee2517b163ef8c53b715d18bb4e4808d02b963",
+- },
+- {
+- "8",
+- "858e6f9cc6c12c31f5df124aa77767b05c8bc021bd683d2b55571550",
+- "46dcd3ea5c43898c5c5fc4fdac7db39c2f02ebee4e3541d1e78047a",
+- },
+- {
+- "9",
+- "2fdcccfee720a77ef6cb3bfbb447f9383117e3daa4a07e36ed15f78d",
+- "371732e4f41bf4f7883035e6a79fcedc0e196eb07b48171697517463",
+- },
+- {
+- "10",
+- "aea9e17a306517eb89152aa7096d2c381ec813c51aa880e7bee2c0fd",
+- "39bb30eab337e0a521b6cba1abe4b2b3a3e524c14a3fe3eb116b655f",
+- },
+- {
+- "11",
+- "ef53b6294aca431f0f3c22dc82eb9050324f1d88d377e716448e507c",
+- "20b510004092e96636cfb7e32efded8265c266dfb754fa6d6491a6da",
+- },
+- {
+- "12",
+- "6e31ee1dc137f81b056752e4deab1443a481033e9b4c93a3044f4f7a",
+- "207dddf0385bfdeab6e9acda8da06b3bbef224a93ab1e9e036109d13",
+- },
+- {
+- "13",
+- "34e8e17a430e43289793c383fac9774247b40e9ebd3366981fcfaeca",
+- "252819f71c7fb7fbcb159be337d37d3336d7feb963724fdfb0ecb767",
+- },
+- {
+- "14",
+- "a53640c83dc208603ded83e4ecf758f24c357d7cf48088b2ce01e9fa",
+- "d5814cd724199c4a5b974a43685fbf5b8bac69459c9469bc8f23ccaf",
+- },
+- {
+- "15",
+- "baa4d8635511a7d288aebeedd12ce529ff102c91f97f867e21916bf9",
+- "979a5f4759f80f4fb4ec2e34f5566d595680a11735e7b61046127989",
+- },
+- {
+- "16",
+- "b6ec4fe1777382404ef679997ba8d1cc5cd8e85349259f590c4c66d",
+- "3399d464345906b11b00e363ef429221f2ec720d2f665d7dead5b482",
+- },
+- {
+- "17",
+- "b8357c3a6ceef288310e17b8bfeff9200846ca8c1942497c484403bc",
+- "ff149efa6606a6bd20ef7d1b06bd92f6904639dce5174db6cc554a26",
+- },
+- {
+- "18",
+- "c9ff61b040874c0568479216824a15eab1a838a797d189746226e4cc",
+- "ea98d60e5ffc9b8fcf999fab1df7e7ef7084f20ddb61bb045a6ce002",
+- },
+- {
+- "19",
+- "a1e81c04f30ce201c7c9ace785ed44cc33b455a022f2acdbc6cae83c",
+- "dcf1f6c3db09c70acc25391d492fe25b4a180babd6cea356c04719cd",
+- },
+- {
+- "20",
+- "fcc7f2b45df1cd5a3c0c0731ca47a8af75cfb0347e8354eefe782455",
+- "d5d7110274cba7cdee90e1a8b0d394c376a5573db6be0bf2747f530",
+- },
+- {
+- "112233445566778899",
+- "61f077c6f62ed802dad7c2f38f5c67f2cc453601e61bd076bb46179e",
+- "2272f9e9f5933e70388ee652513443b5e289dd135dcc0d0299b225e4",
+- },
+- {
+- "112233445566778899112233445566778899",
+- "29895f0af496bfc62b6ef8d8a65c88c613949b03668aab4f0429e35",
+- "3ea6e53f9a841f2019ec24bde1a75677aa9b5902e61081c01064de93",
+- },
+- {
+- "6950511619965839450988900688150712778015737983940691968051900319680",
+- "ab689930bcae4a4aa5f5cb085e823e8ae30fd365eb1da4aba9cf0379",
+- "3345a121bbd233548af0d210654eb40bab788a03666419be6fbd34e7",
+- },
+- {
+- "13479972933410060327035789020509431695094902435494295338570602119423",
+- "bdb6a8817c1f89da1c2f3dd8e97feb4494f2ed302a4ce2bc7f5f4025",
+- "4c7020d57c00411889462d77a5438bb4e97d177700bf7243a07f1680",
+- },
+- {
+- "13479971751745682581351455311314208093898607229429740618390390702079",
+- "d58b61aa41c32dd5eba462647dba75c5d67c83606c0af2bd928446a9",
+- "d24ba6a837be0460dd107ae77725696d211446c5609b4595976b16bd",
+- },
+- {
+- "13479972931865328106486971546324465392952975980343228160962702868479",
+- "dc9fa77978a005510980e929a1485f63716df695d7a0c18bb518df03",
+- "ede2b016f2ddffc2a8c015b134928275ce09e5661b7ab14ce0d1d403",
+- },
+- {
+- "11795773708834916026404142434151065506931607341523388140225443265536",
+- "499d8b2829cfb879c901f7d85d357045edab55028824d0f05ba279ba",
+- "bf929537b06e4015919639d94f57838fa33fc3d952598dcdbb44d638",
+- },
+- {
+- "784254593043826236572847595991346435467177662189391577090",
+- "8246c999137186632c5f9eddf3b1b0e1764c5e8bd0e0d8a554b9cb77",
+- "e80ed8660bc1cb17ac7d845be40a7a022d3306f116ae9f81fea65947",
+- },
+- {
+- "13479767645505654746623887797783387853576174193480695826442858012671",
+- "6670c20afcceaea672c97f75e2e9dd5c8460e54bb38538ebb4bd30eb",
+- "f280d8008d07a4caf54271f993527d46ff3ff46fd1190a3f1faa4f74",
+- },
+- {
+- "205688069665150753842126177372015544874550518966168735589597183",
+- "eca934247425cfd949b795cb5ce1eff401550386e28d1a4c5a8eb",
+- "d4c01040dba19628931bc8855370317c722cbd9ca6156985f1c2e9ce",
+- },
+- {
+- "13479966930919337728895168462090683249159702977113823384618282123295",
+- "ef353bf5c73cd551b96d596fbc9a67f16d61dd9fe56af19de1fba9cd",
+- "21771b9cdce3e8430c09b3838be70b48c21e15bc09ee1f2d7945b91f",
+- },
+- {
+- "50210731791415612487756441341851895584393717453129007497216",
+- "4036052a3091eb481046ad3289c95d3ac905ca0023de2c03ecd451cf",
+- "d768165a38a2b96f812586a9d59d4136035d9c853a5bf2e1c86a4993",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368041",
+- "fcc7f2b45df1cd5a3c0c0731ca47a8af75cfb0347e8354eefe782455",
+- "f2a28eefd8b345832116f1e574f2c6b2c895aa8c24941f40d8b80ad1",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368042",
+- "a1e81c04f30ce201c7c9ace785ed44cc33b455a022f2acdbc6cae83c",
+- "230e093c24f638f533dac6e2b6d01da3b5e7f45429315ca93fb8e634",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368043",
+- "c9ff61b040874c0568479216824a15eab1a838a797d189746226e4cc",
+- "156729f1a003647030666054e208180f8f7b0df2249e44fba5931fff",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368044",
+- "b8357c3a6ceef288310e17b8bfeff9200846ca8c1942497c484403bc",
+- "eb610599f95942df1082e4f9426d086fb9c6231ae8b24933aab5db",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368045",
+- "b6ec4fe1777382404ef679997ba8d1cc5cd8e85349259f590c4c66d",
+- "cc662b9bcba6f94ee4ff1c9c10bd6ddd0d138df2d099a282152a4b7f",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368046",
+- "baa4d8635511a7d288aebeedd12ce529ff102c91f97f867e21916bf9",
+- "6865a0b8a607f0b04b13d1cb0aa992a5a97f5ee8ca1849efb9ed8678",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368047",
+- "a53640c83dc208603ded83e4ecf758f24c357d7cf48088b2ce01e9fa",
+- "2a7eb328dbe663b5a468b5bc97a040a3745396ba636b964370dc3352",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368048",
+- "34e8e17a430e43289793c383fac9774247b40e9ebd3366981fcfaeca",
+- "dad7e608e380480434ea641cc82c82cbc92801469c8db0204f13489a",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368049",
+- "6e31ee1dc137f81b056752e4deab1443a481033e9b4c93a3044f4f7a",
+- "df82220fc7a4021549165325725f94c3410ddb56c54e161fc9ef62ee",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368050",
+- "ef53b6294aca431f0f3c22dc82eb9050324f1d88d377e716448e507c",
+- "df4aefffbf6d1699c930481cd102127c9a3d992048ab05929b6e5927",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368051",
+- "aea9e17a306517eb89152aa7096d2c381ec813c51aa880e7bee2c0fd",
+- "c644cf154cc81f5ade49345e541b4d4b5c1adb3eb5c01c14ee949aa2",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368052",
+- "2fdcccfee720a77ef6cb3bfbb447f9383117e3daa4a07e36ed15f78d",
+- "c8e8cd1b0be40b0877cfca1958603122f1e6914f84b7e8e968ae8b9e",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368053",
+- "858e6f9cc6c12c31f5df124aa77767b05c8bc021bd683d2b55571550",
+- "fb9232c15a3bc7673a3a03b0253824c53d0fd1411b1cabe2e187fb87",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368054",
+- "db2f6be630e246a5cf7d99b85194b123d487e2d466b94b24a03c3e28",
+- "f0c5cff7ab680d09ee11dae84e9c1072ac48ea2e744b1b7f72fd469e",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368055",
+- "1f2483f82572251fca975fea40db821df8ad82a3c002ee6c57112408",
+- "76050f3348af2664aac3a8b05281304ebc7a7914c6ad50a4b4eac383",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368056",
+- "31c49ae75bce7807cdff22055d94ee9021fedbb5ab51c57526f011aa",
+- "d817400e8ba9ca13a45f360e3d121eaaeb39af82d6001c8186f5f866",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368057",
+- "ae99feebb5d26945b54892092a8aee02912930fa41cd114e40447301",
+- "fb7da7f5f13a43b81774373c879cd32d6934c05fa758eeb14fcfab38",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368058",
+- "df1b1d66a551d0d31eff822558b9d2cc75c2180279fe0d08fd896d04",
+- "5c080fc3522f41bbb3f55a97cfecf21f882ce8cbb1e50ca6e67e56dc",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368059",
+- "706a46dc76dcb76798e60e6d89474788d16dc18032d268fd1a704fa6",
+- "e3d4895843da188fd58fb0567976d7b50359d6b78530c8f62d1b1746",
+- },
+- {
+- "26959946667150639794667015087019625940457807714424391721682722368060",
+- "b70e0cbd6bb4bf7f321390b94a03c1d356c21122343280d6115c1d21",
+- "42c89c774a08dc04b3dd201932bc8a5ea5f8b89bbb2a7e667aff81cd",
+- },
+-}
+-
+-func TestBaseMult(t *testing.T) {
+- p224 := P224()
+- for i, e := range p224BaseMultTests {
+- k, ok := new(big.Int).SetString(e.k, 10)
+- if !ok {
+- t.Errorf("%d: bad value for k: %s", i, e.k)
+- }
+- x, y := p224.ScalarBaseMult(k.Bytes())
+- if fmt.Sprintf("%x", x) != e.x || fmt.Sprintf("%x", y) != e.y {
+- t.Errorf("%d: bad output for k=%s: got (%x, %x), want (%s, %s)", i, e.k, x, y, e.x, e.y)
+- }
+- if testing.Short() && i > 5 {
+- break
+- }
+- }
+-}
+-
+-func TestGenericBaseMult(t *testing.T) {
+- // We use the P224 CurveParams directly in order to test the generic implementation.
+- p224 := P224().Params()
+- for i, e := range p224BaseMultTests {
+- k, ok := new(big.Int).SetString(e.k, 10)
+- if !ok {
+- t.Errorf("%d: bad value for k: %s", i, e.k)
+- }
+- x, y := p224.ScalarBaseMult(k.Bytes())
+- if fmt.Sprintf("%x", x) != e.x || fmt.Sprintf("%x", y) != e.y {
+- t.Errorf("%d: bad output for k=%s: got (%x, %x), want (%s, %s)", i, e.k, x, y, e.x, e.y)
+- }
+- if testing.Short() && i > 5 {
+- break
+- }
+- }
+-}
+-
+ func TestInfinity(t *testing.T) {
+ tests := []struct {
+ name string
+ curve Curve
+ }{
+- {"p224", P224()},
+ {"p256", P256()},
+ }
+
+@@ -359,43 +44,3 @@ func TestInfinity(t *testing.T) {
+ }
+ }
+ }
+-
+-func BenchmarkBaseMult(b *testing.B) {
+- b.ResetTimer()
+- p224 := P224()
+- e := p224BaseMultTests[25]
+- k, _ := new(big.Int).SetString(e.k, 10)
+- b.StartTimer()
+- for i := 0; i < b.N; i++ {
+- p224.ScalarBaseMult(k.Bytes())
+- }
+-}
+-
+-func TestMarshal(t *testing.T) {
+- p224 := P224()
+- _, x, y, err := GenerateKey(p224, rand.Reader)
+- if err != nil {
+- t.Error(err)
+- return
+- }
+- serialized := Marshal(p224, x, y)
+- xx, yy := Unmarshal(p224, serialized)
+- if xx == nil {
+- t.Error("failed to unmarshal")
+- return
+- }
+- if xx.Cmp(x) != 0 || yy.Cmp(y) != 0 {
+- t.Error("unmarshal returned different values")
+- return
+- }
+-}
+-
+-func TestP224Overflow(t *testing.T) {
+- // This tests for a specific bug in the P224 implementation.
+- p224 := P224()
+- pointData, _ := hex.DecodeString("049B535B45FB0A2072398A6831834624C7E32CCFD5A4B933BCEAF77F1DD945E08BBE5178F5EDF5E733388F196D2A631D2E075BB16CBFEEA15B")
+- x, y := Unmarshal(p224, pointData)
+- if !p224.IsOnCurve(x, y) {
+- t.Error("P224 failed to validate a correct point")
+- }
+-}
+--- libgo/go/crypto/ecdsa/ecdsa_test.go.jj 2012-12-13 11:32:02.589039782 +0100
++++ libgo/go/crypto/ecdsa/ecdsa_test.go 2014-02-18 17:28:22.909692022 +0100
+@@ -33,7 +33,6 @@ func testKeyGeneration(t *testing.T, c e
+ }
+
+ func TestKeyGeneration(t *testing.T) {
+- testKeyGeneration(t, elliptic.P224(), "p224")
+ if testing.Short() {
+ return
+ }
+@@ -63,7 +62,6 @@ func testSignAndVerify(t *testing.T, c e
+ }
+
+ func TestSignAndVerify(t *testing.T) {
+- testSignAndVerify(t, elliptic.P224(), "p224")
+ if testing.Short() {
+ return
+ }
+@@ -129,8 +127,6 @@ func TestVectors(t *testing.T) {
+ parts := strings.SplitN(line, ",", 2)
+
+ switch parts[0] {
+- case "P-224":
+- pub.Curve = elliptic.P224()
+ case "P-256":
+ pub.Curve = elliptic.P256()
+ case "P-384":
+--- libgo/go/crypto/x509/x509.go.jj 2013-08-14 13:55:08.939843607 +0200
++++ libgo/go/crypto/x509/x509.go 2014-02-18 17:28:22.943691764 +0100
+@@ -283,9 +283,6 @@ func getPublicKeyAlgorithmFromOID(oid as
+
+ // RFC 5480, 2.1.1.1. Named Curve
+ //
+-// secp224r1 OBJECT IDENTIFIER ::= {
+-// iso(1) identified-organization(3) certicom(132) curve(0) 33 }
+-//
+ // secp256r1 OBJECT IDENTIFIER ::= {
+ // iso(1) member-body(2) us(840) ansi-X9-62(10045) curves(3)
+ // prime(1) 7 }
+@@ -298,7 +295,6 @@ func getPublicKeyAlgorithmFromOID(oid as
+ //
+ // NB: secp256r1 is equivalent to prime256v1
+ var (
+- oidNamedCurveP224 = asn1.ObjectIdentifier{1, 3, 132, 0, 33}
+ oidNamedCurveP256 = asn1.ObjectIdentifier{1, 2, 840, 10045, 3, 1, 7}
+ oidNamedCurveP384 = asn1.ObjectIdentifier{1, 3, 132, 0, 34}
+ oidNamedCurveP521 = asn1.ObjectIdentifier{1, 3, 132, 0, 35}
+@@ -306,8 +302,6 @@ var (
+
+ func namedCurveFromOID(oid asn1.ObjectIdentifier) elliptic.Curve {
+ switch {
+- case oid.Equal(oidNamedCurveP224):
+- return elliptic.P224()
+ case oid.Equal(oidNamedCurveP256):
+ return elliptic.P256()
+ case oid.Equal(oidNamedCurveP384):
+@@ -320,8 +314,6 @@ func namedCurveFromOID(oid asn1.ObjectId
+
+ func oidFromNamedCurve(curve elliptic.Curve) (asn1.ObjectIdentifier, bool) {
+ switch curve {
+- case elliptic.P224():
+- return oidNamedCurveP224, true
+ case elliptic.P256():
+ return oidNamedCurveP256, true
+ case elliptic.P384():
+@@ -1212,7 +1204,7 @@ func CreateCertificate(rand io.Reader, t
+ hashFunc = crypto.SHA1
+ case *ecdsa.PrivateKey:
+ switch priv.Curve {
+- case elliptic.P224(), elliptic.P256():
++ case elliptic.P256():
+ hashFunc = crypto.SHA256
+ signatureAlgorithm.Algorithm = oidSignatureECDSAWithSHA256
+ case elliptic.P384():
+--- libgo/go/crypto/elliptic/p224.go.jj 2012-12-13 11:32:02.641039533 +0100
++++ libgo/go/crypto/elliptic/p224.go 2014-02-15 11:40:56.191557928 +0100
+@@ -1,765 +0,0 @@
+-// Copyright 2012 The Go Authors. All rights reserved.
+-// Use of this source code is governed by a BSD-style
+-// license that can be found in the LICENSE file.
+-
+-package elliptic
+-
+-// This is a constant-time, 32-bit implementation of P224. See FIPS 186-3,
+-// section D.2.2.
+-//
+-// See http://www.imperialviolet.org/2010/12/04/ecc.html ([1]) for background.
+-
+-import (
+- "math/big"
+-)
+-
+-var p224 p224Curve
+-
+-type p224Curve struct {
+- *CurveParams
+- gx, gy, b p224FieldElement
+-}
+-
+-func initP224() {
+- // See FIPS 186-3, section D.2.2
+- p224.CurveParams = new(CurveParams)
+- p224.P, _ = new(big.Int).SetString("26959946667150639794667015087019630673557916260026308143510066298881", 10)
+- p224.N, _ = new(big.Int).SetString("26959946667150639794667015087019625940457807714424391721682722368061", 10)
+- p224.B, _ = new(big.Int).SetString("b4050a850c04b3abf54132565044b0b7d7bfd8ba270b39432355ffb4", 16)
+- p224.Gx, _ = new(big.Int).SetString("b70e0cbd6bb4bf7f321390b94a03c1d356c21122343280d6115c1d21", 16)
+- p224.Gy, _ = new(big.Int).SetString("bd376388b5f723fb4c22dfe6cd4375a05a07476444d5819985007e34", 16)
+- p224.BitSize = 224
+-
+- p224FromBig(&p224.gx, p224.Gx)
+- p224FromBig(&p224.gy, p224.Gy)
+- p224FromBig(&p224.b, p224.B)
+-}
+-
+-// P224 returns a Curve which implements P-224 (see FIPS 186-3, section D.2.2)
+-func P224() Curve {
+- initonce.Do(initAll)
+- return p224
+-}
+-
+-func (curve p224Curve) Params() *CurveParams {
+- return curve.CurveParams
+-}
+-
+-func (curve p224Curve) IsOnCurve(bigX, bigY *big.Int) bool {
+- var x, y p224FieldElement
+- p224FromBig(&x, bigX)
+- p224FromBig(&y, bigY)
+-
+- // y² = x³ - 3x + b
+- var tmp p224LargeFieldElement
+- var x3 p224FieldElement
+- p224Square(&x3, &x, &tmp)
+- p224Mul(&x3, &x3, &x, &tmp)
+-
+- for i := 0; i < 8; i++ {
+- x[i] *= 3
+- }
+- p224Sub(&x3, &x3, &x)
+- p224Reduce(&x3)
+- p224Add(&x3, &x3, &curve.b)
+- p224Contract(&x3, &x3)
+-
+- p224Square(&y, &y, &tmp)
+- p224Contract(&y, &y)
+-
+- for i := 0; i < 8; i++ {
+- if y[i] != x3[i] {
+- return false
+- }
+- }
+- return true
+-}
+-
+-func (p224Curve) Add(bigX1, bigY1, bigX2, bigY2 *big.Int) (x, y *big.Int) {
+- var x1, y1, z1, x2, y2, z2, x3, y3, z3 p224FieldElement
+-
+- p224FromBig(&x1, bigX1)
+- p224FromBig(&y1, bigY1)
+- if bigX1.Sign() != 0 || bigY1.Sign() != 0 {
+- z1[0] = 1
+- }
+- p224FromBig(&x2, bigX2)
+- p224FromBig(&y2, bigY2)
+- if bigX2.Sign() != 0 || bigY2.Sign() != 0 {
+- z2[0] = 1
+- }
+-
+- p224AddJacobian(&x3, &y3, &z3, &x1, &y1, &z1, &x2, &y2, &z2)
+- return p224ToAffine(&x3, &y3, &z3)
+-}
+-
+-func (p224Curve) Double(bigX1, bigY1 *big.Int) (x, y *big.Int) {
+- var x1, y1, z1, x2, y2, z2 p224FieldElement
+-
+- p224FromBig(&x1, bigX1)
+- p224FromBig(&y1, bigY1)
+- z1[0] = 1
+-
+- p224DoubleJacobian(&x2, &y2, &z2, &x1, &y1, &z1)
+- return p224ToAffine(&x2, &y2, &z2)
+-}
+-
+-func (p224Curve) ScalarMult(bigX1, bigY1 *big.Int, scalar []byte) (x, y *big.Int) {
+- var x1, y1, z1, x2, y2, z2 p224FieldElement
+-
+- p224FromBig(&x1, bigX1)
+- p224FromBig(&y1, bigY1)
+- z1[0] = 1
+-
+- p224ScalarMult(&x2, &y2, &z2, &x1, &y1, &z1, scalar)
+- return p224ToAffine(&x2, &y2, &z2)
+-}
+-
+-func (curve p224Curve) ScalarBaseMult(scalar []byte) (x, y *big.Int) {
+- var z1, x2, y2, z2 p224FieldElement
+-
+- z1[0] = 1
+- p224ScalarMult(&x2, &y2, &z2, &curve.gx, &curve.gy, &z1, scalar)
+- return p224ToAffine(&x2, &y2, &z2)
+-}
+-
+-// Field element functions.
+-//
+-// The field that we're dealing with is ℤ/pℤ where p = 2**224 - 2**96 + 1.
+-//
+-// Field elements are represented by a FieldElement, which is a typedef to an
+-// array of 8 uint32's. The value of a FieldElement, a, is:
+-// a[0] + 2**28·a[1] + 2**56·a[1] + ... + 2**196·a[7]
+-//
+-// Using 28-bit limbs means that there's only 4 bits of headroom, which is less
+-// than we would really like. But it has the useful feature that we hit 2**224
+-// exactly, making the reflections during a reduce much nicer.
+-type p224FieldElement [8]uint32
+-
+-// p224P is the order of the field, represented as a p224FieldElement.
+-var p224P = [8]uint32{1, 0, 0, 0xffff000, 0xfffffff, 0xfffffff, 0xfffffff, 0xfffffff}
+-
+-// p224IsZero returns 1 if a == 0 mod p and 0 otherwise.
+-//
+-// a[i] < 2**29
+-func p224IsZero(a *p224FieldElement) uint32 {
+- // Since a p224FieldElement contains 224 bits there are two possible
+- // representations of 0: 0 and p.
+- var minimal p224FieldElement
+- p224Contract(&minimal, a)
+-
+- var isZero, isP uint32
+- for i, v := range minimal {
+- isZero |= v
+- isP |= v - p224P[i]
+- }
+-
+- // If either isZero or isP is 0, then we should return 1.
+- isZero |= isZero >> 16
+- isZero |= isZero >> 8
+- isZero |= isZero >> 4
+- isZero |= isZero >> 2
+- isZero |= isZero >> 1
+-
+- isP |= isP >> 16
+- isP |= isP >> 8
+- isP |= isP >> 4
+- isP |= isP >> 2
+- isP |= isP >> 1
+-
+- // For isZero and isP, the LSB is 0 iff all the bits are zero.
+- result := isZero & isP
+- result = (^result) & 1
+-
+- return result
+-}
+-
+-// p224Add computes *out = a+b
+-//
+-// a[i] + b[i] < 2**32
+-func p224Add(out, a, b *p224FieldElement) {
+- for i := 0; i < 8; i++ {
+- out[i] = a[i] + b[i]
+- }
+-}
+-
+-const two31p3 = 1<<31 + 1<<3
+-const two31m3 = 1<<31 - 1<<3
+-const two31m15m3 = 1<<31 - 1<<15 - 1<<3
+-
+-// p224ZeroModP31 is 0 mod p where bit 31 is set in all limbs so that we can
+-// subtract smaller amounts without underflow. See the section "Subtraction" in
+-// [1] for reasoning.
+-var p224ZeroModP31 = []uint32{two31p3, two31m3, two31m3, two31m15m3, two31m3, two31m3, two31m3, two31m3}
+-
+-// p224Sub computes *out = a-b
+-//
+-// a[i], b[i] < 2**30
+-// out[i] < 2**32
+-func p224Sub(out, a, b *p224FieldElement) {
+- for i := 0; i < 8; i++ {
+- out[i] = a[i] + p224ZeroModP31[i] - b[i]
+- }
+-}
+-
+-// LargeFieldElement also represents an element of the field. The limbs are
+-// still spaced 28-bits apart and in little-endian order. So the limbs are at
+-// 0, 28, 56, ..., 392 bits, each 64-bits wide.
+-type p224LargeFieldElement [15]uint64
+-
+-const two63p35 = 1<<63 + 1<<35
+-const two63m35 = 1<<63 - 1<<35
+-const two63m35m19 = 1<<63 - 1<<35 - 1<<19
+-
+-// p224ZeroModP63 is 0 mod p where bit 63 is set in all limbs. See the section
+-// "Subtraction" in [1] for why.
+-var p224ZeroModP63 = [8]uint64{two63p35, two63m35, two63m35, two63m35, two63m35m19, two63m35, two63m35, two63m35}
+-
+-const bottom12Bits = 0xfff
+-const bottom28Bits = 0xfffffff
+-
+-// p224Mul computes *out = a*b
+-//
+-// a[i] < 2**29, b[i] < 2**30 (or vice versa)
+-// out[i] < 2**29
+-func p224Mul(out, a, b *p224FieldElement, tmp *p224LargeFieldElement) {
+- for i := 0; i < 15; i++ {
+- tmp[i] = 0
+- }
+-
+- for i := 0; i < 8; i++ {
+- for j := 0; j < 8; j++ {
+- tmp[i+j] += uint64(a[i]) * uint64(b[j])
+- }
+- }
+-
+- p224ReduceLarge(out, tmp)
+-}
+-
+-// Square computes *out = a*a
+-//
+-// a[i] < 2**29
+-// out[i] < 2**29
+-func p224Square(out, a *p224FieldElement, tmp *p224LargeFieldElement) {
+- for i := 0; i < 15; i++ {
+- tmp[i] = 0
+- }
+-
+- for i := 0; i < 8; i++ {
+- for j := 0; j <= i; j++ {
+- r := uint64(a[i]) * uint64(a[j])
+- if i == j {
+- tmp[i+j] += r
+- } else {
+- tmp[i+j] += r << 1
+- }
+- }
+- }
+-
+- p224ReduceLarge(out, tmp)
+-}
+-
+-// ReduceLarge converts a p224LargeFieldElement to a p224FieldElement.
+-//
+-// in[i] < 2**62
+-func p224ReduceLarge(out *p224FieldElement, in *p224LargeFieldElement) {
+- for i := 0; i < 8; i++ {
+- in[i] += p224ZeroModP63[i]
+- }
+-
+- // Eliminate the coefficients at 2**224 and greater.
+- for i := 14; i >= 8; i-- {
+- in[i-8] -= in[i]
+- in[i-5] += (in[i] & 0xffff) << 12
+- in[i-4] += in[i] >> 16
+- }
+- in[8] = 0
+- // in[0..8] < 2**64
+-
+- // As the values become small enough, we start to store them in |out|
+- // and use 32-bit operations.
+- for i := 1; i < 8; i++ {
+- in[i+1] += in[i] >> 28
+- out[i] = uint32(in[i] & bottom28Bits)
+- }
+- in[0] -= in[8]
+- out[3] += uint32(in[8]&0xffff) << 12
+- out[4] += uint32(in[8] >> 16)
+- // in[0] < 2**64
+- // out[3] < 2**29
+- // out[4] < 2**29
+- // out[1,2,5..7] < 2**28
+-
+- out[0] = uint32(in[0] & bottom28Bits)
+- out[1] += uint32((in[0] >> 28) & bottom28Bits)
+- out[2] += uint32(in[0] >> 56)
+- // out[0] < 2**28
+- // out[1..4] < 2**29
+- // out[5..7] < 2**28
+-}
+-
+-// Reduce reduces the coefficients of a to smaller bounds.
+-//
+-// On entry: a[i] < 2**31 + 2**30
+-// On exit: a[i] < 2**29
+-func p224Reduce(a *p224FieldElement) {
+- for i := 0; i < 7; i++ {
+- a[i+1] += a[i] >> 28
+- a[i] &= bottom28Bits
+- }
+- top := a[7] >> 28
+- a[7] &= bottom28Bits
+-
+- // top < 2**4
+- mask := top
+- mask |= mask >> 2
+- mask |= mask >> 1
+- mask <<= 31
+- mask = uint32(int32(mask) >> 31)
+- // Mask is all ones if top != 0, all zero otherwise
+-
+- a[0] -= top
+- a[3] += top << 12
+-
+- // We may have just made a[0] negative but, if we did, then we must
+- // have added something to a[3], this it's > 2**12. Therefore we can
+- // carry down to a[0].
+- a[3] -= 1 & mask
+- a[2] += mask & (1<<28 - 1)
+- a[1] += mask & (1<<28 - 1)
+- a[0] += mask & (1 << 28)
+-}
+-
+-// p224Invert calculates *out = in**-1 by computing in**(2**224 - 2**96 - 1),
+-// i.e. Fermat's little theorem.
+-func p224Invert(out, in *p224FieldElement) {
+- var f1, f2, f3, f4 p224FieldElement
+- var c p224LargeFieldElement
+-
+- p224Square(&f1, in, &c) // 2
+- p224Mul(&f1, &f1, in, &c) // 2**2 - 1
+- p224Square(&f1, &f1, &c) // 2**3 - 2
+- p224Mul(&f1, &f1, in, &c) // 2**3 - 1
+- p224Square(&f2, &f1, &c) // 2**4 - 2
+- p224Square(&f2, &f2, &c) // 2**5 - 4
+- p224Square(&f2, &f2, &c) // 2**6 - 8
+- p224Mul(&f1, &f1, &f2, &c) // 2**6 - 1
+- p224Square(&f2, &f1, &c) // 2**7 - 2
+- for i := 0; i < 5; i++ { // 2**12 - 2**6
+- p224Square(&f2, &f2, &c)
+- }
+- p224Mul(&f2, &f2, &f1, &c) // 2**12 - 1
+- p224Square(&f3, &f2, &c) // 2**13 - 2
+- for i := 0; i < 11; i++ { // 2**24 - 2**12
+- p224Square(&f3, &f3, &c)
+- }
+- p224Mul(&f2, &f3, &f2, &c) // 2**24 - 1
+- p224Square(&f3, &f2, &c) // 2**25 - 2
+- for i := 0; i < 23; i++ { // 2**48 - 2**24
+- p224Square(&f3, &f3, &c)
+- }
+- p224Mul(&f3, &f3, &f2, &c) // 2**48 - 1
+- p224Square(&f4, &f3, &c) // 2**49 - 2
+- for i := 0; i < 47; i++ { // 2**96 - 2**48
+- p224Square(&f4, &f4, &c)
+- }
+- p224Mul(&f3, &f3, &f4, &c) // 2**96 - 1
+- p224Square(&f4, &f3, &c) // 2**97 - 2
+- for i := 0; i < 23; i++ { // 2**120 - 2**24
+- p224Square(&f4, &f4, &c)
+- }
+- p224Mul(&f2, &f4, &f2, &c) // 2**120 - 1
+- for i := 0; i < 6; i++ { // 2**126 - 2**6
+- p224Square(&f2, &f2, &c)
+- }
+- p224Mul(&f1, &f1, &f2, &c) // 2**126 - 1
+- p224Square(&f1, &f1, &c) // 2**127 - 2
+- p224Mul(&f1, &f1, in, &c) // 2**127 - 1
+- for i := 0; i < 97; i++ { // 2**224 - 2**97
+- p224Square(&f1, &f1, &c)
+- }
+- p224Mul(out, &f1, &f3, &c) // 2**224 - 2**96 - 1
+-}
+-
+-// p224Contract converts a FieldElement to its unique, minimal form.
+-//
+-// On entry, in[i] < 2**29
+-// On exit, in[i] < 2**28
+-func p224Contract(out, in *p224FieldElement) {
+- copy(out[:], in[:])
+-
+- for i := 0; i < 7; i++ {
+- out[i+1] += out[i] >> 28
+- out[i] &= bottom28Bits
+- }
+- top := out[7] >> 28
+- out[7] &= bottom28Bits
+-
+- out[0] -= top
+- out[3] += top << 12
+-
+- // We may just have made out[i] negative. So we carry down. If we made
+- // out[0] negative then we know that out[3] is sufficiently positive
+- // because we just added to it.
+- for i := 0; i < 3; i++ {
+- mask := uint32(int32(out[i]) >> 31)
+- out[i] += (1 << 28) & mask
+- out[i+1] -= 1 & mask
+- }
+-
+- // We might have pushed out[3] over 2**28 so we perform another, partial,
+- // carry chain.
+- for i := 3; i < 7; i++ {
+- out[i+1] += out[i] >> 28
+- out[i] &= bottom28Bits
+- }
+- top = out[7] >> 28
+- out[7] &= bottom28Bits
+-
+- // Eliminate top while maintaining the same value mod p.
+- out[0] -= top
+- out[3] += top << 12
+-
+- // There are two cases to consider for out[3]:
+- // 1) The first time that we eliminated top, we didn't push out[3] over
+- // 2**28. In this case, the partial carry chain didn't change any values
+- // and top is zero.
+- // 2) We did push out[3] over 2**28 the first time that we eliminated top.
+- // The first value of top was in [0..16), therefore, prior to eliminating
+- // the first top, 0xfff1000 <= out[3] <= 0xfffffff. Therefore, after
+- // overflowing and being reduced by the second carry chain, out[3] <=
+- // 0xf000. Thus it cannot have overflowed when we eliminated top for the
+- // second time.
+-
+- // Again, we may just have made out[0] negative, so do the same carry down.
+- // As before, if we made out[0] negative then we know that out[3] is
+- // sufficiently positive.
+- for i := 0; i < 3; i++ {
+- mask := uint32(int32(out[i]) >> 31)
+- out[i] += (1 << 28) & mask
+- out[i+1] -= 1 & mask
+- }
+-
+- // Now we see if the value is >= p and, if so, subtract p.
+-
+- // First we build a mask from the top four limbs, which must all be
+- // equal to bottom28Bits if the whole value is >= p. If top4AllOnes
+- // ends up with any zero bits in the bottom 28 bits, then this wasn't
+- // true.
+- top4AllOnes := uint32(0xffffffff)
+- for i := 4; i < 8; i++ {
+- top4AllOnes &= out[i]
+- }
+- top4AllOnes |= 0xf0000000
+- // Now we replicate any zero bits to all the bits in top4AllOnes.
+- top4AllOnes &= top4AllOnes >> 16
+- top4AllOnes &= top4AllOnes >> 8
+- top4AllOnes &= top4AllOnes >> 4
+- top4AllOnes &= top4AllOnes >> 2
+- top4AllOnes &= top4AllOnes >> 1
+- top4AllOnes = uint32(int32(top4AllOnes<<31) >> 31)
+-
+- // Now we test whether the bottom three limbs are non-zero.
+- bottom3NonZero := out[0] | out[1] | out[2]
+- bottom3NonZero |= bottom3NonZero >> 16
+- bottom3NonZero |= bottom3NonZero >> 8
+- bottom3NonZero |= bottom3NonZero >> 4
+- bottom3NonZero |= bottom3NonZero >> 2
+- bottom3NonZero |= bottom3NonZero >> 1
+- bottom3NonZero = uint32(int32(bottom3NonZero<<31) >> 31)
+-
+- // Everything depends on the value of out[3].
+- // If it's > 0xffff000 and top4AllOnes != 0 then the whole value is >= p
+- // If it's = 0xffff000 and top4AllOnes != 0 and bottom3NonZero != 0,
+- // then the whole value is >= p
+- // If it's < 0xffff000, then the whole value is < p
+- n := out[3] - 0xffff000
+- out3Equal := n
+- out3Equal |= out3Equal >> 16
+- out3Equal |= out3Equal >> 8
+- out3Equal |= out3Equal >> 4
+- out3Equal |= out3Equal >> 2
+- out3Equal |= out3Equal >> 1
+- out3Equal = ^uint32(int32(out3Equal<<31) >> 31)
+-
+- // If out[3] > 0xffff000 then n's MSB will be zero.
+- out3GT := ^uint32(int32(n) >> 31)
+-
+- mask := top4AllOnes & ((out3Equal & bottom3NonZero) | out3GT)
+- out[0] -= 1 & mask
+- out[3] -= 0xffff000 & mask
+- out[4] -= 0xfffffff & mask
+- out[5] -= 0xfffffff & mask
+- out[6] -= 0xfffffff & mask
+- out[7] -= 0xfffffff & mask
+-}
+-
+-// Group element functions.
+-//
+-// These functions deal with group elements. The group is an elliptic curve
+-// group with a = -3 defined in FIPS 186-3, section D.2.2.
+-
+-// p224AddJacobian computes *out = a+b where a != b.
+-func p224AddJacobian(x3, y3, z3, x1, y1, z1, x2, y2, z2 *p224FieldElement) {
+- // See http://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#addition-p224Add-2007-bl
+- var z1z1, z2z2, u1, u2, s1, s2, h, i, j, r, v p224FieldElement
+- var c p224LargeFieldElement
+-
+- z1IsZero := p224IsZero(z1)
+- z2IsZero := p224IsZero(z2)
+-
+- // Z1Z1 = Z1²
+- p224Square(&z1z1, z1, &c)
+- // Z2Z2 = Z2²
+- p224Square(&z2z2, z2, &c)
+- // U1 = X1*Z2Z2
+- p224Mul(&u1, x1, &z2z2, &c)
+- // U2 = X2*Z1Z1
+- p224Mul(&u2, x2, &z1z1, &c)
+- // S1 = Y1*Z2*Z2Z2
+- p224Mul(&s1, z2, &z2z2, &c)
+- p224Mul(&s1, y1, &s1, &c)
+- // S2 = Y2*Z1*Z1Z1
+- p224Mul(&s2, z1, &z1z1, &c)
+- p224Mul(&s2, y2, &s2, &c)
+- // H = U2-U1
+- p224Sub(&h, &u2, &u1)
+- p224Reduce(&h)
+- xEqual := p224IsZero(&h)
+- // I = (2*H)²
+- for j := 0; j < 8; j++ {
+- i[j] = h[j] << 1
+- }
+- p224Reduce(&i)
+- p224Square(&i, &i, &c)
+- // J = H*I
+- p224Mul(&j, &h, &i, &c)
+- // r = 2*(S2-S1)
+- p224Sub(&r, &s2, &s1)
+- p224Reduce(&r)
+- yEqual := p224IsZero(&r)
+- if xEqual == 1 && yEqual == 1 && z1IsZero == 0 && z2IsZero == 0 {
+- p224DoubleJacobian(x3, y3, z3, x1, y1, z1)
+- return
+- }
+- for i := 0; i < 8; i++ {
+- r[i] <<= 1
+- }
+- p224Reduce(&r)
+- // V = U1*I
+- p224Mul(&v, &u1, &i, &c)
+- // Z3 = ((Z1+Z2)²-Z1Z1-Z2Z2)*H
+- p224Add(&z1z1, &z1z1, &z2z2)
+- p224Add(&z2z2, z1, z2)
+- p224Reduce(&z2z2)
+- p224Square(&z2z2, &z2z2, &c)
+- p224Sub(z3, &z2z2, &z1z1)
+- p224Reduce(z3)
+- p224Mul(z3, z3, &h, &c)
+- // X3 = r²-J-2*V
+- for i := 0; i < 8; i++ {
+- z1z1[i] = v[i] << 1
+- }
+- p224Add(&z1z1, &j, &z1z1)
+- p224Reduce(&z1z1)
+- p224Square(x3, &r, &c)
+- p224Sub(x3, x3, &z1z1)
+- p224Reduce(x3)
+- // Y3 = r*(V-X3)-2*S1*J
+- for i := 0; i < 8; i++ {
+- s1[i] <<= 1
+- }
+- p224Mul(&s1, &s1, &j, &c)
+- p224Sub(&z1z1, &v, x3)
+- p224Reduce(&z1z1)
+- p224Mul(&z1z1, &z1z1, &r, &c)
+- p224Sub(y3, &z1z1, &s1)
+- p224Reduce(y3)
+-
+- p224CopyConditional(x3, x2, z1IsZero)
+- p224CopyConditional(x3, x1, z2IsZero)
+- p224CopyConditional(y3, y2, z1IsZero)
+- p224CopyConditional(y3, y1, z2IsZero)
+- p224CopyConditional(z3, z2, z1IsZero)
+- p224CopyConditional(z3, z1, z2IsZero)
+-}
+-
+-// p224DoubleJacobian computes *out = a+a.
+-func p224DoubleJacobian(x3, y3, z3, x1, y1, z1 *p224FieldElement) {
+- var delta, gamma, beta, alpha, t p224FieldElement
+- var c p224LargeFieldElement
+-
+- p224Square(&delta, z1, &c)
+- p224Square(&gamma, y1, &c)
+- p224Mul(&beta, x1, &gamma, &c)
+-
+- // alpha = 3*(X1-delta)*(X1+delta)
+- p224Add(&t, x1, &delta)
+- for i := 0; i < 8; i++ {
+- t[i] += t[i] << 1
+- }
+- p224Reduce(&t)
+- p224Sub(&alpha, x1, &delta)
+- p224Reduce(&alpha)
+- p224Mul(&alpha, &alpha, &t, &c)
+-
+- // Z3 = (Y1+Z1)²-gamma-delta
+- p224Add(z3, y1, z1)
+- p224Reduce(z3)
+- p224Square(z3, z3, &c)
+- p224Sub(z3, z3, &gamma)
+- p224Reduce(z3)
+- p224Sub(z3, z3, &delta)
+- p224Reduce(z3)
+-
+- // X3 = alpha²-8*beta
+- for i := 0; i < 8; i++ {
+- delta[i] = beta[i] << 3
+- }
+- p224Reduce(&delta)
+- p224Square(x3, &alpha, &c)
+- p224Sub(x3, x3, &delta)
+- p224Reduce(x3)
+-
+- // Y3 = alpha*(4*beta-X3)-8*gamma²
+- for i := 0; i < 8; i++ {
+- beta[i] <<= 2
+- }
+- p224Sub(&beta, &beta, x3)
+- p224Reduce(&beta)
+- p224Square(&gamma, &gamma, &c)
+- for i := 0; i < 8; i++ {
+- gamma[i] <<= 3
+- }
+- p224Reduce(&gamma)
+- p224Mul(y3, &alpha, &beta, &c)
+- p224Sub(y3, y3, &gamma)
+- p224Reduce(y3)
+-}
+-
+-// p224CopyConditional sets *out = *in iff the least-significant-bit of control
+-// is true, and it runs in constant time.
+-func p224CopyConditional(out, in *p224FieldElement, control uint32) {
+- control <<= 31
+- control = uint32(int32(control) >> 31)
+-
+- for i := 0; i < 8; i++ {
+- out[i] ^= (out[i] ^ in[i]) & control
+- }
+-}
+-
+-func p224ScalarMult(outX, outY, outZ, inX, inY, inZ *p224FieldElement, scalar []byte) {
+- var xx, yy, zz p224FieldElement
+- for i := 0; i < 8; i++ {
+- outX[i] = 0
+- outY[i] = 0
+- outZ[i] = 0
+- }
+-
+- for _, byte := range scalar {
+- for bitNum := uint(0); bitNum < 8; bitNum++ {
+- p224DoubleJacobian(outX, outY, outZ, outX, outY, outZ)
+- bit := uint32((byte >> (7 - bitNum)) & 1)
+- p224AddJacobian(&xx, &yy, &zz, inX, inY, inZ, outX, outY, outZ)
+- p224CopyConditional(outX, &xx, bit)
+- p224CopyConditional(outY, &yy, bit)
+- p224CopyConditional(outZ, &zz, bit)
+- }
+- }
+-}
+-
+-// p224ToAffine converts from Jacobian to affine form.
+-func p224ToAffine(x, y, z *p224FieldElement) (*big.Int, *big.Int) {
+- var zinv, zinvsq, outx, outy p224FieldElement
+- var tmp p224LargeFieldElement
+-
+- if isPointAtInfinity := p224IsZero(z); isPointAtInfinity == 1 {
+- return new(big.Int), new(big.Int)
+- }
+-
+- p224Invert(&zinv, z)
+- p224Square(&zinvsq, &zinv, &tmp)
+- p224Mul(x, x, &zinvsq, &tmp)
+- p224Mul(&zinvsq, &zinvsq, &zinv, &tmp)
+- p224Mul(y, y, &zinvsq, &tmp)
+-
+- p224Contract(&outx, x)
+- p224Contract(&outy, y)
+- return p224ToBig(&outx), p224ToBig(&outy)
+-}
+-
+-// get28BitsFromEnd returns the least-significant 28 bits from buf>>shift,
+-// where buf is interpreted as a big-endian number.
+-func get28BitsFromEnd(buf []byte, shift uint) (uint32, []byte) {
+- var ret uint32
+-
+- for i := uint(0); i < 4; i++ {
+- var b byte
+- if l := len(buf); l > 0 {
+- b = buf[l-1]
+- // We don't remove the byte if we're about to return and we're not
+- // reading all of it.
+- if i != 3 || shift == 4 {
+- buf = buf[:l-1]
+- }
+- }
+- ret |= uint32(b) << (8 * i) >> shift
+- }
+- ret &= bottom28Bits
+- return ret, buf
+-}
+-
+-// p224FromBig sets *out = *in.
+-func p224FromBig(out *p224FieldElement, in *big.Int) {
+- bytes := in.Bytes()
+- out[0], bytes = get28BitsFromEnd(bytes, 0)
+- out[1], bytes = get28BitsFromEnd(bytes, 4)
+- out[2], bytes = get28BitsFromEnd(bytes, 0)
+- out[3], bytes = get28BitsFromEnd(bytes, 4)
+- out[4], bytes = get28BitsFromEnd(bytes, 0)
+- out[5], bytes = get28BitsFromEnd(bytes, 4)
+- out[6], bytes = get28BitsFromEnd(bytes, 0)
+- out[7], bytes = get28BitsFromEnd(bytes, 4)
+-}
+-
+-// p224ToBig returns in as a big.Int.
+-func p224ToBig(in *p224FieldElement) *big.Int {
+- var buf [28]byte
+- buf[27] = byte(in[0])
+- buf[26] = byte(in[0] >> 8)
+- buf[25] = byte(in[0] >> 16)
+- buf[24] = byte(((in[0] >> 24) & 0x0f) | (in[1]<<4)&0xf0)
+-
+- buf[23] = byte(in[1] >> 4)
+- buf[22] = byte(in[1] >> 12)
+- buf[21] = byte(in[1] >> 20)
+-
+- buf[20] = byte(in[2])
+- buf[19] = byte(in[2] >> 8)
+- buf[18] = byte(in[2] >> 16)
+- buf[17] = byte(((in[2] >> 24) & 0x0f) | (in[3]<<4)&0xf0)
+-
+- buf[16] = byte(in[3] >> 4)
+- buf[15] = byte(in[3] >> 12)
+- buf[14] = byte(in[3] >> 20)
+-
+- buf[13] = byte(in[4])
+- buf[12] = byte(in[4] >> 8)
+- buf[11] = byte(in[4] >> 16)
+- buf[10] = byte(((in[4] >> 24) & 0x0f) | (in[5]<<4)&0xf0)
+-
+- buf[9] = byte(in[5] >> 4)
+- buf[8] = byte(in[5] >> 12)
+- buf[7] = byte(in[5] >> 20)
+-
+- buf[6] = byte(in[6])
+- buf[5] = byte(in[6] >> 8)
+- buf[4] = byte(in[6] >> 16)
+- buf[3] = byte(((in[6] >> 24) & 0x0f) | (in[7]<<4)&0xf0)
+-
+- buf[2] = byte(in[7] >> 4)
+- buf[1] = byte(in[7] >> 12)
+- buf[0] = byte(in[7] >> 20)
+-
+- return new(big.Int).SetBytes(buf[:])
+-}
+--- libgo/go/crypto/elliptic/p224_test.go.jj 2014-02-18 18:03:31.615598561 +0100
++++ libgo/go/crypto/elliptic/p224_test.go 2014-02-15 11:40:56.191557928 +0100
+@@ -1,47 +0,0 @@
+-// Copyright 2012 The Go Authors. All rights reserved.
+-// Use of this source code is governed by a BSD-style
+-// license that can be found in the LICENSE file.
+-
+-package elliptic
+-
+-import (
+- "math/big"
+- "testing"
+-)
+-
+-var toFromBigTests = []string{
+- "0",
+- "1",
+- "23",
+- "b70e0cb46bb4bf7f321390b94a03c1d356c01122343280d6105c1d21",
+- "706a46d476dcb76798e6046d89474788d164c18032d268fd10704fa6",
+-}
+-
+-func p224AlternativeToBig(in *p224FieldElement) *big.Int {
+- ret := new(big.Int)
+- tmp := new(big.Int)
+-
+- for i := uint(0); i < 8; i++ {
+- tmp.SetInt64(int64(in[i]))
+- tmp.Lsh(tmp, 28*i)
+- ret.Add(ret, tmp)
+- }
+- ret.Mod(ret, p224.P)
+- return ret
+-}
+-
+-func TestToFromBig(t *testing.T) {
+- for i, test := range toFromBigTests {
+- n, _ := new(big.Int).SetString(test, 16)
+- var x p224FieldElement
+- p224FromBig(&x, n)
+- m := p224ToBig(&x)
+- if n.Cmp(m) != 0 {
+- t.Errorf("#%d: %x != %x", i, n, m)
+- }
+- q := p224AlternativeToBig(&x)
+- if n.Cmp(q) != 0 {
+- t.Errorf("#%d: %x != %x (alternative)", i, n, m)
+- }
+- }
+-}
diff --git a/gcc48-pr60046.patch b/gcc48-pr60046.patch
new file mode 100644
index 0000000..fde6da9
--- /dev/null
+++ b/gcc48-pr60046.patch
@@ -0,0 +1,43 @@
+2014-02-19 Jason Merrill <jason@redhat.com>
+
+ PR c++/60046
+ * pt.c (maybe_instantiate_noexcept): Don't instantiate exception
+ spec from template context.
+
+--- gcc/cp/pt.c (revision 207920)
++++ gcc/cp/pt.c (revision 207921)
+@@ -18567,6 +18567,10 @@ maybe_instantiate_noexcept (tree fn)
+ {
+ tree fntype, spec, noex, clone;
+
++ /* Don't instantiate a noexcept-specification from template context. */
++ if (processing_template_decl)
++ return;
++
+ if (DECL_CLONED_FUNCTION_P (fn))
+ fn = DECL_CLONED_FUNCTION (fn);
+ fntype = TREE_TYPE (fn);
+--- gcc/testsuite/g++.dg/cpp0x/noexcept22.C (revision 0)
++++ gcc/testsuite/g++.dg/cpp0x/noexcept22.C (revision 207921)
+@@ -0,0 +1,21 @@
++// PR c++/60046
++// { dg-require-effective-target c++11 }
++
++constexpr bool foo () { return noexcept (true); }
++template <typename T>
++struct V
++{
++ void bar (V &) noexcept (foo ()) {}
++};
++template <typename T>
++struct W : public V <int>
++{
++ void bar (W &x) { V <int>::bar (x); }
++};
++
++int
++main ()
++{
++ W <int> a, b;
++ a.bar (b);
++}
diff --git a/gcc48-pr60137.patch b/gcc48-pr60137.patch
new file mode 100644
index 0000000..74cd998
--- /dev/null
+++ b/gcc48-pr60137.patch
@@ -0,0 +1,46 @@
+2014-02-11 Michael Meissner <meissner@linux.vnet.ibm.com>
+
+ PR target/60137
+ * config/rs6000/rs6000.md (128-bit GPR splitter): Add a splitter
+ for VSX/Altivec vectors that land in GPR registers.
+
+ * gcc.target/powerpc/pr60137.c: New file.
+
+--- gcc/config/rs6000/rs6000.md (revision 207698)
++++ gcc/config/rs6000/rs6000.md (revision 207699)
+@@ -9963,6 +9963,15 @@ (define_insn_and_split "reload_vsx_from_
+ [(set_attr "length" "12")
+ (set_attr "type" "three")])
+
++(define_split
++ [(set (match_operand:FMOVE128_GPR 0 "nonimmediate_operand" "")
++ (match_operand:FMOVE128_GPR 1 "input_operand" ""))]
++ "reload_completed
++ && (int_reg_operand (operands[0], <MODE>mode)
++ || int_reg_operand (operands[1], <MODE>mode))"
++ [(pc)]
++{ rs6000_split_multireg_move (operands[0], operands[1]); DONE; })
++
+ ;; Move SFmode to a VSX from a GPR register. Because scalar floating point
+ ;; type is stored internally as double precision in the VSX registers, we have
+ ;; to convert it from the vector format.
+--- gcc/testsuite/gcc.target/powerpc/pr60137.c (revision 0)
++++ gcc/testsuite/gcc.target/powerpc/pr60137.c (revision 207699)
+@@ -0,0 +1,17 @@
++/* { dg-do compile { target { powerpc*-*-* } } } */
++/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */
++/* { dg-require-effective-target powerpc_p8vector_ok } */
++/* { dg-options "-mcpu=power8 -O3 -mno-vsx" } */
++
++/* target/60137, compiler got a 'could not split insn error'. */
++
++extern int target_flags;
++extern char fixed_regs[53];
++extern char call_used_regs[53];
++
++void init_reg_sets_1(void)
++{
++ int i;
++ for (i = 0; i < 53; i++)
++ fixed_regs[i] = call_used_regs[i] = (call_used_regs[i] &((target_flags & 0x02000000) ? 2 : 1)) != 0;
++}
^ permalink raw reply related [flat|nested] only message in thread
only message in thread, other threads:[~2026-06-29 12:26 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-06-29 12:26 [rpms/gcc] rhel-f41-base: 4.8.2-15 Jakub Jelinek
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox