From 81437a813ff18ac95cb5fdcc7e40dd9a98678707 Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Sun, 26 Jan 2020 11:27:43 -0800 Subject: glibc: Update to final 2.31 release Drop ppc 8xx clear cache optimization, which we have been carrying through eglibc days, it has been redone in glibc now (From OE-Core rev: 5c48e655cbd9a45d43c37602db8e09e2e91d2722) Signed-off-by: Khem Raj Signed-off-by: Richard Purdie --- .../glibc/cross-localedef-native_2.31.bb | 9 +- meta/recipes-core/glibc/glibc-version.inc | 2 +- ...def-Add-hardlink-resolver-from-util-linux.patch | 2 +- ...ledef-fix-ups-hardlink-to-make-it-compile.patch | 2 +- ...libc-Look-for-host-system-ld.so.cache-as-.patch | 2 +- ...libc-Fix-buffer-overrun-with-a-relocated-.patch | 2 +- ...libc-Raise-the-size-of-arrays-containing-.patch | 2 +- ...ivesdk-glibc-Allow-64-bit-atomics-for-x86.patch | 2 +- ...libc-Make-relocatable-install-for-locales.patch | 2 +- ...500-e5500-e6500-603e-fsqrt-implementation.patch | 2 +- ...-OECORE_KNOWN_INTERPRETER_NAMES-to-known-.patch | 2 +- ...-Fix-undefined-reference-to-__sqrt_finite.patch | 2 +- ...qrt-f-are-now-inline-functions-and-call-o.patch | 2 +- ...bug-1443-which-explains-what-the-patch-do.patch | 2 +- ...n-libm-err-tab.pl-with-specific-dirs-in-S.patch | 2 +- ...qrt-f-are-now-inline-functions-and-call-o.patch | 2 +- ...-configure.ac-handle-correctly-libc_cv_ro.patch | 2 +- .../glibc/glibc/0016-Add-unused-attribute.patch | 2 +- ...thin-the-path-sets-wrong-config-variables.patch | 2 +- ...-timezone-re-written-tzselect-as-posix-sh.patch | 2 +- ...move-bash-dependency-for-nscd-init-script.patch | 2 +- ...c-Cross-building-and-testing-instructions.patch | 2 +- ...021-eglibc-Help-bootstrap-cross-toolchain.patch | 2 +- .../0022-eglibc-Clear-cache-lines-on-ppc8xx.patch | 80 - ...0022-eglibc-Resolve-__fpscr_values-on-SH4.patch | 53 + ...ward-port-cross-locale-generation-support.patch | 560 ++++ ...0023-eglibc-Resolve-__fpscr_values-on-SH4.patch | 53 - ...0024-Define-DUMMY_LOCALE_T-if-not-defined.patch | 29 + ...ward-port-cross-locale-generation-support.patch | 560 ---- ...0025-Define-DUMMY_LOCALE_T-if-not-defined.patch | 29 - ...dd-to-archive-uses-a-hard-coded-locale-pa.patch | 80 + ....c-Make-_dl_build_local_scope-breadth-fir.patch | 53 + ...dd-to-archive-uses-a-hard-coded-locale-pa.patch | 80 - ....c-Make-_dl_build_local_scope-breadth-fir.patch | 53 - ...tl-Emit-no-lines-in-bison-generated-files.patch | 31 + .../0028-inject-file-assembly-directives.patch | 301 +++ ...tl-Emit-no-lines-in-bison-generated-files.patch | 31 - .../0029-inject-file-assembly-directives.patch | 301 --- ...ent-maybe-uninitialized-errors-with-Os-BZ.patch | 53 + .../glibc/0030-Refactor-FORTIFY-in-glibc.patch | 2780 ++++++++++++++++++++ ...ent-maybe-uninitialized-errors-with-Os-BZ.patch | 53 - .../glibc/0031-Refactor-FORTIFY-in-glibc.patch | 2780 -------------------- meta/recipes-core/glibc/glibc_2.31.bb | 19 +- 43 files changed, 3975 insertions(+), 4057 deletions(-) delete mode 100644 meta/recipes-core/glibc/glibc/0022-eglibc-Clear-cache-lines-on-ppc8xx.patch create mode 100644 meta/recipes-core/glibc/glibc/0022-eglibc-Resolve-__fpscr_values-on-SH4.patch create mode 100644 meta/recipes-core/glibc/glibc/0023-eglibc-Forward-port-cross-locale-generation-support.patch delete mode 100644 meta/recipes-core/glibc/glibc/0023-eglibc-Resolve-__fpscr_values-on-SH4.patch create mode 100644 meta/recipes-core/glibc/glibc/0024-Define-DUMMY_LOCALE_T-if-not-defined.patch delete mode 100644 meta/recipes-core/glibc/glibc/0024-eglibc-Forward-port-cross-locale-generation-support.patch delete mode 100644 meta/recipes-core/glibc/glibc/0025-Define-DUMMY_LOCALE_T-if-not-defined.patch create mode 100644 meta/recipes-core/glibc/glibc/0025-localedef-add-to-archive-uses-a-hard-coded-locale-pa.patch create mode 100644 meta/recipes-core/glibc/glibc/0026-elf-dl-deps.c-Make-_dl_build_local_scope-breadth-fir.patch delete mode 100644 meta/recipes-core/glibc/glibc/0026-localedef-add-to-archive-uses-a-hard-coded-locale-pa.patch delete mode 100644 meta/recipes-core/glibc/glibc/0027-elf-dl-deps.c-Make-_dl_build_local_scope-breadth-fir.patch create mode 100644 meta/recipes-core/glibc/glibc/0027-intl-Emit-no-lines-in-bison-generated-files.patch create mode 100644 meta/recipes-core/glibc/glibc/0028-inject-file-assembly-directives.patch delete mode 100644 meta/recipes-core/glibc/glibc/0028-intl-Emit-no-lines-in-bison-generated-files.patch delete mode 100644 meta/recipes-core/glibc/glibc/0029-inject-file-assembly-directives.patch create mode 100644 meta/recipes-core/glibc/glibc/0029-locale-prevent-maybe-uninitialized-errors-with-Os-BZ.patch create mode 100644 meta/recipes-core/glibc/glibc/0030-Refactor-FORTIFY-in-glibc.patch delete mode 100644 meta/recipes-core/glibc/glibc/0030-locale-prevent-maybe-uninitialized-errors-with-Os-BZ.patch delete mode 100644 meta/recipes-core/glibc/glibc/0031-Refactor-FORTIFY-in-glibc.patch (limited to 'meta') diff --git a/meta/recipes-core/glibc/cross-localedef-native_2.31.bb b/meta/recipes-core/glibc/cross-localedef-native_2.31.bb index a267a591d4..24de55d929 100644 --- a/meta/recipes-core/glibc/cross-localedef-native_2.31.bb +++ b/meta/recipes-core/glibc/cross-localedef-native_2.31.bb @@ -31,11 +31,10 @@ SRC_URI = "${GLIBC_GIT_URI};branch=${SRCBRANCH};name=glibc \ file://0019-Remove-bash-dependency-for-nscd-init-script.patch \ file://0020-eglibc-Cross-building-and-testing-instructions.patch \ file://0021-eglibc-Help-bootstrap-cross-toolchain.patch \ - file://0022-eglibc-Clear-cache-lines-on-ppc8xx.patch \ - file://0023-eglibc-Resolve-__fpscr_values-on-SH4.patch \ - file://0024-eglibc-Forward-port-cross-locale-generation-support.patch \ - file://0025-Define-DUMMY_LOCALE_T-if-not-defined.patch \ - file://0026-localedef-add-to-archive-uses-a-hard-coded-locale-pa.patch \ + file://0022-eglibc-Resolve-__fpscr_values-on-SH4.patch \ + file://0023-eglibc-Forward-port-cross-locale-generation-support.patch \ + file://0024-Define-DUMMY_LOCALE_T-if-not-defined.patch \ + file://0025-localedef-add-to-archive-uses-a-hard-coded-locale-pa.patch \ " # Makes for a rather long rev (22 characters), but... # diff --git a/meta/recipes-core/glibc/glibc-version.inc b/meta/recipes-core/glibc/glibc-version.inc index dca1916e80..c2cfb7e2f1 100644 --- a/meta/recipes-core/glibc/glibc-version.inc +++ b/meta/recipes-core/glibc/glibc-version.inc @@ -1,6 +1,6 @@ SRCBRANCH ?= "master" PV = "2.30.9000" -SRCREV_glibc ?= "def9c08c94da60bfb746644d56cffbe7a9de3477" +SRCREV_glibc ?= "352bb99754ae7c83ff1b974f9c52244e974c9410" SRCREV_localedef ?= "cd9f958c4c94a638fa7b2b4e21627364f1a1a655" GLIBC_GIT_URI ?= "git://sourceware.org/git/glibc.git" diff --git a/meta/recipes-core/glibc/glibc/0001-localedef-Add-hardlink-resolver-from-util-linux.patch b/meta/recipes-core/glibc/glibc/0001-localedef-Add-hardlink-resolver-from-util-linux.patch index 9b75f2a62f..d0786be8b8 100644 --- a/meta/recipes-core/glibc/glibc/0001-localedef-Add-hardlink-resolver-from-util-linux.patch +++ b/meta/recipes-core/glibc/glibc/0001-localedef-Add-hardlink-resolver-from-util-linux.patch @@ -1,4 +1,4 @@ -From 169720859cf8f9133882a13f588b15f44b7b8ae6 Mon Sep 17 00:00:00 2001 +From 3dcf144e998aed17b3fb957a255b1e923ba07d71 Mon Sep 17 00:00:00 2001 From: Jason Wessel Date: Sat, 7 Dec 2019 09:59:22 -0800 Subject: [PATCH] localedef: Add hardlink resolver from util-linux diff --git a/meta/recipes-core/glibc/glibc/0002-localedef-fix-ups-hardlink-to-make-it-compile.patch b/meta/recipes-core/glibc/glibc/0002-localedef-fix-ups-hardlink-to-make-it-compile.patch index 029292fe36..5222e37d1a 100644 --- a/meta/recipes-core/glibc/glibc/0002-localedef-fix-ups-hardlink-to-make-it-compile.patch +++ b/meta/recipes-core/glibc/glibc/0002-localedef-fix-ups-hardlink-to-make-it-compile.patch @@ -1,4 +1,4 @@ -From 9b966b758d0c96ef6654251689318614ef10becc Mon Sep 17 00:00:00 2001 +From b52dba15527380cc18635e3696e0ef87efee9a84 Mon Sep 17 00:00:00 2001 From: Jason Wessel Date: Sat, 7 Dec 2019 10:01:37 -0800 Subject: [PATCH] localedef: fix-ups hardlink to make it compile diff --git a/meta/recipes-core/glibc/glibc/0003-nativesdk-glibc-Look-for-host-system-ld.so.cache-as-.patch b/meta/recipes-core/glibc/glibc/0003-nativesdk-glibc-Look-for-host-system-ld.so.cache-as-.patch index e1c3512e4e..4cdc8354b6 100644 --- a/meta/recipes-core/glibc/glibc/0003-nativesdk-glibc-Look-for-host-system-ld.so.cache-as-.patch +++ b/meta/recipes-core/glibc/glibc/0003-nativesdk-glibc-Look-for-host-system-ld.so.cache-as-.patch @@ -1,4 +1,4 @@ -From 14ddf13b7fc2e39a1ae657ceb3963e35731e95d0 Mon Sep 17 00:00:00 2001 +From 6987ad183770cb56680ccc4f6ea065a04f31ccb6 Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Wed, 18 Mar 2015 01:48:24 +0000 Subject: [PATCH] nativesdk-glibc: Look for host system ld.so.cache as well diff --git a/meta/recipes-core/glibc/glibc/0004-nativesdk-glibc-Fix-buffer-overrun-with-a-relocated-.patch b/meta/recipes-core/glibc/glibc/0004-nativesdk-glibc-Fix-buffer-overrun-with-a-relocated-.patch index 523b6da897..62e12897f5 100644 --- a/meta/recipes-core/glibc/glibc/0004-nativesdk-glibc-Fix-buffer-overrun-with-a-relocated-.patch +++ b/meta/recipes-core/glibc/glibc/0004-nativesdk-glibc-Fix-buffer-overrun-with-a-relocated-.patch @@ -1,4 +1,4 @@ -From 3ac58bf1028841cc0a8fa7f258cbf21466740360 Mon Sep 17 00:00:00 2001 +From 7806340c2accc2c51e7e861b618c29fb5609a007 Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Wed, 18 Mar 2015 01:50:00 +0000 Subject: [PATCH] nativesdk-glibc: Fix buffer overrun with a relocated SDK diff --git a/meta/recipes-core/glibc/glibc/0005-nativesdk-glibc-Raise-the-size-of-arrays-containing-.patch b/meta/recipes-core/glibc/glibc/0005-nativesdk-glibc-Raise-the-size-of-arrays-containing-.patch index 4d88d9b413..294c2b975e 100644 --- a/meta/recipes-core/glibc/glibc/0005-nativesdk-glibc-Raise-the-size-of-arrays-containing-.patch +++ b/meta/recipes-core/glibc/glibc/0005-nativesdk-glibc-Raise-the-size-of-arrays-containing-.patch @@ -1,4 +1,4 @@ -From 702d68cbdf405e086f72e2a062127cbea43045ec Mon Sep 17 00:00:00 2001 +From 1b97befbe693eb93a77b6098f6ae1394a53462f4 Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Wed, 18 Mar 2015 01:51:38 +0000 Subject: [PATCH] nativesdk-glibc: Raise the size of arrays containing dl paths diff --git a/meta/recipes-core/glibc/glibc/0006-nativesdk-glibc-Allow-64-bit-atomics-for-x86.patch b/meta/recipes-core/glibc/glibc/0006-nativesdk-glibc-Allow-64-bit-atomics-for-x86.patch index 0d070a93b9..db8b6c0f1c 100644 --- a/meta/recipes-core/glibc/glibc/0006-nativesdk-glibc-Allow-64-bit-atomics-for-x86.patch +++ b/meta/recipes-core/glibc/glibc/0006-nativesdk-glibc-Allow-64-bit-atomics-for-x86.patch @@ -1,4 +1,4 @@ -From f9993e652bd4a0f03402d0c527cf24b83d0ff7ea Mon Sep 17 00:00:00 2001 +From a752857cc342ee5136c9a593037b6ee6ff8af8ee Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Thu, 31 Dec 2015 14:35:35 -0800 Subject: [PATCH] nativesdk-glibc: Allow 64 bit atomics for x86 diff --git a/meta/recipes-core/glibc/glibc/0007-nativesdk-glibc-Make-relocatable-install-for-locales.patch b/meta/recipes-core/glibc/glibc/0007-nativesdk-glibc-Make-relocatable-install-for-locales.patch index 66abcce3ce..d9985c2fdc 100644 --- a/meta/recipes-core/glibc/glibc/0007-nativesdk-glibc-Make-relocatable-install-for-locales.patch +++ b/meta/recipes-core/glibc/glibc/0007-nativesdk-glibc-Make-relocatable-install-for-locales.patch @@ -1,4 +1,4 @@ -From ee9d5e423e4a709ae5a62abfb476863b3b57378f Mon Sep 17 00:00:00 2001 +From 3df91d1d8b9c7a01b3ef8133c4f9b9764227d583 Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Fri, 3 Aug 2018 09:55:12 -0700 Subject: [PATCH] nativesdk-glibc: Make relocatable install for locales diff --git a/meta/recipes-core/glibc/glibc/0008-fsl-e500-e5500-e6500-603e-fsqrt-implementation.patch b/meta/recipes-core/glibc/glibc/0008-fsl-e500-e5500-e6500-603e-fsqrt-implementation.patch index 4f3ed38065..3dac325380 100644 --- a/meta/recipes-core/glibc/glibc/0008-fsl-e500-e5500-e6500-603e-fsqrt-implementation.patch +++ b/meta/recipes-core/glibc/glibc/0008-fsl-e500-e5500-e6500-603e-fsqrt-implementation.patch @@ -1,4 +1,4 @@ -From 2cc7b79157ce17144791dda1a2e3a6dc4902c736 Mon Sep 17 00:00:00 2001 +From 61b6c9737897c5828ef4b40699ee0a74c570034a Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Wed, 18 Mar 2015 00:01:50 +0000 Subject: [PATCH] fsl e500/e5500/e6500/603e fsqrt implementation diff --git a/meta/recipes-core/glibc/glibc/0009-readlib-Add-OECORE_KNOWN_INTERPRETER_NAMES-to-known-.patch b/meta/recipes-core/glibc/glibc/0009-readlib-Add-OECORE_KNOWN_INTERPRETER_NAMES-to-known-.patch index 6e4259f4ff..456f91fb8e 100644 --- a/meta/recipes-core/glibc/glibc/0009-readlib-Add-OECORE_KNOWN_INTERPRETER_NAMES-to-known-.patch +++ b/meta/recipes-core/glibc/glibc/0009-readlib-Add-OECORE_KNOWN_INTERPRETER_NAMES-to-known-.patch @@ -1,4 +1,4 @@ -From e6ff3960d9e4ed6a9a4be70732313127f0e6d0e0 Mon Sep 17 00:00:00 2001 +From 13beb1f428ec06778590bf526d6e641f73d5cf62 Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Wed, 18 Mar 2015 00:11:22 +0000 Subject: [PATCH] readlib: Add OECORE_KNOWN_INTERPRETER_NAMES to known names diff --git a/meta/recipes-core/glibc/glibc/0010-ppc-sqrt-Fix-undefined-reference-to-__sqrt_finite.patch b/meta/recipes-core/glibc/glibc/0010-ppc-sqrt-Fix-undefined-reference-to-__sqrt_finite.patch index 91da344089..01446abc43 100644 --- a/meta/recipes-core/glibc/glibc/0010-ppc-sqrt-Fix-undefined-reference-to-__sqrt_finite.patch +++ b/meta/recipes-core/glibc/glibc/0010-ppc-sqrt-Fix-undefined-reference-to-__sqrt_finite.patch @@ -1,4 +1,4 @@ -From ad055d58bd99b80e41face63bf20db3f04afa4e3 Mon Sep 17 00:00:00 2001 +From 4483a83074a340a921e319b88d72166f18e0df0b Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Wed, 18 Mar 2015 00:15:07 +0000 Subject: [PATCH] ppc/sqrt: Fix undefined reference to `__sqrt_finite' diff --git a/meta/recipes-core/glibc/glibc/0011-__ieee754_sqrt-f-are-now-inline-functions-and-call-o.patch b/meta/recipes-core/glibc/glibc/0011-__ieee754_sqrt-f-are-now-inline-functions-and-call-o.patch index 6a5a44af9d..451f372650 100644 --- a/meta/recipes-core/glibc/glibc/0011-__ieee754_sqrt-f-are-now-inline-functions-and-call-o.patch +++ b/meta/recipes-core/glibc/glibc/0011-__ieee754_sqrt-f-are-now-inline-functions-and-call-o.patch @@ -1,4 +1,4 @@ -From ac4450bc74dc0754a3724f1bebb2290c4dc29d72 Mon Sep 17 00:00:00 2001 +From 347b2e31d010b04c42e78157a028aa1d58fe0f5e Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Wed, 18 Mar 2015 00:16:38 +0000 Subject: [PATCH] __ieee754_sqrt{,f} are now inline functions and call out diff --git a/meta/recipes-core/glibc/glibc/0012-Quote-from-bug-1443-which-explains-what-the-patch-do.patch b/meta/recipes-core/glibc/glibc/0012-Quote-from-bug-1443-which-explains-what-the-patch-do.patch index e8eaa4d90b..a0b46c0479 100644 --- a/meta/recipes-core/glibc/glibc/0012-Quote-from-bug-1443-which-explains-what-the-patch-do.patch +++ b/meta/recipes-core/glibc/glibc/0012-Quote-from-bug-1443-which-explains-what-the-patch-do.patch @@ -1,4 +1,4 @@ -From 0c73e17d5ea7c88247c1bfbb03511b0ccb6ba6b4 Mon Sep 17 00:00:00 2001 +From 8ca8e5cd78cbd37a713e1181f8f6641b57352aa8 Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Wed, 18 Mar 2015 00:20:09 +0000 Subject: [PATCH] Quote from bug 1443 which explains what the patch does : diff --git a/meta/recipes-core/glibc/glibc/0013-eglibc-run-libm-err-tab.pl-with-specific-dirs-in-S.patch b/meta/recipes-core/glibc/glibc/0013-eglibc-run-libm-err-tab.pl-with-specific-dirs-in-S.patch index 3b3611f448..736de8cf04 100644 --- a/meta/recipes-core/glibc/glibc/0013-eglibc-run-libm-err-tab.pl-with-specific-dirs-in-S.patch +++ b/meta/recipes-core/glibc/glibc/0013-eglibc-run-libm-err-tab.pl-with-specific-dirs-in-S.patch @@ -1,4 +1,4 @@ -From 6a1ebbab0643fb2169314bcf1a0850b0f06dd27e Mon Sep 17 00:00:00 2001 +From 21509735678990760d5ebf9d0c65efa4b52b838d Mon Sep 17 00:00:00 2001 From: Ting Liu Date: Wed, 19 Dec 2012 04:39:57 -0600 Subject: [PATCH] eglibc: run libm-err-tab.pl with specific dirs in ${S} diff --git a/meta/recipes-core/glibc/glibc/0014-__ieee754_sqrt-f-are-now-inline-functions-and-call-o.patch b/meta/recipes-core/glibc/glibc/0014-__ieee754_sqrt-f-are-now-inline-functions-and-call-o.patch index b35de40eea..e73b640c16 100644 --- a/meta/recipes-core/glibc/glibc/0014-__ieee754_sqrt-f-are-now-inline-functions-and-call-o.patch +++ b/meta/recipes-core/glibc/glibc/0014-__ieee754_sqrt-f-are-now-inline-functions-and-call-o.patch @@ -1,4 +1,4 @@ -From 106aee1de5c95fc9e02f10c05537dcc39f8478f4 Mon Sep 17 00:00:00 2001 +From e33deb119734ef443ef44c42a00a569f90e1e149 Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Wed, 18 Mar 2015 00:24:46 +0000 Subject: [PATCH] __ieee754_sqrt{,f} are now inline functions and call out diff --git a/meta/recipes-core/glibc/glibc/0015-sysdeps-gnu-configure.ac-handle-correctly-libc_cv_ro.patch b/meta/recipes-core/glibc/glibc/0015-sysdeps-gnu-configure.ac-handle-correctly-libc_cv_ro.patch index 5669341916..0cdd0567df 100644 --- a/meta/recipes-core/glibc/glibc/0015-sysdeps-gnu-configure.ac-handle-correctly-libc_cv_ro.patch +++ b/meta/recipes-core/glibc/glibc/0015-sysdeps-gnu-configure.ac-handle-correctly-libc_cv_ro.patch @@ -1,4 +1,4 @@ -From 6c07d094556606ce7c1dc08f4dd3bc6af483364f Mon Sep 17 00:00:00 2001 +From c50cae36e90c41849301a9a668adf31e81e43a07 Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Wed, 18 Mar 2015 00:27:10 +0000 Subject: [PATCH] sysdeps/gnu/configure.ac: handle correctly diff --git a/meta/recipes-core/glibc/glibc/0016-Add-unused-attribute.patch b/meta/recipes-core/glibc/glibc/0016-Add-unused-attribute.patch index 3e5bba5a59..574e7c3503 100644 --- a/meta/recipes-core/glibc/glibc/0016-Add-unused-attribute.patch +++ b/meta/recipes-core/glibc/glibc/0016-Add-unused-attribute.patch @@ -1,4 +1,4 @@ -From 8a8c81ba4e652dddb730d3dad2fecab1ee65fd9c Mon Sep 17 00:00:00 2001 +From c323125744020a29f79e50dc4d024b55c482eafc Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Wed, 18 Mar 2015 00:28:41 +0000 Subject: [PATCH] Add unused attribute diff --git a/meta/recipes-core/glibc/glibc/0017-yes-within-the-path-sets-wrong-config-variables.patch b/meta/recipes-core/glibc/glibc/0017-yes-within-the-path-sets-wrong-config-variables.patch index 0b626bdfac..49089af41e 100644 --- a/meta/recipes-core/glibc/glibc/0017-yes-within-the-path-sets-wrong-config-variables.patch +++ b/meta/recipes-core/glibc/glibc/0017-yes-within-the-path-sets-wrong-config-variables.patch @@ -1,4 +1,4 @@ -From 601b2d11b6ddd974f0e1685f70e0d368e706d976 Mon Sep 17 00:00:00 2001 +From c421cd7e885497a99179b982dc4a27e8405f8857 Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Wed, 18 Mar 2015 00:31:06 +0000 Subject: [PATCH] 'yes' within the path sets wrong config variables diff --git a/meta/recipes-core/glibc/glibc/0018-timezone-re-written-tzselect-as-posix-sh.patch b/meta/recipes-core/glibc/glibc/0018-timezone-re-written-tzselect-as-posix-sh.patch index f18c7a1107..20b0ee98ea 100644 --- a/meta/recipes-core/glibc/glibc/0018-timezone-re-written-tzselect-as-posix-sh.patch +++ b/meta/recipes-core/glibc/glibc/0018-timezone-re-written-tzselect-as-posix-sh.patch @@ -1,4 +1,4 @@ -From 8678c584bca244fe9a3f8926eabb6b6c7e9784f1 Mon Sep 17 00:00:00 2001 +From 2023d88c355b8af6458c8e39ce38b75c1ca4ea2a Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Wed, 18 Mar 2015 00:33:03 +0000 Subject: [PATCH] timezone: re-written tzselect as posix sh diff --git a/meta/recipes-core/glibc/glibc/0019-Remove-bash-dependency-for-nscd-init-script.patch b/meta/recipes-core/glibc/glibc/0019-Remove-bash-dependency-for-nscd-init-script.patch index 82026694de..1c15a51308 100644 --- a/meta/recipes-core/glibc/glibc/0019-Remove-bash-dependency-for-nscd-init-script.patch +++ b/meta/recipes-core/glibc/glibc/0019-Remove-bash-dependency-for-nscd-init-script.patch @@ -1,4 +1,4 @@ -From a78f21f2f9b9246cd12b310833313328e8f646ed Mon Sep 17 00:00:00 2001 +From 06da20d9f89907e5f2777537244e6589ca3c9703 Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Thu, 31 Dec 2015 14:33:02 -0800 Subject: [PATCH] Remove bash dependency for nscd init script diff --git a/meta/recipes-core/glibc/glibc/0020-eglibc-Cross-building-and-testing-instructions.patch b/meta/recipes-core/glibc/glibc/0020-eglibc-Cross-building-and-testing-instructions.patch index f8f3efe582..eda5565371 100644 --- a/meta/recipes-core/glibc/glibc/0020-eglibc-Cross-building-and-testing-instructions.patch +++ b/meta/recipes-core/glibc/glibc/0020-eglibc-Cross-building-and-testing-instructions.patch @@ -1,4 +1,4 @@ -From 7c48f61b0c5ef6274df4b03609991d383adc5df0 Mon Sep 17 00:00:00 2001 +From 5641452a24f76c5dafa3749a542fcac93f77390f Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Wed, 18 Mar 2015 00:42:58 +0000 Subject: [PATCH] eglibc: Cross building and testing instructions diff --git a/meta/recipes-core/glibc/glibc/0021-eglibc-Help-bootstrap-cross-toolchain.patch b/meta/recipes-core/glibc/glibc/0021-eglibc-Help-bootstrap-cross-toolchain.patch index 02e5def339..6374ea4086 100644 --- a/meta/recipes-core/glibc/glibc/0021-eglibc-Help-bootstrap-cross-toolchain.patch +++ b/meta/recipes-core/glibc/glibc/0021-eglibc-Help-bootstrap-cross-toolchain.patch @@ -1,4 +1,4 @@ -From 86a6e94e86664976b305c24e5a52093fe962240a Mon Sep 17 00:00:00 2001 +From 6a32d5bf40deee5d12d24c06f3ea9b5479c16802 Mon Sep 17 00:00:00 2001 From: Khem Raj Date: Wed, 18 Mar 2015 00:49:28 +0000 Subject: [PATCH] eglibc: Help bootstrap cross toolchain diff --git a/meta/recipes-core/glibc/glibc/0022-eglibc-Clear-cache-lines-on-ppc8xx.patch b/meta/recipes-core/glibc/glibc/0022-eglibc-Clear-cache-lines-on-ppc8xx.patch deleted file mode 100644 index 913aea9563..0000000000 --- a/meta/recipes-core/glibc/glibc/0022-eglibc-Clear-cache-lines-on-ppc8xx.patch +++ /dev/null @@ -1,80 +0,0 @@ -From b397d653670dd02d8310e1d6f0f19a8da90ebafa Mon Sep 17 00:00:00 2001 -From: Khem Raj -Date: Thu, 31 Dec 2015 15:15:09 -0800 -Subject: [PATCH] eglibc: Clear cache lines on ppc8xx - -2007-06-13 Nathan Sidwell - Mark Shinwell - - * sysdeps/unix/sysv/linux/powerpc/libc-start.c - (__libc_start_main): Detect 8xx parts and clear - __cache_line_size if detected. - * sysdeps/unix/sysv/linux/powerpc/dl-sysdep.c - (DL_PLATFORM_AUXV): Likewise. - -Upstream-Status: Pending - -Signed-off-by: Khem Raj ---- - sysdeps/unix/sysv/linux/powerpc/dl-sysdep.c | 14 +++++++++++++- - sysdeps/unix/sysv/linux/powerpc/libc-start.c | 16 +++++++++++++++- - 2 files changed, 28 insertions(+), 2 deletions(-) - -diff --git a/sysdeps/unix/sysv/linux/powerpc/dl-sysdep.c b/sysdeps/unix/sysv/linux/powerpc/dl-sysdep.c -index 5d65bc6303..c786f9aa7e 100644 ---- a/sysdeps/unix/sysv/linux/powerpc/dl-sysdep.c -+++ b/sysdeps/unix/sysv/linux/powerpc/dl-sysdep.c -@@ -24,9 +24,21 @@ int __cache_line_size attribute_hidden; - /* Scan the Aux Vector for the "Data Cache Block Size" entry. If found - verify that the static extern __cache_line_size is defined by checking - for not NULL. If it is defined then assign the cache block size -- value to __cache_line_size. */ -+ value to __cache_line_size. This is used by memset to -+ optimize setting to zero. We have to detect 8xx processors, which -+ have buggy dcbz implementations that cannot report page faults -+ correctly. That requires reading SPR, which is a privileged -+ operation. Fortunately 2.2.18 and later emulates PowerPC mfspr -+ reads from the PVR register. */ - #define DL_PLATFORM_AUXV \ - case AT_DCACHEBSIZE: \ -+ if (__LINUX_KERNEL_VERSION >= 0x020218) \ -+ { \ -+ unsigned pvr = 0; \ -+ asm ("mfspr %0, 287" : "=r" (pvr)); \ -+ if ((pvr & 0xffff0000) == 0x00500000) \ -+ break; \ -+ } \ - __cache_line_size = av->a_un.a_val; \ - break; - -diff --git a/sysdeps/unix/sysv/linux/powerpc/libc-start.c b/sysdeps/unix/sysv/linux/powerpc/libc-start.c -index 93f8659fa6..9bb07b36be 100644 ---- a/sysdeps/unix/sysv/linux/powerpc/libc-start.c -+++ b/sysdeps/unix/sysv/linux/powerpc/libc-start.c -@@ -73,11 +73,25 @@ __libc_start_main (int argc, char **argv, - - /* Initialize the __cache_line_size variable from the aux vector. For the - static case, we also need _dl_hwcap, _dl_hwcap2 and _dl_platform, so we -- can call __tcb_parse_hwcap_and_convert_at_platform (). */ -+ can call __tcb_parse_hwcap_and_convert_at_platform (). -+ -+ This is used by memset to optimize setting to zero. We have to -+ detect 8xx processors, which have buggy dcbz implementations that -+ cannot report page faults correctly. That requires reading SPR, -+ which is a privileged operation. Fortunately 2.2.18 and later -+ emulates PowerPC mfspr reads from the PVR register. */ - for (ElfW (auxv_t) * av = auxvec; av->a_type != AT_NULL; ++av) - switch (av->a_type) - { - case AT_DCACHEBSIZE: -+ if (__LINUX_KERNEL_VERSION >= 0x020218) -+ { -+ unsigned pvr = 0; -+ -+ asm ("mfspr %0, 287" : "=r" (pvr) :); -+ if ((pvr & 0xffff0000) == 0x00500000) -+ break; -+ } - __cache_line_size = av->a_un.a_val; - break; - #ifndef SHARED diff --git a/meta/recipes-core/glibc/glibc/0022-eglibc-Resolve-__fpscr_values-on-SH4.patch b/meta/recipes-core/glibc/glibc/0022-eglibc-Resolve-__fpscr_values-on-SH4.patch new file mode 100644 index 0000000000..2a503c811e --- /dev/null +++ b/meta/recipes-core/glibc/glibc/0022-eglibc-Resolve-__fpscr_values-on-SH4.patch @@ -0,0 +1,53 @@ +From 25c21857a3fc0eb26831616ba88a696dd31ecba1 Mon Sep 17 00:00:00 2001 +From: Khem Raj +Date: Wed, 18 Mar 2015 00:55:53 +0000 +Subject: [PATCH] eglibc: Resolve __fpscr_values on SH4 + +2010-09-29 Nobuhiro Iwamatsu + Andrew Stubbs + + Resolve SH's __fpscr_values to symbol in libc.so. + + * sysdeps/sh/sh4/fpu/fpu_control.h: Add C++ __set_fpscr prototype. + * sysdeps/unix/sysv/linux/sh/Versions (GLIBC_2.2): Add __fpscr_values. + * sysdeps/unix/sysv/linux/sh/sysdep.S (___fpscr_values): New constant. + +Upstream-Status: Pending + +Signed-off-by: Khem Raj +--- + sysdeps/unix/sysv/linux/sh/Versions | 1 + + sysdeps/unix/sysv/linux/sh/sysdep.S | 11 +++++++++++ + 2 files changed, 12 insertions(+) + +diff --git a/sysdeps/unix/sysv/linux/sh/Versions b/sysdeps/unix/sysv/linux/sh/Versions +index e0938c4165..ca1d7da339 100644 +--- a/sysdeps/unix/sysv/linux/sh/Versions ++++ b/sysdeps/unix/sysv/linux/sh/Versions +@@ -2,6 +2,7 @@ libc { + GLIBC_2.2 { + # functions used in other libraries + __xstat64; __fxstat64; __lxstat64; ++ __fpscr_values; + + # a* + alphasort64; +diff --git a/sysdeps/unix/sysv/linux/sh/sysdep.S b/sysdeps/unix/sysv/linux/sh/sysdep.S +index 85ff3f900e..7743b8d57a 100644 +--- a/sysdeps/unix/sysv/linux/sh/sysdep.S ++++ b/sysdeps/unix/sysv/linux/sh/sysdep.S +@@ -30,3 +30,14 @@ ENTRY (__syscall_error) + + #define __syscall_error __syscall_error_1 + #include ++ ++ .data ++ .align 3 ++ .globl ___fpscr_values ++ .type ___fpscr_values, @object ++ .size ___fpscr_values, 8 ++___fpscr_values: ++ .long 0 ++ .long 0x80000 ++weak_alias (___fpscr_values, __fpscr_values) ++ diff --git a/meta/recipes-core/glibc/glibc/0023-eglibc-Forward-port-cross-locale-generation-support.patch b/meta/recipes-core/glibc/glibc/0023-eglibc-Forward-port-cross-locale-generation-support.patch new file mode 100644 index 0000000000..1a90f22db6 --- /dev/null +++ b/meta/recipes-core/glibc/glibc/0023-eglibc-Forward-port-cross-locale-generation-support.patch @@ -0,0 +1,560 @@ +From 30008327aadf0c775e644bb387d7c25952ed05b5 Mon Sep 17 00:00:00 2001 +From: Khem Raj +Date: Wed, 18 Mar 2015 01:33:49 +0000 +Subject: [PATCH] eglibc: Forward port cross locale generation support + +Upstream-Status: Pending + +Signed-off-by: Khem Raj +--- + locale/Makefile | 3 +- + locale/catnames.c | 46 +++++++++++++++++++++++++++ + locale/localeinfo.h | 2 +- + locale/programs/charmap-dir.c | 6 ++++ + locale/programs/ld-collate.c | 17 +++++----- + locale/programs/ld-ctype.c | 27 ++++++++-------- + locale/programs/ld-time.c | 31 ++++++++++++------ + locale/programs/linereader.c | 2 +- + locale/programs/localedef.c | 8 +++++ + locale/programs/locfile.c | 5 ++- + locale/programs/locfile.h | 59 +++++++++++++++++++++++++++++++++-- + locale/setlocale.c | 29 ----------------- + 12 files changed, 167 insertions(+), 68 deletions(-) + create mode 100644 locale/catnames.c + +diff --git a/locale/Makefile b/locale/Makefile +index c9694e236e..ba7105fad6 100644 +--- a/locale/Makefile ++++ b/locale/Makefile +@@ -26,7 +26,8 @@ headers = langinfo.h locale.h bits/locale.h \ + bits/types/locale_t.h bits/types/__locale_t.h + routines = setlocale findlocale loadlocale loadarchive \ + localeconv nl_langinfo nl_langinfo_l mb_cur_max \ +- newlocale duplocale freelocale uselocale ++ newlocale duplocale freelocale uselocale \ ++ catnames + tests = tst-C-locale tst-locname tst-duplocale + categories = ctype messages monetary numeric time paper name \ + address telephone measurement identification collate +diff --git a/locale/catnames.c b/locale/catnames.c +new file mode 100644 +index 0000000000..538f3f5edb +--- /dev/null ++++ b/locale/catnames.c +@@ -0,0 +1,46 @@ ++/* Copyright (C) 2006 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ The GNU C Library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++ 02111-1307 USA. */ ++ ++#include "localeinfo.h" ++ ++/* Define an array of category names (also the environment variable names). */ ++const struct catnamestr_t _nl_category_names attribute_hidden = ++ { ++#define DEFINE_CATEGORY(category, category_name, items, a) \ ++ category_name, ++#include "categories.def" ++#undef DEFINE_CATEGORY ++ }; ++ ++const uint8_t _nl_category_name_idxs[__LC_LAST] attribute_hidden = ++ { ++#define DEFINE_CATEGORY(category, category_name, items, a) \ ++ [category] = offsetof (struct catnamestr_t, CATNAMEMF (__LINE__)), ++#include "categories.def" ++#undef DEFINE_CATEGORY ++ }; ++ ++/* An array of their lengths, for convenience. */ ++const uint8_t _nl_category_name_sizes[] attribute_hidden = ++ { ++#define DEFINE_CATEGORY(category, category_name, items, a) \ ++ [category] = sizeof (category_name) - 1, ++#include "categories.def" ++#undef DEFINE_CATEGORY ++ [LC_ALL] = sizeof ("LC_ALL") - 1 ++ }; +diff --git a/locale/localeinfo.h b/locale/localeinfo.h +index fdc283c69a..4eeed35f90 100644 +--- a/locale/localeinfo.h ++++ b/locale/localeinfo.h +@@ -230,7 +230,7 @@ __libc_tsd_define (extern, locale_t, LOCALE) + unused. We can manage this playing some tricks with weak references. + But with thread-local locale settings, it becomes quite ungainly unless + we can use __thread variables. So only in that case do we attempt this. */ +-#ifndef SHARED ++#if !defined SHARED && !defined IN_GLIBC_LOCALEDEF + # include + # define NL_CURRENT_INDIRECT 1 + #endif +diff --git a/locale/programs/charmap-dir.c b/locale/programs/charmap-dir.c +index 1a526a240d..0fb2daf936 100644 +--- a/locale/programs/charmap-dir.c ++++ b/locale/programs/charmap-dir.c +@@ -18,7 +18,9 @@ + #include + #include + #include ++#ifndef NO_UNCOMPRESS + #include ++#endif + #include + #include + #include +@@ -154,6 +156,7 @@ charmap_closedir (CHARMAP_DIR *cdir) + return closedir (dir); + } + ++#ifndef NO_UNCOMPRESS + /* Creates a subprocess decompressing the given pathname, and returns + a stream reading its output (the decompressed data). */ + static +@@ -202,6 +205,7 @@ fopen_uncompressed (const char *pathname, const char *compressor) + } + return NULL; + } ++#endif + + /* Opens a charmap for reading, given its name (not an alias name). */ + FILE * +@@ -224,6 +228,7 @@ charmap_open (const char *directory, const char *name) + if (stream != NULL) + return stream; + ++#ifndef NO_UNCOMPRESS + memcpy (p, ".gz", 4); + stream = fopen_uncompressed (pathname, "gzip"); + if (stream != NULL) +@@ -233,6 +238,7 @@ charmap_open (const char *directory, const char *name) + stream = fopen_uncompressed (pathname, "bzip2"); + if (stream != NULL) + return stream; ++#endif + + return NULL; + } +diff --git a/locale/programs/ld-collate.c b/locale/programs/ld-collate.c +index feb1a11258..5a8e522470 100644 +--- a/locale/programs/ld-collate.c ++++ b/locale/programs/ld-collate.c +@@ -349,7 +349,7 @@ new_element (struct locale_collate_t *collate, const char *mbs, size_t mbslen, + } + if (wcs != NULL) + { +- size_t nwcs = wcslen ((wchar_t *) wcs); ++ size_t nwcs = wcslen_uint32 (wcs); + uint32_t zero = 0; + /* Handle as a single character. */ + if (nwcs == 0) +@@ -1772,8 +1772,7 @@ symbol `%s' has the same encoding as"), (*eptr)->name); + + if ((*eptr)->nwcs == runp->nwcs) + { +- int c = wmemcmp ((wchar_t *) (*eptr)->wcs, +- (wchar_t *) runp->wcs, runp->nwcs); ++ int c = wmemcmp_uint32 ((*eptr)->wcs, runp->wcs, runp->nwcs); + + if (c == 0) + { +@@ -2000,9 +1999,9 @@ add_to_tablewc (uint32_t ch, struct element_t *runp) + one consecutive entry. */ + if (runp->wcnext != NULL + && runp->nwcs == runp->wcnext->nwcs +- && wmemcmp ((wchar_t *) runp->wcs, +- (wchar_t *)runp->wcnext->wcs, +- runp->nwcs - 1) == 0 ++ && wmemcmp_uint32 (runp->wcs, ++ runp->wcnext->wcs, ++ runp->nwcs - 1) == 0 + && (runp->wcs[runp->nwcs - 1] + == runp->wcnext->wcs[runp->nwcs - 1] + 1)) + { +@@ -2026,9 +2025,9 @@ add_to_tablewc (uint32_t ch, struct element_t *runp) + runp = runp->wcnext; + while (runp->wcnext != NULL + && runp->nwcs == runp->wcnext->nwcs +- && wmemcmp ((wchar_t *) runp->wcs, +- (wchar_t *)runp->wcnext->wcs, +- runp->nwcs - 1) == 0 ++ && wmemcmp_uint32 (runp->wcs, ++ runp->wcnext->wcs, ++ runp->nwcs - 1) == 0 + && (runp->wcs[runp->nwcs - 1] + == runp->wcnext->wcs[runp->nwcs - 1] + 1)); + +diff --git a/locale/programs/ld-ctype.c b/locale/programs/ld-ctype.c +index 3328093d0e..d58fb0f4b7 100644 +--- a/locale/programs/ld-ctype.c ++++ b/locale/programs/ld-ctype.c +@@ -915,7 +915,7 @@ ctype_output (struct localedef_t *locale, const struct charmap_t *charmap, + allocate_arrays (ctype, charmap, ctype->repertoire); + + default_missing_len = (ctype->default_missing +- ? wcslen ((wchar_t *) ctype->default_missing) ++ ? wcslen_uint32 (ctype->default_missing) + : 0); + + init_locale_data (&file, nelems); +@@ -1927,7 +1927,7 @@ read_translit_entry (struct linereader *ldfile, struct locale_ctype_t *ctype, + ignore = 1; + else + /* This value is usable. */ +- obstack_grow (ob, to_wstr, wcslen ((wchar_t *) to_wstr) * 4); ++ obstack_grow (ob, to_wstr, wcslen_uint32 (to_wstr) * 4); + + first = 0; + } +@@ -2461,8 +2461,8 @@ with character code range values one must use the absolute ellipsis `...'")); + } + + handle_tok_digit: +- class_bit = _ISwdigit; +- class256_bit = _ISdigit; ++ class_bit = BITw (tok_digit); ++ class256_bit = BIT (tok_digit); + handle_digits = 1; + goto read_charclass; + +@@ -3904,8 +3904,7 @@ allocate_arrays (struct locale_ctype_t *ctype, const struct charmap_t *charmap, + + while (idx < number) + { +- int res = wcscmp ((const wchar_t *) sorted[idx]->from, +- (const wchar_t *) runp->from); ++ int res = wcscmp_uint32 (sorted[idx]->from, runp->from); + if (res == 0) + { + replace = 1; +@@ -3942,11 +3941,11 @@ allocate_arrays (struct locale_ctype_t *ctype, const struct charmap_t *charmap, + for (size_t cnt = 0; cnt < number; ++cnt) + { + struct translit_to_t *srunp; +- from_len += wcslen ((const wchar_t *) sorted[cnt]->from) + 1; ++ from_len += wcslen_uint32 (sorted[cnt]->from) + 1; + srunp = sorted[cnt]->to; + while (srunp != NULL) + { +- to_len += wcslen ((const wchar_t *) srunp->str) + 1; ++ to_len += wcslen_uint32 (srunp->str) + 1; + srunp = srunp->next; + } + /* Plus one for the extra NUL character marking the end of +@@ -3970,18 +3969,18 @@ allocate_arrays (struct locale_ctype_t *ctype, const struct charmap_t *charmap, + ctype->translit_from_idx[cnt] = from_len; + ctype->translit_to_idx[cnt] = to_len; + +- len = wcslen ((const wchar_t *) sorted[cnt]->from) + 1; +- wmemcpy ((wchar_t *) &ctype->translit_from_tbl[from_len], +- (const wchar_t *) sorted[cnt]->from, len); ++ len = wcslen_uint32 (sorted[cnt]->from) + 1; ++ wmemcpy_uint32 (&ctype->translit_from_tbl[from_len], ++ sorted[cnt]->from, len); + from_len += len; + + ctype->translit_to_idx[cnt] = to_len; + srunp = sorted[cnt]->to; + while (srunp != NULL) + { +- len = wcslen ((const wchar_t *) srunp->str) + 1; +- wmemcpy ((wchar_t *) &ctype->translit_to_tbl[to_len], +- (const wchar_t *) srunp->str, len); ++ len = wcslen_uint32 (srunp->str) + 1; ++ wmemcpy_uint32 (&ctype->translit_to_tbl[to_len], ++ srunp->str, len); + to_len += len; + srunp = srunp->next; + } +diff --git a/locale/programs/ld-time.c b/locale/programs/ld-time.c +index f7db873adb..fec3773c9d 100644 +--- a/locale/programs/ld-time.c ++++ b/locale/programs/ld-time.c +@@ -220,8 +220,10 @@ No definition for %s category found"), "LC_TIME"); + } + else + { ++ static const uint32_t wt_fmt_ampm[] ++ = { '%','I',':','%','M',':','%','S',' ','%','p',0 }; + time->t_fmt_ampm = "%I:%M:%S %p"; +- time->wt_fmt_ampm = (const uint32_t *) L"%I:%M:%S %p"; ++ time->wt_fmt_ampm = wt_fmt_ampm; + } + } + +@@ -231,7 +233,7 @@ No definition for %s category found"), "LC_TIME"); + const int days_per_month[12] = { 31, 29, 31, 30, 31, 30, + 31, 31, 30, 31 ,30, 31 }; + size_t idx; +- wchar_t *wstr; ++ uint32_t *wstr; + + time->era_entries = + (struct era_data *) xmalloc (time->num_era +@@ -457,18 +459,18 @@ No definition for %s category found"), "LC_TIME"); + } + + /* Now generate the wide character name and format. */ +- wstr = wcschr ((wchar_t *) time->wera[idx], L':');/* end direction */ +- wstr = wstr ? wcschr (wstr + 1, L':') : NULL; /* end offset */ +- wstr = wstr ? wcschr (wstr + 1, L':') : NULL; /* end start */ +- wstr = wstr ? wcschr (wstr + 1, L':') : NULL; /* end end */ ++ wstr = wcschr_uint32 (time->wera[idx], L':'); /* end direction */ ++ wstr = wstr ? wcschr_uint32 (wstr + 1, L':') : NULL; /* end offset */ ++ wstr = wstr ? wcschr_uint32 (wstr + 1, L':') : NULL; /* end start */ ++ wstr = wstr ? wcschr_uint32 (wstr + 1, L':') : NULL; /* end end */ + if (wstr != NULL) + { +- time->era_entries[idx].wname = (uint32_t *) wstr + 1; +- wstr = wcschr (wstr + 1, L':'); /* end name */ ++ time->era_entries[idx].wname = wstr + 1; ++ wstr = wcschr_uint32 (wstr + 1, L':'); /* end name */ + if (wstr != NULL) + { + *wstr = L'\0'; +- time->era_entries[idx].wformat = (uint32_t *) wstr + 1; ++ time->era_entries[idx].wformat = wstr + 1; + } + else + time->era_entries[idx].wname = +@@ -527,7 +529,16 @@ No definition for %s category found"), "LC_TIME"); + if (time->date_fmt == NULL) + time->date_fmt = "%a %b %e %H:%M:%S %Z %Y"; + if (time->wdate_fmt == NULL) +- time->wdate_fmt = (const uint32_t *) L"%a %b %e %H:%M:%S %Z %Y"; ++ { ++ static const uint32_t wdate_fmt[] = ++ { '%','a',' ', ++ '%','b',' ', ++ '%','e',' ', ++ '%','H',':','%','M',':','%','S',' ', ++ '%','Z',' ', ++ '%','Y',0 }; ++ time->wdate_fmt = wdate_fmt; ++ } + } + + +diff --git a/locale/programs/linereader.c b/locale/programs/linereader.c +index 7ebd933801..5753750756 100644 +--- a/locale/programs/linereader.c ++++ b/locale/programs/linereader.c +@@ -595,7 +595,7 @@ get_string (struct linereader *lr, const struct charmap_t *charmap, + { + int return_widestr = lr->return_widestr; + char *buf; +- wchar_t *buf2 = NULL; ++ uint32_t *buf2 = NULL; + size_t bufact; + size_t bufmax = 56; + +diff --git a/locale/programs/localedef.c b/locale/programs/localedef.c +index dbbb0145c0..097a8b6193 100644 +--- a/locale/programs/localedef.c ++++ b/locale/programs/localedef.c +@@ -109,6 +109,7 @@ void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version; + #define OPT_NO_WARN 402 + #define OPT_WARN 403 + #define OPT_NO_HARD_LINKS 404 ++#define OPT_UINT32_ALIGN 405 + + /* Definitions of arguments for argp functions. */ + static const struct argp_option options[] = +@@ -153,6 +154,8 @@ static const struct argp_option options[] = + N_("Generate little-endian output") }, + { "big-endian", OPT_BIG_ENDIAN, NULL, 0, + N_("Generate big-endian output") }, ++ { "uint32-align", OPT_UINT32_ALIGN, "ALIGNMENT", 0, ++ N_("Set the target's uint32_t alignment in bytes (default 4)") }, + { NULL, 0, NULL, 0, NULL } + }; + +@@ -242,12 +245,14 @@ main (int argc, char *argv[]) + ctype locale. (P1003.2 4.35.5.2) */ + setlocale (LC_CTYPE, "POSIX"); + ++#ifndef NO_SYSCONF + /* Look whether the system really allows locale definitions. POSIX + defines error code 3 for this situation so I think it must be + a fatal error (see P1003.2 4.35.8). */ + if (sysconf (_SC_2_LOCALEDEF) < 0) + record_error (3, 0, _("\ + FATAL: system does not define `_POSIX2_LOCALEDEF'")); ++#endif + + /* Process charmap file. */ + charmap = charmap_read (charmap_file, verbose, 1, be_quiet, 1); +@@ -399,6 +404,9 @@ parse_opt (int key, char *arg, struct argp_state *state) + /* Do not hard link to other locales. */ + hard_links = false; + break; ++ case OPT_UINT32_ALIGN: ++ uint32_align_mask = strtol (arg, NULL, 0) - 1; ++ break; + case 'c': + force_output = 1; + break; +diff --git a/locale/programs/locfile.c b/locale/programs/locfile.c +index eb2f4634da..d387147323 100644 +--- a/locale/programs/locfile.c ++++ b/locale/programs/locfile.c +@@ -544,6 +544,9 @@ compare_files (const char *filename1, const char *filename2, size_t size, + machine running localedef. */ + bool swap_endianness_p; + ++/* The target's value of __align__(uint32_t) - 1. */ ++unsigned int uint32_align_mask = 3; ++ + /* When called outside a start_locale_structure/end_locale_structure + or start_locale_prelude/end_locale_prelude block, record that the + next byte in FILE's obstack will be the first byte of a new element. +@@ -621,7 +624,7 @@ add_locale_string (struct locale_file *file, const char *string) + void + add_locale_wstring (struct locale_file *file, const uint32_t *string) + { +- add_locale_uint32_array (file, string, wcslen ((const wchar_t *) string) + 1); ++ add_locale_uint32_array (file, string, wcslen_uint32 (string) + 1); + } + + /* Record that FILE's next element is the 32-bit integer VALUE. */ +diff --git a/locale/programs/locfile.h b/locale/programs/locfile.h +index 7ea10038b4..0888c09762 100644 +--- a/locale/programs/locfile.h ++++ b/locale/programs/locfile.h +@@ -71,6 +71,8 @@ extern void write_all_categories (struct localedef_t *definitions, + + extern bool swap_endianness_p; + ++extern unsigned int uint32_align_mask; ++ + /* Change the output to be big-endian if BIG_ENDIAN is true and + little-endian otherwise. */ + static inline void +@@ -89,7 +91,8 @@ maybe_swap_uint32 (uint32_t value) + } + + /* Likewise, but munge an array of N uint32_ts starting at ARRAY. */ +-static inline void ++static void ++__attribute__ ((unused)) + maybe_swap_uint32_array (uint32_t *array, size_t n) + { + if (swap_endianness_p) +@@ -99,7 +102,8 @@ maybe_swap_uint32_array (uint32_t *array, size_t n) + + /* Like maybe_swap_uint32_array, but the array of N elements is at + the end of OBSTACK's current object. */ +-static inline void ++static void ++__attribute__ ((unused)) + maybe_swap_uint32_obstack (struct obstack *obstack, size_t n) + { + maybe_swap_uint32_array ((uint32_t *) obstack_next_free (obstack) - n, n); +@@ -276,4 +280,55 @@ extern void identification_output (struct localedef_t *locale, + const struct charmap_t *charmap, + const char *output_path); + ++static size_t wcslen_uint32 (const uint32_t *str) __attribute__ ((unused)); ++static uint32_t * wmemcpy_uint32 (uint32_t *s1, const uint32_t *s2, size_t n) __attribute__ ((unused)); ++static uint32_t * wcschr_uint32 (const uint32_t *s, uint32_t ch) __attribute__ ((unused)); ++static int wcscmp_uint32 (const uint32_t *s1, const uint32_t *s2) __attribute__ ((unused)); ++static int wmemcmp_uint32 (const uint32_t *s1, const uint32_t *s2, size_t n) __attribute__ ((unused)); ++ ++static size_t ++wcslen_uint32 (const uint32_t *str) ++{ ++ size_t len = 0; ++ while (str[len] != 0) ++ len++; ++ return len; ++} ++ ++static int ++wmemcmp_uint32 (const uint32_t *s1, const uint32_t *s2, size_t n) ++{ ++ while (n-- != 0) ++ { ++ int diff = *s1++ - *s2++; ++ if (diff != 0) ++ return diff; ++ } ++ return 0; ++} ++ ++static int ++wcscmp_uint32 (const uint32_t *s1, const uint32_t *s2) ++{ ++ while (*s1 != 0 && *s1 == *s2) ++ s1++, s2++; ++ return *s1 - *s2; ++} ++ ++static uint32_t * ++wmemcpy_uint32 (uint32_t *s1, const uint32_t *s2, size_t n) ++{ ++ return memcpy (s1, s2, n * sizeof (uint32_t)); ++} ++ ++static uint32_t * ++wcschr_uint32 (const uint32_t *s, uint32_t ch) ++{ ++ do ++ if (*s == ch) ++ return (uint32_t *) s; ++ while (*s++ != 0); ++ return 0; ++} ++ + #endif /* locfile.h */ +diff --git a/locale/setlocale.c b/locale/setlocale.c +index 030f1727bd..096d8ed895 100644 +--- a/locale/setlocale.c ++++ b/locale/setlocale.c +@@ -63,35 +63,6 @@ static char *const _nl_current_used[] = + + #endif + +- +-/* Define an array of category names (also the environment variable names). */ +-const struct catnamestr_t _nl_category_names attribute_hidden = +- { +-#define DEFINE_CATEGORY(category, category_name, items, a) \ +- category_name, +-#include "categories.def" +-#undef DEFINE_CATEGORY +- }; +- +-const uint8_t _nl_category_name_idxs[__LC_LAST] attribute_hidden = +- { +-#define DEFINE_CATEGORY(category, category_name, items, a) \ +- [category] = offsetof (struct catnamestr_t, CATNAMEMF (__LINE__)), +-#include "categories.def" +-#undef DEFINE_CATEGORY +- }; +- +-/* An array of their lengths, for convenience. */ +-const uint8_t _nl_category_name_sizes[] attribute_hidden = +- { +-#define DEFINE_CATEGORY(category, category_name, items, a) \ +- [category] = sizeof (category_name) - 1, +-#include "categories.def" +-#undef DEFINE_CATEGORY +- [LC_ALL] = sizeof ("LC_ALL") - 1 +- }; +- +- + #ifdef NL_CURRENT_INDIRECT + # define WEAK_POSTLOAD(postload) weak_extern (postload) + #else diff --git a/meta/recipes-core/glibc/glibc/0023-eglibc-Resolve-__fpscr_values-on-SH4.patch b/meta/recipes-core/glibc/glibc/0023-eglibc-Resolve-__fpscr_values-on-SH4.patch deleted file mode 100644 index cc8ddeea6f..0000000000 --- a/meta/recipes-core/glibc/glibc/0023-eglibc-Resolve-__fpscr_values-on-SH4.patch +++ /dev/null @@ -1,53 +0,0 @@ -From 02b69fc14ae1d6309e4e17081842b1f89bd40338 Mon Sep 17 00:00:00 2001 -From: Khem Raj -Date: Wed, 18 Mar 2015 00:55:53 +0000 -Subject: [PATCH] eglibc: Resolve __fpscr_values on SH4 - -2010-09-29 Nobuhiro Iwamatsu - Andrew Stubbs - - Resolve SH's __fpscr_values to symbol in libc.so. - - * sysdeps/sh/sh4/fpu/fpu_control.h: Add C++ __set_fpscr prototype. - * sysdeps/unix/sysv/linux/sh/Versions (GLIBC_2.2): Add __fpscr_values. - * sysdeps/unix/sysv/linux/sh/sysdep.S (___fpscr_values): New constant. - -Upstream-Status: Pending - -Signed-off-by: Khem Raj ---- - sysdeps/unix/sysv/linux/sh/Versions | 1 + - sysdeps/unix/sysv/linux/sh/sysdep.S | 11 +++++++++++ - 2 files changed, 12 insertions(+) - -diff --git a/sysdeps/unix/sysv/linux/sh/Versions b/sysdeps/unix/sysv/linux/sh/Versions -index e0938c4165..ca1d7da339 100644 ---- a/sysdeps/unix/sysv/linux/sh/Versions -+++ b/sysdeps/unix/sysv/linux/sh/Versions -@@ -2,6 +2,7 @@ libc { - GLIBC_2.2 { - # functions used in other libraries - __xstat64; __fxstat64; __lxstat64; -+ __fpscr_values; - - # a* - alphasort64; -diff --git a/sysdeps/unix/sysv/linux/sh/sysdep.S b/sysdeps/unix/sysv/linux/sh/sysdep.S -index 85ff3f900e..7743b8d57a 100644 ---- a/sysdeps/unix/sysv/linux/sh/sysdep.S -+++ b/sysdeps/unix/sysv/linux/sh/sysdep.S -@@ -30,3 +30,14 @@ ENTRY (__syscall_error) - - #define __syscall_error __syscall_error_1 - #include -+ -+ .data -+ .align 3 -+ .globl ___fpscr_values -+ .type ___fpscr_values, @object -+ .size ___fpscr_values, 8 -+___fpscr_values: -+ .long 0 -+ .long 0x80000 -+weak_alias (___fpscr_values, __fpscr_values) -+ diff --git a/meta/recipes-core/glibc/glibc/0024-Define-DUMMY_LOCALE_T-if-not-defined.patch b/meta/recipes-core/glibc/glibc/0024-Define-DUMMY_LOCALE_T-if-not-defined.patch new file mode 100644 index 0000000000..15e460eb08 --- /dev/null +++ b/meta/recipes-core/glibc/glibc/0024-Define-DUMMY_LOCALE_T-if-not-defined.patch @@ -0,0 +1,29 @@ +From 067f71a381ce6626ef1179be3dd90c4ed2aa52fb Mon Sep 17 00:00:00 2001 +From: Khem Raj +Date: Wed, 20 Apr 2016 21:11:00 -0700 +Subject: [PATCH] Define DUMMY_LOCALE_T if not defined + +This is a hack to fix building the locale bits on an older +CentOs 5.X machine + +Upstream-Status: Inappropriate [other] + +Signed-off-by: Khem Raj +--- + locale/programs/config.h | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/locale/programs/config.h b/locale/programs/config.h +index d76d9f7e8b..92b56d7df3 100644 +--- a/locale/programs/config.h ++++ b/locale/programs/config.h +@@ -19,6 +19,9 @@ + #ifndef _LD_CONFIG_H + #define _LD_CONFIG_H 1 + ++#ifndef DUMMY_LOCALE_T ++#define DUMMY_LOCALE_T ++#endif + /* Use the internal textdomain used for libc messages. */ + #define PACKAGE _libc_intl_domainname + #ifndef VERSION diff --git a/meta/recipes-core/glibc/glibc/0024-eglibc-Forward-port-cross-locale-generation-support.patch b/meta/recipes-core/glibc/glibc/0024-eglibc-Forward-port-cross-locale-generation-support.patch deleted file mode 100644 index 72278a6822..0000000000 --- a/meta/recipes-core/glibc/glibc/0024-eglibc-Forward-port-cross-locale-generation-support.patch +++ /dev/null @@ -1,560 +0,0 @@ -From 42fc64ee872491667749499db50e3c51d6a4bfb3 Mon Sep 17 00:00:00 2001 -From: Khem Raj -Date: Wed, 18 Mar 2015 01:33:49 +0000 -Subject: [PATCH] eglibc: Forward port cross locale generation support - -Upstream-Status: Pending - -Signed-off-by: Khem Raj ---- - locale/Makefile | 3 +- - locale/catnames.c | 46 +++++++++++++++++++++++++++ - locale/localeinfo.h | 2 +- - locale/programs/charmap-dir.c | 6 ++++ - locale/programs/ld-collate.c | 17 +++++----- - locale/programs/ld-ctype.c | 27 ++++++++-------- - locale/programs/ld-time.c | 31 ++++++++++++------ - locale/programs/linereader.c | 2 +- - locale/programs/localedef.c | 8 +++++ - locale/programs/locfile.c | 5 ++- - locale/programs/locfile.h | 59 +++++++++++++++++++++++++++++++++-- - locale/setlocale.c | 29 ----------------- - 12 files changed, 167 insertions(+), 68 deletions(-) - create mode 100644 locale/catnames.c - -diff --git a/locale/Makefile b/locale/Makefile -index c9694e236e..ba7105fad6 100644 ---- a/locale/Makefile -+++ b/locale/Makefile -@@ -26,7 +26,8 @@ headers = langinfo.h locale.h bits/locale.h \ - bits/types/locale_t.h bits/types/__locale_t.h - routines = setlocale findlocale loadlocale loadarchive \ - localeconv nl_langinfo nl_langinfo_l mb_cur_max \ -- newlocale duplocale freelocale uselocale -+ newlocale duplocale freelocale uselocale \ -+ catnames - tests = tst-C-locale tst-locname tst-duplocale - categories = ctype messages monetary numeric time paper name \ - address telephone measurement identification collate -diff --git a/locale/catnames.c b/locale/catnames.c -new file mode 100644 -index 0000000000..538f3f5edb ---- /dev/null -+++ b/locale/catnames.c -@@ -0,0 +1,46 @@ -+/* Copyright (C) 2006 Free Software Foundation, Inc. -+ This file is part of the GNU C Library. -+ -+ The GNU C Library is free software; you can redistribute it and/or -+ modify it under the terms of the GNU Lesser General Public -+ License as published by the Free Software Foundation; either -+ version 2.1 of the License, or (at your option) any later version. -+ -+ The GNU C Library is distributed in the hope that it will be useful, -+ but WITHOUT ANY WARRANTY; without even the implied warranty of -+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -+ Lesser General Public License for more details. -+ -+ You should have received a copy of the GNU Lesser General Public -+ License along with the GNU C Library; if not, write to the Free -+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA -+ 02111-1307 USA. */ -+ -+#include "localeinfo.h" -+ -+/* Define an array of category names (also the environment variable names). */ -+const struct catnamestr_t _nl_category_names attribute_hidden = -+ { -+#define DEFINE_CATEGORY(category, category_name, items, a) \ -+ category_name, -+#include "categories.def" -+#undef DEFINE_CATEGORY -+ }; -+ -+const uint8_t _nl_category_name_idxs[__LC_LAST] attribute_hidden = -+ { -+#define DEFINE_CATEGORY(category, category_name, items, a) \ -+ [category] = offsetof (struct catnamestr_t, CATNAMEMF (__LINE__)), -+#include "categories.def" -+#undef DEFINE_CATEGORY -+ }; -+ -+/* An array of their lengths, for convenience. */ -+const uint8_t _nl_category_name_sizes[] attribute_hidden = -+ { -+#define DEFINE_CATEGORY(category, category_name, items, a) \ -+ [category] = sizeof (category_name) - 1, -+#include "categories.def" -+#undef DEFINE_CATEGORY -+ [LC_ALL] = sizeof ("LC_ALL") - 1 -+ }; -diff --git a/locale/localeinfo.h b/locale/localeinfo.h -index fdc283c69a..4eeed35f90 100644 ---- a/locale/localeinfo.h -+++ b/locale/localeinfo.h -@@ -230,7 +230,7 @@ __libc_tsd_define (extern, locale_t, LOCALE) - unused. We can manage this playing some tricks with weak references. - But with thread-local locale settings, it becomes quite ungainly unless - we can use __thread variables. So only in that case do we attempt this. */ --#ifndef SHARED -+#if !defined SHARED && !defined IN_GLIBC_LOCALEDEF - # include - # define NL_CURRENT_INDIRECT 1 - #endif -diff --git a/locale/programs/charmap-dir.c b/locale/programs/charmap-dir.c -index 1a526a240d..0fb2daf936 100644 ---- a/locale/programs/charmap-dir.c -+++ b/locale/programs/charmap-dir.c -@@ -18,7 +18,9 @@ - #include - #include - #include -+#ifndef NO_UNCOMPRESS - #include -+#endif - #include - #include - #include -@@ -154,6 +156,7 @@ charmap_closedir (CHARMAP_DIR *cdir) - return closedir (dir); - } - -+#ifndef NO_UNCOMPRESS - /* Creates a subprocess decompressing the given pathname, and returns - a stream reading its output (the decompressed data). */ - static -@@ -202,6 +205,7 @@ fopen_uncompressed (const char *pathname, const char *compressor) - } - return NULL; - } -+#endif - - /* Opens a charmap for reading, given its name (not an alias name). */ - FILE * -@@ -224,6 +228,7 @@ charmap_open (const char *directory, const char *name) - if (stream != NULL) - return stream; - -+#ifndef NO_UNCOMPRESS - memcpy (p, ".gz", 4); - stream = fopen_uncompressed (pathname, "gzip"); - if (stream != NULL) -@@ -233,6 +238,7 @@ charmap_open (const char *directory, const char *name) - stream = fopen_uncompressed (pathname, "bzip2"); - if (stream != NULL) - return stream; -+#endif - - return NULL; - } -diff --git a/locale/programs/ld-collate.c b/locale/programs/ld-collate.c -index feb1a11258..5a8e522470 100644 ---- a/locale/programs/ld-collate.c -+++ b/locale/programs/ld-collate.c -@@ -349,7 +349,7 @@ new_element (struct locale_collate_t *collate, const char *mbs, size_t mbslen, - } - if (wcs != NULL) - { -- size_t nwcs = wcslen ((wchar_t *) wcs); -+ size_t nwcs = wcslen_uint32 (wcs); - uint32_t zero = 0; - /* Handle as a single character. */ - if (nwcs == 0) -@@ -1772,8 +1772,7 @@ symbol `%s' has the same encoding as"), (*eptr)->name); - - if ((*eptr)->nwcs == runp->nwcs) - { -- int c = wmemcmp ((wchar_t *) (*eptr)->wcs, -- (wchar_t *) runp->wcs, runp->nwcs); -+ int c = wmemcmp_uint32 ((*eptr)->wcs, runp->wcs, runp->nwcs); - - if (c == 0) - { -@@ -2000,9 +1999,9 @@ add_to_tablewc (uint32_t ch, struct element_t *runp) - one consecutive entry. */ - if (runp->wcnext != NULL - && runp->nwcs == runp->wcnext->nwcs -- && wmemcmp ((wchar_t *) runp->wcs, -- (wchar_t *)runp->wcnext->wcs, -- runp->nwcs - 1) == 0 -+ && wmemcmp_uint32 (runp->wcs, -+ runp->wcnext->wcs, -+ runp->nwcs - 1) == 0 - && (runp->wcs[runp->nwcs - 1] - == runp->wcnext->wcs[runp->nwcs - 1] + 1)) - { -@@ -2026,9 +2025,9 @@ add_to_tablewc (uint32_t ch, struct element_t *runp) - runp = runp->wcnext; - while (runp->wcnext != NULL - && runp->nwcs == runp->wcnext->nwcs -- && wmemcmp ((wchar_t *) runp->wcs, -- (wchar_t *)runp->wcnext->wcs, -- runp->nwcs - 1) == 0 -+ && wmemcmp_uint32 (runp->wcs, -+ runp->wcnext->wcs, -+ runp->nwcs - 1) == 0 - && (runp->wcs[runp->nwcs - 1] - == runp->wcnext->wcs[runp->nwcs - 1] + 1)); - -diff --git a/locale/programs/ld-ctype.c b/locale/programs/ld-ctype.c -index 3328093d0e..d58fb0f4b7 100644 ---- a/locale/programs/ld-ctype.c -+++ b/locale/programs/ld-ctype.c -@@ -915,7 +915,7 @@ ctype_output (struct localedef_t *locale, const struct charmap_t *charmap, - allocate_arrays (ctype, charmap, ctype->repertoire); - - default_missing_len = (ctype->default_missing -- ? wcslen ((wchar_t *) ctype->default_missing) -+ ? wcslen_uint32 (ctype->default_missing) - : 0); - - init_locale_data (&file, nelems); -@@ -1927,7 +1927,7 @@ read_translit_entry (struct linereader *ldfile, struct locale_ctype_t *ctype, - ignore = 1; - else - /* This value is usable. */ -- obstack_grow (ob, to_wstr, wcslen ((wchar_t *) to_wstr) * 4); -+ obstack_grow (ob, to_wstr, wcslen_uint32 (to_wstr) * 4); - - first = 0; - } -@@ -2461,8 +2461,8 @@ with character code range values one must use the absolute ellipsis `...'")); - } - - handle_tok_digit: -- class_bit = _ISwdigit; -- class256_bit = _ISdigit; -+ class_bit = BITw (tok_digit); -+ class256_bit = BIT (tok_digit); - handle_digits = 1; - goto read_charclass; - -@@ -3904,8 +3904,7 @@ allocate_arrays (struct locale_ctype_t *ctype, const struct charmap_t *charmap, - - while (idx < number) - { -- int res = wcscmp ((const wchar_t *) sorted[idx]->from, -- (const wchar_t *) runp->from); -+ int res = wcscmp_uint32 (sorted[idx]->from, runp->from); - if (res == 0) - { - replace = 1; -@@ -3942,11 +3941,11 @@ allocate_arrays (struct locale_ctype_t *ctype, const struct charmap_t *charmap, - for (size_t cnt = 0; cnt < number; ++cnt) - { - struct translit_to_t *srunp; -- from_len += wcslen ((const wchar_t *) sorted[cnt]->from) + 1; -+ from_len += wcslen_uint32 (sorted[cnt]->from) + 1; - srunp = sorted[cnt]->to; - while (srunp != NULL) - { -- to_len += wcslen ((const wchar_t *) srunp->str) + 1; -+ to_len += wcslen_uint32 (srunp->str) + 1; - srunp = srunp->next; - } - /* Plus one for the extra NUL character marking the end of -@@ -3970,18 +3969,18 @@ allocate_arrays (struct locale_ctype_t *ctype, const struct charmap_t *charmap, - ctype->translit_from_idx[cnt] = from_len; - ctype->translit_to_idx[cnt] = to_len; - -- len = wcslen ((const wchar_t *) sorted[cnt]->from) + 1; -- wmemcpy ((wchar_t *) &ctype->translit_from_tbl[from_len], -- (const wchar_t *) sorted[cnt]->from, len); -+ len = wcslen_uint32 (sorted[cnt]->from) + 1; -+ wmemcpy_uint32 (&ctype->translit_from_tbl[from_len], -+ sorted[cnt]->from, len); - from_len += len; - - ctype->translit_to_idx[cnt] = to_len; - srunp = sorted[cnt]->to; - while (srunp != NULL) - { -- len = wcslen ((const wchar_t *) srunp->str) + 1; -- wmemcpy ((wchar_t *) &ctype->translit_to_tbl[to_len], -- (const wchar_t *) srunp->str, len); -+ len = wcslen_uint32 (srunp->str) + 1; -+ wmemcpy_uint32 (&ctype->translit_to_tbl[to_len], -+ srunp->str, len); - to_len += len; - srunp = srunp->next; - } -diff --git a/locale/programs/ld-time.c b/locale/programs/ld-time.c -index f7db873adb..fec3773c9d 100644 ---- a/locale/programs/ld-time.c -+++ b/locale/programs/ld-time.c -@@ -220,8 +220,10 @@ No definition for %s category found"), "LC_TIME"); - } - else - { -+ static const uint32_t wt_fmt_ampm[] -+ = { '%','I',':','%','M',':','%','S',' ','%','p',0 }; - time->t_fmt_ampm = "%I:%M:%S %p"; -- time->wt_fmt_ampm = (const uint32_t *) L"%I:%M:%S %p"; -+ time->wt_fmt_ampm = wt_fmt_ampm; - } - } - -@@ -231,7 +233,7 @@ No definition for %s category found"), "LC_TIME"); - const int days_per_month[12] = { 31, 29, 31, 30, 31, 30, - 31, 31, 30, 31 ,30, 31 }; - size_t idx; -- wchar_t *wstr; -+ uint32_t *wstr; - - time->era_entries = - (struct era_data *) xmalloc (time->num_era -@@ -457,18 +459,18 @@ No definition for %s category found"), "LC_TIME"); - } - - /* Now generate the wide character name and format. */ -- wstr = wcschr ((wchar_t *) time->wera[idx], L':');/* end direction */ -- wstr = wstr ? wcschr (wstr + 1, L':') : NULL; /* end offset */ -- wstr = wstr ? wcschr (wstr + 1, L':') : NULL; /* end start */ -- wstr = wstr ? wcschr (wstr + 1, L':') : NULL; /* end end */ -+ wstr = wcschr_uint32 (time->wera[idx], L':'); /* end direction */ -+ wstr = wstr ? wcschr_uint32 (wstr + 1, L':') : NULL; /* end offset */ -+ wstr = wstr ? wcschr_uint32 (wstr + 1, L':') : NULL; /* end start */ -+ wstr = wstr ? wcschr_uint32 (wstr + 1, L':') : NULL; /* end end */ - if (wstr != NULL) - { -- time->era_entries[idx].wname = (uint32_t *) wstr + 1; -- wstr = wcschr (wstr + 1, L':'); /* end name */ -+ time->era_entries[idx].wname = wstr + 1; -+ wstr = wcschr_uint32 (wstr + 1, L':'); /* end name */ - if (wstr != NULL) - { - *wstr = L'\0'; -- time->era_entries[idx].wformat = (uint32_t *) wstr + 1; -+ time->era_entries[idx].wformat = wstr + 1; - } - else - time->era_entries[idx].wname = -@@ -527,7 +529,16 @@ No definition for %s category found"), "LC_TIME"); - if (time->date_fmt == NULL) - time->date_fmt = "%a %b %e %H:%M:%S %Z %Y"; - if (time->wdate_fmt == NULL) -- time->wdate_fmt = (const uint32_t *) L"%a %b %e %H:%M:%S %Z %Y"; -+ { -+ static const uint32_t wdate_fmt[] = -+ { '%','a',' ', -+ '%','b',' ', -+ '%','e',' ', -+ '%','H',':','%','M',':','%','S',' ', -+ '%','Z',' ', -+ '%','Y',0 }; -+ time->wdate_fmt = wdate_fmt; -+ } - } - - -diff --git a/locale/programs/linereader.c b/locale/programs/linereader.c -index 7ebd933801..5753750756 100644 ---- a/locale/programs/linereader.c -+++ b/locale/programs/linereader.c -@@ -595,7 +595,7 @@ get_string (struct linereader *lr, const struct charmap_t *charmap, - { - int return_widestr = lr->return_widestr; - char *buf; -- wchar_t *buf2 = NULL; -+ uint32_t *buf2 = NULL; - size_t bufact; - size_t bufmax = 56; - -diff --git a/locale/programs/localedef.c b/locale/programs/localedef.c -index dbbb0145c0..097a8b6193 100644 ---- a/locale/programs/localedef.c -+++ b/locale/programs/localedef.c -@@ -109,6 +109,7 @@ void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version; - #define OPT_NO_WARN 402 - #define OPT_WARN 403 - #define OPT_NO_HARD_LINKS 404 -+#define OPT_UINT32_ALIGN 405 - - /* Definitions of arguments for argp functions. */ - static const struct argp_option options[] = -@@ -153,6 +154,8 @@ static const struct argp_option options[] = - N_("Generate little-endian output") }, - { "big-endian", OPT_BIG_ENDIAN, NULL, 0, - N_("Generate big-endian output") }, -+ { "uint32-align", OPT_UINT32_ALIGN, "ALIGNMENT", 0, -+ N_("Set the target's uint32_t alignment in bytes (default 4)") }, - { NULL, 0, NULL, 0, NULL } - }; - -@@ -242,12 +245,14 @@ main (int argc, char *argv[]) - ctype locale. (P1003.2 4.35.5.2) */ - setlocale (LC_CTYPE, "POSIX"); - -+#ifndef NO_SYSCONF - /* Look whether the system really allows locale definitions. POSIX - defines error code 3 for this situation so I think it must be - a fatal error (see P1003.2 4.35.8). */ - if (sysconf (_SC_2_LOCALEDEF) < 0) - record_error (3, 0, _("\ - FATAL: system does not define `_POSIX2_LOCALEDEF'")); -+#endif - - /* Process charmap file. */ - charmap = charmap_read (charmap_file, verbose, 1, be_quiet, 1); -@@ -399,6 +404,9 @@ parse_opt (int key, char *arg, struct argp_state *state) - /* Do not hard link to other locales. */ - hard_links = false; - break; -+ case OPT_UINT32_ALIGN: -+ uint32_align_mask = strtol (arg, NULL, 0) - 1; -+ break; - case 'c': - force_output = 1; - break; -diff --git a/locale/programs/locfile.c b/locale/programs/locfile.c -index eb2f4634da..d387147323 100644 ---- a/locale/programs/locfile.c -+++ b/locale/programs/locfile.c -@@ -544,6 +544,9 @@ compare_files (const char *filename1, const char *filename2, size_t size, - machine running localedef. */ - bool swap_endianness_p; - -+/* The target's value of __align__(uint32_t) - 1. */ -+unsigned int uint32_align_mask = 3; -+ - /* When called outside a start_locale_structure/end_locale_structure - or start_locale_prelude/end_locale_prelude block, record that the - next byte in FILE's obstack will be the first byte of a new element. -@@ -621,7 +624,7 @@ add_locale_string (struct locale_file *file, const char *string) - void - add_locale_wstring (struct locale_file *file, const uint32_t *string) - { -- add_locale_uint32_array (file, string, wcslen ((const wchar_t *) string) + 1); -+ add_locale_uint32_array (file, string, wcslen_uint32 (string) + 1); - } - - /* Record that FILE's next element is the 32-bit integer VALUE. */ -diff --git a/locale/programs/locfile.h b/locale/programs/locfile.h -index 7ea10038b4..0888c09762 100644 ---- a/locale/programs/locfile.h -+++ b/locale/programs/locfile.h -@@ -71,6 +71,8 @@ extern void write_all_categories (struct localedef_t *definitions, - - extern bool swap_endianness_p; - -+extern unsigned int uint32_align_mask; -+ - /* Change the output to be big-endian if BIG_ENDIAN is true and - little-endian otherwise. */ - static inline void -@@ -89,7 +91,8 @@ maybe_swap_uint32 (uint32_t value) - } - - /* Likewise, but munge an array of N uint32_ts starting at ARRAY. */ --static inline void -+static void -+__attribute__ ((unused)) - maybe_swap_uint32_array (uint32_t *array, size_t n) - { - if (swap_endianness_p) -@@ -99,7 +102,8 @@ maybe_swap_uint32_array (uint32_t *array, size_t n) - - /* Like maybe_swap_uint32_array, but the array of N elements is at - the end of OBSTACK's current object. */ --static inline void -+static void -+__attribute__ ((unused)) - maybe_swap_uint32_obstack (struct obstack *obstack, size_t n) - { - maybe_swap_uint32_array ((uint32_t *) obstack_next_free (obstack) - n, n); -@@ -276,4 +280,55 @@ extern void identification_output (struct localedef_t *locale, - const struct charmap_t *charmap, - const char *output_path); - -+static size_t wcslen_uint32 (const uint32_t *str) __attribute__ ((unused)); -+static uint32_t * wmemcpy_uint32 (uint32_t *s1, const uint32_t *s2, size_t n) __attribute__ ((unused)); -+static uint32_t * wcschr_uint32 (const uint32_t *s, uint32_t ch) __attribute__ ((unused)); -+static int wcscmp_uint32 (const uint32_t *s1, const uint32_t *s2) __attribute__ ((unused)); -+static int wmemcmp_uint32 (const uint32_t *s1, const uint32_t *s2, size_t n) __attribute__ ((unused)); -+ -+static size_t -+wcslen_uint32 (const uint32_t *str) -+{ -+ size_t len = 0; -+ while (str[len] != 0) -+ len++; -+ return len; -+} -+ -+static int -+wmemcmp_uint32 (const uint32_t *s1, const uint32_t *s2, size_t n) -+{ -+ while (n-- != 0) -+ { -+ int diff = *s1++ - *s2++; -+ if (diff != 0) -+ return diff; -+ } -+ return 0; -+} -+ -+static int -+wcscmp_uint32 (const uint32_t *s1, const uint32_t *s2) -+{ -+ while (*s1 != 0 && *s1 == *s2) -+ s1++, s2++; -+ return *s1 - *s2; -+} -+ -+static uint32_t * -+wmemcpy_uint32 (uint32_t *s1, const uint32_t *s2, size_t n) -+{ -+ return memcpy (s1, s2, n * sizeof (uint32_t)); -+} -+ -+static uint32_t * -+wcschr_uint32 (const uint32_t *s, uint32_t ch) -+{ -+ do -+ if (*s == ch) -+ return (uint32_t *) s; -+ while (*s++ != 0); -+ return 0; -+} -+ - #endif /* locfile.h */ -diff --git a/locale/setlocale.c b/locale/setlocale.c -index 030f1727bd..096d8ed895 100644 ---- a/locale/setlocale.c -+++ b/locale/setlocale.c -@@ -63,35 +63,6 @@ static char *const _nl_current_used[] = - - #endif - -- --/* Define an array of category names (also the environment variable names). */ --const struct catnamestr_t _nl_category_names attribute_hidden = -- { --#define DEFINE_CATEGORY(category, category_name, items, a) \ -- category_name, --#include "categories.def" --#undef DEFINE_CATEGORY -- }; -- --const uint8_t _nl_category_name_idxs[__LC_LAST] attribute_hidden = -- { --#define DEFINE_CATEGORY(category, category_name, items, a) \ -- [category] = offsetof (struct catnamestr_t, CATNAMEMF (__LINE__)), --#include "categories.def" --#undef DEFINE_CATEGORY -- }; -- --/* An array of their lengths, for convenience. */ --const uint8_t _nl_category_name_sizes[] attribute_hidden = -- { --#define DEFINE_CATEGORY(category, category_name, items, a) \ -- [category] = sizeof (category_name) - 1, --#include "categories.def" --#undef DEFINE_CATEGORY -- [LC_ALL] = sizeof ("LC_ALL") - 1 -- }; -- -- - #ifdef NL_CURRENT_INDIRECT - # define WEAK_POSTLOAD(postload) weak_extern (postload) - #else diff --git a/meta/recipes-core/glibc/glibc/0025-Define-DUMMY_LOCALE_T-if-not-defined.patch b/meta/recipes-core/glibc/glibc/0025-Define-DUMMY_LOCALE_T-if-not-defined.patch deleted file mode 100644 index d359518751..0000000000 --- a/meta/recipes-core/glibc/glibc/0025-Define-DUMMY_LOCALE_T-if-not-defined.patch +++ /dev/null @@ -1,29 +0,0 @@ -From 5e565710aa061ffffd34d8400910c35a8d50a4ec Mon Sep 17 00:00:00 2001 -From: Khem Raj -Date: Wed, 20 Apr 2016 21:11:00 -0700 -Subject: [PATCH] Define DUMMY_LOCALE_T if not defined - -This is a hack to fix building the locale bits on an older -CentOs 5.X machine - -Upstream-Status: Inappropriate [other] - -Signed-off-by: Khem Raj ---- - locale/programs/config.h | 3 +++ - 1 file changed, 3 insertions(+) - -diff --git a/locale/programs/config.h b/locale/programs/config.h -index d76d9f7e8b..92b56d7df3 100644 ---- a/locale/programs/config.h -+++ b/locale/programs/config.h -@@ -19,6 +19,9 @@ - #ifndef _LD_CONFIG_H - #define _LD_CONFIG_H 1 - -+#ifndef DUMMY_LOCALE_T -+#define DUMMY_LOCALE_T -+#endif - /* Use the internal textdomain used for libc messages. */ - #define PACKAGE _libc_intl_domainname - #ifndef VERSION diff --git a/meta/recipes-core/glibc/glibc/0025-localedef-add-to-archive-uses-a-hard-coded-locale-pa.patch b/meta/recipes-core/glibc/glibc/0025-localedef-add-to-archive-uses-a-hard-coded-locale-pa.patch new file mode 100644 index 0000000000..543f65d6ea --- /dev/null +++ b/meta/recipes-core/glibc/glibc/0025-localedef-add-to-archive-uses-a-hard-coded-locale-pa.patch @@ -0,0 +1,80 @@ +From 8f4b0bac85d14b184e08848b02de3f30775f05b1 Mon Sep 17 00:00:00 2001 +From: Khem Raj +Date: Fri, 3 Aug 2018 09:42:06 -0700 +Subject: [PATCH] localedef --add-to-archive uses a hard-coded locale path + +it doesn't exist in normal use, and there's no way to pass an +alternative filename. + +Add a fallback of $LOCALEARCHIVE from the environment, and allow +creation of new locale archives that are not the system archive. + +Upstream-Status: Inappropriate (OE-specific) + +Signed-off-by: Ross Burton +Signed-off-by: Khem Raj +--- + locale/programs/locarchive.c | 35 +++++++++++++++++++++++++---------- + 1 file changed, 25 insertions(+), 10 deletions(-) + +diff --git a/locale/programs/locarchive.c b/locale/programs/locarchive.c +index dccaf04e3b..ae0b7fe155 100644 +--- a/locale/programs/locarchive.c ++++ b/locale/programs/locarchive.c +@@ -340,12 +340,24 @@ enlarge_archive (struct locarhandle *ah, const struct locarhead *head) + struct namehashent *oldnamehashtab; + struct locarhandle new_ah; + size_t prefix_len = output_prefix ? strlen (output_prefix) : 0; +- char archivefname[prefix_len + sizeof (ARCHIVE_NAME)]; +- char fname[prefix_len + sizeof (ARCHIVE_NAME) + sizeof (".XXXXXX") - 1]; ++ char *archivefname; ++ char *fname; ++ char *envarchive = getenv("LOCALEARCHIVE"); + +- if (output_prefix) +- memcpy (archivefname, output_prefix, prefix_len); +- strcpy (archivefname + prefix_len, ARCHIVE_NAME); ++ if (envarchive != NULL) ++ { ++ archivefname = xmalloc(strlen(envarchive) + 1); ++ fname = xmalloc(strlen(envarchive) + sizeof (".XXXXXX")); ++ strcpy (archivefname, envarchive); ++ } ++ else ++ { ++ archivefname = xmalloc(prefix_len + sizeof (ARCHIVE_NAME)); ++ fname = xmalloc(prefix_len + sizeof (ARCHIVE_NAME) + sizeof (".XXXXXX") - 1); ++ if (output_prefix) ++ memcpy (archivefname, output_prefix, prefix_len); ++ strcpy (archivefname + prefix_len, ARCHIVE_NAME); ++ } + strcpy (stpcpy (fname, archivefname), ".XXXXXX"); + + /* Not all of the old file has to be mapped. Change this now this +@@ -569,10 +581,13 @@ open_archive (struct locarhandle *ah, bool readonly) + /* If ah has a non-NULL fname open that otherwise open the default. */ + if (archivefname == NULL) + { +- archivefname = default_fname; +- if (output_prefix) +- memcpy (default_fname, output_prefix, prefix_len); +- strcpy (default_fname + prefix_len, ARCHIVE_NAME); ++ archivefname = getenv("LOCALEARCHIVE"); ++ if (archivefname == NULL) { ++ archivefname = default_fname; ++ if (output_prefix) ++ memcpy (default_fname, output_prefix, prefix_len); ++ strcpy (default_fname + prefix_len, ARCHIVE_NAME); ++ } + } + + while (1) +@@ -585,7 +600,7 @@ open_archive (struct locarhandle *ah, bool readonly) + the default locale archive we ignore the failure and + list an empty archive, otherwise we print an error + and exit. */ +- if (errno == ENOENT && archivefname == default_fname) ++ if (errno == ENOENT) + { + if (readonly) + { diff --git a/meta/recipes-core/glibc/glibc/0026-elf-dl-deps.c-Make-_dl_build_local_scope-breadth-fir.patch b/meta/recipes-core/glibc/glibc/0026-elf-dl-deps.c-Make-_dl_build_local_scope-breadth-fir.patch new file mode 100644 index 0000000000..5f6ee40f22 --- /dev/null +++ b/meta/recipes-core/glibc/glibc/0026-elf-dl-deps.c-Make-_dl_build_local_scope-breadth-fir.patch @@ -0,0 +1,53 @@ +From 1dad746ce93928a57b2fe618c74722f710751826 Mon Sep 17 00:00:00 2001 +From: Mark Hatle +Date: Thu, 18 Aug 2016 14:07:58 -0500 +Subject: [PATCH] elf/dl-deps.c: Make _dl_build_local_scope breadth first + +According to the ELF specification: + +When resolving symbolic references, the dynamic linker examines the symbol +tables with a breadth-first search. + +This function was using a depth first search. By doing so the conflict +resolution reported to the prelinker (when LD_TRACE_PRELINKING=1 is set) +was incorrect. This caused problems when their were various circular +dependencies between libraries. The problem usually manifested itself by +the wrong IFUNC being executed. + +[BZ# 20488] + +Upstream-Status: Submitted [libc-alpha] + +Signed-off-by: Mark Hatle +--- + elf/dl-deps.c | 14 ++++++++++---- + 1 file changed, 10 insertions(+), 4 deletions(-) + +diff --git a/elf/dl-deps.c b/elf/dl-deps.c +index 5103a8a111..54cd80aaff 100644 +--- a/elf/dl-deps.c ++++ b/elf/dl-deps.c +@@ -73,13 +73,19 @@ _dl_build_local_scope (struct link_map **list, struct link_map *map) + { + struct link_map **p = list; + struct link_map **q; ++ struct link_map **r; + + *p++ = map; + map->l_reserved = 1; +- if (map->l_initfini) +- for (q = map->l_initfini + 1; *q; ++q) +- if (! (*q)->l_reserved) +- p += _dl_build_local_scope (p, *q); ++ ++ for (r = list; r < p; ++r) ++ if ((*r)->l_initfini) ++ for (q = (*r)->l_initfini + 1; *q; ++q) ++ if (! (*q)->l_reserved) ++ { ++ *p++ = *q; ++ (*q)->l_reserved = 1; ++ } + return p - list; + } + diff --git a/meta/recipes-core/glibc/glibc/0026-localedef-add-to-archive-uses-a-hard-coded-locale-pa.patch b/meta/recipes-core/glibc/glibc/0026-localedef-add-to-archive-uses-a-hard-coded-locale-pa.patch deleted file mode 100644 index 8df09d82ee..0000000000 --- a/meta/recipes-core/glibc/glibc/0026-localedef-add-to-archive-uses-a-hard-coded-locale-pa.patch +++ /dev/null @@ -1,80 +0,0 @@ -From c5b63c8eafc00e01556edd2acff4c541448924cf Mon Sep 17 00:00:00 2001 -From: Khem Raj -Date: Fri, 3 Aug 2018 09:42:06 -0700 -Subject: [PATCH] localedef --add-to-archive uses a hard-coded locale path - -it doesn't exist in normal use, and there's no way to pass an -alternative filename. - -Add a fallback of $LOCALEARCHIVE from the environment, and allow -creation of new locale archives that are not the system archive. - -Upstream-Status: Inappropriate (OE-specific) - -Signed-off-by: Ross Burton -Signed-off-by: Khem Raj ---- - locale/programs/locarchive.c | 35 +++++++++++++++++++++++++---------- - 1 file changed, 25 insertions(+), 10 deletions(-) - -diff --git a/locale/programs/locarchive.c b/locale/programs/locarchive.c -index dccaf04e3b..ae0b7fe155 100644 ---- a/locale/programs/locarchive.c -+++ b/locale/programs/locarchive.c -@@ -340,12 +340,24 @@ enlarge_archive (struct locarhandle *ah, const struct locarhead *head) - struct namehashent *oldnamehashtab; - struct locarhandle new_ah; - size_t prefix_len = output_prefix ? strlen (output_prefix) : 0; -- char archivefname[prefix_len + sizeof (ARCHIVE_NAME)]; -- char fname[prefix_len + sizeof (ARCHIVE_NAME) + sizeof (".XXXXXX") - 1]; -+ char *archivefname; -+ char *fname; -+ char *envarchive = getenv("LOCALEARCHIVE"); - -- if (output_prefix) -- memcpy (archivefname, output_prefix, prefix_len); -- strcpy (archivefname + prefix_len, ARCHIVE_NAME); -+ if (envarchive != NULL) -+ { -+ archivefname = xmalloc(strlen(envarchive) + 1); -+ fname = xmalloc(strlen(envarchive) + sizeof (".XXXXXX")); -+ strcpy (archivefname, envarchive); -+ } -+ else -+ { -+ archivefname = xmalloc(prefix_len + sizeof (ARCHIVE_NAME)); -+ fname = xmalloc(prefix_len + sizeof (ARCHIVE_NAME) + sizeof (".XXXXXX") - 1); -+ if (output_prefix) -+ memcpy (archivefname, output_prefix, prefix_len); -+ strcpy (archivefname + prefix_len, ARCHIVE_NAME); -+ } - strcpy (stpcpy (fname, archivefname), ".XXXXXX"); - - /* Not all of the old file has to be mapped. Change this now this -@@ -569,10 +581,13 @@ open_archive (struct locarhandle *ah, bool readonly) - /* If ah has a non-NULL fname open that otherwise open the default. */ - if (archivefname == NULL) - { -- archivefname = default_fname; -- if (output_prefix) -- memcpy (default_fname, output_prefix, prefix_len); -- strcpy (default_fname + prefix_len, ARCHIVE_NAME); -+ archivefname = getenv("LOCALEARCHIVE"); -+ if (archivefname == NULL) { -+ archivefname = default_fname; -+ if (output_prefix) -+ memcpy (default_fname, output_prefix, prefix_len); -+ strcpy (default_fname + prefix_len, ARCHIVE_NAME); -+ } - } - - while (1) -@@ -585,7 +600,7 @@ open_archive (struct locarhandle *ah, bool readonly) - the default locale archive we ignore the failure and - list an empty archive, otherwise we print an error - and exit. */ -- if (errno == ENOENT && archivefname == default_fname) -+ if (errno == ENOENT) - { - if (readonly) - { diff --git a/meta/recipes-core/glibc/glibc/0027-elf-dl-deps.c-Make-_dl_build_local_scope-breadth-fir.patch b/meta/recipes-core/glibc/glibc/0027-elf-dl-deps.c-Make-_dl_build_local_scope-breadth-fir.patch deleted file mode 100644 index 55250d8d8e..0000000000 --- a/meta/recipes-core/glibc/glibc/0027-elf-dl-deps.c-Make-_dl_build_local_scope-breadth-fir.patch +++ /dev/null @@ -1,53 +0,0 @@ -From d3349ae8d9b17fecf6ef560b845d04d682db291c Mon Sep 17 00:00:00 2001 -From: Mark Hatle -Date: Thu, 18 Aug 2016 14:07:58 -0500 -Subject: [PATCH] elf/dl-deps.c: Make _dl_build_local_scope breadth first - -According to the ELF specification: - -When resolving symbolic references, the dynamic linker examines the symbol -tables with a breadth-first search. - -This function was using a depth first search. By doing so the conflict -resolution reported to the prelinker (when LD_TRACE_PRELINKING=1 is set) -was incorrect. This caused problems when their were various circular -dependencies between libraries. The problem usually manifested itself by -the wrong IFUNC being executed. - -[BZ# 20488] - -Upstream-Status: Submitted [libc-alpha] - -Signed-off-by: Mark Hatle ---- - elf/dl-deps.c | 14 ++++++++++---- - 1 file changed, 10 insertions(+), 4 deletions(-) - -diff --git a/elf/dl-deps.c b/elf/dl-deps.c -index 5103a8a111..54cd80aaff 100644 ---- a/elf/dl-deps.c -+++ b/elf/dl-deps.c -@@ -73,13 +73,19 @@ _dl_build_local_scope (struct link_map **list, struct link_map *map) - { - struct link_map **p = list; - struct link_map **q; -+ struct link_map **r; - - *p++ = map; - map->l_reserved = 1; -- if (map->l_initfini) -- for (q = map->l_initfini + 1; *q; ++q) -- if (! (*q)->l_reserved) -- p += _dl_build_local_scope (p, *q); -+ -+ for (r = list; r < p; ++r) -+ if ((*r)->l_initfini) -+ for (q = (*r)->l_initfini + 1; *q; ++q) -+ if (! (*q)->l_reserved) -+ { -+ *p++ = *q; -+ (*q)->l_reserved = 1; -+ } - return p - list; - } - diff --git a/meta/recipes-core/glibc/glibc/0027-intl-Emit-no-lines-in-bison-generated-files.patch b/meta/recipes-core/glibc/glibc/0027-intl-Emit-no-lines-in-bison-generated-files.patch new file mode 100644 index 0000000000..2c317d58aa --- /dev/null +++ b/meta/recipes-core/glibc/glibc/0027-intl-Emit-no-lines-in-bison-generated-files.patch @@ -0,0 +1,31 @@ +From 3c8d9eae83ab4f1677afc9b379f97114e8503363 Mon Sep 17 00:00:00 2001 +From: Khem Raj +Date: Fri, 3 Aug 2018 09:44:00 -0700 +Subject: [PATCH] intl: Emit no lines in bison generated files + +Improve reproducibility: +Do not put any #line preprocessor commands in bison generated files. +These lines contain absolute paths containing file locations on +the host build machine. + +Upstream-Status: Pending + +Signed-off-by: Juro Bystricky +Signed-off-by: Khem Raj +--- + intl/Makefile | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/intl/Makefile b/intl/Makefile +index ce3072420f..58457840d9 100644 +--- a/intl/Makefile ++++ b/intl/Makefile +@@ -155,7 +155,7 @@ $(objpfx)tst-gettext6.out: $(objpfx)tst-gettext.out + + CPPFLAGS += -D'LOCALEDIR="$(localedir)"' \ + -D'LOCALE_ALIAS_PATH="$(localedir)"' +-BISONFLAGS = --yacc --name-prefix=__gettext --output ++BISONFLAGS = --yacc --no-lines --name-prefix=__gettext --output + + $(inst_localedir)/locale.alias: locale.alias $(+force) + $(do-install) diff --git a/meta/recipes-core/glibc/glibc/0028-inject-file-assembly-directives.patch b/meta/recipes-core/glibc/glibc/0028-inject-file-assembly-directives.patch new file mode 100644 index 0000000000..e1a030d10c --- /dev/null +++ b/meta/recipes-core/glibc/glibc/0028-inject-file-assembly-directives.patch @@ -0,0 +1,301 @@ +From 420454f7098b5445730caa855c37b8143bfccc1b Mon Sep 17 00:00:00 2001 +From: Khem Raj +Date: Thu, 29 Nov 2018 17:29:35 -0800 +Subject: [PATCH] inject file assembly directives + +Currently, non-IA builds are not reproducibile since build paths are +being injected into the debug symbols. These are coming from the use of +.S assembler files during the glibc build. No STT_FILE section is added +during the assembly but when linking, ld decides to add one to aid +debugging and ensure references between the different object files its +linking remain clear. + +We can avoid this by injecting a file header into the assembler files +ahead of time, choosing a filename which does not contain build system +paths. + +This is a bit of a workaround/hack but does significantly reduce the +build system references in target binaries for the non-IA architectures +which use .S files. + +RP +2018/10/3 + +Upstream-Status: Pending + +Signed-off-by: Khem Raj +--- + csu/abi-note.S | 2 ++ + sysdeps/aarch64/crti.S | 2 ++ + sysdeps/aarch64/crtn.S | 2 ++ + sysdeps/aarch64/dl-tlsdesc.S | 2 ++ + sysdeps/aarch64/dl-trampoline.S | 2 ++ + sysdeps/aarch64/start.S | 2 ++ + sysdeps/arm/abi-note.S | 2 ++ + sysdeps/arm/crti.S | 2 ++ + sysdeps/arm/crtn.S | 2 ++ + sysdeps/arm/dl-tlsdesc.S | 2 ++ + sysdeps/arm/dl-trampoline.S | 2 ++ + sysdeps/arm/start.S | 2 ++ + sysdeps/mips/start.S | 2 ++ + sysdeps/powerpc/powerpc32/dl-start.S | 2 ++ + sysdeps/powerpc/powerpc32/start.S | 2 ++ + sysdeps/powerpc/powerpc64/start.S | 2 ++ + sysdeps/unix/sysv/linux/aarch64/__read_tp.S | 2 ++ + sysdeps/unix/sysv/linux/arm/aeabi_read_tp.S | 2 ++ + sysdeps/unix/sysv/linux/arm/libc-do-syscall.S | 2 ++ + sysdeps/unix/sysv/linux/powerpc/dl-brk.S | 2 ++ + 20 files changed, 40 insertions(+) + +diff --git a/csu/abi-note.S b/csu/abi-note.S +index 2b4b5f8824..964843016c 100644 +--- a/csu/abi-note.S ++++ b/csu/abi-note.S +@@ -56,6 +56,8 @@ offset length contents + #include + #include /* OS-specific ABI tag value */ + ++ .file "abi-note.S" ++ + /* The linker (GNU ld 2.8 and later) recognizes an allocated section whose + name begins with `.note' and creates a PT_NOTE program header entry + pointing at it. */ +diff --git a/sysdeps/aarch64/crti.S b/sysdeps/aarch64/crti.S +index 1728eac37a..76a8ab590b 100644 +--- a/sysdeps/aarch64/crti.S ++++ b/sysdeps/aarch64/crti.S +@@ -50,6 +50,8 @@ + # define PREINIT_FUNCTION_WEAK 1 + #endif + ++ .file "crti.S" ++ + #if PREINIT_FUNCTION_WEAK + weak_extern (PREINIT_FUNCTION) + #else +diff --git a/sysdeps/aarch64/crtn.S b/sysdeps/aarch64/crtn.S +index c3e97cc449..fc2e5c2df8 100644 +--- a/sysdeps/aarch64/crtn.S ++++ b/sysdeps/aarch64/crtn.S +@@ -37,6 +37,8 @@ + /* crtn.S puts function epilogues in the .init and .fini sections + corresponding to the prologues in crti.S. */ + ++ .file "crtn.S" ++ + .section .init,"ax",%progbits + ldp x29, x30, [sp], 16 + RET +diff --git a/sysdeps/aarch64/dl-tlsdesc.S b/sysdeps/aarch64/dl-tlsdesc.S +index 557ad1d505..194a8531da 100644 +--- a/sysdeps/aarch64/dl-tlsdesc.S ++++ b/sysdeps/aarch64/dl-tlsdesc.S +@@ -22,6 +22,8 @@ + #include + #include "tlsdesc.h" + ++ .file "dl-tlsdesc.S" ++ + #define NSAVEDQREGPAIRS 16 + #define SAVE_Q_REGISTERS \ + stp q0, q1, [sp, #-32*NSAVEDQREGPAIRS]!; \ +diff --git a/sysdeps/aarch64/dl-trampoline.S b/sysdeps/aarch64/dl-trampoline.S +index 94e965c096..ba18742f3e 100644 +--- a/sysdeps/aarch64/dl-trampoline.S ++++ b/sysdeps/aarch64/dl-trampoline.S +@@ -21,6 +21,8 @@ + + #include "dl-link.h" + ++ .file "dl-trampoline.S" ++ + #define ip0 x16 + #define ip0l PTR_REG (16) + #define ip1 x17 +diff --git a/sysdeps/aarch64/start.S b/sysdeps/aarch64/start.S +index d96cf57e2d..07a523978a 100644 +--- a/sysdeps/aarch64/start.S ++++ b/sysdeps/aarch64/start.S +@@ -18,6 +18,8 @@ + + #include + ++ .file "start.S" ++ + /* This is the canonical entry point, usually the first thing in the text + segment. + +diff --git a/sysdeps/arm/abi-note.S b/sysdeps/arm/abi-note.S +index 07bd4c4619..7213b16f27 100644 +--- a/sysdeps/arm/abi-note.S ++++ b/sysdeps/arm/abi-note.S +@@ -1,3 +1,5 @@ ++ .file "abi-note.S" ++ + /* Tag_ABI_align8_preserved: This code preserves 8-byte + alignment in any callee. */ + .eabi_attribute 25, 1 +diff --git a/sysdeps/arm/crti.S b/sysdeps/arm/crti.S +index 8169783267..f56e0c85a6 100644 +--- a/sysdeps/arm/crti.S ++++ b/sysdeps/arm/crti.S +@@ -57,6 +57,8 @@ + .hidden PREINIT_FUNCTION + #endif + ++ .file "crti.S" ++ + #if PREINIT_FUNCTION_WEAK + .p2align 2 + .type call_weak_fn, %function +diff --git a/sysdeps/arm/crtn.S b/sysdeps/arm/crtn.S +index d60f9f05de..1e10ec439f 100644 +--- a/sysdeps/arm/crtn.S ++++ b/sysdeps/arm/crtn.S +@@ -37,6 +37,8 @@ + #define NO_THUMB + #include + ++ .file "crtn.S" ++ + /* crtn.S puts function epilogues in the .init and .fini sections + corresponding to the prologues in crti.S. */ + +diff --git a/sysdeps/arm/dl-tlsdesc.S b/sysdeps/arm/dl-tlsdesc.S +index 8415e47607..29c2cb8128 100644 +--- a/sysdeps/arm/dl-tlsdesc.S ++++ b/sysdeps/arm/dl-tlsdesc.S +@@ -21,6 +21,8 @@ + #include + #include "tlsdesc.h" + ++ .file "dl-tlsdesc.S" ++ + .text + @ emit debug information with cfi + @ use arm-specific pseudos for unwinding itself +diff --git a/sysdeps/arm/dl-trampoline.S b/sysdeps/arm/dl-trampoline.S +index a20baf555e..2dd3bef04e 100644 +--- a/sysdeps/arm/dl-trampoline.S ++++ b/sysdeps/arm/dl-trampoline.S +@@ -21,6 +21,8 @@ + #include + #include + ++ .file "dl-trampoline.S" ++ + .text + .globl _dl_runtime_resolve + .type _dl_runtime_resolve, #function +diff --git a/sysdeps/arm/start.S b/sysdeps/arm/start.S +index 2ff56179d2..c118046ec6 100644 +--- a/sysdeps/arm/start.S ++++ b/sysdeps/arm/start.S +@@ -57,6 +57,8 @@ + NULL + */ + ++ .file "start.S" ++ + /* Tag_ABI_align8_preserved: This code preserves 8-byte + alignment in any callee. */ + .eabi_attribute 25, 1 +diff --git a/sysdeps/mips/start.S b/sysdeps/mips/start.S +index fabc8080df..83c6b91d7d 100644 +--- a/sysdeps/mips/start.S ++++ b/sysdeps/mips/start.S +@@ -38,6 +38,8 @@ + #include + #include + ++ .file "start.S" ++ + #ifndef ENTRY_POINT + #error ENTRY_POINT needs to be defined for start.S on MIPS/ELF. + #endif +diff --git a/sysdeps/powerpc/powerpc32/dl-start.S b/sysdeps/powerpc/powerpc32/dl-start.S +index c15242d3bc..6ca27715a4 100644 +--- a/sysdeps/powerpc/powerpc32/dl-start.S ++++ b/sysdeps/powerpc/powerpc32/dl-start.S +@@ -18,6 +18,8 @@ + + #include + ++ .file "dl-start.S" ++ + /* Initial entry point code for the dynamic linker. + The C function `_dl_start' is the real entry point; + its return value is the user program's entry point. */ +diff --git a/sysdeps/powerpc/powerpc32/start.S b/sysdeps/powerpc/powerpc32/start.S +index b7b9a133a2..8df714f81a 100644 +--- a/sysdeps/powerpc/powerpc32/start.S ++++ b/sysdeps/powerpc/powerpc32/start.S +@@ -35,6 +35,8 @@ + + #include + ++ .file "start.S" ++ + /* We do not want .eh_frame info for crt1.o since crt1.o is linked + before crtbegin.o, the file defining __EH_FRAME_BEGIN__. */ + #undef cfi_startproc +diff --git a/sysdeps/powerpc/powerpc64/start.S b/sysdeps/powerpc/powerpc64/start.S +index 94bf771e83..cffb99500a 100644 +--- a/sysdeps/powerpc/powerpc64/start.S ++++ b/sysdeps/powerpc/powerpc64/start.S +@@ -35,6 +35,8 @@ + + #include + ++ .file "start.S" ++ + /* We do not want .eh_frame info for crt1.o since crt1.o is linked + before crtbegin.o, the file defining __EH_FRAME_BEGIN__. */ + #undef cfi_startproc +diff --git a/sysdeps/unix/sysv/linux/aarch64/__read_tp.S b/sysdeps/unix/sysv/linux/aarch64/__read_tp.S +index 12e1131fe7..767e0d043b 100644 +--- a/sysdeps/unix/sysv/linux/aarch64/__read_tp.S ++++ b/sysdeps/unix/sysv/linux/aarch64/__read_tp.S +@@ -18,6 +18,8 @@ + + #include + ++ .file "__read_tp.S" ++ + .hidden __read_tp + ENTRY (__read_tp) + mrs x0, tpidr_el0 +diff --git a/sysdeps/unix/sysv/linux/arm/aeabi_read_tp.S b/sysdeps/unix/sysv/linux/arm/aeabi_read_tp.S +index 3b0d611039..4a7e476c37 100644 +--- a/sysdeps/unix/sysv/linux/arm/aeabi_read_tp.S ++++ b/sysdeps/unix/sysv/linux/arm/aeabi_read_tp.S +@@ -39,6 +39,8 @@ + a normal function call) in a high page of memory; tail call to the + helper. */ + ++ .file "aeabi_read_tp.S" ++ + .hidden __aeabi_read_tp + ENTRY (__aeabi_read_tp) + #ifdef ARCH_HAS_HARD_TP +diff --git a/sysdeps/unix/sysv/linux/arm/libc-do-syscall.S b/sysdeps/unix/sysv/linux/arm/libc-do-syscall.S +index fb5e0c7d97..bd07bdb38b 100644 +--- a/sysdeps/unix/sysv/linux/arm/libc-do-syscall.S ++++ b/sysdeps/unix/sysv/linux/arm/libc-do-syscall.S +@@ -27,6 +27,8 @@ + ARM unwind tables for register to register moves, the actual opcodes + are not defined. */ + ++ .file "libc-do-syscall.S" ++ + #if defined(__thumb__) + .thumb + .syntax unified +diff --git a/sysdeps/unix/sysv/linux/powerpc/dl-brk.S b/sysdeps/unix/sysv/linux/powerpc/dl-brk.S +index eeb96544e3..da182b28f8 100644 +--- a/sysdeps/unix/sysv/linux/powerpc/dl-brk.S ++++ b/sysdeps/unix/sysv/linux/powerpc/dl-brk.S +@@ -1 +1,3 @@ ++ .file "dl-brk.S" ++ + #include diff --git a/meta/recipes-core/glibc/glibc/0028-intl-Emit-no-lines-in-bison-generated-files.patch b/meta/recipes-core/glibc/glibc/0028-intl-Emit-no-lines-in-bison-generated-files.patch deleted file mode 100644 index 06d23c988d..0000000000 --- a/meta/recipes-core/glibc/glibc/0028-intl-Emit-no-lines-in-bison-generated-files.patch +++ /dev/null @@ -1,31 +0,0 @@ -From 3650ad7f01509138aa72f235e680c9d4f6c09a7d Mon Sep 17 00:00:00 2001 -From: Khem Raj -Date: Fri, 3 Aug 2018 09:44:00 -0700 -Subject: [PATCH] intl: Emit no lines in bison generated files - -Improve reproducibility: -Do not put any #line preprocessor commands in bison generated files. -These lines contain absolute paths containing file locations on -the host build machine. - -Upstream-Status: Pending - -Signed-off-by: Juro Bystricky -Signed-off-by: Khem Raj ---- - intl/Makefile | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - -diff --git a/intl/Makefile b/intl/Makefile -index ce3072420f..58457840d9 100644 ---- a/intl/Makefile -+++ b/intl/Makefile -@@ -155,7 +155,7 @@ $(objpfx)tst-gettext6.out: $(objpfx)tst-gettext.out - - CPPFLAGS += -D'LOCALEDIR="$(localedir)"' \ - -D'LOCALE_ALIAS_PATH="$(localedir)"' --BISONFLAGS = --yacc --name-prefix=__gettext --output -+BISONFLAGS = --yacc --no-lines --name-prefix=__gettext --output - - $(inst_localedir)/locale.alias: locale.alias $(+force) - $(do-install) diff --git a/meta/recipes-core/glibc/glibc/0029-inject-file-assembly-directives.patch b/meta/recipes-core/glibc/glibc/0029-inject-file-assembly-directives.patch deleted file mode 100644 index 62e615786d..0000000000 --- a/meta/recipes-core/glibc/glibc/0029-inject-file-assembly-directives.patch +++ /dev/null @@ -1,301 +0,0 @@ -From a9be0c7c67e67d870e2c5e0ece4f6ac76e5c0fe2 Mon Sep 17 00:00:00 2001 -From: Khem Raj -Date: Thu, 29 Nov 2018 17:29:35 -0800 -Subject: [PATCH] inject file assembly directives - -Currently, non-IA builds are not reproducibile since build paths are -being injected into the debug symbols. These are coming from the use of -.S assembler files during the glibc build. No STT_FILE section is added -during the assembly but when linking, ld decides to add one to aid -debugging and ensure references between the different object files its -linking remain clear. - -We can avoid this by injecting a file header into the assembler files -ahead of time, choosing a filename which does not contain build system -paths. - -This is a bit of a workaround/hack but does significantly reduce the -build system references in target binaries for the non-IA architectures -which use .S files. - -RP -2018/10/3 - -Upstream-Status: Pending - -Signed-off-by: Khem Raj ---- - csu/abi-note.S | 2 ++ - sysdeps/aarch64/crti.S | 2 ++ - sysdeps/aarch64/crtn.S | 2 ++ - sysdeps/aarch64/dl-tlsdesc.S | 2 ++ - sysdeps/aarch64/dl-trampoline.S | 2 ++ - sysdeps/aarch64/start.S | 2 ++ - sysdeps/arm/abi-note.S | 2 ++ - sysdeps/arm/crti.S | 2 ++ - sysdeps/arm/crtn.S | 2 ++ - sysdeps/arm/dl-tlsdesc.S | 2 ++ - sysdeps/arm/dl-trampoline.S | 2 ++ - sysdeps/arm/start.S | 2 ++ - sysdeps/mips/start.S | 2 ++ - sysdeps/powerpc/powerpc32/dl-start.S | 2 ++ - sysdeps/powerpc/powerpc32/start.S | 2 ++ - sysdeps/powerpc/powerpc64/start.S | 2 ++ - sysdeps/unix/sysv/linux/aarch64/__read_tp.S | 2 ++ - sysdeps/unix/sysv/linux/arm/aeabi_read_tp.S | 2 ++ - sysdeps/unix/sysv/linux/arm/libc-do-syscall.S | 2 ++ - sysdeps/unix/sysv/linux/powerpc/dl-brk.S | 2 ++ - 20 files changed, 40 insertions(+) - -diff --git a/csu/abi-note.S b/csu/abi-note.S -index 2b4b5f8824..964843016c 100644 ---- a/csu/abi-note.S -+++ b/csu/abi-note.S -@@ -56,6 +56,8 @@ offset length contents - #include - #include /* OS-specific ABI tag value */ - -+ .file "abi-note.S" -+ - /* The linker (GNU ld 2.8 and later) recognizes an allocated section whose - name begins with `.note' and creates a PT_NOTE program header entry - pointing at it. */ -diff --git a/sysdeps/aarch64/crti.S b/sysdeps/aarch64/crti.S -index 1728eac37a..76a8ab590b 100644 ---- a/sysdeps/aarch64/crti.S -+++ b/sysdeps/aarch64/crti.S -@@ -50,6 +50,8 @@ - # define PREINIT_FUNCTION_WEAK 1 - #endif - -+ .file "crti.S" -+ - #if PREINIT_FUNCTION_WEAK - weak_extern (PREINIT_FUNCTION) - #else -diff --git a/sysdeps/aarch64/crtn.S b/sysdeps/aarch64/crtn.S -index c3e97cc449..fc2e5c2df8 100644 ---- a/sysdeps/aarch64/crtn.S -+++ b/sysdeps/aarch64/crtn.S -@@ -37,6 +37,8 @@ - /* crtn.S puts function epilogues in the .init and .fini sections - corresponding to the prologues in crti.S. */ - -+ .file "crtn.S" -+ - .section .init,"ax",%progbits - ldp x29, x30, [sp], 16 - RET -diff --git a/sysdeps/aarch64/dl-tlsdesc.S b/sysdeps/aarch64/dl-tlsdesc.S -index 557ad1d505..194a8531da 100644 ---- a/sysdeps/aarch64/dl-tlsdesc.S -+++ b/sysdeps/aarch64/dl-tlsdesc.S -@@ -22,6 +22,8 @@ - #include - #include "tlsdesc.h" - -+ .file "dl-tlsdesc.S" -+ - #define NSAVEDQREGPAIRS 16 - #define SAVE_Q_REGISTERS \ - stp q0, q1, [sp, #-32*NSAVEDQREGPAIRS]!; \ -diff --git a/sysdeps/aarch64/dl-trampoline.S b/sysdeps/aarch64/dl-trampoline.S -index 94e965c096..ba18742f3e 100644 ---- a/sysdeps/aarch64/dl-trampoline.S -+++ b/sysdeps/aarch64/dl-trampoline.S -@@ -21,6 +21,8 @@ - - #include "dl-link.h" - -+ .file "dl-trampoline.S" -+ - #define ip0 x16 - #define ip0l PTR_REG (16) - #define ip1 x17 -diff --git a/sysdeps/aarch64/start.S b/sysdeps/aarch64/start.S -index d96cf57e2d..07a523978a 100644 ---- a/sysdeps/aarch64/start.S -+++ b/sysdeps/aarch64/start.S -@@ -18,6 +18,8 @@ - - #include - -+ .file "start.S" -+ - /* This is the canonical entry point, usually the first thing in the text - segment. - -diff --git a/sysdeps/arm/abi-note.S b/sysdeps/arm/abi-note.S -index 07bd4c4619..7213b16f27 100644 ---- a/sysdeps/arm/abi-note.S -+++ b/sysdeps/arm/abi-note.S -@@ -1,3 +1,5 @@ -+ .file "abi-note.S" -+ - /* Tag_ABI_align8_preserved: This code preserves 8-byte - alignment in any callee. */ - .eabi_attribute 25, 1 -diff --git a/sysdeps/arm/crti.S b/sysdeps/arm/crti.S -index 8169783267..f56e0c85a6 100644 ---- a/sysdeps/arm/crti.S -+++ b/sysdeps/arm/crti.S -@@ -57,6 +57,8 @@ - .hidden PREINIT_FUNCTION - #endif - -+ .file "crti.S" -+ - #if PREINIT_FUNCTION_WEAK - .p2align 2 - .type call_weak_fn, %function -diff --git a/sysdeps/arm/crtn.S b/sysdeps/arm/crtn.S -index d60f9f05de..1e10ec439f 100644 ---- a/sysdeps/arm/crtn.S -+++ b/sysdeps/arm/crtn.S -@@ -37,6 +37,8 @@ - #define NO_THUMB - #include - -+ .file "crtn.S" -+ - /* crtn.S puts function epilogues in the .init and .fini sections - corresponding to the prologues in crti.S. */ - -diff --git a/sysdeps/arm/dl-tlsdesc.S b/sysdeps/arm/dl-tlsdesc.S -index 8415e47607..29c2cb8128 100644 ---- a/sysdeps/arm/dl-tlsdesc.S -+++ b/sysdeps/arm/dl-tlsdesc.S -@@ -21,6 +21,8 @@ - #include - #include "tlsdesc.h" - -+ .file "dl-tlsdesc.S" -+ - .text - @ emit debug information with cfi - @ use arm-specific pseudos for unwinding itself -diff --git a/sysdeps/arm/dl-trampoline.S b/sysdeps/arm/dl-trampoline.S -index a20baf555e..2dd3bef04e 100644 ---- a/sysdeps/arm/dl-trampoline.S -+++ b/sysdeps/arm/dl-trampoline.S -@@ -21,6 +21,8 @@ - #include - #include - -+ .file "dl-trampoline.S" -+ - .text - .globl _dl_runtime_resolve - .type _dl_runtime_resolve, #function -diff --git a/sysdeps/arm/start.S b/sysdeps/arm/start.S -index 2ff56179d2..c118046ec6 100644 ---- a/sysdeps/arm/start.S -+++ b/sysdeps/arm/start.S -@@ -57,6 +57,8 @@ - NULL - */ - -+ .file "start.S" -+ - /* Tag_ABI_align8_preserved: This code preserves 8-byte - alignment in any callee. */ - .eabi_attribute 25, 1 -diff --git a/sysdeps/mips/start.S b/sysdeps/mips/start.S -index fabc8080df..83c6b91d7d 100644 ---- a/sysdeps/mips/start.S -+++ b/sysdeps/mips/start.S -@@ -38,6 +38,8 @@ - #include - #include - -+ .file "start.S" -+ - #ifndef ENTRY_POINT - #error ENTRY_POINT needs to be defined for start.S on MIPS/ELF. - #endif -diff --git a/sysdeps/powerpc/powerpc32/dl-start.S b/sysdeps/powerpc/powerpc32/dl-start.S -index c15242d3bc..6ca27715a4 100644 ---- a/sysdeps/powerpc/powerpc32/dl-start.S -+++ b/sysdeps/powerpc/powerpc32/dl-start.S -@@ -18,6 +18,8 @@ - - #include - -+ .file "dl-start.S" -+ - /* Initial entry point code for the dynamic linker. - The C function `_dl_start' is the real entry point; - its return value is the user program's entry point. */ -diff --git a/sysdeps/powerpc/powerpc32/start.S b/sysdeps/powerpc/powerpc32/start.S -index b7b9a133a2..8df714f81a 100644 ---- a/sysdeps/powerpc/powerpc32/start.S -+++ b/sysdeps/powerpc/powerpc32/start.S -@@ -35,6 +35,8 @@ - - #include - -+ .file "start.S" -+ - /* We do not want .eh_frame info for crt1.o since crt1.o is linked - before crtbegin.o, the file defining __EH_FRAME_BEGIN__. */ - #undef cfi_startproc -diff --git a/sysdeps/powerpc/powerpc64/start.S b/sysdeps/powerpc/powerpc64/start.S -index 94bf771e83..cffb99500a 100644 ---- a/sysdeps/powerpc/powerpc64/start.S -+++ b/sysdeps/powerpc/powerpc64/start.S -@@ -35,6 +35,8 @@ - - #include - -+ .file "start.S" -+ - /* We do not want .eh_frame info for crt1.o since crt1.o is linked - before crtbegin.o, the file defining __EH_FRAME_BEGIN__. */ - #undef cfi_startproc -diff --git a/sysdeps/unix/sysv/linux/aarch64/__read_tp.S b/sysdeps/unix/sysv/linux/aarch64/__read_tp.S -index 12e1131fe7..767e0d043b 100644 ---- a/sysdeps/unix/sysv/linux/aarch64/__read_tp.S -+++ b/sysdeps/unix/sysv/linux/aarch64/__read_tp.S -@@ -18,6 +18,8 @@ - - #include - -+ .file "__read_tp.S" -+ - .hidden __read_tp - ENTRY (__read_tp) - mrs x0, tpidr_el0 -diff --git a/sysdeps/unix/sysv/linux/arm/aeabi_read_tp.S b/sysdeps/unix/sysv/linux/arm/aeabi_read_tp.S -index 3b0d611039..4a7e476c37 100644 ---- a/sysdeps/unix/sysv/linux/arm/aeabi_read_tp.S -+++ b/sysdeps/unix/sysv/linux/arm/aeabi_read_tp.S -@@ -39,6 +39,8 @@ - a normal function call) in a high page of memory; tail call to the - helper. */ - -+ .file "aeabi_read_tp.S" -+ - .hidden __aeabi_read_tp - ENTRY (__aeabi_read_tp) - #ifdef ARCH_HAS_HARD_TP -diff --git a/sysdeps/unix/sysv/linux/arm/libc-do-syscall.S b/sysdeps/unix/sysv/linux/arm/libc-do-syscall.S -index fb5e0c7d97..bd07bdb38b 100644 ---- a/sysdeps/unix/sysv/linux/arm/libc-do-syscall.S -+++ b/sysdeps/unix/sysv/linux/arm/libc-do-syscall.S -@@ -27,6 +27,8 @@ - ARM unwind tables for register to register moves, the actual opcodes - are not defined. */ - -+ .file "libc-do-syscall.S" -+ - #if defined(__thumb__) - .thumb - .syntax unified -diff --git a/sysdeps/unix/sysv/linux/powerpc/dl-brk.S b/sysdeps/unix/sysv/linux/powerpc/dl-brk.S -index eeb96544e3..da182b28f8 100644 ---- a/sysdeps/unix/sysv/linux/powerpc/dl-brk.S -+++ b/sysdeps/unix/sysv/linux/powerpc/dl-brk.S -@@ -1 +1,3 @@ -+ .file "dl-brk.S" -+ - #include diff --git a/meta/recipes-core/glibc/glibc/0029-locale-prevent-maybe-uninitialized-errors-with-Os-BZ.patch b/meta/recipes-core/glibc/glibc/0029-locale-prevent-maybe-uninitialized-errors-with-Os-BZ.patch new file mode 100644 index 0000000000..c8c359f2b8 --- /dev/null +++ b/meta/recipes-core/glibc/glibc/0029-locale-prevent-maybe-uninitialized-errors-with-Os-BZ.patch @@ -0,0 +1,53 @@ +From 66963ad83bdd3b075006ddca9dfe357aed181d6a Mon Sep 17 00:00:00 2001 +From: Martin Jansa +Date: Mon, 17 Dec 2018 21:36:18 +0000 +Subject: [PATCH] locale: prevent maybe-uninitialized errors with -Os [BZ + #19444] + +Fixes following error when building for aarch64 with -Os: +| In file included from strcoll_l.c:43: +| strcoll_l.c: In function '__strcoll_l': +| ../locale/weight.h:31:26: error: 'seq2.back_us' may be used uninitialized in this function [-Werror=maybe-uninitialized] +| int_fast32_t i = table[*(*cpp)++]; +| ^~~~~~~~~ +| strcoll_l.c:304:18: note: 'seq2.back_us' was declared here +| coll_seq seq1, seq2; +| ^~~~ +| In file included from strcoll_l.c:43: +| ../locale/weight.h:31:26: error: 'seq1.back_us' may be used uninitialized in this function [-Werror=maybe-uninitialized] +| int_fast32_t i = table[*(*cpp)++]; +| ^~~~~~~~~ +| strcoll_l.c:304:12: note: 'seq1.back_us' was declared here +| coll_seq seq1, seq2; +| ^~~~ + + Partial fix for [BZ #19444] + * locale/weight.h: Fix build with -Os. + +Upstream-Status: Submitted [https://patchwork.ozlabs.org/patch/1014766] + +Signed-off-by: Martin Jansa +Signed-off-by: Khem Raj +--- + locale/weight.h | 7 +++++++ + 1 file changed, 7 insertions(+) + +diff --git a/locale/weight.h b/locale/weight.h +index e071253f85..2889c395f1 100644 +--- a/locale/weight.h ++++ b/locale/weight.h +@@ -28,7 +28,14 @@ findidx (const int32_t *table, + const unsigned char *extra, + const unsigned char **cpp, size_t len) + { ++ /* With GCC 8 when compiling with -Os the compiler warns that ++ seq1.back_us and seq2.back_us might be used uninitialized. ++ This uninitialized use is impossible for the same reason ++ as described in comments in locale/weightwc.h. */ ++ DIAG_PUSH_NEEDS_COMMENT; ++ DIAG_IGNORE_Os_NEEDS_COMMENT (8, "-Wmaybe-uninitialized"); + int_fast32_t i = table[*(*cpp)++]; ++ DIAG_POP_NEEDS_COMMENT; + const unsigned char *cp; + const unsigned char *usrc; + diff --git a/meta/recipes-core/glibc/glibc/0030-Refactor-FORTIFY-in-glibc.patch b/meta/recipes-core/glibc/glibc/0030-Refactor-FORTIFY-in-glibc.patch new file mode 100644 index 0000000000..7fe71ad92f --- /dev/null +++ b/meta/recipes-core/glibc/glibc/0030-Refactor-FORTIFY-in-glibc.patch @@ -0,0 +1,2780 @@ +From fecfc4050ce075e543fb1cf19d6d1da481260b95 Mon Sep 17 00:00:00 2001 +From: George Burgess IV +Date: Sat, 11 Jan 2020 10:33:19 -0800 +Subject: [PATCH] Refactor FORTIFY in glibc + +Upstream-Status: Submitted [https://sourceware.org/ml/libc-alpha/2017-09/msg00434.html] + +Signed-off-by: George Burgess IV +Signed-off-by: Khem Raj +--- + io/bits/fcntl2.h | 125 ++++++-- + io/bits/poll2.h | 54 ++-- + io/fcntl.h | 2 +- + libio/bits/stdio2.h | 303 +++++++++++--------- + misc/bits/syslog.h | 38 ++- + misc/sys/cdefs.h | 164 ++++++++++- + posix/bits/unistd.h | 366 ++++++++++-------------- + rt/bits/mqueue2.h | 44 ++- + rt/mqueue.h | 2 +- + socket/bits/socket2.h | 56 ++-- + stdlib/bits/stdlib.h | 117 ++++---- + string/bits/string_fortified.h | 136 ++++++--- + string/bits/strings_fortified.h | 36 ++- + wcsmbs/bits/wchar2.h | 487 ++++++++++++++------------------ + 14 files changed, 1093 insertions(+), 837 deletions(-) + +diff --git a/io/bits/fcntl2.h b/io/bits/fcntl2.h +index 85b922dab8..04cc377040 100644 +--- a/io/bits/fcntl2.h ++++ b/io/bits/fcntl2.h +@@ -32,10 +32,28 @@ extern int __REDIRECT (__open_2, (const char *__path, int __oflag), + extern int __REDIRECT (__open_alias, (const char *__path, int __oflag, ...), + open64) __nonnull ((1)); + #endif +-__errordecl (__open_too_many_args, +- "open can be called either with 2 or 3 arguments, not more"); +-__errordecl (__open_missing_mode, +- "open with O_CREAT or O_TMPFILE in second argument needs 3 arguments"); ++ ++#define __warn_open_too_many_args \ ++ "open can be called either with 2 or 3 arguments, not more" ++#define __warn_open_missing_mode \ ++ "open with O_CREAT in second argument needs 3 arguments" ++#ifdef __use_clang_fortify ++__fortify_overload __clang_prefer_this_overload int ++open (const char *const __clang_pass_object_size __path, int __oflag) ++ __clang_error_if (__OPEN_NEEDS_MODE (__oflag), __warn_open_missing_mode) ++{ ++ return __open_2 (__path, __oflag); ++} ++ ++__fortify_overload int ++open (const char *const __clang_pass_object_size __path, int __oflag, ++ mode_t __mode) ++{ ++ return __open_alias (__path, __oflag, __mode); ++} ++#else ++__errordecl (__open_too_many_args, __warn_open_too_many_args); ++__errordecl (__open_missing_mode, __warn_open_missing_mode); + + __fortify_function int + open (const char *__path, int __oflag, ...) +@@ -58,16 +76,37 @@ open (const char *__path, int __oflag, ...) + + return __open_alias (__path, __oflag, __va_arg_pack ()); + } ++#endif ++#undef __warn_open_too_many_args ++#undef __warn_open_missing_mode + + + #ifdef __USE_LARGEFILE64 + extern int __open64_2 (const char *__path, int __oflag) __nonnull ((1)); + extern int __REDIRECT (__open64_alias, (const char *__path, int __oflag, + ...), open64) __nonnull ((1)); +-__errordecl (__open64_too_many_args, +- "open64 can be called either with 2 or 3 arguments, not more"); +-__errordecl (__open64_missing_mode, +- "open64 with O_CREAT or O_TMPFILE in second argument needs 3 arguments"); ++ ++# define __warn_open64_too_many_args \ ++ "open64 can be called either with 2 or 3 arguments, not more" ++# define __warn_open64_missing_mode \ ++ "open64 with O_CREAT in second argument needs 3 arguments" ++# ifdef __use_clang_fortify ++__fortify_overload __clang_prefer_this_overload int ++open64 (const char *const __clang_pass_object_size __path, int __oflag) ++ __clang_error_if (__OPEN_NEEDS_MODE (__oflag), __warn_open64_missing_mode) ++{ ++ return __open64_2 (__path, __oflag); ++} ++ ++__fortify_overload __clang_prefer_this_overload int ++open64 (const char *const __clang_pass_object_size __path, int __oflag, ++ int __mode) ++{ ++ return __open64_alias (__path, __oflag, __mode); ++} ++# else ++__errordecl (__open64_too_many_args, __warn_open64_too_many_args); ++__errordecl (__open64_missing_mode, __warn_open64_missing_mode); + + __fortify_function int + open64 (const char *__path, int __oflag, ...) +@@ -90,6 +129,9 @@ open64 (const char *__path, int __oflag, ...) + + return __open64_alias (__path, __oflag, __va_arg_pack ()); + } ++# endif ++# undef __warn_open64_too_many_args ++# undef __warn_open64_missing_mode + #endif + + +@@ -108,10 +150,32 @@ extern int __REDIRECT (__openat_alias, (int __fd, const char *__path, + int __oflag, ...), openat64) + __nonnull ((2)); + # endif +-__errordecl (__openat_too_many_args, +- "openat can be called either with 3 or 4 arguments, not more"); +-__errordecl (__openat_missing_mode, +- "openat with O_CREAT or O_TMPFILE in third argument needs 4 arguments"); ++ ++# define __warn_openat_too_many_args "openat can be called either with 3 or " \ ++ "4 arguments, not more" ++# define __warn_openat_missing_mode "openat with O_CREAT in third argument " \ ++ "needs 4 arguments" ++# ifdef __use_clang_fortify ++__fortify_error_function __clang_error (__warn_openat_too_many_args) int ++openat (int __fd, const char *__path, int __oflag, int __mode, ...); ++ ++__fortify_overload __clang_prefer_this_overload int ++openat (int __fd, const char *const __clang_pass_object_size __path, ++ int __oflag) ++ __clang_error_if (__OPEN_NEEDS_MODE (__oflag), __warn_openat_missing_mode) ++{ ++ return __openat_2 (__fd, __path, __oflag); ++} ++ ++__fortify_overload __clang_prefer_this_overload int ++openat (int __fd, const char *const __clang_pass_object_size __path, ++ int __oflag, int __mode) ++{ ++ return __openat_alias (__fd, __path, __oflag, __mode); ++} ++# else ++__errordecl (__openat_too_many_args, __warn_openat_too_many_args); ++__errordecl (__openat_missing_mode, __warn_openat_missing_mode); + + __fortify_function int + openat (int __fd, const char *__path, int __oflag, ...) +@@ -134,6 +198,9 @@ openat (int __fd, const char *__path, int __oflag, ...) + + return __openat_alias (__fd, __path, __oflag, __va_arg_pack ()); + } ++# endif ++# undef __warn_openat_too_many_args ++# undef __warn_openat_missing_mode + + + # ifdef __USE_LARGEFILE64 +@@ -142,11 +209,34 @@ extern int __openat64_2 (int __fd, const char *__path, int __oflag) + extern int __REDIRECT (__openat64_alias, (int __fd, const char *__path, + int __oflag, ...), openat64) + __nonnull ((2)); +-__errordecl (__openat64_too_many_args, +- "openat64 can be called either with 3 or 4 arguments, not more"); +-__errordecl (__openat64_missing_mode, +- "openat64 with O_CREAT or O_TMPFILE in third argument needs 4 arguments"); + ++# define __warn_openat64_too_many_args "openat64 can be called either with " \ ++ "3 or 4 arguments, not more" ++# define __warn_openat64_missing_mode "openat64 with O_CREAT in third " \ ++ "argument needs 4 arguments" ++ ++# ifdef __use_clang_fortify ++__fortify_error_function __clang_error (__warn_openat64_too_many_args) int ++openat64 (int __fd, const char *__path, int __oflag, int __mode, ...); ++ ++__fortify_overload __clang_prefer_this_overload int ++openat64 (int __fd, const char *const __clang_pass_object_size __path, ++ int __oflag) ++ __clang_error_if (__OPEN_NEEDS_MODE (__oflag), ++ __warn_openat64_missing_mode) ++{ ++ return __openat64_2 (__fd, __path, __oflag); ++} ++ ++__fortify_overload __clang_prefer_this_overload int ++openat64 (int __fd, const char *const __clang_pass_object_size __path, ++ int __oflag, int __mode) ++{ ++ return __openat64_alias (__fd, __path, __oflag, __mode); ++} ++# else ++__errordecl (__openat64_too_many_args, __warn_openat64_too_many_args); ++__errordecl (__openat64_missing_mode, __warn_openat64_missing_mode); + __fortify_function int + openat64 (int __fd, const char *__path, int __oflag, ...) + { +@@ -168,5 +258,8 @@ openat64 (int __fd, const char *__path, int __oflag, ...) + + return __openat64_alias (__fd, __path, __oflag, __va_arg_pack ()); + } ++# endif ++# undef __warn_openat64_too_many_args ++# undef __warn_openat64_missing_mode + # endif + #endif +diff --git a/io/bits/poll2.h b/io/bits/poll2.h +index dca49717db..cc149711af 100644 +--- a/io/bits/poll2.h ++++ b/io/bits/poll2.h +@@ -27,25 +27,20 @@ extern int __REDIRECT (__poll_alias, (struct pollfd *__fds, nfds_t __nfds, + int __timeout), poll); + extern int __poll_chk (struct pollfd *__fds, nfds_t __nfds, int __timeout, + __SIZE_TYPE__ __fdslen); +-extern int __REDIRECT (__poll_chk_warn, (struct pollfd *__fds, nfds_t __nfds, +- int __timeout, __SIZE_TYPE__ __fdslen), +- __poll_chk) +- __warnattr ("poll called with fds buffer too small file nfds entries"); + +-__fortify_function int +-poll (struct pollfd *__fds, nfds_t __nfds, int __timeout) ++__fortify_potential_overload int ++poll (struct pollfd *const __clang_pass_object_size __fds, nfds_t __nfds, ++ int __timeout) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT2 (__poll_warn, __nfds, __fds, ++ sizeof (*__fds), ++ "poll called with fds buffer too small") + { +- if (__bos (__fds) != (__SIZE_TYPE__) -1) +- { +- if (! __builtin_constant_p (__nfds)) +- return __poll_chk (__fds, __nfds, __timeout, __bos (__fds)); +- else if (__bos (__fds) / sizeof (*__fds) < __nfds) +- return __poll_chk_warn (__fds, __nfds, __timeout, __bos (__fds)); +- } +- ++ if (__FORTIFY_CALL_CHK && __bos (__fds) != (__SIZE_TYPE__) -1) ++ return __poll_chk (__fds, __nfds, __timeout, __bos (__fds)); + return __poll_alias (__fds, __nfds, __timeout); + } +- ++__FORTIFY_FUNCTION_END + + #ifdef __USE_GNU + extern int __REDIRECT (__ppoll_alias, (struct pollfd *__fds, nfds_t __nfds, +@@ -54,28 +49,21 @@ extern int __REDIRECT (__ppoll_alias, (struct pollfd *__fds, nfds_t __nfds, + extern int __ppoll_chk (struct pollfd *__fds, nfds_t __nfds, + const struct timespec *__timeout, + const __sigset_t *__ss, __SIZE_TYPE__ __fdslen); +-extern int __REDIRECT (__ppoll_chk_warn, (struct pollfd *__fds, nfds_t __nfds, +- const struct timespec *__timeout, +- const __sigset_t *__ss, +- __SIZE_TYPE__ __fdslen), +- __ppoll_chk) +- __warnattr ("ppoll called with fds buffer too small file nfds entries"); + +-__fortify_function int +-ppoll (struct pollfd *__fds, nfds_t __nfds, const struct timespec *__timeout, +- const __sigset_t *__ss) ++__fortify_potential_overload int ++ppoll (struct pollfd *const __clang_pass_object_size __fds, nfds_t __nfds, ++ const struct timespec *__timeout, const __sigset_t *__ss) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT2 (__ppoll_warn, __nfds, __fds, ++ sizeof (*__fds), ++ "ppoll called with fds buffer too " ++ "small file nfds entries") + { +- if (__bos (__fds) != (__SIZE_TYPE__) -1) +- { +- if (! __builtin_constant_p (__nfds)) +- return __ppoll_chk (__fds, __nfds, __timeout, __ss, __bos (__fds)); +- else if (__bos (__fds) / sizeof (*__fds) < __nfds) +- return __ppoll_chk_warn (__fds, __nfds, __timeout, __ss, +- __bos (__fds)); +- } +- ++ if (__FORTIFY_CALL_CHK && __bos (__fds) != (__SIZE_TYPE__) -1) ++ return __ppoll_chk (__fds, __nfds, __timeout, __ss, __bos (__fds)); + return __ppoll_alias (__fds, __nfds, __timeout, __ss); + } ++__FORTIFY_FUNCTION_END + #endif + + __END_DECLS +diff --git a/io/fcntl.h b/io/fcntl.h +index 21b60c264d..83f2c8e117 100644 +--- a/io/fcntl.h ++++ b/io/fcntl.h +@@ -325,7 +325,7 @@ extern int posix_fallocate64 (int __fd, off64_t __offset, off64_t __len); + + /* Define some inlines helping to catch common problems. */ + #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function \ +- && defined __va_arg_pack_len ++ && (defined __va_arg_pack_len || defined __use_clang_fortify) + # include + #endif + +diff --git a/libio/bits/stdio2.h b/libio/bits/stdio2.h +index 60bc81735e..1338f418ba 100644 +--- a/libio/bits/stdio2.h ++++ b/libio/bits/stdio2.h +@@ -29,12 +29,23 @@ extern int __vsprintf_chk (char *__restrict __s, int __flag, size_t __slen, + const char *__restrict __format, + __gnuc_va_list __ap) __THROW; + +-#ifdef __va_arg_pack +-__fortify_function int +-__NTH (sprintf (char *__restrict __s, const char *__restrict __fmt, ...)) ++#define __mul_may_overflow(size, n) \ ++ ((size | n) >= (((size_t)1) << (8 * sizeof (size_t) / 2))) ++ ++#ifdef __FORTIFY_ARG_PACK_OK ++/* clang doesn't have __va_arg_pack, so we need to defer to the va_arg versions ++ of these functions. */ ++__fortify_potential_overload int ++__NTH (sprintf (char *__restrict const __clang_pass_object_size __s, ++ const char *__restrict __fmt, ...)) + { +- return __builtin___sprintf_chk (__s, __USE_FORTIFY_LEVEL - 1, +- __bos (__s), __fmt, __va_arg_pack ()); ++ __FORTIFY_INIT_ARG_PACK(__fmt); ++ int __result = __FORTIFY_CALL_VA_BUILTIN (sprintf, __s, ++ __USE_FORTIFY_LEVEL - 1, ++ __bos (__s), __fmt, ++ __FORTIFY_ARG_PACK); ++ __FORTIFY_FREE_ARG_PACK(); ++ return __result; + } + #elif !defined __cplusplus + # define sprintf(str, ...) \ +@@ -42,9 +53,9 @@ __NTH (sprintf (char *__restrict __s, const char *__restrict __fmt, ...)) + __VA_ARGS__) + #endif + +-__fortify_function int +-__NTH (vsprintf (char *__restrict __s, const char *__restrict __fmt, +- __gnuc_va_list __ap)) ++__fortify_potential_overload int ++__NTH (vsprintf (char *__restrict const __clang_pass_object_size __s, ++ const char *__restrict __fmt, __gnuc_va_list __ap)) + { + return __builtin___vsprintf_chk (__s, __USE_FORTIFY_LEVEL - 1, + __bos (__s), __fmt, __ap); +@@ -59,13 +70,21 @@ extern int __vsnprintf_chk (char *__restrict __s, size_t __n, int __flag, + size_t __slen, const char *__restrict __format, + __gnuc_va_list __ap) __THROW; + +-# ifdef __va_arg_pack +-__fortify_function int +-__NTH (snprintf (char *__restrict __s, size_t __n, +- const char *__restrict __fmt, ...)) ++# ifdef __FORTIFY_ARG_PACK_OK ++__fortify_potential_overload __attribute__ ((__format__ (__printf__, 3, 4))) int ++__NTH (snprintf (char *__restrict const __clang_pass_object_size __s, ++ size_t __n, const char *__restrict __fmt, ...)) ++ /* GCC's builtin will catch this, so we just need to cover clang here. */ ++ __clang_warning_if (__bos_static_lt (__n, __s), ++ "call to snprintf may overflow the destination buffer") + { +- return __builtin___snprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, +- __bos (__s), __fmt, __va_arg_pack ()); ++ __FORTIFY_INIT_ARG_PACK(__fmt); ++ int __result = __FORTIFY_CALL_VA_BUILTIN (snprintf, __s, __n, ++ __USE_FORTIFY_LEVEL - 1, ++ __bos (__s), __fmt, ++ __FORTIFY_ARG_PACK); ++ __FORTIFY_FREE_ARG_PACK(); ++ return __result; + } + # elif !defined __cplusplus + # define snprintf(str, len, ...) \ +@@ -73,9 +92,12 @@ __NTH (snprintf (char *__restrict __s, size_t __n, + __VA_ARGS__) + # endif + +-__fortify_function int +-__NTH (vsnprintf (char *__restrict __s, size_t __n, +- const char *__restrict __fmt, __gnuc_va_list __ap)) ++__fortify_potential_overload __attribute__ ((__format__ (__printf__, 3, 0))) int ++__NTH (vsnprintf (char *__restrict const __clang_pass_object_size __s, ++ size_t __n, const char *__restrict __fmt, __gnuc_va_list __ap)) ++ __clang_warning_if (__bos_static_lt (__n, __s), ++ "call to vsnprintf may overflow the destination " ++ "buffer") + { + return __builtin___vsnprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, + __bos (__s), __fmt, __ap); +@@ -93,18 +115,27 @@ extern int __vfprintf_chk (FILE *__restrict __stream, int __flag, + extern int __vprintf_chk (int __flag, const char *__restrict __format, + __gnuc_va_list __ap); + +-# ifdef __va_arg_pack +-__fortify_function int +-fprintf (FILE *__restrict __stream, const char *__restrict __fmt, ...) ++# ifdef __FORTIFY_ARG_PACK_OK ++__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 3))) int ++fprintf (FILE *__restrict const __clang_pass_object_size __stream, ++ const char *__restrict __fmt, ...) + { +- return __fprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, +- __va_arg_pack ()); ++ __FORTIFY_INIT_ARG_PACK(__fmt); ++ int __result = __FORTIFY_CALL_VA_CHK (fprintf, __stream, ++ __USE_FORTIFY_LEVEL - 1, __fmt, ++ __FORTIFY_ARG_PACK); ++ __FORTIFY_FREE_ARG_PACK(); ++ return __result; + } + +-__fortify_function int +-printf (const char *__restrict __fmt, ...) ++__fortify_potential_overload __attribute__ ((__format__ (__printf__, 1, 2))) int ++printf (const char *__restrict const __clang_pass_object_size __fmt, ...) + { +- return __printf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ()); ++ __FORTIFY_INIT_ARG_PACK(__fmt); ++ int __result = __FORTIFY_CALL_VA_CHK (printf, __USE_FORTIFY_LEVEL - 1, __fmt, ++ __FORTIFY_ARG_PACK); ++ __FORTIFY_FREE_ARG_PACK(); ++ return __result; + } + # elif !defined __cplusplus + # define printf(...) \ +@@ -113,8 +144,9 @@ printf (const char *__restrict __fmt, ...) + __fprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) + # endif + +-__fortify_function int +-vprintf (const char *__restrict __fmt, __gnuc_va_list __ap) ++__fortify_potential_overload __attribute__ ((__format__ (__printf__, 1, 0))) int ++vprintf (const char *__restrict const __clang_pass_object_size __fmt, ++ __gnuc_va_list __ap) + { + #ifdef __USE_EXTERN_INLINES + return __vfprintf_chk (stdout, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); +@@ -122,9 +154,8 @@ vprintf (const char *__restrict __fmt, __gnuc_va_list __ap) + return __vprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __ap); + #endif + } +- +-__fortify_function int +-vfprintf (FILE *__restrict __stream, ++__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 0))) int ++vfprintf (FILE *__restrict const __clang_pass_object_size __stream, + const char *__restrict __fmt, __gnuc_va_list __ap) + { + return __vfprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); +@@ -137,20 +168,26 @@ extern int __vdprintf_chk (int __fd, int __flag, + const char *__restrict __fmt, __gnuc_va_list __arg) + __attribute__ ((__format__ (__printf__, 3, 0))); + +-# ifdef __va_arg_pack +-__fortify_function int +-dprintf (int __fd, const char *__restrict __fmt, ...) ++# ifdef __FORTIFY_ARG_PACK_OK ++__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 3))) int ++dprintf (int __fd, const char *__restrict const __clang_pass_object_size __fmt, ++ ...) + { +- return __dprintf_chk (__fd, __USE_FORTIFY_LEVEL - 1, __fmt, +- __va_arg_pack ()); ++ __FORTIFY_INIT_ARG_PACK(__fmt); ++ int __result = __FORTIFY_CALL_VA_CHK (dprintf, __fd, __USE_FORTIFY_LEVEL - 1, ++ __fmt, __FORTIFY_ARG_PACK); ++ __FORTIFY_FREE_ARG_PACK(); ++ return __result; + } + # elif !defined __cplusplus + # define dprintf(fd, ...) \ + __dprintf_chk (fd, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) + # endif + +-__fortify_function int +-vdprintf (int __fd, const char *__restrict __fmt, __gnuc_va_list __ap) ++__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 0))) int ++vdprintf (int __fd, ++ const char *__restrict const __clang_pass_object_size __fmt, ++ __gnuc_va_list __ap) + { + return __vdprintf_chk (__fd, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); + } +@@ -174,28 +211,49 @@ extern int __obstack_vprintf_chk (struct obstack *__restrict __obstack, + __gnuc_va_list __args) + __THROW __attribute__ ((__format__ (__printf__, 3, 0))); + +-# ifdef __va_arg_pack +-__fortify_function int +-__NTH (asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...)) ++# ifdef __FORTIFY_ARG_PACK_OK ++__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 3))) ++__wur int ++__NTH (asprintf (char **__restrict const __clang_pass_object_size __ptr, ++ const char *__restrict __fmt, ...)) + { +- return __asprintf_chk (__ptr, __USE_FORTIFY_LEVEL - 1, __fmt, +- __va_arg_pack ()); ++ __FORTIFY_INIT_ARG_PACK(__fmt); ++ int __result = __FORTIFY_CALL_VA_CHK (asprintf, __ptr, ++ __USE_FORTIFY_LEVEL - 1, __fmt, ++ __FORTIFY_ARG_PACK); ++ __FORTIFY_FREE_ARG_PACK(); ++ return __result; + } + +-__fortify_function int +-__NTH (__asprintf (char **__restrict __ptr, const char *__restrict __fmt, +- ...)) ++__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 3))) ++__wur int ++__NTH (__asprintf (char **__restrict const __clang_pass_object_size __ptr, ++ const char *__restrict __fmt, ...)) + { +- return __asprintf_chk (__ptr, __USE_FORTIFY_LEVEL - 1, __fmt, +- __va_arg_pack ()); ++ __FORTIFY_INIT_ARG_PACK(__fmt); ++ int __result = __FORTIFY_CALL_VA_CHK (asprintf, __ptr, ++ __USE_FORTIFY_LEVEL - 1, __fmt, ++ __FORTIFY_ARG_PACK); ++ __FORTIFY_FREE_ARG_PACK(); ++ return __result; + } + +-__fortify_function int +-__NTH (obstack_printf (struct obstack *__restrict __obstack, ++__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 3))) int ++__NTH (obstack_printf (struct obstack * ++ __restrict const __clang_pass_object_size __obstack, + const char *__restrict __fmt, ...)) + { +- return __obstack_printf_chk (__obstack, __USE_FORTIFY_LEVEL - 1, __fmt, +- __va_arg_pack ()); ++ __FORTIFY_INIT_ARG_PACK(__fmt); ++ int __result = ++# ifdef __use_clang_fortify ++ __obstack_vprintf_chk ++# else ++ __obstack_printf_chk ++# endif ++ (__obstack, __USE_FORTIFY_LEVEL - 1, __fmt, ++ __FORTIFY_ARG_PACK); ++ __FORTIFY_FREE_ARG_PACK(); ++ return __result; + } + # elif !defined __cplusplus + # define asprintf(ptr, ...) \ +@@ -206,15 +264,17 @@ __NTH (obstack_printf (struct obstack *__restrict __obstack, + __obstack_printf_chk (obstack, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) + # endif + +-__fortify_function int +-__NTH (vasprintf (char **__restrict __ptr, const char *__restrict __fmt, +- __gnuc_va_list __ap)) ++__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 0))) ++__wur int ++__NTH (vasprintf (char **__restrict const __clang_pass_object_size __ptr, ++ const char *__restrict __fmt, __gnuc_va_list __ap)) + { + return __vasprintf_chk (__ptr, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); + } + +-__fortify_function int +-__NTH (obstack_vprintf (struct obstack *__restrict __obstack, ++__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 0))) int ++__NTH (obstack_vprintf (struct obstack * ++ __restrict const __clang_pass_object_size __obstack, + const char *__restrict __fmt, __gnuc_va_list __ap)) + { + return __obstack_vprintf_chk (__obstack, __USE_FORTIFY_LEVEL - 1, __fmt, +@@ -227,17 +287,20 @@ __NTH (obstack_vprintf (struct obstack *__restrict __obstack, + + #if __GLIBC_USE (DEPRECATED_GETS) + extern char *__gets_chk (char *__str, size_t) __wur; +-extern char *__REDIRECT (__gets_warn, (char *__str), gets) +- __wur __warnattr ("please use fgets or getline instead, gets can't " +- "specify buffer size"); +- +-__fortify_function __wur char * +-gets (char *__str) ++extern char *__REDIRECT_NTH (__gets_alias, (char *__buf), gets) __wur; ++ ++__fortify_potential_overload __wur char * ++gets (char *const __clang_pass_object_size __str) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_IF (__gets_warn, __bos (__str) == (size_t) -1, ++ "please use fgets or getline instead, gets can't " ++ "specify buffer size") + { + if (__bos (__str) != (size_t) -1) + return __gets_chk (__str, __bos (__str)); +- return __gets_warn (__str); ++ return __gets_alias (__str); + } ++__FORTIFY_FUNCTION_END + #endif + + extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n, +@@ -245,25 +308,20 @@ extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n, + extern char *__REDIRECT (__fgets_alias, + (char *__restrict __s, int __n, + FILE *__restrict __stream), fgets) __wur; +-extern char *__REDIRECT (__fgets_chk_warn, +- (char *__restrict __s, size_t __size, int __n, +- FILE *__restrict __stream), __fgets_chk) +- __wur __warnattr ("fgets called with bigger size than length " +- "of destination buffer"); +- +-__fortify_function __wur char * +-fgets (char *__restrict __s, int __n, FILE *__restrict __stream) ++ ++__fortify_potential_overload __wur char * ++fgets (char *__restrict const __clang_pass_object_size __s, int __n, ++ FILE *__restrict __stream) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_IF (__fgets_warn, __bos_static_lt (__n, __s) && __n > 0, ++ "fgets called with bigger size than length of " ++ "destination buffer") + { + if (__bos (__s) != (size_t) -1) +- { +- if (!__builtin_constant_p (__n) || __n <= 0) +- return __fgets_chk (__s, __bos (__s), __n, __stream); +- +- if ((size_t) __n > __bos (__s)) +- return __fgets_chk_warn (__s, __bos (__s), __n, __stream); +- } ++ return __fgets_chk (__s, __bos (__s), __n, __stream); + return __fgets_alias (__s, __n, __stream); + } ++__FORTIFY_FUNCTION_END + + extern size_t __fread_chk (void *__restrict __ptr, size_t __ptrlen, + size_t __size, size_t __n, +@@ -272,30 +330,21 @@ extern size_t __REDIRECT (__fread_alias, + (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream), + fread) __wur; +-extern size_t __REDIRECT (__fread_chk_warn, +- (void *__restrict __ptr, size_t __ptrlen, +- size_t __size, size_t __n, +- FILE *__restrict __stream), +- __fread_chk) +- __wur __warnattr ("fread called with bigger size * nmemb than length " +- "of destination buffer"); + +-__fortify_function __wur size_t +-fread (void *__restrict __ptr, size_t __size, size_t __n, +- FILE *__restrict __stream) ++__fortify_potential_overload __wur size_t ++fread (void *__restrict const __clang_pass_object_size0 __ptr, size_t __size, ++ size_t __n, FILE *__restrict __stream) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_IF (__fread_warn, __bos0_static_lt (__size * __n, __ptr) ++ && !__mul_may_overflow (__size, __n), ++ "fread called with bigger size * nmemb than length " ++ "of destination buffer") + { + if (__bos0 (__ptr) != (size_t) -1) +- { +- if (!__builtin_constant_p (__size) +- || !__builtin_constant_p (__n) +- || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2))) +- return __fread_chk (__ptr, __bos0 (__ptr), __size, __n, __stream); +- +- if (__size * __n > __bos0 (__ptr)) +- return __fread_chk_warn (__ptr, __bos0 (__ptr), __size, __n, __stream); +- } ++ return __fread_chk (__ptr, __bos0 (__ptr), __size, __n, __stream); + return __fread_alias (__ptr, __size, __n, __stream); + } ++__FORTIFY_FUNCTION_END + + #ifdef __USE_GNU + extern char *__fgets_unlocked_chk (char *__restrict __s, size_t __size, +@@ -303,25 +352,21 @@ extern char *__fgets_unlocked_chk (char *__restrict __s, size_t __size, + extern char *__REDIRECT (__fgets_unlocked_alias, + (char *__restrict __s, int __n, + FILE *__restrict __stream), fgets_unlocked) __wur; +-extern char *__REDIRECT (__fgets_unlocked_chk_warn, +- (char *__restrict __s, size_t __size, int __n, +- FILE *__restrict __stream), __fgets_unlocked_chk) +- __wur __warnattr ("fgets_unlocked called with bigger size than length " +- "of destination buffer"); +- +-__fortify_function __wur char * +-fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream) ++ ++__fortify_potential_overload __wur char * ++fgets_unlocked (char *__restrict const __clang_pass_object_size __s, int __n, ++ FILE *__restrict __stream) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_IF (__fgets_unlocked_warn, ++ __bos_static_lt (__n, __s) && __n > 0, ++ "fgets_unlocked called with bigger size than length " ++ "of destination buffer") + { + if (__bos (__s) != (size_t) -1) +- { +- if (!__builtin_constant_p (__n) || __n <= 0) +- return __fgets_unlocked_chk (__s, __bos (__s), __n, __stream); +- +- if ((size_t) __n > __bos (__s)) +- return __fgets_unlocked_chk_warn (__s, __bos (__s), __n, __stream); +- } ++ return __fgets_unlocked_chk (__s, __bos (__s), __n, __stream); + return __fgets_unlocked_alias (__s, __n, __stream); + } ++__FORTIFY_FUNCTION_END + #endif + + #ifdef __USE_MISC +@@ -333,30 +378,19 @@ extern size_t __REDIRECT (__fread_unlocked_alias, + (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream), + fread_unlocked) __wur; +-extern size_t __REDIRECT (__fread_unlocked_chk_warn, +- (void *__restrict __ptr, size_t __ptrlen, +- size_t __size, size_t __n, +- FILE *__restrict __stream), +- __fread_unlocked_chk) +- __wur __warnattr ("fread_unlocked called with bigger size * nmemb than " +- "length of destination buffer"); + +-__fortify_function __wur size_t +-fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n, +- FILE *__restrict __stream) ++__fortify_potential_overload __wur size_t ++fread_unlocked (void *__restrict const __clang_pass_object_size0 __ptr, ++ size_t __size, size_t __n, FILE *__restrict __stream) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_IF (__fread_unlocked_warn, ++ __bos0_static_lt (__size * __n, __ptr) ++ && !__mul_may_overflow(__size, __n), ++ "fread_unlocked called with bigger size * n than " ++ "length of destination buffer") + { + if (__bos0 (__ptr) != (size_t) -1) +- { +- if (!__builtin_constant_p (__size) +- || !__builtin_constant_p (__n) +- || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2))) +- return __fread_unlocked_chk (__ptr, __bos0 (__ptr), __size, __n, +- __stream); +- +- if (__size * __n > __bos0 (__ptr)) +- return __fread_unlocked_chk_warn (__ptr, __bos0 (__ptr), __size, __n, +- __stream); +- } ++ return __fread_unlocked_chk (__ptr, __bos0 (__ptr), __size, __n, __stream); + + # ifdef __USE_EXTERN_INLINES + if (__builtin_constant_p (__size) +@@ -381,6 +415,7 @@ fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n, + # endif + return __fread_unlocked_alias (__ptr, __size, __n, __stream); + } ++__FORTIFY_FUNCTION_END + #endif +- ++#undef __mul_may_overflow + #endif /* bits/stdio2.h. */ +diff --git a/misc/bits/syslog.h b/misc/bits/syslog.h +index 322192df21..68b90a5cb8 100644 +--- a/misc/bits/syslog.h ++++ b/misc/bits/syslog.h +@@ -20,11 +20,34 @@ + # error "Never include directly; use instead." + #endif + ++#ifdef __USE_MISC ++extern void __vsyslog_chk (int __pri, int __flag, const char *__fmt, ++ __gnuc_va_list __ap) ++ __attribute__ ((__format__ (__printf__, 3, 0))); ++ ++__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 0))) void ++vsyslog (int __pri, const char *const __clang_pass_object_size __fmt, ++ __gnuc_va_list __ap) ++{ ++ __vsyslog_chk (__pri, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); ++} ++#endif + + extern void __syslog_chk (int __pri, int __flag, const char *__fmt, ...) + __attribute__ ((__format__ (__printf__, 3, 4))); + +-#ifdef __va_arg_pack ++#if defined __use_clang_fortify && __USE_MISC ++/* clang doesn't support __va_arg_pack, so this is only possible if we have ++ vsyslog. */ ++__fortify_overload __attribute__ ((__format__ (__printf__, 2, 3))) void ++syslog (int __pri, const char *const __clang_pass_object_size __fmt, ...) ++{ ++ __gnuc_va_list __ap; ++ va_start (__ap, __fmt); ++ __vsyslog_chk (__pri, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); ++ va_end (__ap); ++} ++#elif defined __va_arg_pack + __fortify_function void + syslog (int __pri, const char *__fmt, ...) + { +@@ -34,16 +57,3 @@ syslog (int __pri, const char *__fmt, ...) + # define syslog(pri, ...) \ + __syslog_chk (pri, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) + #endif +- +- +-#ifdef __USE_MISC +-extern void __vsyslog_chk (int __pri, int __flag, const char *__fmt, +- __gnuc_va_list __ap) +- __attribute__ ((__format__ (__printf__, 3, 0))); +- +-__fortify_function void +-vsyslog (int __pri, const char *__fmt, __gnuc_va_list __ap) +-{ +- __vsyslog_chk (__pri, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); +-} +-#endif +diff --git a/misc/sys/cdefs.h b/misc/sys/cdefs.h +index ff7144f3f3..a42ffd5d36 100644 +--- a/misc/sys/cdefs.h ++++ b/misc/sys/cdefs.h +@@ -118,11 +118,150 @@ + # define __END_DECLS + #endif + ++#if defined __clang__ && defined __has_extension ++# define __clang_has_extension(x) __has_extension (x) ++#else ++# define __clang_has_extension(x) 0 ++#endif + + /* Fortify support. */ +-#define __bos(ptr) __builtin_object_size (ptr, __USE_FORTIFY_LEVEL > 1) ++#define __fortify_function __extern_always_inline __attribute_artificial__ ++#if defined __clang__ && __USE_FORTIFY_LEVEL > 0 \ ++ && !defined _CLANG_FORTIFY_DISABLE \ ++ && __clang_has_extension(overloadable_unmarked) ++# define __use_clang_fortify 1 ++/* Clang-style FORTIFY creates a different symbol for each FORTIFY'ed function, ++ whereas GCC-style doesn't. Thus, GCC can assume that the FORTIFY'ed ++ function is always available externally, but clang can't. */ ++# define __attribute_overloadable__ __attribute__ ((__overloadable__)) ++# define __attribute_transparent_overload__ \ ++ __attribute__ ((__overloadable__("transparent"))) ++# define __fortify_overload static __always_inline __attribute_overloadable__ ++/* For FORTIFY functions that exist only as decls. */ ++# define __fortify_error_function static __attribute_overloadable__ ++# define __clang_pass_object_size_n(n) __attribute__ ((pass_object_size (n))) ++# define __clang_warning(what) __attribute__ ((deprecated(what))) ++# define __clang_prefer_this_overload __attribute__ ((enable_if (1, ""))) ++# define __clang_warning_if(c, m) \ ++ __attribute__ ((__diagnose_if__ ((c), (m), "warning"))) ++# define __clang_error(what) __attribute__ ((unavailable(what))) ++# define __clang_error_if(c, m) \ ++ __attribute__ ((__diagnose_if__ ((c), (m), "error"))) ++# define __fortify_potential_overload __fortify_overload ++#else ++# define __fortify_potential_overload __fortify_function ++/* Some functions/decls can be shared between clang and non-clang FORTIFY. ++ Turning these into nops makes that possible. */ ++# define __clang_pass_object_size_n(n) ++# define __attribute_overloadable__ ++# define __bos_n(ptr, n) __builtin_object_size (ptr, n) ++# define __clang_warning_if(c, m) ++# define __clang_error_if(c, m) ++#endif ++ ++#define __bos_level (__USE_FORTIFY_LEVEL > 1) ++#define __bos(ptr) __builtin_object_size (ptr, __bos_level) + #define __bos0(ptr) __builtin_object_size (ptr, 0) + ++#define __clang_pass_object_size0 __clang_pass_object_size_n (0) ++#define __clang_pass_object_size __clang_pass_object_size_n (__bos_level) ++ ++/* Some of these macros are awkwardly written, and more repetitive than they'd ++ ideally need to be. This is because both clang and gcc will emit 'note's ++ about where these warnings originate from. For every macro that's expanded, ++ the user sees a note that ultimately doesn't matter to them... */ ++#ifdef __use_clang_fortify ++# define __FORTIFY_PRECONDITIONS ++# define __FORTIFY_FUNCTION_END ++# define __FORTIFY_WARNING_IF(_, c, msg) __clang_warning_if(c, msg) ++/* __builtin_constant_p isn't needed: this is only used in constructs that ++ must be fully evaluated at compile-time. */ ++# define __bos_static_lt_impl(bos_val, n, s) \ ++ ((bos_val) != -1ULL && (n) > (bos_val) / (s)) ++# define __FORTIFY_CALL_CHK 1 ++ ++# define __FORTIFY_BOSN_ARGS(bos_fn, n, buf, div, complaint) \ ++ (__bos_static_lt_impl (bos_fn (buf), n, div)), (complaint), "warning" ++ ++#define __FORTIFY_WARNING_ONLY_IF_BOS0_LT2(fn_name, n, buf, div, complaint) \ ++ __attribute__ ((__diagnose_if__ \ ++ (__FORTIFY_BOSN_ARGS (__bos0, n, buf, div, complaint)))) ++#define __FORTIFY_WARNING_ONLY_IF_BOS0_LT(fn_name, n, buf, complaint) \ ++ __attribute__ ((__diagnose_if__ \ ++ (__FORTIFY_BOSN_ARGS (__bos0, n, buf, 1, complaint)))) ++#define __FORTIFY_WARNING_ONLY_IF_BOS_LT2(fn_name, n, buf, div, complaint) \ ++ __attribute__ ((__diagnose_if__ \ ++ (__FORTIFY_BOSN_ARGS (__bos, n, buf, div, complaint)))) ++#define __FORTIFY_WARNING_ONLY_IF_BOS_LT(fn_name, n, buf, complaint) \ ++ __attribute__ ((__diagnose_if__ \ ++ (__FORTIFY_BOSN_ARGS (__bos, n, buf, 1, complaint)))) ++#else ++# define __FORTIFY_PRECONDITIONS { ++# define __FORTIFY_FUNCTION_END } ++/* __chk_fail was chosen arbitrarily. The function should never be called ++ anyway; it just exists to be reachable after optimizations. */ ++# define __FORTIFY_DECLARE_WARNING_FUNCTION(name, msg) \ ++ __attribute ((__warning__(msg))) \ ++ extern void __REDIRECT_NTH (name, (void), __chk_fail) ++ ++# define __FORTIFY_WARNING_IF_BEGIN(fn_name, cond, complaint, if_cond_true) \ ++ { \ ++ if (cond) { \ ++ if_cond_true; \ ++ __FORTIFY_DECLARE_WARNING_FUNCTION (fn_name, complaint); \ ++ volatile char __t = 0; \ ++ if (__glibc_unlikely (__t)) \ ++ { ++ ++# define __FORTIFY_WARNING_IF_END \ ++ } \ ++ } \ ++ } ++ ++# define __FORTIFY_WARNING_IF(err_fn, cond, complaint) \ ++ __FORTIFY_WARNING_IF_BEGIN (err_fn, cond, complaint, (void)0) \ ++ err_fn (); \ ++ __FORTIFY_WARNING_IF_END ++ ++# define __bos_static_lt_impl(bos_val, n, s) \ ++ (__builtin_constant_p (n) && (bos_val) != -1ULL && (n) > (bos_val) / (s)) ++ ++#define __FORTIFY_BOS_WARNING_BEGIN(fn_name, bos_fn, n, buf, div, complaint) \ ++ char __need_dynamic_check = !__builtin_constant_p (n); \ ++ __FORTIFY_WARNING_IF_BEGIN (fn_name, \ ++ __bos_static_lt_impl (bos_fn (buf), n, div), \ ++ complaint, (__need_dynamic_check = 1)) ++ ++/* Duplicate this so that the fn_name call happens with the smallest possible ++ macro "call stack". This minimizes diagnostics about expanding macros. */ ++#define __FORTIFY_WARNING_ONLY_IF_BOS0_LT2(err_fn, n, buf, div, complaint) \ ++ __FORTIFY_BOS_WARNING_BEGIN (err_fn, __bos0, n, buf, div, complaint) \ ++ err_fn (); \ ++ __FORTIFY_WARNING_IF_END ++ ++#define __FORTIFY_WARNING_ONLY_IF_BOS0_LT(err_fn, n, buf, complaint) \ ++ __FORTIFY_BOS_WARNING_BEGIN (err_fn, __bos0, n, buf, 1, complaint) \ ++ err_fn (); \ ++ __FORTIFY_WARNING_IF_END ++ ++#define __FORTIFY_WARNING_ONLY_IF_BOS_LT2(err_fn, n, buf, div, complaint) \ ++ __FORTIFY_BOS_WARNING_BEGIN (err_fn, __bos, n, buf, div, complaint) \ ++ err_fn (); \ ++ __FORTIFY_WARNING_IF_END ++ ++#define __FORTIFY_WARNING_ONLY_IF_BOS_LT(err_fn, n, buf, complaint) \ ++ __FORTIFY_BOS_WARNING_BEGIN (err_fn, __bos, n, buf, 1, complaint) \ ++ err_fn (); \ ++ __FORTIFY_WARNING_IF_END ++ ++# define __FORTIFY_CALL_CHK (__need_dynamic_check) ++#endif ++ ++#define __bos_static_lt2(n, e, s) __bos_static_lt_impl (__bos (e), n, s) ++#define __bos_static_lt(n, e) __bos_static_lt2 (n, e, 1) ++#define __bos0_static_lt2(n, e, s) __bos_static_lt_impl (__bos0 (e), n, s) ++#define __bos0_static_lt(n, e) __bos0_static_lt2 (n, e, 1) ++ + #if __GNUC_PREREQ (4,3) + # define __warndecl(name, msg) \ + extern void name (void) __attribute__((__warning__ (msg))) +@@ -363,6 +502,29 @@ + # define __va_arg_pack_len() __builtin_va_arg_pack_len () + #endif + ++#if defined(__use_clang_fortify) ++/* clang doesn't support __va_arg_pack, so we need to call the v* version of ++ FORTIFY'ed functions. */ ++#define __FORTIFY_ARG_PACK __fortify_ap ++#define __FORTIFY_INIT_ARG_PACK(va_arg) \ ++ __gnuc_va_list __FORTIFY_ARG_PACK; \ ++ va_start (__FORTIFY_ARG_PACK, va_arg) ++#define __FORTIFY_CALL_VA_ALIAS(fn, ...) __v##fn##_alias (__VA_ARGS__) ++#define __FORTIFY_CALL_VA_CHK(fn, ...) __v##fn##_chk (__VA_ARGS__) ++#define __FORTIFY_CALL_VA_BUILTIN(fn, ...) \ ++ __builtin___v##fn##_chk (__VA_ARGS__) ++#define __FORTIFY_FREE_ARG_PACK() va_end (__FORTIFY_ARG_PACK) ++#define __FORTIFY_ARG_PACK_OK 1 ++#elif defined(__va_arg_pack) ++#define __FORTIFY_ARG_PACK __va_arg_pack () ++#define __FORTIFY_INIT_ARG_PACK(va_arg) ++#define __FORTIFY_CALL_VA_ALIAS(fn, ...) __##fn##_alias (__VA_ARGS__) ++#define __FORTIFY_CALL_VA_CHK(fn, ...) __##fn##_chk (__VA_ARGS__) ++#define __FORTIFY_CALL_VA_BUILTIN(fn, ...) __builtin___##fn##_chk (__VA_ARGS__) ++#define __FORTIFY_FREE_ARG_PACK() ++#define __FORTIFY_ARG_PACK_OK 1 ++#endif ++ + /* It is possible to compile containing GCC extensions even if GCC is + run in pedantic mode if the uses are carefully marked using the + `__extension__' keyword. But this is not generally available before +diff --git a/posix/bits/unistd.h b/posix/bits/unistd.h +index b8a8211d83..895d87832e 100644 +--- a/posix/bits/unistd.h ++++ b/posix/bits/unistd.h +@@ -24,25 +24,19 @@ extern ssize_t __read_chk (int __fd, void *__buf, size_t __nbytes, + size_t __buflen) __wur; + extern ssize_t __REDIRECT (__read_alias, (int __fd, void *__buf, + size_t __nbytes), read) __wur; +-extern ssize_t __REDIRECT (__read_chk_warn, +- (int __fd, void *__buf, size_t __nbytes, +- size_t __buflen), __read_chk) +- __wur __warnattr ("read called with bigger length than size of " +- "the destination buffer"); + +-__fortify_function __wur ssize_t +-read (int __fd, void *__buf, size_t __nbytes) ++__fortify_potential_overload __wur ssize_t ++read (int __fd, void *const __clang_pass_object_size0 __buf, size_t __nbytes) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS0_LT (__read_warn, __nbytes, __buf, ++ "read called with bigger length than " ++ "size of the destination buffer") + { +- if (__bos0 (__buf) != (size_t) -1) +- { +- if (!__builtin_constant_p (__nbytes)) +- return __read_chk (__fd, __buf, __nbytes, __bos0 (__buf)); +- +- if (__nbytes > __bos0 (__buf)) +- return __read_chk_warn (__fd, __buf, __nbytes, __bos0 (__buf)); +- } ++ if (__FORTIFY_CALL_CHK && __bos0 (__buf) != (size_t) -1) ++ return __read_chk (__fd, __buf, __nbytes, __bos0 (__buf)); + return __read_alias (__fd, __buf, __nbytes); + } ++__FORTIFY_FUNCTION_END + + #ifdef __USE_UNIX98 + extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes, +@@ -55,67 +49,49 @@ extern ssize_t __REDIRECT (__pread_alias, + extern ssize_t __REDIRECT (__pread64_alias, + (int __fd, void *__buf, size_t __nbytes, + __off64_t __offset), pread64) __wur; +-extern ssize_t __REDIRECT (__pread_chk_warn, +- (int __fd, void *__buf, size_t __nbytes, +- __off_t __offset, size_t __bufsize), __pread_chk) +- __wur __warnattr ("pread called with bigger length than size of " +- "the destination buffer"); +-extern ssize_t __REDIRECT (__pread64_chk_warn, +- (int __fd, void *__buf, size_t __nbytes, +- __off64_t __offset, size_t __bufsize), +- __pread64_chk) +- __wur __warnattr ("pread64 called with bigger length than size of " +- "the destination buffer"); + + # ifndef __USE_FILE_OFFSET64 +-__fortify_function __wur ssize_t +-pread (int __fd, void *__buf, size_t __nbytes, __off_t __offset) +-{ +- if (__bos0 (__buf) != (size_t) -1) +- { +- if (!__builtin_constant_p (__nbytes)) +- return __pread_chk (__fd, __buf, __nbytes, __offset, __bos0 (__buf)); +- +- if ( __nbytes > __bos0 (__buf)) +- return __pread_chk_warn (__fd, __buf, __nbytes, __offset, +- __bos0 (__buf)); +- } +- return __pread_alias (__fd, __buf, __nbytes, __offset); +-} ++# define __fo_pread_chk __pread_chk ++# define __fo_pread_alias __pread_alias ++# define __fo_off_t __off_t + # else +-__fortify_function __wur ssize_t +-pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) +-{ +- if (__bos0 (__buf) != (size_t) -1) +- { +- if (!__builtin_constant_p (__nbytes)) +- return __pread64_chk (__fd, __buf, __nbytes, __offset, __bos0 (__buf)); +- +- if ( __nbytes > __bos0 (__buf)) +- return __pread64_chk_warn (__fd, __buf, __nbytes, __offset, +- __bos0 (__buf)); +- } +- +- return __pread64_alias (__fd, __buf, __nbytes, __offset); +-} ++# define __fo_pread_chk __pread64_chk ++# define __fo_pread_alias __pread64_alias ++# define __fo_off_t __off64_t + # endif + +-# ifdef __USE_LARGEFILE64 +-__fortify_function __wur ssize_t +-pread64 (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) ++__fortify_potential_overload __wur ssize_t ++pread (int __fd, void *const __clang_pass_object_size0 __buf, size_t __nbytes, ++ __fo_off_t __offset) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS0_LT (__pread_chk_warn, __nbytes, __buf, ++ "pread called with bigger length than " ++ "size of the destination buffer") + { +- if (__bos0 (__buf) != (size_t) -1) +- { +- if (!__builtin_constant_p (__nbytes)) +- return __pread64_chk (__fd, __buf, __nbytes, __offset, __bos0 (__buf)); ++ if (__FORTIFY_CALL_CHK && __bos0 (__buf) != (size_t) -1) ++ return __fo_pread_chk (__fd, __buf, __nbytes, __offset, __bos0 (__buf)); ++ return __fo_pread_alias (__fd, __buf, __nbytes, __offset); ++} ++__FORTIFY_FUNCTION_END + +- if ( __nbytes > __bos0 (__buf)) +- return __pread64_chk_warn (__fd, __buf, __nbytes, __offset, +- __bos0 (__buf)); +- } ++#undef __fo_pread_chk ++#undef __fo_pread_alias ++#undef __fo_off_t + ++# ifdef __USE_LARGEFILE64 ++__fortify_potential_overload __wur ssize_t ++pread64 (int __fd, void *const __clang_pass_object_size0 __buf, ++ size_t __nbytes, __off64_t __offset) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS0_LT (__pread64_warn, __nbytes, __buf, ++ "pread64 called with bigger length " ++ "than size of the destination buffer") ++{ ++ if (__FORTIFY_CALL_CHK && __bos0 (__buf) != (size_t) -1) ++ return __pread64_chk (__fd, __buf, __nbytes, __offset, __bos0 (__buf)); + return __pread64_alias (__fd, __buf, __nbytes, __offset); + } ++__FORTIFY_FUNCTION_END + # endif + #endif + +@@ -128,27 +104,21 @@ extern ssize_t __REDIRECT_NTH (__readlink_alias, + (const char *__restrict __path, + char *__restrict __buf, size_t __len), readlink) + __nonnull ((1, 2)) __wur; +-extern ssize_t __REDIRECT_NTH (__readlink_chk_warn, +- (const char *__restrict __path, +- char *__restrict __buf, size_t __len, +- size_t __buflen), __readlink_chk) +- __nonnull ((1, 2)) __wur __warnattr ("readlink called with bigger length " +- "than size of destination buffer"); + +-__fortify_function __nonnull ((1, 2)) __wur ssize_t +-__NTH (readlink (const char *__restrict __path, char *__restrict __buf, ++__fortify_potential_overload __nonnull ((1, 2)) __wur ssize_t ++__NTH (readlink (const char *__restrict __path, ++ char *__restrict const __clang_pass_object_size __buf, + size_t __len)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__readlink_warn, __len, __buf, ++ "readlink called with bigger length " ++ "than size of destination buffer") + { +- if (__bos (__buf) != (size_t) -1) +- { +- if (!__builtin_constant_p (__len)) +- return __readlink_chk (__path, __buf, __len, __bos (__buf)); +- +- if ( __len > __bos (__buf)) +- return __readlink_chk_warn (__path, __buf, __len, __bos (__buf)); +- } ++ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) ++ return __readlink_chk (__path, __buf, __len, __bos (__buf)); + return __readlink_alias (__path, __buf, __len); + } ++__FORTIFY_FUNCTION_END + #endif + + #ifdef __USE_ATFILE +@@ -161,119 +131,104 @@ extern ssize_t __REDIRECT_NTH (__readlinkat_alias, + char *__restrict __buf, size_t __len), + readlinkat) + __nonnull ((2, 3)) __wur; +-extern ssize_t __REDIRECT_NTH (__readlinkat_chk_warn, +- (int __fd, const char *__restrict __path, +- char *__restrict __buf, size_t __len, +- size_t __buflen), __readlinkat_chk) +- __nonnull ((2, 3)) __wur __warnattr ("readlinkat called with bigger " +- "length than size of destination " +- "buffer"); +- +-__fortify_function __nonnull ((2, 3)) __wur ssize_t +-__NTH (readlinkat (int __fd, const char *__restrict __path, +- char *__restrict __buf, size_t __len)) ++ ++__fortify_potential_overload __nonnull ((2, 3)) __wur ssize_t ++__NTH (readlinkat (int __fd, ++ const char *__restrict __path, ++ char *__restrict const __clang_pass_object_size __buf, ++ size_t __len)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__readlinkat_warn, __len, __buf, ++ "readlinkat called with bigger length " ++ "than size of destination buffer") + { +- if (__bos (__buf) != (size_t) -1) +- { +- if (!__builtin_constant_p (__len)) +- return __readlinkat_chk (__fd, __path, __buf, __len, __bos (__buf)); +- +- if (__len > __bos (__buf)) +- return __readlinkat_chk_warn (__fd, __path, __buf, __len, +- __bos (__buf)); +- } ++ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) ++ return __readlinkat_chk (__fd, __path, __buf, __len, __bos (__buf)); + return __readlinkat_alias (__fd, __path, __buf, __len); + } ++__FORTIFY_FUNCTION_END + #endif + + extern char *__getcwd_chk (char *__buf, size_t __size, size_t __buflen) + __THROW __wur; + extern char *__REDIRECT_NTH (__getcwd_alias, + (char *__buf, size_t __size), getcwd) __wur; +-extern char *__REDIRECT_NTH (__getcwd_chk_warn, +- (char *__buf, size_t __size, size_t __buflen), +- __getcwd_chk) +- __wur __warnattr ("getcwd caller with bigger length than size of " +- "destination buffer"); +- +-__fortify_function __wur char * +-__NTH (getcwd (char *__buf, size_t __size)) +-{ +- if (__bos (__buf) != (size_t) -1) +- { +- if (!__builtin_constant_p (__size)) +- return __getcwd_chk (__buf, __size, __bos (__buf)); + +- if (__size > __bos (__buf)) +- return __getcwd_chk_warn (__buf, __size, __bos (__buf)); +- } ++__fortify_potential_overload __wur char * ++__NTH (getcwd (char *const __clang_pass_object_size __buf, size_t __size)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__getcwd_warn, __size, __buf, ++ "getcwd called with bigger length than " ++ "size of destination buffer") ++{ ++ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) ++ return __getcwd_chk (__buf, __size, __bos (__buf)); + return __getcwd_alias (__buf, __size); + } ++__FORTIFY_FUNCTION_END + + #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED ++# define __warn_getwd_use_something_else \ ++ "please use getcwd instead, as getwd doesn't specify buffer size" ++ + extern char *__getwd_chk (char *__buf, size_t buflen) + __THROW __nonnull ((1)) __wur; + extern char *__REDIRECT_NTH (__getwd_warn, (char *__buf), getwd) +- __nonnull ((1)) __wur __warnattr ("please use getcwd instead, as getwd " +- "doesn't specify buffer size"); ++ __nonnull ((1)) __wur __warnattr (__warn_getwd_use_something_else); + +-__fortify_function __nonnull ((1)) __attribute_deprecated__ __wur char * +-__NTH (getwd (char *__buf)) ++extern char *__REDIRECT (__getwd_alias, (char *__str), getwd) __wur; ++ ++__fortify_potential_overload __nonnull ((1)) __attribute_deprecated__ __wur ++char * ++__NTH (getwd (char *const __clang_pass_object_size __buf)) ++ __clang_warning_if (__bos (__buf) == (size_t) -1, ++ __warn_getwd_use_something_else) + { + if (__bos (__buf) != (size_t) -1) + return __getwd_chk (__buf, __bos (__buf)); + return __getwd_warn (__buf); + } ++# undef __warn_getwd_use_something_else + #endif + + extern size_t __confstr_chk (int __name, char *__buf, size_t __len, + size_t __buflen) __THROW; + extern size_t __REDIRECT_NTH (__confstr_alias, (int __name, char *__buf, + size_t __len), confstr); +-extern size_t __REDIRECT_NTH (__confstr_chk_warn, +- (int __name, char *__buf, size_t __len, +- size_t __buflen), __confstr_chk) +- __warnattr ("confstr called with bigger length than size of destination " +- "buffer"); +- +-__fortify_function size_t +-__NTH (confstr (int __name, char *__buf, size_t __len)) +-{ +- if (__bos (__buf) != (size_t) -1) +- { +- if (!__builtin_constant_p (__len)) +- return __confstr_chk (__name, __buf, __len, __bos (__buf)); + +- if (__bos (__buf) < __len) +- return __confstr_chk_warn (__name, __buf, __len, __bos (__buf)); +- } ++__fortify_potential_overload size_t ++__NTH (confstr (int __name, char *const __clang_pass_object_size __buf, ++ size_t __len)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__confstr_warn, __len, __buf, ++ "confstr called with bigger length than " ++ "size of destination buffer") ++{ ++ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) ++ return __confstr_chk (__name, __buf, __len, __bos (__buf)); + return __confstr_alias (__name, __buf, __len); + } +- ++__FORTIFY_FUNCTION_END + + extern int __getgroups_chk (int __size, __gid_t __list[], size_t __listlen) + __THROW __wur; + extern int __REDIRECT_NTH (__getgroups_alias, (int __size, __gid_t __list[]), + getgroups) __wur; +-extern int __REDIRECT_NTH (__getgroups_chk_warn, +- (int __size, __gid_t __list[], size_t __listlen), +- __getgroups_chk) +- __wur __warnattr ("getgroups called with bigger group count than what " +- "can fit into destination buffer"); +- +-__fortify_function int +-__NTH (getgroups (int __size, __gid_t __list[])) ++ ++__fortify_potential_overload int ++__NTH (getgroups (int __size, __gid_t *const __clang_pass_object_size __list)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__getgroups_warn, ++ __size * sizeof (__gid_t), __list, ++ "getgroups called with bigger group " ++ "count than what can fit into " ++ "destination buffer") + { +- if (__bos (__list) != (size_t) -1) +- { +- if (!__builtin_constant_p (__size) || __size < 0) +- return __getgroups_chk (__size, __list, __bos (__list)); +- +- if (__size * sizeof (__gid_t) > __bos (__list)) +- return __getgroups_chk_warn (__size, __list, __bos (__list)); +- } ++ if (__FORTIFY_CALL_CHK && __bos (__list) != (size_t) -1) ++ return __getgroups_chk (__size, __list, __bos (__list)); + return __getgroups_alias (__size, __list); + } ++__FORTIFY_FUNCTION_END + + + extern int __ttyname_r_chk (int __fd, char *__buf, size_t __buflen, +@@ -287,19 +242,19 @@ extern int __REDIRECT_NTH (__ttyname_r_chk_warn, + __nonnull ((2)) __warnattr ("ttyname_r called with bigger buflen than " + "size of destination buffer"); + +-__fortify_function int +-__NTH (ttyname_r (int __fd, char *__buf, size_t __buflen)) ++__fortify_potential_overload int ++__NTH (ttyname_r (int __fd, char *const __clang_pass_object_size __buf, ++ size_t __buflen)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__ttyname_r_warn, __buflen, __buf, ++ "ttyname_r called with bigger buflen " ++ "than size of destination buffer") + { +- if (__bos (__buf) != (size_t) -1) +- { +- if (!__builtin_constant_p (__buflen)) +- return __ttyname_r_chk (__fd, __buf, __buflen, __bos (__buf)); +- +- if (__buflen > __bos (__buf)) +- return __ttyname_r_chk_warn (__fd, __buf, __buflen, __bos (__buf)); +- } +- return __ttyname_r_alias (__fd, __buf, __buflen); +-} ++ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) ++ return __ttyname_r_chk (__fd, __buf, __buflen, __bos (__buf)); ++ return __ttyname_r_alias (__fd, __buf, __buflen); ++ } ++__FORTIFY_FUNCTION_END + + + #ifdef __USE_POSIX199506 +@@ -307,25 +262,19 @@ extern int __getlogin_r_chk (char *__buf, size_t __buflen, size_t __nreal) + __nonnull ((1)); + extern int __REDIRECT (__getlogin_r_alias, (char *__buf, size_t __buflen), + getlogin_r) __nonnull ((1)); +-extern int __REDIRECT (__getlogin_r_chk_warn, +- (char *__buf, size_t __buflen, size_t __nreal), +- __getlogin_r_chk) +- __nonnull ((1)) __warnattr ("getlogin_r called with bigger buflen than " +- "size of destination buffer"); + +-__fortify_function int +-getlogin_r (char *__buf, size_t __buflen) ++__fortify_potential_overload int ++getlogin_r (char *const __clang_pass_object_size __buf, size_t __buflen) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__getlogin_r_warn, __buflen, __buf, ++ "getlogin_r called with bigger buflen " ++ "than size of destination buffer") + { +- if (__bos (__buf) != (size_t) -1) +- { +- if (!__builtin_constant_p (__buflen)) +- return __getlogin_r_chk (__buf, __buflen, __bos (__buf)); +- +- if (__buflen > __bos (__buf)) +- return __getlogin_r_chk_warn (__buf, __buflen, __bos (__buf)); +- } ++ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) ++ return __getlogin_r_chk (__buf, __buflen, __bos (__buf)); + return __getlogin_r_alias (__buf, __buflen); + } ++__FORTIFY_FUNCTION_END + #endif + + +@@ -334,25 +283,20 @@ extern int __gethostname_chk (char *__buf, size_t __buflen, size_t __nreal) + __THROW __nonnull ((1)); + extern int __REDIRECT_NTH (__gethostname_alias, (char *__buf, size_t __buflen), + gethostname) __nonnull ((1)); +-extern int __REDIRECT_NTH (__gethostname_chk_warn, +- (char *__buf, size_t __buflen, size_t __nreal), +- __gethostname_chk) +- __nonnull ((1)) __warnattr ("gethostname called with bigger buflen than " +- "size of destination buffer"); + +-__fortify_function int +-__NTH (gethostname (char *__buf, size_t __buflen)) ++__fortify_potential_overload int ++__NTH (gethostname (char *const __clang_pass_object_size __buf, ++ size_t __buflen)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__gethostname_warn, __buflen, __buf, ++ "gethostname called with bigger buflen " ++ "than size of destination buffer") + { +- if (__bos (__buf) != (size_t) -1) +- { +- if (!__builtin_constant_p (__buflen)) +- return __gethostname_chk (__buf, __buflen, __bos (__buf)); +- +- if (__buflen > __bos (__buf)) +- return __gethostname_chk_warn (__buf, __buflen, __bos (__buf)); +- } ++ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) ++ return __gethostname_chk (__buf, __buflen, __bos (__buf)); + return __gethostname_alias (__buf, __buflen); + } ++__FORTIFY_FUNCTION_END + #endif + + +@@ -362,24 +306,18 @@ extern int __getdomainname_chk (char *__buf, size_t __buflen, size_t __nreal) + extern int __REDIRECT_NTH (__getdomainname_alias, (char *__buf, + size_t __buflen), + getdomainname) __nonnull ((1)) __wur; +-extern int __REDIRECT_NTH (__getdomainname_chk_warn, +- (char *__buf, size_t __buflen, size_t __nreal), +- __getdomainname_chk) +- __nonnull ((1)) __wur __warnattr ("getdomainname called with bigger " +- "buflen than size of destination " +- "buffer"); +- +-__fortify_function int +-__NTH (getdomainname (char *__buf, size_t __buflen)) +-{ +- if (__bos (__buf) != (size_t) -1) +- { +- if (!__builtin_constant_p (__buflen)) +- return __getdomainname_chk (__buf, __buflen, __bos (__buf)); + +- if (__buflen > __bos (__buf)) +- return __getdomainname_chk_warn (__buf, __buflen, __bos (__buf)); +- } ++__fortify_potential_overload int ++__NTH (getdomainname (char *const __clang_pass_object_size __buf, ++ size_t __buflen)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__getdomainname_warn, __buflen, __buf, ++ "getdomainname called with bigger " ++ "buflen than size of destination buffer") ++{ ++ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) ++ return __getdomainname_chk (__buf, __buflen, __bos (__buf)); + return __getdomainname_alias (__buf, __buflen); + } ++__FORTIFY_FUNCTION_END + #endif +diff --git a/rt/bits/mqueue2.h b/rt/bits/mqueue2.h +index 354f0d53bf..388b63a4f8 100644 +--- a/rt/bits/mqueue2.h ++++ b/rt/bits/mqueue2.h +@@ -29,10 +29,47 @@ extern mqd_t __mq_open_2 (const char *__name, int __oflag) + extern mqd_t __REDIRECT_NTH (__mq_open_alias, (const char *__name, + int __oflag, ...), mq_open) + __nonnull ((1)); ++ ++#define __warn_mq_open_wrong_number_of_args "mq_open can be called either " \ ++ "with 2 or 4 arguments" ++#define __warn_mq_open_missing_mode_and_attr "mq_open with O_CREAT in " \ ++ "second argument needs 4 arguments" ++#ifdef __use_clang_fortify ++__fortify_overload __clang_error (__warn_mq_open_wrong_number_of_args) mqd_t ++__NTH (mq_open (const char *const __clang_pass_object_size __name, int __oflag, ++ int __mode)) ++{ ++ return __mq_open_alias (__name, __oflag, __mode); ++} ++ ++__fortify_overload __clang_error (__warn_mq_open_wrong_number_of_args) ++mqd_t ++__NTH (mq_open (const char *const __clang_pass_object_size __name, int __oflag, ++ int __mode, struct mq_attr *__attr, ...)) ++{ ++ return __mq_open_alias (__name, __oflag, __mode, __attr); ++} ++ ++__fortify_overload __clang_prefer_this_overload mqd_t ++__NTH (mq_open (const char *const __clang_pass_object_size __name, ++ int __oflag)) ++ __clang_error_if ((__oflag & O_CREAT), ++ __warn_mq_open_missing_mode_and_attr) ++{ ++ return __mq_open_alias (__name, __oflag); ++} ++ ++__fortify_overload __clang_prefer_this_overload mqd_t ++__NTH (mq_open (const char *const __clang_pass_object_size __name, int __oflag, ++ int __mode, struct mq_attr *__attr)) ++{ ++ return __mq_open_alias (__name, __oflag, __mode, __attr); ++} ++#else + __errordecl (__mq_open_wrong_number_of_args, +- "mq_open can be called either with 2 or 4 arguments"); ++ __warn_mq_open_wrong_number_of_args); + __errordecl (__mq_open_missing_mode_and_attr, +- "mq_open with O_CREAT in second argument needs 4 arguments"); ++ __warn_mq_open_missing_mode_and_attr); + + __fortify_function mqd_t + __NTH (mq_open (const char *__name, int __oflag, ...)) +@@ -55,3 +92,6 @@ __NTH (mq_open (const char *__name, int __oflag, ...)) + + return __mq_open_alias (__name, __oflag, __va_arg_pack ()); + } ++#endif ++#undef __warn_mq_open_wrong_number_of_args ++#undef __warn_mq_open_missing_mode_and_attr +diff --git a/rt/mqueue.h b/rt/mqueue.h +index a2a2aa1771..5a2976d1be 100644 +--- a/rt/mqueue.h ++++ b/rt/mqueue.h +@@ -89,7 +89,7 @@ extern int mq_timedsend (mqd_t __mqdes, const char *__msg_ptr, + + /* Define some inlines helping to catch common problems. */ + #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function \ +- && defined __va_arg_pack_len ++ && (defined __va_arg_pack_len || defined __use_clang_fortify) + # include + #endif + +diff --git a/socket/bits/socket2.h b/socket/bits/socket2.h +index c0421ce244..12d2e75f57 100644 +--- a/socket/bits/socket2.h ++++ b/socket/bits/socket2.h +@@ -24,25 +24,20 @@ extern ssize_t __recv_chk (int __fd, void *__buf, size_t __n, size_t __buflen, + int __flags); + extern ssize_t __REDIRECT (__recv_alias, (int __fd, void *__buf, size_t __n, + int __flags), recv); +-extern ssize_t __REDIRECT (__recv_chk_warn, +- (int __fd, void *__buf, size_t __n, size_t __buflen, +- int __flags), __recv_chk) +- __warnattr ("recv called with bigger length than size of destination " +- "buffer"); + +-__fortify_function ssize_t +-recv (int __fd, void *__buf, size_t __n, int __flags) ++__fortify_potential_overload ssize_t ++recv (int __fd, void *const __clang_pass_object_size0 __buf, size_t __n, ++ int __flags) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS0_LT (__recv_warn, __n, __buf, ++ "recv called with bigger length than " ++ "size of destination buffer") + { +- if (__bos0 (__buf) != (size_t) -1) +- { +- if (!__builtin_constant_p (__n)) +- return __recv_chk (__fd, __buf, __n, __bos0 (__buf), __flags); +- +- if (__n > __bos0 (__buf)) +- return __recv_chk_warn (__fd, __buf, __n, __bos0 (__buf), __flags); +- } ++ if (__FORTIFY_CALL_CHK && __bos0 (__buf) != (size_t) -1) ++ return __recv_chk (__fd, __buf, __n, __bos0 (__buf), __flags); + return __recv_alias (__fd, __buf, __n, __flags); + } ++__FORTIFY_FUNCTION_END + + extern ssize_t __recvfrom_chk (int __fd, void *__restrict __buf, size_t __n, + size_t __buflen, int __flags, +@@ -52,26 +47,19 @@ extern ssize_t __REDIRECT (__recvfrom_alias, + (int __fd, void *__restrict __buf, size_t __n, + int __flags, __SOCKADDR_ARG __addr, + socklen_t *__restrict __addr_len), recvfrom); +-extern ssize_t __REDIRECT (__recvfrom_chk_warn, +- (int __fd, void *__restrict __buf, size_t __n, +- size_t __buflen, int __flags, +- __SOCKADDR_ARG __addr, +- socklen_t *__restrict __addr_len), __recvfrom_chk) +- __warnattr ("recvfrom called with bigger length than size of " +- "destination buffer"); + +-__fortify_function ssize_t +-recvfrom (int __fd, void *__restrict __buf, size_t __n, int __flags, +- __SOCKADDR_ARG __addr, socklen_t *__restrict __addr_len) ++__fortify_potential_overload ssize_t ++recvfrom (int __fd, void *__restrict const __clang_pass_object_size0 __buf, ++ size_t __n, int __flags, __SOCKADDR_ARG __addr, ++ socklen_t *__restrict __addr_len) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS0_LT (__recvfrom_warn, __n, __buf, ++ "recvfrom called with bigger length " ++ "than size of destination buffer") + { +- if (__bos0 (__buf) != (size_t) -1) +- { +- if (!__builtin_constant_p (__n)) +- return __recvfrom_chk (__fd, __buf, __n, __bos0 (__buf), __flags, +- __addr, __addr_len); +- if (__n > __bos0 (__buf)) +- return __recvfrom_chk_warn (__fd, __buf, __n, __bos0 (__buf), __flags, +- __addr, __addr_len); +- } ++ if (__FORTIFY_CALL_CHK && __bos0 (__buf) != (size_t) -1) ++ return __recvfrom_chk (__fd, __buf, __n, __bos0 (__buf), __flags, __addr, ++ __addr_len); + return __recvfrom_alias (__fd, __buf, __n, __flags, __addr, __addr_len); + } ++__FORTIFY_FUNCTION_END +diff --git a/stdlib/bits/stdlib.h b/stdlib/bits/stdlib.h +index bfdee75073..a15f965b12 100644 +--- a/stdlib/bits/stdlib.h ++++ b/stdlib/bits/stdlib.h +@@ -26,27 +26,27 @@ extern char *__realpath_chk (const char *__restrict __name, + extern char *__REDIRECT_NTH (__realpath_alias, + (const char *__restrict __name, + char *__restrict __resolved), realpath) __wur; +-extern char *__REDIRECT_NTH (__realpath_chk_warn, +- (const char *__restrict __name, +- char *__restrict __resolved, +- size_t __resolvedlen), __realpath_chk) __wur +- __warnattr ("second argument of realpath must be either NULL or at " +- "least PATH_MAX bytes long buffer"); + +-__fortify_function __wur char * +-__NTH (realpath (const char *__restrict __name, char *__restrict __resolved)) ++__fortify_potential_overload __wur char * ++__NTH (realpath (const char *__restrict __name, ++ char *__restrict const __clang_pass_object_size __resolved)) ++__FORTIFY_PRECONDITIONS ++#if defined _LIBC_LIMITS_H_ && defined PATH_MAX ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__realpath_warn, PATH_MAX, __resolved, ++ "second argument of realpath must be " ++ "either NULL or at least PATH_MAX " ++ "bytes long buffer") ++#endif + { +- if (__bos (__resolved) != (size_t) -1) +- { ++ if ( + #if defined _LIBC_LIMITS_H_ && defined PATH_MAX +- if (__bos (__resolved) < PATH_MAX) +- return __realpath_chk_warn (__name, __resolved, __bos (__resolved)); ++ __FORTIFY_CALL_CHK && + #endif +- return __realpath_chk (__name, __resolved, __bos (__resolved)); +- } +- ++ __bos (__resolved) != (size_t) -1) ++ return __realpath_chk (__name, __resolved, __bos (__resolved)); + return __realpath_alias (__name, __resolved); + } ++__FORTIFY_FUNCTION_END + + + extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen, +@@ -54,33 +54,28 @@ extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen, + extern int __REDIRECT_NTH (__ptsname_r_alias, (int __fd, char *__buf, + size_t __buflen), ptsname_r) + __nonnull ((2)); +-extern int __REDIRECT_NTH (__ptsname_r_chk_warn, +- (int __fd, char *__buf, size_t __buflen, +- size_t __nreal), __ptsname_r_chk) +- __nonnull ((2)) __warnattr ("ptsname_r called with buflen bigger than " +- "size of buf"); +- +-__fortify_function int +-__NTH (ptsname_r (int __fd, char *__buf, size_t __buflen)) ++ ++__fortify_potential_overload int ++__NTH (ptsname_r (int __fd, char *const __clang_pass_object_size __buf, ++ size_t __buflen)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__ptsname_r_warn, __buflen, __buf, ++ "ptsname_r called with buflen " ++ "bigger than size of buf") + { +- if (__bos (__buf) != (size_t) -1) +- { +- if (!__builtin_constant_p (__buflen)) +- return __ptsname_r_chk (__fd, __buf, __buflen, __bos (__buf)); +- if (__buflen > __bos (__buf)) +- return __ptsname_r_chk_warn (__fd, __buf, __buflen, __bos (__buf)); +- } ++ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) ++ return __ptsname_r_chk (__fd, __buf, __buflen, __bos (__buf)); + return __ptsname_r_alias (__fd, __buf, __buflen); + } +- ++__FORTIFY_FUNCTION_END + + extern int __wctomb_chk (char *__s, wchar_t __wchar, size_t __buflen) + __THROW __wur; + extern int __REDIRECT_NTH (__wctomb_alias, (char *__s, wchar_t __wchar), + wctomb) __wur; + +-__fortify_function __wur int +-__NTH (wctomb (char *__s, wchar_t __wchar)) ++__fortify_potential_overload __wur int ++__NTH (wctomb (char *const __clang_pass_object_size __s, wchar_t __wchar)) + { + /* We would have to include to get a definition of MB_LEN_MAX. + But this would only disturb the namespace. So we define our own +@@ -102,29 +97,22 @@ extern size_t __REDIRECT_NTH (__mbstowcs_alias, + (wchar_t *__restrict __dst, + const char *__restrict __src, + size_t __len), mbstowcs); +-extern size_t __REDIRECT_NTH (__mbstowcs_chk_warn, +- (wchar_t *__restrict __dst, +- const char *__restrict __src, +- size_t __len, size_t __dstlen), __mbstowcs_chk) +- __warnattr ("mbstowcs called with dst buffer smaller than len " +- "* sizeof (wchar_t)"); + +-__fortify_function size_t +-__NTH (mbstowcs (wchar_t *__restrict __dst, const char *__restrict __src, +- size_t __len)) ++__fortify_potential_overload size_t ++__NTH (mbstowcs (wchar_t *__restrict const __clang_pass_object_size __dst, ++ const char *__restrict __src, size_t __len)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT2 (__mbstowcs_warn, __len, __dst, ++ sizeof (wchar_t), ++ "mbstowcs called with dst buffer " ++ "smaller than len * sizeof (wchar_t)") + { +- if (__bos (__dst) != (size_t) -1) +- { +- if (!__builtin_constant_p (__len)) +- return __mbstowcs_chk (__dst, __src, __len, +- __bos (__dst) / sizeof (wchar_t)); +- +- if (__len > __bos (__dst) / sizeof (wchar_t)) +- return __mbstowcs_chk_warn (__dst, __src, __len, +- __bos (__dst) / sizeof (wchar_t)); +- } ++ if (__FORTIFY_CALL_CHK && __bos (__dst) != (size_t) -1) ++ return __mbstowcs_chk (__dst, __src, __len, ++ __bos (__dst) / sizeof (wchar_t)); + return __mbstowcs_alias (__dst, __src, __len); + } ++__FORTIFY_FUNCTION_END + + + extern size_t __wcstombs_chk (char *__restrict __dst, +@@ -134,22 +122,17 @@ extern size_t __REDIRECT_NTH (__wcstombs_alias, + (char *__restrict __dst, + const wchar_t *__restrict __src, + size_t __len), wcstombs); +-extern size_t __REDIRECT_NTH (__wcstombs_chk_warn, +- (char *__restrict __dst, +- const wchar_t *__restrict __src, +- size_t __len, size_t __dstlen), __wcstombs_chk) +- __warnattr ("wcstombs called with dst buffer smaller than len"); + +-__fortify_function size_t +-__NTH (wcstombs (char *__restrict __dst, const wchar_t *__restrict __src, +- size_t __len)) ++__fortify_potential_overload size_t ++__NTH (wcstombs (char *__restrict const __clang_pass_object_size __dst, ++ const wchar_t *__restrict __src, size_t __len)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__wcstombs_warn, __len, __dst, ++ "wcstombs called with dst buffer " ++ "smaller than len") + { +- if (__bos (__dst) != (size_t) -1) +- { +- if (!__builtin_constant_p (__len)) +- return __wcstombs_chk (__dst, __src, __len, __bos (__dst)); +- if (__len > __bos (__dst)) +- return __wcstombs_chk_warn (__dst, __src, __len, __bos (__dst)); +- } ++ if (__FORTIFY_CALL_CHK && __bos (__dst) != (size_t) -1) ++ return __wcstombs_chk (__dst, __src, __len, __bos (__dst)); + return __wcstombs_alias (__dst, __src, __len); + } ++__FORTIFY_FUNCTION_END +diff --git a/string/bits/string_fortified.h b/string/bits/string_fortified.h +index e4d07cb50c..f73528ba7e 100644 +--- a/string/bits/string_fortified.h ++++ b/string/bits/string_fortified.h +@@ -22,45 +22,82 @@ + # error "Never use directly; include instead." + #endif + +-#if !__GNUC_PREREQ (5,0) +-__warndecl (__warn_memset_zero_len, +- "memset used with constant zero length parameter; this could be due to transposed parameters"); +-#endif +- +-__fortify_function void * +-__NTH (memcpy (void *__restrict __dest, const void *__restrict __src, +- size_t __len)) ++#define __warn_len_too_large \ ++ "function called with bigger length than the destination buffer" ++/* Repeat bodies here to reduce 'note's if we detect a problem. */ ++#define __size_too_small(bos, dest, len) \ ++ (bos (dest) != (size_t) -1 && bos (dest) < len) ++#define __warn_if_dest_too_small(dest, len) \ ++ __clang_warning_if (__size_too_small (__bos, dest, len), \ ++ __warn_len_too_large) ++#define __warn_if_dest_too_small0(dest, len) \ ++ __clang_warning_if (__size_too_small (__bos0, dest, len), \ ++ __warn_len_too_large) ++ ++#define __warn_input_str_too_large \ ++ "destination buffer will always be overflown by source" ++#define __warn_if_src_too_large(dest, src) \ ++ __clang_warning_if (__size_too_small (__bos, dest, __builtin_strlen (src) + 1), \ ++ __warn_input_str_too_large) ++ ++__fortify_potential_overload void * ++__NTH (memcpy (void *__restrict const __clang_pass_object_size0 __dest, ++ const void *__restrict __src, size_t __len)) ++ __warn_if_dest_too_small0 (__dest, __len) + { +- return __builtin___memcpy_chk (__dest, __src, __len, __bos0 (__dest)); ++ size_t __bos_dst = __bos0 (__dest); ++ if (__bos_dst == (size_t) -1 || (__builtin_constant_p (__len) ++ && __bos_dst >= __len)) ++ return __builtin_memcpy (__dest, __src, __len); ++ return __builtin___memcpy_chk (__dest, __src, __len, __bos_dst); + } + +-__fortify_function void * +-__NTH (memmove (void *__dest, const void *__src, size_t __len)) ++__fortify_potential_overload void * ++__NTH (memmove (void *const __clang_pass_object_size0 __dest, ++ const void *__src, size_t __len)) ++ __warn_if_dest_too_small0 (__dest, __len) + { +- return __builtin___memmove_chk (__dest, __src, __len, __bos0 (__dest)); ++ size_t __bos_dst = __bos0 (__dest); ++ if (__bos_dst == (size_t) -1 || (__builtin_constant_p (__len) ++ && __bos_dst >= __len)) ++ return __builtin_memmove (__dest, __src, __len); ++ return __builtin___memmove_chk (__dest, __src, __len, __bos_dst); + } + + #ifdef __USE_GNU +-__fortify_function void * +-__NTH (mempcpy (void *__restrict __dest, const void *__restrict __src, +- size_t __len)) ++__fortify_potential_overload void * ++__NTH (mempcpy (void *__restrict const __clang_pass_object_size0 __dest, ++ const void *__restrict __src, size_t __len)) ++ __warn_if_dest_too_small0 (__dest, __len) + { +- return __builtin___mempcpy_chk (__dest, __src, __len, __bos0 (__dest)); ++ size_t __bos_dst = __bos0 (__dest); ++ if (__bos_dst == (size_t) -1 || (__builtin_constant_p (__len) ++ && __bos_dst >= __len)) ++ return __builtin_mempcpy (__dest, __src, __len); ++ return __builtin___mempcpy_chk (__dest, __src, __len, __bos_dst); + } + #endif + +- + /* The first two tests here help to catch a somewhat common problem + where the second and third parameter are transposed. This is + especially problematic if the intended fill value is zero. In this + case no work is done at all. We detect these problems by referring + non-existing functions. */ +-__fortify_function void * +-__NTH (memset (void *__dest, int __ch, size_t __len)) ++#define __warn_memset_zero_len_msg \ ++ "memset used with constant zero length parameter; this could be due to " \ ++ "transposed parameters" ++#if !__GNUC_PREREQ (5,0) ++__warndecl (__warn_memset_zero_len, __warn_memset_zero_len_msg); ++#endif ++__fortify_potential_overload void * ++__NTH (memset (void *const __clang_pass_object_size0 __dest, int __ch, ++ size_t __len)) ++ __warn_if_dest_too_small0 (__dest, __len) ++ __clang_warning_if (__len == 0 && __ch != 0, __warn_memset_zero_len_msg) + { + /* GCC-5.0 and newer implements these checks in the compiler, so we don't + need them here. */ +-#if !__GNUC_PREREQ (5,0) ++#if !__GNUC_PREREQ (5,0) && !defined __use_clang_fortify + if (__builtin_constant_p (__len) && __len == 0 + && (!__builtin_constant_p (__ch) || __ch != 0)) + { +@@ -68,8 +105,13 @@ __NTH (memset (void *__dest, int __ch, size_t __len)) + return __dest; + } + #endif +- return __builtin___memset_chk (__dest, __ch, __len, __bos0 (__dest)); ++ size_t __bos_dst = __bos0 (__dest); ++ if (__bos_dst == (size_t) -1 || (__builtin_constant_p (__len) ++ && __bos_dst >= __len)) ++ return __builtin_memset (__dest, __ch, __len); ++ return __builtin___memset_chk (__dest, __ch, __len, __bos_dst); + } ++#undef __warn_memset_zero_len_msg + + #ifdef __USE_MISC + # include +@@ -84,24 +126,30 @@ __NTH (explicit_bzero (void *__dest, size_t __len)) + } + #endif + +-__fortify_function char * +-__NTH (strcpy (char *__restrict __dest, const char *__restrict __src)) ++__fortify_potential_overload char * ++__NTH (strcpy (char *__restrict const __clang_pass_object_size __dest, ++ const char *__restrict __src)) ++ __warn_if_src_too_large (__dest, __src) + { + return __builtin___strcpy_chk (__dest, __src, __bos (__dest)); + } + + #ifdef __USE_GNU +-__fortify_function char * +-__NTH (stpcpy (char *__restrict __dest, const char *__restrict __src)) ++__fortify_potential_overload char * ++__NTH (stpcpy (char *__restrict const __clang_pass_object_size __dest, ++ const char *__restrict __src)) ++ __warn_if_src_too_large (__dest, __src) + { + return __builtin___stpcpy_chk (__dest, __src, __bos (__dest)); + } + #endif + +- +-__fortify_function char * +-__NTH (strncpy (char *__restrict __dest, const char *__restrict __src, +- size_t __len)) ++__fortify_potential_overload char * ++__NTH (strncpy (char *__restrict const __clang_pass_object_size __dest, ++ const char *__restrict __src, size_t __len)) ++/* clang: Don't warn when __builtin_strlen (__src) < __bos (__dest), ++ but __len > __bos (__dest). The user should fix their code instead. */ ++ __warn_if_dest_too_small (__dest, __len) + { + return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest)); + } +@@ -112,28 +160,36 @@ extern char *__stpncpy_chk (char *__dest, const char *__src, size_t __n, + extern char *__REDIRECT_NTH (__stpncpy_alias, (char *__dest, const char *__src, + size_t __n), stpncpy); + +-__fortify_function char * +-__NTH (stpncpy (char *__dest, const char *__src, size_t __n)) ++__fortify_potential_overload char * ++__NTH (stpncpy (char *const __clang_pass_object_size __dest, const char *__src, ++ size_t __n)) ++ __warn_if_dest_too_small (__dest, __n) + { +- if (__bos (__dest) != (size_t) -1 +- && (!__builtin_constant_p (__n) || __n > __bos (__dest))) ++ if (__bos (__dest) != (size_t) -1) + return __stpncpy_chk (__dest, __src, __n, __bos (__dest)); + return __stpncpy_alias (__dest, __src, __n); + } + +- +-__fortify_function char * +-__NTH (strcat (char *__restrict __dest, const char *__restrict __src)) ++__fortify_potential_overload char * ++__NTH (strcat (char *__restrict const __clang_pass_object_size __dest, ++ const char *__restrict __src)) ++ __warn_if_src_too_large (__dest, __src) + { + return __builtin___strcat_chk (__dest, __src, __bos (__dest)); + } + +- +-__fortify_function char * +-__NTH (strncat (char *__restrict __dest, const char *__restrict __src, +- size_t __len)) ++__fortify_potential_overload char * ++__NTH (strncat (char *__restrict const __clang_pass_object_size __dest, ++ const char *__restrict __src, size_t __len)) ++ __warn_if_src_too_large (__dest, __src) + { + return __builtin___strncat_chk (__dest, __src, __len, __bos (__dest)); + } + ++#undef __warn_len_too_large ++#undef __size_too_small ++#undef __warn_if_dest_too_small ++#undef __warn_if_dest_too_small0 ++#undef __warn_input_str_too_large ++#undef __warn_if_src_too_large + #endif /* bits/string_fortified.h */ +diff --git a/string/bits/strings_fortified.h b/string/bits/strings_fortified.h +index d4091f4f69..4d0cd02612 100644 +--- a/string/bits/strings_fortified.h ++++ b/string/bits/strings_fortified.h +@@ -19,16 +19,40 @@ + #ifndef __STRINGS_FORTIFIED + # define __STRINGS_FORTIFIED 1 + +-__fortify_function void +-__NTH (bcopy (const void *__src, void *__dest, size_t __len)) ++#define __strings_warn_len_too_large \ ++ "function called with bigger length than the destination buffer" ++ ++#define __strings_size_too_small(dest, len) \ ++ (__bos0 (dest) != (size_t) -1 && __bos0 (dest) < len) ++ ++__fortify_potential_overload void ++__NTH (bcopy (const void *__src, void *const __clang_pass_object_size0 __dest, ++ size_t __len)) ++ __clang_warning_if (__strings_size_too_small (__dest, __len), ++ __strings_warn_len_too_large) + { +- (void) __builtin___memmove_chk (__dest, __src, __len, __bos0 (__dest)); ++ size_t __bos_dst = __bos0 (__dest); ++ if (__bos_dst == (size_t) -1 || (__builtin_constant_p (__len) ++ && __bos_dst >= __len)) ++ (void) __builtin_memmove (__dest, __src, __len); ++ else ++ (void) __builtin___memmove_chk (__dest, __src, __len, __bos_dst); + } + +-__fortify_function void +-__NTH (bzero (void *__dest, size_t __len)) ++__fortify_potential_overload void ++__NTH (bzero (void *const __clang_pass_object_size0 __dest, size_t __len)) ++ __clang_warning_if (__strings_size_too_small (__dest, __len), ++ __strings_warn_len_too_large) + { +- (void) __builtin___memset_chk (__dest, '\0', __len, __bos0 (__dest)); ++ size_t __bos_dst = __bos0 (__dest); ++ if (__bos_dst == (size_t) -1 || (__builtin_constant_p (__len) ++ && __bos_dst >= __len)) ++ (void) __builtin_memset (__dest, '\0', __len); ++ else ++ (void) __builtin___memset_chk (__dest, '\0', __len, __bos_dst); + } + ++ ++#undef __strings_size_too_small ++#undef __strings_warn_len_too_large + #endif +diff --git a/wcsmbs/bits/wchar2.h b/wcsmbs/bits/wchar2.h +index 86e8e23e76..1b0718119a 100644 +--- a/wcsmbs/bits/wchar2.h ++++ b/wcsmbs/bits/wchar2.h +@@ -20,7 +20,6 @@ + # error "Never include directly; use instead." + #endif + +- + extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n, + size_t __ns1) __THROW; +@@ -28,57 +27,42 @@ extern wchar_t *__REDIRECT_NTH (__wmemcpy_alias, + (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n), + wmemcpy); +-extern wchar_t *__REDIRECT_NTH (__wmemcpy_chk_warn, +- (wchar_t *__restrict __s1, +- const wchar_t *__restrict __s2, size_t __n, +- size_t __ns1), __wmemcpy_chk) +- __warnattr ("wmemcpy called with length bigger than size of destination " +- "buffer"); + +-__fortify_function wchar_t * +-__NTH (wmemcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, +- size_t __n)) ++__fortify_potential_overload wchar_t * ++__NTH (wmemcpy (wchar_t *__restrict const __clang_pass_object_size0 __s1, ++ const wchar_t *__restrict __s2, size_t __n)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS0_LT2 (__wmemcpy_warn, __n, __s1, ++ sizeof (wchar_t), ++ "wmemcpy called with length bigger " ++ "than size of destination buffer") + { +- if (__bos0 (__s1) != (size_t) -1) +- { +- if (!__builtin_constant_p (__n)) +- return __wmemcpy_chk (__s1, __s2, __n, +- __bos0 (__s1) / sizeof (wchar_t)); +- +- if (__n > __bos0 (__s1) / sizeof (wchar_t)) +- return __wmemcpy_chk_warn (__s1, __s2, __n, +- __bos0 (__s1) / sizeof (wchar_t)); +- } +- return __wmemcpy_alias (__s1, __s2, __n); ++ if (__FORTIFY_CALL_CHK && __bos0 (__s1) != (size_t)-1) ++ return __wmemcpy_chk(__s1, __s2, __n, __bos0(__s1) / sizeof (wchar_t)); ++ return __wmemcpy_alias(__s1, __s2, __n); + } +- ++__FORTIFY_FUNCTION_END + + extern wchar_t *__wmemmove_chk (wchar_t *__s1, const wchar_t *__s2, + size_t __n, size_t __ns1) __THROW; + extern wchar_t *__REDIRECT_NTH (__wmemmove_alias, (wchar_t *__s1, + const wchar_t *__s2, + size_t __n), wmemmove); +-extern wchar_t *__REDIRECT_NTH (__wmemmove_chk_warn, +- (wchar_t *__s1, const wchar_t *__s2, +- size_t __n, size_t __ns1), __wmemmove_chk) +- __warnattr ("wmemmove called with length bigger than size of destination " +- "buffer"); +- +-__fortify_function wchar_t * +-__NTH (wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)) ++ ++__fortify_potential_overload wchar_t * ++__NTH (wmemmove (wchar_t *const __clang_pass_object_size0 __s1, ++ const wchar_t *__s2, size_t __n)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS0_LT2 (__wmemmove_warn, __n, __s1, ++ sizeof (wchar_t), ++ "wmemmove called with length bigger " ++ "than size of destination buffer") + { +- if (__bos0 (__s1) != (size_t) -1) +- { +- if (!__builtin_constant_p (__n)) +- return __wmemmove_chk (__s1, __s2, __n, +- __bos0 (__s1) / sizeof (wchar_t)); +- +- if (__n > __bos0 (__s1) / sizeof (wchar_t)) +- return __wmemmove_chk_warn (__s1, __s2, __n, +- __bos0 (__s1) / sizeof (wchar_t)); +- } ++ if (__FORTIFY_CALL_CHK && __bos0 (__s1) != (size_t) -1) ++ return __wmemmove_chk (__s1, __s2, __n, __bos0 (__s1) / sizeof (wchar_t)); + return __wmemmove_alias (__s1, __s2, __n); + } ++__FORTIFY_FUNCTION_END + + + #ifdef __USE_GNU +@@ -89,29 +73,21 @@ extern wchar_t *__REDIRECT_NTH (__wmempcpy_alias, + (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, + size_t __n), wmempcpy); +-extern wchar_t *__REDIRECT_NTH (__wmempcpy_chk_warn, +- (wchar_t *__restrict __s1, +- const wchar_t *__restrict __s2, size_t __n, +- size_t __ns1), __wmempcpy_chk) +- __warnattr ("wmempcpy called with length bigger than size of destination " +- "buffer"); +- +-__fortify_function wchar_t * +-__NTH (wmempcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, +- size_t __n)) ++ ++__fortify_potential_overload wchar_t * ++__NTH(wmempcpy(wchar_t *__restrict const __clang_pass_object_size0 __s1, ++ const wchar_t *__restrict __s2, size_t __n)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS0_LT2 (__wmempcpy_warn, __n, __s1, ++ sizeof (wchar_t), ++ "wmempcpy called with length bigger " ++ "than size of destination buffer") + { +- if (__bos0 (__s1) != (size_t) -1) +- { +- if (!__builtin_constant_p (__n)) +- return __wmempcpy_chk (__s1, __s2, __n, +- __bos0 (__s1) / sizeof (wchar_t)); +- +- if (__n > __bos0 (__s1) / sizeof (wchar_t)) +- return __wmempcpy_chk_warn (__s1, __s2, __n, +- __bos0 (__s1) / sizeof (wchar_t)); +- } +- return __wmempcpy_alias (__s1, __s2, __n); ++ if (__FORTIFY_CALL_CHK && __bos0 (__s1) != (size_t)-1) ++ return __wmempcpy_chk(__s1, __s2, __n, __bos0(__s1) / sizeof (wchar_t)); ++ return __wmempcpy_alias(__s1, __s2, __n); + } ++__FORTIFY_FUNCTION_END + #endif + + +@@ -119,26 +95,21 @@ extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n, + size_t __ns) __THROW; + extern wchar_t *__REDIRECT_NTH (__wmemset_alias, (wchar_t *__s, wchar_t __c, + size_t __n), wmemset); +-extern wchar_t *__REDIRECT_NTH (__wmemset_chk_warn, +- (wchar_t *__s, wchar_t __c, size_t __n, +- size_t __ns), __wmemset_chk) +- __warnattr ("wmemset called with length bigger than size of destination " +- "buffer"); +- +-__fortify_function wchar_t * +-__NTH (wmemset (wchar_t *__s, wchar_t __c, size_t __n)) ++ ++__fortify_potential_overload wchar_t * ++__NTH (wmemset (wchar_t *const __clang_pass_object_size0 __s, wchar_t __c, ++ size_t __n)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS0_LT2 (__wmemset_warn, __n, __s, ++ sizeof (wchar_t), ++ "wmemset called with length bigger " ++ "than size of destination buffer") + { +- if (__bos0 (__s) != (size_t) -1) +- { +- if (!__builtin_constant_p (__n)) +- return __wmemset_chk (__s, __c, __n, __bos0 (__s) / sizeof (wchar_t)); +- +- if (__n > __bos0 (__s) / sizeof (wchar_t)) +- return __wmemset_chk_warn (__s, __c, __n, +- __bos0 (__s) / sizeof (wchar_t)); +- } ++ if (__FORTIFY_CALL_CHK && __bos0 (__s) != (size_t) -1) ++ return __wmemset_chk (__s, __c, __n, __bos0 (__s) / sizeof (wchar_t)); + return __wmemset_alias (__s, __c, __n); + } ++__FORTIFY_FUNCTION_END + + + extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest, +@@ -148,8 +119,9 @@ extern wchar_t *__REDIRECT_NTH (__wcscpy_alias, + (wchar_t *__restrict __dest, + const wchar_t *__restrict __src), wcscpy); + +-__fortify_function wchar_t * +-__NTH (wcscpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src)) ++__fortify_potential_overload wchar_t * ++__NTH (wcscpy (wchar_t *__restrict const __clang_pass_object_size __dest, ++ const wchar_t *__restrict __src)) + { + if (__bos (__dest) != (size_t) -1) + return __wcscpy_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t)); +@@ -164,8 +136,9 @@ extern wchar_t *__REDIRECT_NTH (__wcpcpy_alias, + (wchar_t *__restrict __dest, + const wchar_t *__restrict __src), wcpcpy); + +-__fortify_function wchar_t * +-__NTH (wcpcpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src)) ++__fortify_potential_overload wchar_t * ++__NTH (wcpcpy (wchar_t *__restrict const __clang_pass_object_size __dest, ++ const wchar_t *__restrict __src)) + { + if (__bos (__dest) != (size_t) -1) + return __wcpcpy_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t)); +@@ -180,28 +153,22 @@ extern wchar_t *__REDIRECT_NTH (__wcsncpy_alias, + (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, + size_t __n), wcsncpy); +-extern wchar_t *__REDIRECT_NTH (__wcsncpy_chk_warn, +- (wchar_t *__restrict __dest, +- const wchar_t *__restrict __src, +- size_t __n, size_t __destlen), __wcsncpy_chk) +- __warnattr ("wcsncpy called with length bigger than size of destination " +- "buffer"); + +-__fortify_function wchar_t * +-__NTH (wcsncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, +- size_t __n)) ++__fortify_potential_overload wchar_t * ++__NTH (wcsncpy (wchar_t *__restrict const __clang_pass_object_size __dest, ++ const wchar_t *__restrict __src, size_t __n)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT2 (__wcsncpy_warn, __n, __dest, ++ sizeof (wchar_t), ++ "wcsncpy called with length bigger " ++ "than size of destination buffer") + { +- if (__bos (__dest) != (size_t) -1) +- { +- if (!__builtin_constant_p (__n)) +- return __wcsncpy_chk (__dest, __src, __n, +- __bos (__dest) / sizeof (wchar_t)); +- if (__n > __bos (__dest) / sizeof (wchar_t)) +- return __wcsncpy_chk_warn (__dest, __src, __n, +- __bos (__dest) / sizeof (wchar_t)); +- } ++ if (__FORTIFY_CALL_CHK && __bos (__dest) != (size_t) -1) ++ return __wcsncpy_chk (__dest, __src, __n, ++ __bos (__dest) / sizeof (wchar_t)); + return __wcsncpy_alias (__dest, __src, __n); + } ++__FORTIFY_FUNCTION_END + + + extern wchar_t *__wcpncpy_chk (wchar_t *__restrict __dest, +@@ -211,29 +178,22 @@ extern wchar_t *__REDIRECT_NTH (__wcpncpy_alias, + (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, + size_t __n), wcpncpy); +-extern wchar_t *__REDIRECT_NTH (__wcpncpy_chk_warn, +- (wchar_t *__restrict __dest, +- const wchar_t *__restrict __src, +- size_t __n, size_t __destlen), __wcpncpy_chk) +- __warnattr ("wcpncpy called with length bigger than size of destination " +- "buffer"); + +-__fortify_function wchar_t * +-__NTH (wcpncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, +- size_t __n)) ++__fortify_potential_overload wchar_t * ++__NTH (wcpncpy (wchar_t *__restrict const __clang_pass_object_size __dest, ++ const wchar_t *__restrict __src, size_t __n)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT2 (__wcpncpy_warn, __n, __dest, ++ sizeof (wchar_t), ++ "wcpncpy called with length bigger " ++ "than size of destination buffer") + { +- if (__bos (__dest) != (size_t) -1) +- { +- if (!__builtin_constant_p (__n)) +- return __wcpncpy_chk (__dest, __src, __n, +- __bos (__dest) / sizeof (wchar_t)); +- if (__n > __bos (__dest) / sizeof (wchar_t)) +- return __wcpncpy_chk_warn (__dest, __src, __n, +- __bos (__dest) / sizeof (wchar_t)); +- } ++ if (__FORTIFY_CALL_CHK && __bos (__dest) != (size_t) -1) ++ return __wcpncpy_chk (__dest, __src, __n, ++ __bos (__dest) / sizeof (wchar_t)); + return __wcpncpy_alias (__dest, __src, __n); + } +- ++__FORTIFY_FUNCTION_END + + extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, +@@ -242,8 +202,9 @@ extern wchar_t *__REDIRECT_NTH (__wcscat_alias, + (wchar_t *__restrict __dest, + const wchar_t *__restrict __src), wcscat); + +-__fortify_function wchar_t * +-__NTH (wcscat (wchar_t *__restrict __dest, const wchar_t *__restrict __src)) ++__fortify_potential_overload wchar_t * ++__NTH (wcscat (wchar_t *__restrict const __clang_pass_object_size __dest, ++ const wchar_t *__restrict __src)) + { + if (__bos (__dest) != (size_t) -1) + return __wcscat_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t)); +@@ -259,9 +220,9 @@ extern wchar_t *__REDIRECT_NTH (__wcsncat_alias, + const wchar_t *__restrict __src, + size_t __n), wcsncat); + +-__fortify_function wchar_t * +-__NTH (wcsncat (wchar_t *__restrict __dest, const wchar_t *__restrict __src, +- size_t __n)) ++__fortify_potential_overload wchar_t * ++__NTH (wcsncat (wchar_t *__restrict const __clang_pass_object_size __dest, ++ const wchar_t *__restrict __src, size_t __n)) + { + if (__bos (__dest) != (size_t) -1) + return __wcsncat_chk (__dest, __src, __n, +@@ -280,16 +241,34 @@ extern int __REDIRECT_NTH_LDBL (__swprintf_alias, + const wchar_t *__restrict __fmt, ...), + swprintf); + +-#ifdef __va_arg_pack +-__fortify_function int +-__NTH (swprintf (wchar_t *__restrict __s, size_t __n, +- const wchar_t *__restrict __fmt, ...)) ++extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n, ++ int __flag, size_t __s_len, ++ const wchar_t *__restrict __format, ++ __gnuc_va_list __arg) ++ __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 0))) */; ++ ++extern int __REDIRECT_NTH_LDBL (__vswprintf_alias, ++ (wchar_t *__restrict __s, size_t __n, ++ const wchar_t *__restrict __fmt, ++ __gnuc_va_list __ap), vswprintf); ++ ++#ifdef __FORTIFY_ARG_PACK_OK ++__fortify_potential_overload int ++__NTH (swprintf (wchar_t *__restrict const __clang_pass_object_size __s, ++ size_t __n, const wchar_t *__restrict __fmt, ...)) + { ++ __FORTIFY_INIT_ARG_PACK(__fmt); ++ int __result; + if (__bos (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1) +- return __swprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, +- __bos (__s) / sizeof (wchar_t), +- __fmt, __va_arg_pack ()); +- return __swprintf_alias (__s, __n, __fmt, __va_arg_pack ()); ++ __result = __FORTIFY_CALL_VA_CHK(swprintf, __s, __n, ++ __USE_FORTIFY_LEVEL - 1, ++ __bos (__s) / sizeof (wchar_t), __fmt, ++ __FORTIFY_ARG_PACK); ++ else ++ __result = __FORTIFY_CALL_VA_ALIAS(swprintf, __s, __n, __fmt, ++ __FORTIFY_ARG_PACK); ++ __FORTIFY_FREE_ARG_PACK(); ++ return __result; + } + #elif !defined __cplusplus + /* XXX We might want to have support in gcc for swprintf. */ +@@ -300,20 +279,10 @@ __NTH (swprintf (wchar_t *__restrict __s, size_t __n, + : swprintf (s, n, __VA_ARGS__)) + #endif + +-extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n, +- int __flag, size_t __s_len, +- const wchar_t *__restrict __format, +- __gnuc_va_list __arg) +- __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 0))) */; +- +-extern int __REDIRECT_NTH_LDBL (__vswprintf_alias, +- (wchar_t *__restrict __s, size_t __n, +- const wchar_t *__restrict __fmt, +- __gnuc_va_list __ap), vswprintf); +- +-__fortify_function int +-__NTH (vswprintf (wchar_t *__restrict __s, size_t __n, +- const wchar_t *__restrict __fmt, __gnuc_va_list __ap)) ++__fortify_potential_overload int ++__NTH (vswprintf (wchar_t *__restrict const __clang_pass_object_size __s, ++ size_t __n, const wchar_t *__restrict __fmt, ++ __gnuc_va_list __ap)) + { + if (__bos (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1) + return __vswprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, +@@ -334,18 +303,27 @@ extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag, + extern int __vwprintf_chk (int __flag, const wchar_t *__restrict __format, + __gnuc_va_list __ap); + +-# ifdef __va_arg_pack +-__fortify_function int +-wprintf (const wchar_t *__restrict __fmt, ...) ++ ++#ifdef __FORTIFY_ARG_PACK_OK ++__fortify_potential_overload int ++wprintf (const wchar_t *__restrict const __clang_pass_object_size __fmt, ...) + { +- return __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ()); ++ __FORTIFY_INIT_ARG_PACK(__fmt); ++ int __r = __FORTIFY_CALL_VA_CHK (wprintf, __USE_FORTIFY_LEVEL - 1, __fmt, ++ __FORTIFY_ARG_PACK); ++ __FORTIFY_FREE_ARG_PACK(); ++ return __r; + } + +-__fortify_function int +-fwprintf (__FILE *__restrict __stream, const wchar_t *__restrict __fmt, ...) ++__fortify_potential_overload int ++fwprintf (__FILE *__restrict const __clang_pass_object_size __stream, ++ const wchar_t *__restrict __fmt, ...) + { +- return __fwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, +- __va_arg_pack ()); ++ __FORTIFY_INIT_ARG_PACK(__fmt); ++ int __r = __FORTIFY_CALL_VA_CHK (fwprintf, __stream, __USE_FORTIFY_LEVEL - 1, ++ __fmt, __FORTIFY_ARG_PACK); ++ __FORTIFY_FREE_ARG_PACK(); ++ return __r; + } + # elif !defined __cplusplus + # define wprintf(...) \ +@@ -354,14 +332,15 @@ fwprintf (__FILE *__restrict __stream, const wchar_t *__restrict __fmt, ...) + __fwprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) + # endif + +-__fortify_function int +-vwprintf (const wchar_t *__restrict __fmt, __gnuc_va_list __ap) ++__fortify_potential_overload int ++vwprintf (const wchar_t *__restrict const __clang_pass_object_size __fmt, ++ __gnuc_va_list __ap) + { + return __vwprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __ap); + } + +-__fortify_function int +-vfwprintf (__FILE *__restrict __stream, ++__fortify_potential_overload int ++vfwprintf (__FILE *__restrict const __clang_pass_object_size __stream, + const wchar_t *__restrict __fmt, __gnuc_va_list __ap) + { + return __vfwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); +@@ -374,27 +353,21 @@ extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n, + extern wchar_t *__REDIRECT (__fgetws_alias, + (wchar_t *__restrict __s, int __n, + __FILE *__restrict __stream), fgetws) __wur; +-extern wchar_t *__REDIRECT (__fgetws_chk_warn, +- (wchar_t *__restrict __s, size_t __size, int __n, +- __FILE *__restrict __stream), __fgetws_chk) +- __wur __warnattr ("fgetws called with bigger size than length " +- "of destination buffer"); +- +-__fortify_function __wur wchar_t * +-fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) +-{ +- if (__bos (__s) != (size_t) -1) +- { +- if (!__builtin_constant_p (__n) || __n <= 0) +- return __fgetws_chk (__s, __bos (__s) / sizeof (wchar_t), +- __n, __stream); + +- if ((size_t) __n > __bos (__s) / sizeof (wchar_t)) +- return __fgetws_chk_warn (__s, __bos (__s) / sizeof (wchar_t), +- __n, __stream); +- } ++__fortify_potential_overload __wur wchar_t * ++fgetws (wchar_t *__restrict const __clang_pass_object_size __s, int __n, ++ __FILE *__restrict __stream) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT2 (__fgetws_warn, __n, __s, ++ sizeof (wchar_t), ++ "fgetws called with length bigger " ++ "than size of destination buffer") ++{ ++ if (__FORTIFY_CALL_CHK && __bos (__s) != (size_t) -1) ++ return __fgetws_chk (__s, __bos (__s) / sizeof (wchar_t), __n, __stream); + return __fgetws_alias (__s, __n, __stream); + } ++__FORTIFY_FUNCTION_END + + #ifdef __USE_GNU + extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size, +@@ -404,28 +377,23 @@ extern wchar_t *__REDIRECT (__fgetws_unlocked_alias, + (wchar_t *__restrict __s, int __n, + __FILE *__restrict __stream), fgetws_unlocked) + __wur; +-extern wchar_t *__REDIRECT (__fgetws_unlocked_chk_warn, +- (wchar_t *__restrict __s, size_t __size, int __n, +- __FILE *__restrict __stream), +- __fgetws_unlocked_chk) +- __wur __warnattr ("fgetws_unlocked called with bigger size than length " +- "of destination buffer"); +- +-__fortify_function __wur wchar_t * +-fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) ++ ++__fortify_potential_overload __wur wchar_t * ++fgetws_unlocked (wchar_t *__restrict const __clang_pass_object_size __s, ++ int __n, __FILE *__restrict __stream) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_IF (__fgetws_unlocked_warn, ++ __n > 0 ++ && __bos_static_lt2 (__n, __s, sizeof (wchar_t)), ++ "fgetws_unlocked called with bigger size than " ++ "length of destination buffer") + { + if (__bos (__s) != (size_t) -1) +- { +- if (!__builtin_constant_p (__n) || __n <= 0) +- return __fgetws_unlocked_chk (__s, __bos (__s) / sizeof (wchar_t), +- __n, __stream); +- +- if ((size_t) __n > __bos (__s) / sizeof (wchar_t)) +- return __fgetws_unlocked_chk_warn (__s, __bos (__s) / sizeof (wchar_t), +- __n, __stream); +- } ++ return __fgetws_unlocked_chk (__s, __bos (__s) / sizeof (wchar_t), ++ __n, __stream); + return __fgetws_unlocked_alias (__s, __n, __stream); + } ++__FORTIFY_FUNCTION_END + #endif + + +@@ -436,9 +404,9 @@ extern size_t __REDIRECT_NTH (__wcrtomb_alias, + (char *__restrict __s, wchar_t __wchar, + mbstate_t *__restrict __ps), wcrtomb) __wur; + +-__fortify_function __wur size_t +-__NTH (wcrtomb (char *__restrict __s, wchar_t __wchar, +- mbstate_t *__restrict __ps)) ++__fortify_potential_overload __wur size_t ++__NTH (wcrtomb (char *__restrict const __clang_pass_object_size __s, ++ wchar_t __wchar, mbstate_t *__restrict __ps)) + { + /* We would have to include to get a definition of MB_LEN_MAX. + But this would only disturb the namespace. So we define our own +@@ -462,30 +430,23 @@ extern size_t __REDIRECT_NTH (__mbsrtowcs_alias, + const char **__restrict __src, + size_t __len, mbstate_t *__restrict __ps), + mbsrtowcs); +-extern size_t __REDIRECT_NTH (__mbsrtowcs_chk_warn, +- (wchar_t *__restrict __dst, +- const char **__restrict __src, +- size_t __len, mbstate_t *__restrict __ps, +- size_t __dstlen), __mbsrtowcs_chk) +- __warnattr ("mbsrtowcs called with dst buffer smaller than len " +- "* sizeof (wchar_t)"); + +-__fortify_function size_t +-__NTH (mbsrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, +- size_t __len, mbstate_t *__restrict __ps)) ++__fortify_potential_overload size_t ++__NTH (mbsrtowcs (wchar_t *__restrict const __clang_pass_object_size __dst, ++ const char **__restrict __src, size_t __len, ++ mbstate_t *__restrict __ps)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT2 (__mbsrtowcs_warn, __len, __dst, ++ sizeof (wchar_t), ++ "mbsrtowcs called with dst buffer " ++ "smaller than len * sizeof (wchar_t)") + { +- if (__bos (__dst) != (size_t) -1) +- { +- if (!__builtin_constant_p (__len)) +- return __mbsrtowcs_chk (__dst, __src, __len, __ps, +- __bos (__dst) / sizeof (wchar_t)); +- +- if (__len > __bos (__dst) / sizeof (wchar_t)) +- return __mbsrtowcs_chk_warn (__dst, __src, __len, __ps, +- __bos (__dst) / sizeof (wchar_t)); +- } ++ if (__FORTIFY_CALL_CHK && __bos (__dst) != (size_t) -1) ++ return __mbsrtowcs_chk (__dst, __src, __len, __ps, ++ __bos (__dst) / sizeof (wchar_t)); + return __mbsrtowcs_alias (__dst, __src, __len, __ps); + } ++__FORTIFY_FUNCTION_END + + + extern size_t __wcsrtombs_chk (char *__restrict __dst, +@@ -497,27 +458,21 @@ extern size_t __REDIRECT_NTH (__wcsrtombs_alias, + const wchar_t **__restrict __src, + size_t __len, mbstate_t *__restrict __ps), + wcsrtombs); +-extern size_t __REDIRECT_NTH (__wcsrtombs_chk_warn, +- (char *__restrict __dst, +- const wchar_t **__restrict __src, +- size_t __len, mbstate_t *__restrict __ps, +- size_t __dstlen), __wcsrtombs_chk) +- __warnattr ("wcsrtombs called with dst buffer smaller than len"); + +-__fortify_function size_t +-__NTH (wcsrtombs (char *__restrict __dst, const wchar_t **__restrict __src, +- size_t __len, mbstate_t *__restrict __ps)) ++__fortify_potential_overload size_t ++__NTH (wcsrtombs (char *__restrict const __clang_pass_object_size __dst, ++ const wchar_t **__restrict __src, size_t __len, ++ mbstate_t *__restrict __ps)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__wcsrtombs_warn, __len, __dst, ++ "wcsrtombs called with dst buffer " ++ "smaller than len") + { +- if (__bos (__dst) != (size_t) -1) +- { +- if (!__builtin_constant_p (__len)) +- return __wcsrtombs_chk (__dst, __src, __len, __ps, __bos (__dst)); +- +- if (__len > __bos (__dst)) +- return __wcsrtombs_chk_warn (__dst, __src, __len, __ps, __bos (__dst)); +- } ++ if (__FORTIFY_CALL_CHK && __bos (__dst) != (size_t) -1) ++ return __wcsrtombs_chk (__dst, __src, __len, __ps, __bos (__dst)); + return __wcsrtombs_alias (__dst, __src, __len, __ps); + } ++__FORTIFY_FUNCTION_END + + + #ifdef __USE_GNU +@@ -530,30 +485,23 @@ extern size_t __REDIRECT_NTH (__mbsnrtowcs_alias, + const char **__restrict __src, size_t __nmc, + size_t __len, mbstate_t *__restrict __ps), + mbsnrtowcs); +-extern size_t __REDIRECT_NTH (__mbsnrtowcs_chk_warn, +- (wchar_t *__restrict __dst, +- const char **__restrict __src, size_t __nmc, +- size_t __len, mbstate_t *__restrict __ps, +- size_t __dstlen), __mbsnrtowcs_chk) +- __warnattr ("mbsnrtowcs called with dst buffer smaller than len " +- "* sizeof (wchar_t)"); + +-__fortify_function size_t +-__NTH (mbsnrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, +- size_t __nmc, size_t __len, mbstate_t *__restrict __ps)) ++__fortify_potential_overload size_t ++__NTH (mbsnrtowcs (wchar_t *__restrict const __clang_pass_object_size __dst, ++ const char **__restrict __src, size_t __nmc, size_t __len, ++ mbstate_t *__restrict __ps)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__mbsnrtowcs_warn, ++ sizeof (wchar_t) * __len, __dst, ++ "mbsnrtowcs called with dst buffer " ++ "smaller than len * sizeof (wchar_t)") + { +- if (__bos (__dst) != (size_t) -1) +- { +- if (!__builtin_constant_p (__len)) +- return __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps, +- __bos (__dst) / sizeof (wchar_t)); +- +- if (__len > __bos (__dst) / sizeof (wchar_t)) +- return __mbsnrtowcs_chk_warn (__dst, __src, __nmc, __len, __ps, +- __bos (__dst) / sizeof (wchar_t)); +- } ++ if (__FORTIFY_CALL_CHK && __bos (__dst) != (size_t) -1) ++ return __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps, ++ __bos (__dst) / sizeof (wchar_t)); + return __mbsnrtowcs_alias (__dst, __src, __nmc, __len, __ps); + } ++__FORTIFY_FUNCTION_END + + + extern size_t __wcsnrtombs_chk (char *__restrict __dst, +@@ -566,28 +514,19 @@ extern size_t __REDIRECT_NTH (__wcsnrtombs_alias, + const wchar_t **__restrict __src, + size_t __nwc, size_t __len, + mbstate_t *__restrict __ps), wcsnrtombs); +-extern size_t __REDIRECT_NTH (__wcsnrtombs_chk_warn, +- (char *__restrict __dst, +- const wchar_t **__restrict __src, +- size_t __nwc, size_t __len, +- mbstate_t *__restrict __ps, +- size_t __dstlen), __wcsnrtombs_chk) +- __warnattr ("wcsnrtombs called with dst buffer smaller than len"); + +-__fortify_function size_t +-__NTH (wcsnrtombs (char *__restrict __dst, const wchar_t **__restrict __src, +- size_t __nwc, size_t __len, mbstate_t *__restrict __ps)) ++__fortify_potential_overload size_t ++__NTH (wcsnrtombs (char *__restrict const __clang_pass_object_size __dst, ++ const wchar_t **__restrict __src, size_t __nwc, size_t __len, ++ mbstate_t *__restrict __ps)) ++__FORTIFY_PRECONDITIONS ++ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__wcsnrtombs_warn, __len, __dst, ++ "wcsnrtombs called with dst buffer " ++ "smaller than len") + { +- if (__bos (__dst) != (size_t) -1) +- { +- if (!__builtin_constant_p (__len)) +- return __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps, +- __bos (__dst)); +- +- if (__len > __bos (__dst)) +- return __wcsnrtombs_chk_warn (__dst, __src, __nwc, __len, __ps, +- __bos (__dst)); +- } ++ if (__FORTIFY_CALL_CHK && __bos (__dst) != (size_t) -1) ++ return __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps, __bos (__dst)); + return __wcsnrtombs_alias (__dst, __src, __nwc, __len, __ps); + } ++__FORTIFY_FUNCTION_END + #endif diff --git a/meta/recipes-core/glibc/glibc/0030-locale-prevent-maybe-uninitialized-errors-with-Os-BZ.patch b/meta/recipes-core/glibc/glibc/0030-locale-prevent-maybe-uninitialized-errors-with-Os-BZ.patch deleted file mode 100644 index 195b1b0081..0000000000 --- a/meta/recipes-core/glibc/glibc/0030-locale-prevent-maybe-uninitialized-errors-with-Os-BZ.patch +++ /dev/null @@ -1,53 +0,0 @@ -From eaa1e89df6d760c3719e7060662c60b41ab6e87b Mon Sep 17 00:00:00 2001 -From: Martin Jansa -Date: Mon, 17 Dec 2018 21:36:18 +0000 -Subject: [PATCH] locale: prevent maybe-uninitialized errors with -Os [BZ - #19444] - -Fixes following error when building for aarch64 with -Os: -| In file included from strcoll_l.c:43: -| strcoll_l.c: In function '__strcoll_l': -| ../locale/weight.h:31:26: error: 'seq2.back_us' may be used uninitialized in this function [-Werror=maybe-uninitialized] -| int_fast32_t i = table[*(*cpp)++]; -| ^~~~~~~~~ -| strcoll_l.c:304:18: note: 'seq2.back_us' was declared here -| coll_seq seq1, seq2; -| ^~~~ -| In file included from strcoll_l.c:43: -| ../locale/weight.h:31:26: error: 'seq1.back_us' may be used uninitialized in this function [-Werror=maybe-uninitialized] -| int_fast32_t i = table[*(*cpp)++]; -| ^~~~~~~~~ -| strcoll_l.c:304:12: note: 'seq1.back_us' was declared here -| coll_seq seq1, seq2; -| ^~~~ - - Partial fix for [BZ #19444] - * locale/weight.h: Fix build with -Os. - -Upstream-Status: Submitted [https://patchwork.ozlabs.org/patch/1014766] - -Signed-off-by: Martin Jansa -Signed-off-by: Khem Raj ---- - locale/weight.h | 7 +++++++ - 1 file changed, 7 insertions(+) - -diff --git a/locale/weight.h b/locale/weight.h -index e071253f85..2889c395f1 100644 ---- a/locale/weight.h -+++ b/locale/weight.h -@@ -28,7 +28,14 @@ findidx (const int32_t *table, - const unsigned char *extra, - const unsigned char **cpp, size_t len) - { -+ /* With GCC 8 when compiling with -Os the compiler warns that -+ seq1.back_us and seq2.back_us might be used uninitialized. -+ This uninitialized use is impossible for the same reason -+ as described in comments in locale/weightwc.h. */ -+ DIAG_PUSH_NEEDS_COMMENT; -+ DIAG_IGNORE_Os_NEEDS_COMMENT (8, "-Wmaybe-uninitialized"); - int_fast32_t i = table[*(*cpp)++]; -+ DIAG_POP_NEEDS_COMMENT; - const unsigned char *cp; - const unsigned char *usrc; - diff --git a/meta/recipes-core/glibc/glibc/0031-Refactor-FORTIFY-in-glibc.patch b/meta/recipes-core/glibc/glibc/0031-Refactor-FORTIFY-in-glibc.patch deleted file mode 100644 index fe10218c31..0000000000 --- a/meta/recipes-core/glibc/glibc/0031-Refactor-FORTIFY-in-glibc.patch +++ /dev/null @@ -1,2780 +0,0 @@ -From 4a6f67ae2438c5e7f9cd627d5cf4a7148b9ad18d Mon Sep 17 00:00:00 2001 -From: George Burgess IV -Date: Sat, 11 Jan 2020 10:33:19 -0800 -Subject: [PATCH] Refactor FORTIFY in glibc - -Upstream-Status: Submitted [https://sourceware.org/ml/libc-alpha/2017-09/msg00434.html] - -Signed-off-by: George Burgess IV -Signed-off-by: Khem Raj ---- - io/bits/fcntl2.h | 125 ++++++-- - io/bits/poll2.h | 54 ++-- - io/fcntl.h | 2 +- - libio/bits/stdio2.h | 303 +++++++++++--------- - misc/bits/syslog.h | 38 ++- - misc/sys/cdefs.h | 164 ++++++++++- - posix/bits/unistd.h | 366 ++++++++++-------------- - rt/bits/mqueue2.h | 44 ++- - rt/mqueue.h | 2 +- - socket/bits/socket2.h | 56 ++-- - stdlib/bits/stdlib.h | 117 ++++---- - string/bits/string_fortified.h | 136 ++++++--- - string/bits/strings_fortified.h | 36 ++- - wcsmbs/bits/wchar2.h | 487 ++++++++++++++------------------ - 14 files changed, 1093 insertions(+), 837 deletions(-) - ---- a/io/bits/fcntl2.h -+++ b/io/bits/fcntl2.h -@@ -32,10 +32,28 @@ extern int __REDIRECT (__open_2, (const - extern int __REDIRECT (__open_alias, (const char *__path, int __oflag, ...), - open64) __nonnull ((1)); - #endif --__errordecl (__open_too_many_args, -- "open can be called either with 2 or 3 arguments, not more"); --__errordecl (__open_missing_mode, -- "open with O_CREAT or O_TMPFILE in second argument needs 3 arguments"); -+ -+#define __warn_open_too_many_args \ -+ "open can be called either with 2 or 3 arguments, not more" -+#define __warn_open_missing_mode \ -+ "open with O_CREAT in second argument needs 3 arguments" -+#ifdef __use_clang_fortify -+__fortify_overload __clang_prefer_this_overload int -+open (const char *const __clang_pass_object_size __path, int __oflag) -+ __clang_error_if (__OPEN_NEEDS_MODE (__oflag), __warn_open_missing_mode) -+{ -+ return __open_2 (__path, __oflag); -+} -+ -+__fortify_overload int -+open (const char *const __clang_pass_object_size __path, int __oflag, -+ mode_t __mode) -+{ -+ return __open_alias (__path, __oflag, __mode); -+} -+#else -+__errordecl (__open_too_many_args, __warn_open_too_many_args); -+__errordecl (__open_missing_mode, __warn_open_missing_mode); - - __fortify_function int - open (const char *__path, int __oflag, ...) -@@ -58,16 +76,37 @@ open (const char *__path, int __oflag, . - - return __open_alias (__path, __oflag, __va_arg_pack ()); - } -+#endif -+#undef __warn_open_too_many_args -+#undef __warn_open_missing_mode - - - #ifdef __USE_LARGEFILE64 - extern int __open64_2 (const char *__path, int __oflag) __nonnull ((1)); - extern int __REDIRECT (__open64_alias, (const char *__path, int __oflag, - ...), open64) __nonnull ((1)); --__errordecl (__open64_too_many_args, -- "open64 can be called either with 2 or 3 arguments, not more"); --__errordecl (__open64_missing_mode, -- "open64 with O_CREAT or O_TMPFILE in second argument needs 3 arguments"); -+ -+# define __warn_open64_too_many_args \ -+ "open64 can be called either with 2 or 3 arguments, not more" -+# define __warn_open64_missing_mode \ -+ "open64 with O_CREAT in second argument needs 3 arguments" -+# ifdef __use_clang_fortify -+__fortify_overload __clang_prefer_this_overload int -+open64 (const char *const __clang_pass_object_size __path, int __oflag) -+ __clang_error_if (__OPEN_NEEDS_MODE (__oflag), __warn_open64_missing_mode) -+{ -+ return __open64_2 (__path, __oflag); -+} -+ -+__fortify_overload __clang_prefer_this_overload int -+open64 (const char *const __clang_pass_object_size __path, int __oflag, -+ int __mode) -+{ -+ return __open64_alias (__path, __oflag, __mode); -+} -+# else -+__errordecl (__open64_too_many_args, __warn_open64_too_many_args); -+__errordecl (__open64_missing_mode, __warn_open64_missing_mode); - - __fortify_function int - open64 (const char *__path, int __oflag, ...) -@@ -90,6 +129,9 @@ open64 (const char *__path, int __oflag, - - return __open64_alias (__path, __oflag, __va_arg_pack ()); - } -+# endif -+# undef __warn_open64_too_many_args -+# undef __warn_open64_missing_mode - #endif - - -@@ -108,10 +150,32 @@ extern int __REDIRECT (__openat_alias, ( - int __oflag, ...), openat64) - __nonnull ((2)); - # endif --__errordecl (__openat_too_many_args, -- "openat can be called either with 3 or 4 arguments, not more"); --__errordecl (__openat_missing_mode, -- "openat with O_CREAT or O_TMPFILE in third argument needs 4 arguments"); -+ -+# define __warn_openat_too_many_args "openat can be called either with 3 or " \ -+ "4 arguments, not more" -+# define __warn_openat_missing_mode "openat with O_CREAT in third argument " \ -+ "needs 4 arguments" -+# ifdef __use_clang_fortify -+__fortify_error_function __clang_error (__warn_openat_too_many_args) int -+openat (int __fd, const char *__path, int __oflag, int __mode, ...); -+ -+__fortify_overload __clang_prefer_this_overload int -+openat (int __fd, const char *const __clang_pass_object_size __path, -+ int __oflag) -+ __clang_error_if (__OPEN_NEEDS_MODE (__oflag), __warn_openat_missing_mode) -+{ -+ return __openat_2 (__fd, __path, __oflag); -+} -+ -+__fortify_overload __clang_prefer_this_overload int -+openat (int __fd, const char *const __clang_pass_object_size __path, -+ int __oflag, int __mode) -+{ -+ return __openat_alias (__fd, __path, __oflag, __mode); -+} -+# else -+__errordecl (__openat_too_many_args, __warn_openat_too_many_args); -+__errordecl (__openat_missing_mode, __warn_openat_missing_mode); - - __fortify_function int - openat (int __fd, const char *__path, int __oflag, ...) -@@ -134,6 +198,9 @@ openat (int __fd, const char *__path, in - - return __openat_alias (__fd, __path, __oflag, __va_arg_pack ()); - } -+# endif -+# undef __warn_openat_too_many_args -+# undef __warn_openat_missing_mode - - - # ifdef __USE_LARGEFILE64 -@@ -142,11 +209,34 @@ extern int __openat64_2 (int __fd, const - extern int __REDIRECT (__openat64_alias, (int __fd, const char *__path, - int __oflag, ...), openat64) - __nonnull ((2)); --__errordecl (__openat64_too_many_args, -- "openat64 can be called either with 3 or 4 arguments, not more"); --__errordecl (__openat64_missing_mode, -- "openat64 with O_CREAT or O_TMPFILE in third argument needs 4 arguments"); - -+# define __warn_openat64_too_many_args "openat64 can be called either with " \ -+ "3 or 4 arguments, not more" -+# define __warn_openat64_missing_mode "openat64 with O_CREAT in third " \ -+ "argument needs 4 arguments" -+ -+# ifdef __use_clang_fortify -+__fortify_error_function __clang_error (__warn_openat64_too_many_args) int -+openat64 (int __fd, const char *__path, int __oflag, int __mode, ...); -+ -+__fortify_overload __clang_prefer_this_overload int -+openat64 (int __fd, const char *const __clang_pass_object_size __path, -+ int __oflag) -+ __clang_error_if (__OPEN_NEEDS_MODE (__oflag), -+ __warn_openat64_missing_mode) -+{ -+ return __openat64_2 (__fd, __path, __oflag); -+} -+ -+__fortify_overload __clang_prefer_this_overload int -+openat64 (int __fd, const char *const __clang_pass_object_size __path, -+ int __oflag, int __mode) -+{ -+ return __openat64_alias (__fd, __path, __oflag, __mode); -+} -+# else -+__errordecl (__openat64_too_many_args, __warn_openat64_too_many_args); -+__errordecl (__openat64_missing_mode, __warn_openat64_missing_mode); - __fortify_function int - openat64 (int __fd, const char *__path, int __oflag, ...) - { -@@ -168,5 +258,8 @@ openat64 (int __fd, const char *__path, - - return __openat64_alias (__fd, __path, __oflag, __va_arg_pack ()); - } -+# endif -+# undef __warn_openat64_too_many_args -+# undef __warn_openat64_missing_mode - # endif - #endif ---- a/io/bits/poll2.h -+++ b/io/bits/poll2.h -@@ -27,25 +27,20 @@ extern int __REDIRECT (__poll_alias, (st - int __timeout), poll); - extern int __poll_chk (struct pollfd *__fds, nfds_t __nfds, int __timeout, - __SIZE_TYPE__ __fdslen); --extern int __REDIRECT (__poll_chk_warn, (struct pollfd *__fds, nfds_t __nfds, -- int __timeout, __SIZE_TYPE__ __fdslen), -- __poll_chk) -- __warnattr ("poll called with fds buffer too small file nfds entries"); - --__fortify_function int --poll (struct pollfd *__fds, nfds_t __nfds, int __timeout) -+__fortify_potential_overload int -+poll (struct pollfd *const __clang_pass_object_size __fds, nfds_t __nfds, -+ int __timeout) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT2 (__poll_warn, __nfds, __fds, -+ sizeof (*__fds), -+ "poll called with fds buffer too small") - { -- if (__bos (__fds) != (__SIZE_TYPE__) -1) -- { -- if (! __builtin_constant_p (__nfds)) -- return __poll_chk (__fds, __nfds, __timeout, __bos (__fds)); -- else if (__bos (__fds) / sizeof (*__fds) < __nfds) -- return __poll_chk_warn (__fds, __nfds, __timeout, __bos (__fds)); -- } -- -+ if (__FORTIFY_CALL_CHK && __bos (__fds) != (__SIZE_TYPE__) -1) -+ return __poll_chk (__fds, __nfds, __timeout, __bos (__fds)); - return __poll_alias (__fds, __nfds, __timeout); - } -- -+__FORTIFY_FUNCTION_END - - #ifdef __USE_GNU - extern int __REDIRECT (__ppoll_alias, (struct pollfd *__fds, nfds_t __nfds, -@@ -54,28 +49,21 @@ extern int __REDIRECT (__ppoll_alias, (s - extern int __ppoll_chk (struct pollfd *__fds, nfds_t __nfds, - const struct timespec *__timeout, - const __sigset_t *__ss, __SIZE_TYPE__ __fdslen); --extern int __REDIRECT (__ppoll_chk_warn, (struct pollfd *__fds, nfds_t __nfds, -- const struct timespec *__timeout, -- const __sigset_t *__ss, -- __SIZE_TYPE__ __fdslen), -- __ppoll_chk) -- __warnattr ("ppoll called with fds buffer too small file nfds entries"); - --__fortify_function int --ppoll (struct pollfd *__fds, nfds_t __nfds, const struct timespec *__timeout, -- const __sigset_t *__ss) -+__fortify_potential_overload int -+ppoll (struct pollfd *const __clang_pass_object_size __fds, nfds_t __nfds, -+ const struct timespec *__timeout, const __sigset_t *__ss) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT2 (__ppoll_warn, __nfds, __fds, -+ sizeof (*__fds), -+ "ppoll called with fds buffer too " -+ "small file nfds entries") - { -- if (__bos (__fds) != (__SIZE_TYPE__) -1) -- { -- if (! __builtin_constant_p (__nfds)) -- return __ppoll_chk (__fds, __nfds, __timeout, __ss, __bos (__fds)); -- else if (__bos (__fds) / sizeof (*__fds) < __nfds) -- return __ppoll_chk_warn (__fds, __nfds, __timeout, __ss, -- __bos (__fds)); -- } -- -+ if (__FORTIFY_CALL_CHK && __bos (__fds) != (__SIZE_TYPE__) -1) -+ return __ppoll_chk (__fds, __nfds, __timeout, __ss, __bos (__fds)); - return __ppoll_alias (__fds, __nfds, __timeout, __ss); - } -+__FORTIFY_FUNCTION_END - #endif - - __END_DECLS ---- a/io/fcntl.h -+++ b/io/fcntl.h -@@ -325,7 +325,7 @@ extern int posix_fallocate64 (int __fd, - - /* Define some inlines helping to catch common problems. */ - #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function \ -- && defined __va_arg_pack_len -+ && (defined __va_arg_pack_len || defined __use_clang_fortify) - # include - #endif - ---- a/libio/bits/stdio2.h -+++ b/libio/bits/stdio2.h -@@ -29,12 +29,23 @@ extern int __vsprintf_chk (char *__restr - const char *__restrict __format, - __gnuc_va_list __ap) __THROW; - --#ifdef __va_arg_pack --__fortify_function int --__NTH (sprintf (char *__restrict __s, const char *__restrict __fmt, ...)) --{ -- return __builtin___sprintf_chk (__s, __USE_FORTIFY_LEVEL - 1, -- __bos (__s), __fmt, __va_arg_pack ()); -+#define __mul_may_overflow(size, n) \ -+ ((size | n) >= (((size_t)1) << (8 * sizeof (size_t) / 2))) -+ -+#ifdef __FORTIFY_ARG_PACK_OK -+/* clang doesn't have __va_arg_pack, so we need to defer to the va_arg versions -+ of these functions. */ -+__fortify_potential_overload int -+__NTH (sprintf (char *__restrict const __clang_pass_object_size __s, -+ const char *__restrict __fmt, ...)) -+{ -+ __FORTIFY_INIT_ARG_PACK(__fmt); -+ int __result = __FORTIFY_CALL_VA_BUILTIN (sprintf, __s, -+ __USE_FORTIFY_LEVEL - 1, -+ __bos (__s), __fmt, -+ __FORTIFY_ARG_PACK); -+ __FORTIFY_FREE_ARG_PACK(); -+ return __result; - } - #elif !defined __cplusplus - # define sprintf(str, ...) \ -@@ -42,9 +53,9 @@ __NTH (sprintf (char *__restrict __s, co - __VA_ARGS__) - #endif - --__fortify_function int --__NTH (vsprintf (char *__restrict __s, const char *__restrict __fmt, -- __gnuc_va_list __ap)) -+__fortify_potential_overload int -+__NTH (vsprintf (char *__restrict const __clang_pass_object_size __s, -+ const char *__restrict __fmt, __gnuc_va_list __ap)) - { - return __builtin___vsprintf_chk (__s, __USE_FORTIFY_LEVEL - 1, - __bos (__s), __fmt, __ap); -@@ -59,13 +70,21 @@ extern int __vsnprintf_chk (char *__rest - size_t __slen, const char *__restrict __format, - __gnuc_va_list __ap) __THROW; - --# ifdef __va_arg_pack --__fortify_function int --__NTH (snprintf (char *__restrict __s, size_t __n, -- const char *__restrict __fmt, ...)) --{ -- return __builtin___snprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, -- __bos (__s), __fmt, __va_arg_pack ()); -+# ifdef __FORTIFY_ARG_PACK_OK -+__fortify_potential_overload __attribute__ ((__format__ (__printf__, 3, 4))) int -+__NTH (snprintf (char *__restrict const __clang_pass_object_size __s, -+ size_t __n, const char *__restrict __fmt, ...)) -+ /* GCC's builtin will catch this, so we just need to cover clang here. */ -+ __clang_warning_if (__bos_static_lt (__n, __s), -+ "call to snprintf may overflow the destination buffer") -+{ -+ __FORTIFY_INIT_ARG_PACK(__fmt); -+ int __result = __FORTIFY_CALL_VA_BUILTIN (snprintf, __s, __n, -+ __USE_FORTIFY_LEVEL - 1, -+ __bos (__s), __fmt, -+ __FORTIFY_ARG_PACK); -+ __FORTIFY_FREE_ARG_PACK(); -+ return __result; - } - # elif !defined __cplusplus - # define snprintf(str, len, ...) \ -@@ -73,9 +92,12 @@ __NTH (snprintf (char *__restrict __s, s - __VA_ARGS__) - # endif - --__fortify_function int --__NTH (vsnprintf (char *__restrict __s, size_t __n, -- const char *__restrict __fmt, __gnuc_va_list __ap)) -+__fortify_potential_overload __attribute__ ((__format__ (__printf__, 3, 0))) int -+__NTH (vsnprintf (char *__restrict const __clang_pass_object_size __s, -+ size_t __n, const char *__restrict __fmt, __gnuc_va_list __ap)) -+ __clang_warning_if (__bos_static_lt (__n, __s), -+ "call to vsnprintf may overflow the destination " -+ "buffer") - { - return __builtin___vsnprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, - __bos (__s), __fmt, __ap); -@@ -93,18 +115,27 @@ extern int __vfprintf_chk (FILE *__restr - extern int __vprintf_chk (int __flag, const char *__restrict __format, - __gnuc_va_list __ap); - --# ifdef __va_arg_pack --__fortify_function int --fprintf (FILE *__restrict __stream, const char *__restrict __fmt, ...) --{ -- return __fprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, -- __va_arg_pack ()); --} -- --__fortify_function int --printf (const char *__restrict __fmt, ...) --{ -- return __printf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ()); -+# ifdef __FORTIFY_ARG_PACK_OK -+__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 3))) int -+fprintf (FILE *__restrict const __clang_pass_object_size __stream, -+ const char *__restrict __fmt, ...) -+{ -+ __FORTIFY_INIT_ARG_PACK(__fmt); -+ int __result = __FORTIFY_CALL_VA_CHK (fprintf, __stream, -+ __USE_FORTIFY_LEVEL - 1, __fmt, -+ __FORTIFY_ARG_PACK); -+ __FORTIFY_FREE_ARG_PACK(); -+ return __result; -+} -+ -+__fortify_potential_overload __attribute__ ((__format__ (__printf__, 1, 2))) int -+printf (const char *__restrict const __clang_pass_object_size __fmt, ...) -+{ -+ __FORTIFY_INIT_ARG_PACK(__fmt); -+ int __result = __FORTIFY_CALL_VA_CHK (printf, __USE_FORTIFY_LEVEL - 1, __fmt, -+ __FORTIFY_ARG_PACK); -+ __FORTIFY_FREE_ARG_PACK(); -+ return __result; - } - # elif !defined __cplusplus - # define printf(...) \ -@@ -113,8 +144,9 @@ printf (const char *__restrict __fmt, .. - __fprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) - # endif - --__fortify_function int --vprintf (const char *__restrict __fmt, __gnuc_va_list __ap) -+__fortify_potential_overload __attribute__ ((__format__ (__printf__, 1, 0))) int -+vprintf (const char *__restrict const __clang_pass_object_size __fmt, -+ __gnuc_va_list __ap) - { - #ifdef __USE_EXTERN_INLINES - return __vfprintf_chk (stdout, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); -@@ -122,9 +154,8 @@ vprintf (const char *__restrict __fmt, _ - return __vprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __ap); - #endif - } -- --__fortify_function int --vfprintf (FILE *__restrict __stream, -+__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 0))) int -+vfprintf (FILE *__restrict const __clang_pass_object_size __stream, - const char *__restrict __fmt, __gnuc_va_list __ap) - { - return __vfprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); -@@ -137,20 +168,26 @@ extern int __vdprintf_chk (int __fd, int - const char *__restrict __fmt, __gnuc_va_list __arg) - __attribute__ ((__format__ (__printf__, 3, 0))); - --# ifdef __va_arg_pack --__fortify_function int --dprintf (int __fd, const char *__restrict __fmt, ...) --{ -- return __dprintf_chk (__fd, __USE_FORTIFY_LEVEL - 1, __fmt, -- __va_arg_pack ()); -+# ifdef __FORTIFY_ARG_PACK_OK -+__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 3))) int -+dprintf (int __fd, const char *__restrict const __clang_pass_object_size __fmt, -+ ...) -+{ -+ __FORTIFY_INIT_ARG_PACK(__fmt); -+ int __result = __FORTIFY_CALL_VA_CHK (dprintf, __fd, __USE_FORTIFY_LEVEL - 1, -+ __fmt, __FORTIFY_ARG_PACK); -+ __FORTIFY_FREE_ARG_PACK(); -+ return __result; - } - # elif !defined __cplusplus - # define dprintf(fd, ...) \ - __dprintf_chk (fd, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) - # endif - --__fortify_function int --vdprintf (int __fd, const char *__restrict __fmt, __gnuc_va_list __ap) -+__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 0))) int -+vdprintf (int __fd, -+ const char *__restrict const __clang_pass_object_size __fmt, -+ __gnuc_va_list __ap) - { - return __vdprintf_chk (__fd, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); - } -@@ -174,28 +211,49 @@ extern int __obstack_vprintf_chk (struct - __gnuc_va_list __args) - __THROW __attribute__ ((__format__ (__printf__, 3, 0))); - --# ifdef __va_arg_pack --__fortify_function int --__NTH (asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...)) --{ -- return __asprintf_chk (__ptr, __USE_FORTIFY_LEVEL - 1, __fmt, -- __va_arg_pack ()); --} -- --__fortify_function int --__NTH (__asprintf (char **__restrict __ptr, const char *__restrict __fmt, -- ...)) -+# ifdef __FORTIFY_ARG_PACK_OK -+__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 3))) -+__wur int -+__NTH (asprintf (char **__restrict const __clang_pass_object_size __ptr, -+ const char *__restrict __fmt, ...)) - { -- return __asprintf_chk (__ptr, __USE_FORTIFY_LEVEL - 1, __fmt, -- __va_arg_pack ()); --} -- --__fortify_function int --__NTH (obstack_printf (struct obstack *__restrict __obstack, -+ __FORTIFY_INIT_ARG_PACK(__fmt); -+ int __result = __FORTIFY_CALL_VA_CHK (asprintf, __ptr, -+ __USE_FORTIFY_LEVEL - 1, __fmt, -+ __FORTIFY_ARG_PACK); -+ __FORTIFY_FREE_ARG_PACK(); -+ return __result; -+} -+ -+__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 3))) -+__wur int -+__NTH (__asprintf (char **__restrict const __clang_pass_object_size __ptr, -+ const char *__restrict __fmt, ...)) -+{ -+ __FORTIFY_INIT_ARG_PACK(__fmt); -+ int __result = __FORTIFY_CALL_VA_CHK (asprintf, __ptr, -+ __USE_FORTIFY_LEVEL - 1, __fmt, -+ __FORTIFY_ARG_PACK); -+ __FORTIFY_FREE_ARG_PACK(); -+ return __result; -+} -+ -+__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 3))) int -+__NTH (obstack_printf (struct obstack * -+ __restrict const __clang_pass_object_size __obstack, - const char *__restrict __fmt, ...)) - { -- return __obstack_printf_chk (__obstack, __USE_FORTIFY_LEVEL - 1, __fmt, -- __va_arg_pack ()); -+ __FORTIFY_INIT_ARG_PACK(__fmt); -+ int __result = -+# ifdef __use_clang_fortify -+ __obstack_vprintf_chk -+# else -+ __obstack_printf_chk -+# endif -+ (__obstack, __USE_FORTIFY_LEVEL - 1, __fmt, -+ __FORTIFY_ARG_PACK); -+ __FORTIFY_FREE_ARG_PACK(); -+ return __result; - } - # elif !defined __cplusplus - # define asprintf(ptr, ...) \ -@@ -206,15 +264,17 @@ __NTH (obstack_printf (struct obstack *_ - __obstack_printf_chk (obstack, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) - # endif - --__fortify_function int --__NTH (vasprintf (char **__restrict __ptr, const char *__restrict __fmt, -- __gnuc_va_list __ap)) -+__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 0))) -+__wur int -+__NTH (vasprintf (char **__restrict const __clang_pass_object_size __ptr, -+ const char *__restrict __fmt, __gnuc_va_list __ap)) - { - return __vasprintf_chk (__ptr, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); - } - --__fortify_function int --__NTH (obstack_vprintf (struct obstack *__restrict __obstack, -+__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 0))) int -+__NTH (obstack_vprintf (struct obstack * -+ __restrict const __clang_pass_object_size __obstack, - const char *__restrict __fmt, __gnuc_va_list __ap)) - { - return __obstack_vprintf_chk (__obstack, __USE_FORTIFY_LEVEL - 1, __fmt, -@@ -227,17 +287,20 @@ __NTH (obstack_vprintf (struct obstack * - - #if __GLIBC_USE (DEPRECATED_GETS) - extern char *__gets_chk (char *__str, size_t) __wur; --extern char *__REDIRECT (__gets_warn, (char *__str), gets) -- __wur __warnattr ("please use fgets or getline instead, gets can't " -- "specify buffer size"); -+extern char *__REDIRECT_NTH (__gets_alias, (char *__buf), gets) __wur; - --__fortify_function __wur char * --gets (char *__str) -+__fortify_potential_overload __wur char * -+gets (char *const __clang_pass_object_size __str) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_IF (__gets_warn, __bos (__str) == (size_t) -1, -+ "please use fgets or getline instead, gets can't " -+ "specify buffer size") - { - if (__bos (__str) != (size_t) -1) - return __gets_chk (__str, __bos (__str)); -- return __gets_warn (__str); -+ return __gets_alias (__str); - } -+__FORTIFY_FUNCTION_END - #endif - - extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n, -@@ -245,25 +308,20 @@ extern char *__fgets_chk (char *__restri - extern char *__REDIRECT (__fgets_alias, - (char *__restrict __s, int __n, - FILE *__restrict __stream), fgets) __wur; --extern char *__REDIRECT (__fgets_chk_warn, -- (char *__restrict __s, size_t __size, int __n, -- FILE *__restrict __stream), __fgets_chk) -- __wur __warnattr ("fgets called with bigger size than length " -- "of destination buffer"); - --__fortify_function __wur char * --fgets (char *__restrict __s, int __n, FILE *__restrict __stream) -+__fortify_potential_overload __wur char * -+fgets (char *__restrict const __clang_pass_object_size __s, int __n, -+ FILE *__restrict __stream) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_IF (__fgets_warn, __bos_static_lt (__n, __s) && __n > 0, -+ "fgets called with bigger size than length of " -+ "destination buffer") - { - if (__bos (__s) != (size_t) -1) -- { -- if (!__builtin_constant_p (__n) || __n <= 0) -- return __fgets_chk (__s, __bos (__s), __n, __stream); -- -- if ((size_t) __n > __bos (__s)) -- return __fgets_chk_warn (__s, __bos (__s), __n, __stream); -- } -+ return __fgets_chk (__s, __bos (__s), __n, __stream); - return __fgets_alias (__s, __n, __stream); - } -+__FORTIFY_FUNCTION_END - - extern size_t __fread_chk (void *__restrict __ptr, size_t __ptrlen, - size_t __size, size_t __n, -@@ -272,30 +330,21 @@ extern size_t __REDIRECT (__fread_alias, - (void *__restrict __ptr, size_t __size, - size_t __n, FILE *__restrict __stream), - fread) __wur; --extern size_t __REDIRECT (__fread_chk_warn, -- (void *__restrict __ptr, size_t __ptrlen, -- size_t __size, size_t __n, -- FILE *__restrict __stream), -- __fread_chk) -- __wur __warnattr ("fread called with bigger size * nmemb than length " -- "of destination buffer"); - --__fortify_function __wur size_t --fread (void *__restrict __ptr, size_t __size, size_t __n, -- FILE *__restrict __stream) -+__fortify_potential_overload __wur size_t -+fread (void *__restrict const __clang_pass_object_size0 __ptr, size_t __size, -+ size_t __n, FILE *__restrict __stream) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_IF (__fread_warn, __bos0_static_lt (__size * __n, __ptr) -+ && !__mul_may_overflow (__size, __n), -+ "fread called with bigger size * nmemb than length " -+ "of destination buffer") - { - if (__bos0 (__ptr) != (size_t) -1) -- { -- if (!__builtin_constant_p (__size) -- || !__builtin_constant_p (__n) -- || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2))) -- return __fread_chk (__ptr, __bos0 (__ptr), __size, __n, __stream); -- -- if (__size * __n > __bos0 (__ptr)) -- return __fread_chk_warn (__ptr, __bos0 (__ptr), __size, __n, __stream); -- } -+ return __fread_chk (__ptr, __bos0 (__ptr), __size, __n, __stream); - return __fread_alias (__ptr, __size, __n, __stream); - } -+__FORTIFY_FUNCTION_END - - #ifdef __USE_GNU - extern char *__fgets_unlocked_chk (char *__restrict __s, size_t __size, -@@ -303,25 +352,21 @@ extern char *__fgets_unlocked_chk (char - extern char *__REDIRECT (__fgets_unlocked_alias, - (char *__restrict __s, int __n, - FILE *__restrict __stream), fgets_unlocked) __wur; --extern char *__REDIRECT (__fgets_unlocked_chk_warn, -- (char *__restrict __s, size_t __size, int __n, -- FILE *__restrict __stream), __fgets_unlocked_chk) -- __wur __warnattr ("fgets_unlocked called with bigger size than length " -- "of destination buffer"); - --__fortify_function __wur char * --fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream) -+__fortify_potential_overload __wur char * -+fgets_unlocked (char *__restrict const __clang_pass_object_size __s, int __n, -+ FILE *__restrict __stream) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_IF (__fgets_unlocked_warn, -+ __bos_static_lt (__n, __s) && __n > 0, -+ "fgets_unlocked called with bigger size than length " -+ "of destination buffer") - { - if (__bos (__s) != (size_t) -1) -- { -- if (!__builtin_constant_p (__n) || __n <= 0) -- return __fgets_unlocked_chk (__s, __bos (__s), __n, __stream); -- -- if ((size_t) __n > __bos (__s)) -- return __fgets_unlocked_chk_warn (__s, __bos (__s), __n, __stream); -- } -+ return __fgets_unlocked_chk (__s, __bos (__s), __n, __stream); - return __fgets_unlocked_alias (__s, __n, __stream); - } -+__FORTIFY_FUNCTION_END - #endif - - #ifdef __USE_MISC -@@ -333,30 +378,19 @@ extern size_t __REDIRECT (__fread_unlock - (void *__restrict __ptr, size_t __size, - size_t __n, FILE *__restrict __stream), - fread_unlocked) __wur; --extern size_t __REDIRECT (__fread_unlocked_chk_warn, -- (void *__restrict __ptr, size_t __ptrlen, -- size_t __size, size_t __n, -- FILE *__restrict __stream), -- __fread_unlocked_chk) -- __wur __warnattr ("fread_unlocked called with bigger size * nmemb than " -- "length of destination buffer"); - --__fortify_function __wur size_t --fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n, -- FILE *__restrict __stream) -+__fortify_potential_overload __wur size_t -+fread_unlocked (void *__restrict const __clang_pass_object_size0 __ptr, -+ size_t __size, size_t __n, FILE *__restrict __stream) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_IF (__fread_unlocked_warn, -+ __bos0_static_lt (__size * __n, __ptr) -+ && !__mul_may_overflow(__size, __n), -+ "fread_unlocked called with bigger size * n than " -+ "length of destination buffer") - { - if (__bos0 (__ptr) != (size_t) -1) -- { -- if (!__builtin_constant_p (__size) -- || !__builtin_constant_p (__n) -- || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2))) -- return __fread_unlocked_chk (__ptr, __bos0 (__ptr), __size, __n, -- __stream); -- -- if (__size * __n > __bos0 (__ptr)) -- return __fread_unlocked_chk_warn (__ptr, __bos0 (__ptr), __size, __n, -- __stream); -- } -+ return __fread_unlocked_chk (__ptr, __bos0 (__ptr), __size, __n, __stream); - - # ifdef __USE_EXTERN_INLINES - if (__builtin_constant_p (__size) -@@ -381,6 +415,7 @@ fread_unlocked (void *__restrict __ptr, - # endif - return __fread_unlocked_alias (__ptr, __size, __n, __stream); - } -+__FORTIFY_FUNCTION_END - #endif -- -+#undef __mul_may_overflow - #endif /* bits/stdio2.h. */ ---- a/misc/bits/syslog.h -+++ b/misc/bits/syslog.h -@@ -20,11 +20,34 @@ - # error "Never include directly; use instead." - #endif - -+#ifdef __USE_MISC -+extern void __vsyslog_chk (int __pri, int __flag, const char *__fmt, -+ __gnuc_va_list __ap) -+ __attribute__ ((__format__ (__printf__, 3, 0))); -+ -+__fortify_potential_overload __attribute__ ((__format__ (__printf__, 2, 0))) void -+vsyslog (int __pri, const char *const __clang_pass_object_size __fmt, -+ __gnuc_va_list __ap) -+{ -+ __vsyslog_chk (__pri, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); -+} -+#endif - - extern void __syslog_chk (int __pri, int __flag, const char *__fmt, ...) - __attribute__ ((__format__ (__printf__, 3, 4))); - --#ifdef __va_arg_pack -+#if defined __use_clang_fortify && __USE_MISC -+/* clang doesn't support __va_arg_pack, so this is only possible if we have -+ vsyslog. */ -+__fortify_overload __attribute__ ((__format__ (__printf__, 2, 3))) void -+syslog (int __pri, const char *const __clang_pass_object_size __fmt, ...) -+{ -+ __gnuc_va_list __ap; -+ va_start (__ap, __fmt); -+ __vsyslog_chk (__pri, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); -+ va_end (__ap); -+} -+#elif defined __va_arg_pack - __fortify_function void - syslog (int __pri, const char *__fmt, ...) - { -@@ -34,16 +57,3 @@ syslog (int __pri, const char *__fmt, .. - # define syslog(pri, ...) \ - __syslog_chk (pri, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) - #endif -- -- --#ifdef __USE_MISC --extern void __vsyslog_chk (int __pri, int __flag, const char *__fmt, -- __gnuc_va_list __ap) -- __attribute__ ((__format__ (__printf__, 3, 0))); -- --__fortify_function void --vsyslog (int __pri, const char *__fmt, __gnuc_va_list __ap) --{ -- __vsyslog_chk (__pri, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); --} --#endif ---- a/misc/sys/cdefs.h -+++ b/misc/sys/cdefs.h -@@ -118,11 +118,150 @@ - # define __END_DECLS - #endif - -+#if defined __clang__ && defined __has_extension -+# define __clang_has_extension(x) __has_extension (x) -+#else -+# define __clang_has_extension(x) 0 -+#endif - - /* Fortify support. */ --#define __bos(ptr) __builtin_object_size (ptr, __USE_FORTIFY_LEVEL > 1) -+#define __fortify_function __extern_always_inline __attribute_artificial__ -+#if defined __clang__ && __USE_FORTIFY_LEVEL > 0 \ -+ && !defined _CLANG_FORTIFY_DISABLE \ -+ && __clang_has_extension(overloadable_unmarked) -+# define __use_clang_fortify 1 -+/* Clang-style FORTIFY creates a different symbol for each FORTIFY'ed function, -+ whereas GCC-style doesn't. Thus, GCC can assume that the FORTIFY'ed -+ function is always available externally, but clang can't. */ -+# define __attribute_overloadable__ __attribute__ ((__overloadable__)) -+# define __attribute_transparent_overload__ \ -+ __attribute__ ((__overloadable__("transparent"))) -+# define __fortify_overload static __always_inline __attribute_overloadable__ -+/* For FORTIFY functions that exist only as decls. */ -+# define __fortify_error_function static __attribute_overloadable__ -+# define __clang_pass_object_size_n(n) __attribute__ ((pass_object_size (n))) -+# define __clang_warning(what) __attribute__ ((deprecated(what))) -+# define __clang_prefer_this_overload __attribute__ ((enable_if (1, ""))) -+# define __clang_warning_if(c, m) \ -+ __attribute__ ((__diagnose_if__ ((c), (m), "warning"))) -+# define __clang_error(what) __attribute__ ((unavailable(what))) -+# define __clang_error_if(c, m) \ -+ __attribute__ ((__diagnose_if__ ((c), (m), "error"))) -+# define __fortify_potential_overload __fortify_overload -+#else -+# define __fortify_potential_overload __fortify_function -+/* Some functions/decls can be shared between clang and non-clang FORTIFY. -+ Turning these into nops makes that possible. */ -+# define __clang_pass_object_size_n(n) -+# define __attribute_overloadable__ -+# define __bos_n(ptr, n) __builtin_object_size (ptr, n) -+# define __clang_warning_if(c, m) -+# define __clang_error_if(c, m) -+#endif -+ -+#define __bos_level (__USE_FORTIFY_LEVEL > 1) -+#define __bos(ptr) __builtin_object_size (ptr, __bos_level) - #define __bos0(ptr) __builtin_object_size (ptr, 0) - -+#define __clang_pass_object_size0 __clang_pass_object_size_n (0) -+#define __clang_pass_object_size __clang_pass_object_size_n (__bos_level) -+ -+/* Some of these macros are awkwardly written, and more repetitive than they'd -+ ideally need to be. This is because both clang and gcc will emit 'note's -+ about where these warnings originate from. For every macro that's expanded, -+ the user sees a note that ultimately doesn't matter to them... */ -+#ifdef __use_clang_fortify -+# define __FORTIFY_PRECONDITIONS -+# define __FORTIFY_FUNCTION_END -+# define __FORTIFY_WARNING_IF(_, c, msg) __clang_warning_if(c, msg) -+/* __builtin_constant_p isn't needed: this is only used in constructs that -+ must be fully evaluated at compile-time. */ -+# define __bos_static_lt_impl(bos_val, n, s) \ -+ ((bos_val) != -1ULL && (n) > (bos_val) / (s)) -+# define __FORTIFY_CALL_CHK 1 -+ -+# define __FORTIFY_BOSN_ARGS(bos_fn, n, buf, div, complaint) \ -+ (__bos_static_lt_impl (bos_fn (buf), n, div)), (complaint), "warning" -+ -+#define __FORTIFY_WARNING_ONLY_IF_BOS0_LT2(fn_name, n, buf, div, complaint) \ -+ __attribute__ ((__diagnose_if__ \ -+ (__FORTIFY_BOSN_ARGS (__bos0, n, buf, div, complaint)))) -+#define __FORTIFY_WARNING_ONLY_IF_BOS0_LT(fn_name, n, buf, complaint) \ -+ __attribute__ ((__diagnose_if__ \ -+ (__FORTIFY_BOSN_ARGS (__bos0, n, buf, 1, complaint)))) -+#define __FORTIFY_WARNING_ONLY_IF_BOS_LT2(fn_name, n, buf, div, complaint) \ -+ __attribute__ ((__diagnose_if__ \ -+ (__FORTIFY_BOSN_ARGS (__bos, n, buf, div, complaint)))) -+#define __FORTIFY_WARNING_ONLY_IF_BOS_LT(fn_name, n, buf, complaint) \ -+ __attribute__ ((__diagnose_if__ \ -+ (__FORTIFY_BOSN_ARGS (__bos, n, buf, 1, complaint)))) -+#else -+# define __FORTIFY_PRECONDITIONS { -+# define __FORTIFY_FUNCTION_END } -+/* __chk_fail was chosen arbitrarily. The function should never be called -+ anyway; it just exists to be reachable after optimizations. */ -+# define __FORTIFY_DECLARE_WARNING_FUNCTION(name, msg) \ -+ __attribute ((__warning__(msg))) \ -+ extern void __REDIRECT_NTH (name, (void), __chk_fail) -+ -+# define __FORTIFY_WARNING_IF_BEGIN(fn_name, cond, complaint, if_cond_true) \ -+ { \ -+ if (cond) { \ -+ if_cond_true; \ -+ __FORTIFY_DECLARE_WARNING_FUNCTION (fn_name, complaint); \ -+ volatile char __t = 0; \ -+ if (__glibc_unlikely (__t)) \ -+ { -+ -+# define __FORTIFY_WARNING_IF_END \ -+ } \ -+ } \ -+ } -+ -+# define __FORTIFY_WARNING_IF(err_fn, cond, complaint) \ -+ __FORTIFY_WARNING_IF_BEGIN (err_fn, cond, complaint, (void)0) \ -+ err_fn (); \ -+ __FORTIFY_WARNING_IF_END -+ -+# define __bos_static_lt_impl(bos_val, n, s) \ -+ (__builtin_constant_p (n) && (bos_val) != -1ULL && (n) > (bos_val) / (s)) -+ -+#define __FORTIFY_BOS_WARNING_BEGIN(fn_name, bos_fn, n, buf, div, complaint) \ -+ char __need_dynamic_check = !__builtin_constant_p (n); \ -+ __FORTIFY_WARNING_IF_BEGIN (fn_name, \ -+ __bos_static_lt_impl (bos_fn (buf), n, div), \ -+ complaint, (__need_dynamic_check = 1)) -+ -+/* Duplicate this so that the fn_name call happens with the smallest possible -+ macro "call stack". This minimizes diagnostics about expanding macros. */ -+#define __FORTIFY_WARNING_ONLY_IF_BOS0_LT2(err_fn, n, buf, div, complaint) \ -+ __FORTIFY_BOS_WARNING_BEGIN (err_fn, __bos0, n, buf, div, complaint) \ -+ err_fn (); \ -+ __FORTIFY_WARNING_IF_END -+ -+#define __FORTIFY_WARNING_ONLY_IF_BOS0_LT(err_fn, n, buf, complaint) \ -+ __FORTIFY_BOS_WARNING_BEGIN (err_fn, __bos0, n, buf, 1, complaint) \ -+ err_fn (); \ -+ __FORTIFY_WARNING_IF_END -+ -+#define __FORTIFY_WARNING_ONLY_IF_BOS_LT2(err_fn, n, buf, div, complaint) \ -+ __FORTIFY_BOS_WARNING_BEGIN (err_fn, __bos, n, buf, div, complaint) \ -+ err_fn (); \ -+ __FORTIFY_WARNING_IF_END -+ -+#define __FORTIFY_WARNING_ONLY_IF_BOS_LT(err_fn, n, buf, complaint) \ -+ __FORTIFY_BOS_WARNING_BEGIN (err_fn, __bos, n, buf, 1, complaint) \ -+ err_fn (); \ -+ __FORTIFY_WARNING_IF_END -+ -+# define __FORTIFY_CALL_CHK (__need_dynamic_check) -+#endif -+ -+#define __bos_static_lt2(n, e, s) __bos_static_lt_impl (__bos (e), n, s) -+#define __bos_static_lt(n, e) __bos_static_lt2 (n, e, 1) -+#define __bos0_static_lt2(n, e, s) __bos_static_lt_impl (__bos0 (e), n, s) -+#define __bos0_static_lt(n, e) __bos0_static_lt2 (n, e, 1) -+ - #if __GNUC_PREREQ (4,3) - # define __warndecl(name, msg) \ - extern void name (void) __attribute__((__warning__ (msg))) -@@ -363,6 +502,29 @@ - # define __va_arg_pack_len() __builtin_va_arg_pack_len () - #endif - -+#if defined(__use_clang_fortify) -+/* clang doesn't support __va_arg_pack, so we need to call the v* version of -+ FORTIFY'ed functions. */ -+#define __FORTIFY_ARG_PACK __fortify_ap -+#define __FORTIFY_INIT_ARG_PACK(va_arg) \ -+ __gnuc_va_list __FORTIFY_ARG_PACK; \ -+ va_start (__FORTIFY_ARG_PACK, va_arg) -+#define __FORTIFY_CALL_VA_ALIAS(fn, ...) __v##fn##_alias (__VA_ARGS__) -+#define __FORTIFY_CALL_VA_CHK(fn, ...) __v##fn##_chk (__VA_ARGS__) -+#define __FORTIFY_CALL_VA_BUILTIN(fn, ...) \ -+ __builtin___v##fn##_chk (__VA_ARGS__) -+#define __FORTIFY_FREE_ARG_PACK() va_end (__FORTIFY_ARG_PACK) -+#define __FORTIFY_ARG_PACK_OK 1 -+#elif defined(__va_arg_pack) -+#define __FORTIFY_ARG_PACK __va_arg_pack () -+#define __FORTIFY_INIT_ARG_PACK(va_arg) -+#define __FORTIFY_CALL_VA_ALIAS(fn, ...) __##fn##_alias (__VA_ARGS__) -+#define __FORTIFY_CALL_VA_CHK(fn, ...) __##fn##_chk (__VA_ARGS__) -+#define __FORTIFY_CALL_VA_BUILTIN(fn, ...) __builtin___##fn##_chk (__VA_ARGS__) -+#define __FORTIFY_FREE_ARG_PACK() -+#define __FORTIFY_ARG_PACK_OK 1 -+#endif -+ - /* It is possible to compile containing GCC extensions even if GCC is - run in pedantic mode if the uses are carefully marked using the - `__extension__' keyword. But this is not generally available before ---- a/posix/bits/unistd.h -+++ b/posix/bits/unistd.h -@@ -24,25 +24,19 @@ extern ssize_t __read_chk (int __fd, voi - size_t __buflen) __wur; - extern ssize_t __REDIRECT (__read_alias, (int __fd, void *__buf, - size_t __nbytes), read) __wur; --extern ssize_t __REDIRECT (__read_chk_warn, -- (int __fd, void *__buf, size_t __nbytes, -- size_t __buflen), __read_chk) -- __wur __warnattr ("read called with bigger length than size of " -- "the destination buffer"); -- --__fortify_function __wur ssize_t --read (int __fd, void *__buf, size_t __nbytes) --{ -- if (__bos0 (__buf) != (size_t) -1) -- { -- if (!__builtin_constant_p (__nbytes)) -- return __read_chk (__fd, __buf, __nbytes, __bos0 (__buf)); -- -- if (__nbytes > __bos0 (__buf)) -- return __read_chk_warn (__fd, __buf, __nbytes, __bos0 (__buf)); -- } -+ -+__fortify_potential_overload __wur ssize_t -+read (int __fd, void *const __clang_pass_object_size0 __buf, size_t __nbytes) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS0_LT (__read_warn, __nbytes, __buf, -+ "read called with bigger length than " -+ "size of the destination buffer") -+{ -+ if (__FORTIFY_CALL_CHK && __bos0 (__buf) != (size_t) -1) -+ return __read_chk (__fd, __buf, __nbytes, __bos0 (__buf)); - return __read_alias (__fd, __buf, __nbytes); - } -+__FORTIFY_FUNCTION_END - - #ifdef __USE_UNIX98 - extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes, -@@ -55,67 +49,49 @@ extern ssize_t __REDIRECT (__pread_alias - extern ssize_t __REDIRECT (__pread64_alias, - (int __fd, void *__buf, size_t __nbytes, - __off64_t __offset), pread64) __wur; --extern ssize_t __REDIRECT (__pread_chk_warn, -- (int __fd, void *__buf, size_t __nbytes, -- __off_t __offset, size_t __bufsize), __pread_chk) -- __wur __warnattr ("pread called with bigger length than size of " -- "the destination buffer"); --extern ssize_t __REDIRECT (__pread64_chk_warn, -- (int __fd, void *__buf, size_t __nbytes, -- __off64_t __offset, size_t __bufsize), -- __pread64_chk) -- __wur __warnattr ("pread64 called with bigger length than size of " -- "the destination buffer"); - - # ifndef __USE_FILE_OFFSET64 --__fortify_function __wur ssize_t --pread (int __fd, void *__buf, size_t __nbytes, __off_t __offset) --{ -- if (__bos0 (__buf) != (size_t) -1) -- { -- if (!__builtin_constant_p (__nbytes)) -- return __pread_chk (__fd, __buf, __nbytes, __offset, __bos0 (__buf)); -- -- if ( __nbytes > __bos0 (__buf)) -- return __pread_chk_warn (__fd, __buf, __nbytes, __offset, -- __bos0 (__buf)); -- } -- return __pread_alias (__fd, __buf, __nbytes, __offset); --} -+# define __fo_pread_chk __pread_chk -+# define __fo_pread_alias __pread_alias -+# define __fo_off_t __off_t - # else --__fortify_function __wur ssize_t --pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) --{ -- if (__bos0 (__buf) != (size_t) -1) -- { -- if (!__builtin_constant_p (__nbytes)) -- return __pread64_chk (__fd, __buf, __nbytes, __offset, __bos0 (__buf)); -- -- if ( __nbytes > __bos0 (__buf)) -- return __pread64_chk_warn (__fd, __buf, __nbytes, __offset, -- __bos0 (__buf)); -- } -- -- return __pread64_alias (__fd, __buf, __nbytes, __offset); --} -+# define __fo_pread_chk __pread64_chk -+# define __fo_pread_alias __pread64_alias -+# define __fo_off_t __off64_t - # endif - -+__fortify_potential_overload __wur ssize_t -+pread (int __fd, void *const __clang_pass_object_size0 __buf, size_t __nbytes, -+ __fo_off_t __offset) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS0_LT (__pread_chk_warn, __nbytes, __buf, -+ "pread called with bigger length than " -+ "size of the destination buffer") -+{ -+ if (__FORTIFY_CALL_CHK && __bos0 (__buf) != (size_t) -1) -+ return __fo_pread_chk (__fd, __buf, __nbytes, __offset, __bos0 (__buf)); -+ return __fo_pread_alias (__fd, __buf, __nbytes, __offset); -+} -+__FORTIFY_FUNCTION_END -+ -+#undef __fo_pread_chk -+#undef __fo_pread_alias -+#undef __fo_off_t -+ - # ifdef __USE_LARGEFILE64 --__fortify_function __wur ssize_t --pread64 (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) -+__fortify_potential_overload __wur ssize_t -+pread64 (int __fd, void *const __clang_pass_object_size0 __buf, -+ size_t __nbytes, __off64_t __offset) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS0_LT (__pread64_warn, __nbytes, __buf, -+ "pread64 called with bigger length " -+ "than size of the destination buffer") - { -- if (__bos0 (__buf) != (size_t) -1) -- { -- if (!__builtin_constant_p (__nbytes)) -- return __pread64_chk (__fd, __buf, __nbytes, __offset, __bos0 (__buf)); -- -- if ( __nbytes > __bos0 (__buf)) -- return __pread64_chk_warn (__fd, __buf, __nbytes, __offset, -- __bos0 (__buf)); -- } -- -+ if (__FORTIFY_CALL_CHK && __bos0 (__buf) != (size_t) -1) -+ return __pread64_chk (__fd, __buf, __nbytes, __offset, __bos0 (__buf)); - return __pread64_alias (__fd, __buf, __nbytes, __offset); - } -+__FORTIFY_FUNCTION_END - # endif - #endif - -@@ -128,27 +104,21 @@ extern ssize_t __REDIRECT_NTH (__readlin - (const char *__restrict __path, - char *__restrict __buf, size_t __len), readlink) - __nonnull ((1, 2)) __wur; --extern ssize_t __REDIRECT_NTH (__readlink_chk_warn, -- (const char *__restrict __path, -- char *__restrict __buf, size_t __len, -- size_t __buflen), __readlink_chk) -- __nonnull ((1, 2)) __wur __warnattr ("readlink called with bigger length " -- "than size of destination buffer"); - --__fortify_function __nonnull ((1, 2)) __wur ssize_t --__NTH (readlink (const char *__restrict __path, char *__restrict __buf, -+__fortify_potential_overload __nonnull ((1, 2)) __wur ssize_t -+__NTH (readlink (const char *__restrict __path, -+ char *__restrict const __clang_pass_object_size __buf, - size_t __len)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__readlink_warn, __len, __buf, -+ "readlink called with bigger length " -+ "than size of destination buffer") - { -- if (__bos (__buf) != (size_t) -1) -- { -- if (!__builtin_constant_p (__len)) -- return __readlink_chk (__path, __buf, __len, __bos (__buf)); -- -- if ( __len > __bos (__buf)) -- return __readlink_chk_warn (__path, __buf, __len, __bos (__buf)); -- } -+ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) -+ return __readlink_chk (__path, __buf, __len, __bos (__buf)); - return __readlink_alias (__path, __buf, __len); - } -+__FORTIFY_FUNCTION_END - #endif - - #ifdef __USE_ATFILE -@@ -161,119 +131,104 @@ extern ssize_t __REDIRECT_NTH (__readlin - char *__restrict __buf, size_t __len), - readlinkat) - __nonnull ((2, 3)) __wur; --extern ssize_t __REDIRECT_NTH (__readlinkat_chk_warn, -- (int __fd, const char *__restrict __path, -- char *__restrict __buf, size_t __len, -- size_t __buflen), __readlinkat_chk) -- __nonnull ((2, 3)) __wur __warnattr ("readlinkat called with bigger " -- "length than size of destination " -- "buffer"); -- --__fortify_function __nonnull ((2, 3)) __wur ssize_t --__NTH (readlinkat (int __fd, const char *__restrict __path, -- char *__restrict __buf, size_t __len)) -+ -+__fortify_potential_overload __nonnull ((2, 3)) __wur ssize_t -+__NTH (readlinkat (int __fd, -+ const char *__restrict __path, -+ char *__restrict const __clang_pass_object_size __buf, -+ size_t __len)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__readlinkat_warn, __len, __buf, -+ "readlinkat called with bigger length " -+ "than size of destination buffer") - { -- if (__bos (__buf) != (size_t) -1) -- { -- if (!__builtin_constant_p (__len)) -- return __readlinkat_chk (__fd, __path, __buf, __len, __bos (__buf)); -- -- if (__len > __bos (__buf)) -- return __readlinkat_chk_warn (__fd, __path, __buf, __len, -- __bos (__buf)); -- } -+ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) -+ return __readlinkat_chk (__fd, __path, __buf, __len, __bos (__buf)); - return __readlinkat_alias (__fd, __path, __buf, __len); - } -+__FORTIFY_FUNCTION_END - #endif - - extern char *__getcwd_chk (char *__buf, size_t __size, size_t __buflen) - __THROW __wur; - extern char *__REDIRECT_NTH (__getcwd_alias, - (char *__buf, size_t __size), getcwd) __wur; --extern char *__REDIRECT_NTH (__getcwd_chk_warn, -- (char *__buf, size_t __size, size_t __buflen), -- __getcwd_chk) -- __wur __warnattr ("getcwd caller with bigger length than size of " -- "destination buffer"); - --__fortify_function __wur char * --__NTH (getcwd (char *__buf, size_t __size)) -+__fortify_potential_overload __wur char * -+__NTH (getcwd (char *const __clang_pass_object_size __buf, size_t __size)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__getcwd_warn, __size, __buf, -+ "getcwd called with bigger length than " -+ "size of destination buffer") - { -- if (__bos (__buf) != (size_t) -1) -- { -- if (!__builtin_constant_p (__size)) -- return __getcwd_chk (__buf, __size, __bos (__buf)); -- -- if (__size > __bos (__buf)) -- return __getcwd_chk_warn (__buf, __size, __bos (__buf)); -- } -+ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) -+ return __getcwd_chk (__buf, __size, __bos (__buf)); - return __getcwd_alias (__buf, __size); - } -+__FORTIFY_FUNCTION_END - - #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED -+# define __warn_getwd_use_something_else \ -+ "please use getcwd instead, as getwd doesn't specify buffer size" -+ - extern char *__getwd_chk (char *__buf, size_t buflen) - __THROW __nonnull ((1)) __wur; - extern char *__REDIRECT_NTH (__getwd_warn, (char *__buf), getwd) -- __nonnull ((1)) __wur __warnattr ("please use getcwd instead, as getwd " -- "doesn't specify buffer size"); -+ __nonnull ((1)) __wur __warnattr (__warn_getwd_use_something_else); -+ -+extern char *__REDIRECT (__getwd_alias, (char *__str), getwd) __wur; - --__fortify_function __nonnull ((1)) __attribute_deprecated__ __wur char * --__NTH (getwd (char *__buf)) -+__fortify_potential_overload __nonnull ((1)) __attribute_deprecated__ __wur -+char * -+__NTH (getwd (char *const __clang_pass_object_size __buf)) -+ __clang_warning_if (__bos (__buf) == (size_t) -1, -+ __warn_getwd_use_something_else) - { - if (__bos (__buf) != (size_t) -1) - return __getwd_chk (__buf, __bos (__buf)); - return __getwd_warn (__buf); - } -+# undef __warn_getwd_use_something_else - #endif - - extern size_t __confstr_chk (int __name, char *__buf, size_t __len, - size_t __buflen) __THROW; - extern size_t __REDIRECT_NTH (__confstr_alias, (int __name, char *__buf, - size_t __len), confstr); --extern size_t __REDIRECT_NTH (__confstr_chk_warn, -- (int __name, char *__buf, size_t __len, -- size_t __buflen), __confstr_chk) -- __warnattr ("confstr called with bigger length than size of destination " -- "buffer"); - --__fortify_function size_t --__NTH (confstr (int __name, char *__buf, size_t __len)) -+__fortify_potential_overload size_t -+__NTH (confstr (int __name, char *const __clang_pass_object_size __buf, -+ size_t __len)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__confstr_warn, __len, __buf, -+ "confstr called with bigger length than " -+ "size of destination buffer") - { -- if (__bos (__buf) != (size_t) -1) -- { -- if (!__builtin_constant_p (__len)) -- return __confstr_chk (__name, __buf, __len, __bos (__buf)); -- -- if (__bos (__buf) < __len) -- return __confstr_chk_warn (__name, __buf, __len, __bos (__buf)); -- } -+ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) -+ return __confstr_chk (__name, __buf, __len, __bos (__buf)); - return __confstr_alias (__name, __buf, __len); - } -- -+__FORTIFY_FUNCTION_END - - extern int __getgroups_chk (int __size, __gid_t __list[], size_t __listlen) - __THROW __wur; - extern int __REDIRECT_NTH (__getgroups_alias, (int __size, __gid_t __list[]), - getgroups) __wur; --extern int __REDIRECT_NTH (__getgroups_chk_warn, -- (int __size, __gid_t __list[], size_t __listlen), -- __getgroups_chk) -- __wur __warnattr ("getgroups called with bigger group count than what " -- "can fit into destination buffer"); -- --__fortify_function int --__NTH (getgroups (int __size, __gid_t __list[])) --{ -- if (__bos (__list) != (size_t) -1) -- { -- if (!__builtin_constant_p (__size) || __size < 0) -- return __getgroups_chk (__size, __list, __bos (__list)); -- -- if (__size * sizeof (__gid_t) > __bos (__list)) -- return __getgroups_chk_warn (__size, __list, __bos (__list)); -- } -+ -+__fortify_potential_overload int -+__NTH (getgroups (int __size, __gid_t *const __clang_pass_object_size __list)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__getgroups_warn, -+ __size * sizeof (__gid_t), __list, -+ "getgroups called with bigger group " -+ "count than what can fit into " -+ "destination buffer") -+{ -+ if (__FORTIFY_CALL_CHK && __bos (__list) != (size_t) -1) -+ return __getgroups_chk (__size, __list, __bos (__list)); - return __getgroups_alias (__size, __list); - } -+__FORTIFY_FUNCTION_END - - - extern int __ttyname_r_chk (int __fd, char *__buf, size_t __buflen, -@@ -287,19 +242,19 @@ extern int __REDIRECT_NTH (__ttyname_r_c - __nonnull ((2)) __warnattr ("ttyname_r called with bigger buflen than " - "size of destination buffer"); - --__fortify_function int --__NTH (ttyname_r (int __fd, char *__buf, size_t __buflen)) --{ -- if (__bos (__buf) != (size_t) -1) -- { -- if (!__builtin_constant_p (__buflen)) -- return __ttyname_r_chk (__fd, __buf, __buflen, __bos (__buf)); -- -- if (__buflen > __bos (__buf)) -- return __ttyname_r_chk_warn (__fd, __buf, __buflen, __bos (__buf)); -- } -- return __ttyname_r_alias (__fd, __buf, __buflen); --} -+__fortify_potential_overload int -+__NTH (ttyname_r (int __fd, char *const __clang_pass_object_size __buf, -+ size_t __buflen)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__ttyname_r_warn, __buflen, __buf, -+ "ttyname_r called with bigger buflen " -+ "than size of destination buffer") -+{ -+ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) -+ return __ttyname_r_chk (__fd, __buf, __buflen, __bos (__buf)); -+ return __ttyname_r_alias (__fd, __buf, __buflen); -+ } -+__FORTIFY_FUNCTION_END - - - #ifdef __USE_POSIX199506 -@@ -307,25 +262,19 @@ extern int __getlogin_r_chk (char *__buf - __nonnull ((1)); - extern int __REDIRECT (__getlogin_r_alias, (char *__buf, size_t __buflen), - getlogin_r) __nonnull ((1)); --extern int __REDIRECT (__getlogin_r_chk_warn, -- (char *__buf, size_t __buflen, size_t __nreal), -- __getlogin_r_chk) -- __nonnull ((1)) __warnattr ("getlogin_r called with bigger buflen than " -- "size of destination buffer"); - --__fortify_function int --getlogin_r (char *__buf, size_t __buflen) -+__fortify_potential_overload int -+getlogin_r (char *const __clang_pass_object_size __buf, size_t __buflen) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__getlogin_r_warn, __buflen, __buf, -+ "getlogin_r called with bigger buflen " -+ "than size of destination buffer") - { -- if (__bos (__buf) != (size_t) -1) -- { -- if (!__builtin_constant_p (__buflen)) -- return __getlogin_r_chk (__buf, __buflen, __bos (__buf)); -- -- if (__buflen > __bos (__buf)) -- return __getlogin_r_chk_warn (__buf, __buflen, __bos (__buf)); -- } -+ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) -+ return __getlogin_r_chk (__buf, __buflen, __bos (__buf)); - return __getlogin_r_alias (__buf, __buflen); - } -+__FORTIFY_FUNCTION_END - #endif - - -@@ -334,25 +283,20 @@ extern int __gethostname_chk (char *__bu - __THROW __nonnull ((1)); - extern int __REDIRECT_NTH (__gethostname_alias, (char *__buf, size_t __buflen), - gethostname) __nonnull ((1)); --extern int __REDIRECT_NTH (__gethostname_chk_warn, -- (char *__buf, size_t __buflen, size_t __nreal), -- __gethostname_chk) -- __nonnull ((1)) __warnattr ("gethostname called with bigger buflen than " -- "size of destination buffer"); - --__fortify_function int --__NTH (gethostname (char *__buf, size_t __buflen)) -+__fortify_potential_overload int -+__NTH (gethostname (char *const __clang_pass_object_size __buf, -+ size_t __buflen)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__gethostname_warn, __buflen, __buf, -+ "gethostname called with bigger buflen " -+ "than size of destination buffer") - { -- if (__bos (__buf) != (size_t) -1) -- { -- if (!__builtin_constant_p (__buflen)) -- return __gethostname_chk (__buf, __buflen, __bos (__buf)); -- -- if (__buflen > __bos (__buf)) -- return __gethostname_chk_warn (__buf, __buflen, __bos (__buf)); -- } -+ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) -+ return __gethostname_chk (__buf, __buflen, __bos (__buf)); - return __gethostname_alias (__buf, __buflen); - } -+__FORTIFY_FUNCTION_END - #endif - - -@@ -362,24 +306,18 @@ extern int __getdomainname_chk (char *__ - extern int __REDIRECT_NTH (__getdomainname_alias, (char *__buf, - size_t __buflen), - getdomainname) __nonnull ((1)) __wur; --extern int __REDIRECT_NTH (__getdomainname_chk_warn, -- (char *__buf, size_t __buflen, size_t __nreal), -- __getdomainname_chk) -- __nonnull ((1)) __wur __warnattr ("getdomainname called with bigger " -- "buflen than size of destination " -- "buffer"); - --__fortify_function int --__NTH (getdomainname (char *__buf, size_t __buflen)) -+__fortify_potential_overload int -+__NTH (getdomainname (char *const __clang_pass_object_size __buf, -+ size_t __buflen)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__getdomainname_warn, __buflen, __buf, -+ "getdomainname called with bigger " -+ "buflen than size of destination buffer") - { -- if (__bos (__buf) != (size_t) -1) -- { -- if (!__builtin_constant_p (__buflen)) -- return __getdomainname_chk (__buf, __buflen, __bos (__buf)); -- -- if (__buflen > __bos (__buf)) -- return __getdomainname_chk_warn (__buf, __buflen, __bos (__buf)); -- } -+ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) -+ return __getdomainname_chk (__buf, __buflen, __bos (__buf)); - return __getdomainname_alias (__buf, __buflen); - } -+__FORTIFY_FUNCTION_END - #endif ---- a/rt/bits/mqueue2.h -+++ b/rt/bits/mqueue2.h -@@ -29,10 +29,47 @@ extern mqd_t __mq_open_2 (const char *__ - extern mqd_t __REDIRECT_NTH (__mq_open_alias, (const char *__name, - int __oflag, ...), mq_open) - __nonnull ((1)); -+ -+#define __warn_mq_open_wrong_number_of_args "mq_open can be called either " \ -+ "with 2 or 4 arguments" -+#define __warn_mq_open_missing_mode_and_attr "mq_open with O_CREAT in " \ -+ "second argument needs 4 arguments" -+#ifdef __use_clang_fortify -+__fortify_overload __clang_error (__warn_mq_open_wrong_number_of_args) mqd_t -+__NTH (mq_open (const char *const __clang_pass_object_size __name, int __oflag, -+ int __mode)) -+{ -+ return __mq_open_alias (__name, __oflag, __mode); -+} -+ -+__fortify_overload __clang_error (__warn_mq_open_wrong_number_of_args) -+mqd_t -+__NTH (mq_open (const char *const __clang_pass_object_size __name, int __oflag, -+ int __mode, struct mq_attr *__attr, ...)) -+{ -+ return __mq_open_alias (__name, __oflag, __mode, __attr); -+} -+ -+__fortify_overload __clang_prefer_this_overload mqd_t -+__NTH (mq_open (const char *const __clang_pass_object_size __name, -+ int __oflag)) -+ __clang_error_if ((__oflag & O_CREAT), -+ __warn_mq_open_missing_mode_and_attr) -+{ -+ return __mq_open_alias (__name, __oflag); -+} -+ -+__fortify_overload __clang_prefer_this_overload mqd_t -+__NTH (mq_open (const char *const __clang_pass_object_size __name, int __oflag, -+ int __mode, struct mq_attr *__attr)) -+{ -+ return __mq_open_alias (__name, __oflag, __mode, __attr); -+} -+#else - __errordecl (__mq_open_wrong_number_of_args, -- "mq_open can be called either with 2 or 4 arguments"); -+ __warn_mq_open_wrong_number_of_args); - __errordecl (__mq_open_missing_mode_and_attr, -- "mq_open with O_CREAT in second argument needs 4 arguments"); -+ __warn_mq_open_missing_mode_and_attr); - - __fortify_function mqd_t - __NTH (mq_open (const char *__name, int __oflag, ...)) -@@ -55,3 +92,6 @@ __NTH (mq_open (const char *__name, int - - return __mq_open_alias (__name, __oflag, __va_arg_pack ()); - } -+#endif -+#undef __warn_mq_open_wrong_number_of_args -+#undef __warn_mq_open_missing_mode_and_attr ---- a/rt/mqueue.h -+++ b/rt/mqueue.h -@@ -89,7 +89,7 @@ extern int mq_timedsend (mqd_t __mqdes, - - /* Define some inlines helping to catch common problems. */ - #if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function \ -- && defined __va_arg_pack_len -+ && (defined __va_arg_pack_len || defined __use_clang_fortify) - # include - #endif - ---- a/socket/bits/socket2.h -+++ b/socket/bits/socket2.h -@@ -24,25 +24,20 @@ extern ssize_t __recv_chk (int __fd, voi - int __flags); - extern ssize_t __REDIRECT (__recv_alias, (int __fd, void *__buf, size_t __n, - int __flags), recv); --extern ssize_t __REDIRECT (__recv_chk_warn, -- (int __fd, void *__buf, size_t __n, size_t __buflen, -- int __flags), __recv_chk) -- __warnattr ("recv called with bigger length than size of destination " -- "buffer"); - --__fortify_function ssize_t --recv (int __fd, void *__buf, size_t __n, int __flags) -+__fortify_potential_overload ssize_t -+recv (int __fd, void *const __clang_pass_object_size0 __buf, size_t __n, -+ int __flags) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS0_LT (__recv_warn, __n, __buf, -+ "recv called with bigger length than " -+ "size of destination buffer") - { -- if (__bos0 (__buf) != (size_t) -1) -- { -- if (!__builtin_constant_p (__n)) -- return __recv_chk (__fd, __buf, __n, __bos0 (__buf), __flags); -- -- if (__n > __bos0 (__buf)) -- return __recv_chk_warn (__fd, __buf, __n, __bos0 (__buf), __flags); -- } -+ if (__FORTIFY_CALL_CHK && __bos0 (__buf) != (size_t) -1) -+ return __recv_chk (__fd, __buf, __n, __bos0 (__buf), __flags); - return __recv_alias (__fd, __buf, __n, __flags); - } -+__FORTIFY_FUNCTION_END - - extern ssize_t __recvfrom_chk (int __fd, void *__restrict __buf, size_t __n, - size_t __buflen, int __flags, -@@ -52,26 +47,19 @@ extern ssize_t __REDIRECT (__recvfrom_al - (int __fd, void *__restrict __buf, size_t __n, - int __flags, __SOCKADDR_ARG __addr, - socklen_t *__restrict __addr_len), recvfrom); --extern ssize_t __REDIRECT (__recvfrom_chk_warn, -- (int __fd, void *__restrict __buf, size_t __n, -- size_t __buflen, int __flags, -- __SOCKADDR_ARG __addr, -- socklen_t *__restrict __addr_len), __recvfrom_chk) -- __warnattr ("recvfrom called with bigger length than size of " -- "destination buffer"); - --__fortify_function ssize_t --recvfrom (int __fd, void *__restrict __buf, size_t __n, int __flags, -- __SOCKADDR_ARG __addr, socklen_t *__restrict __addr_len) -+__fortify_potential_overload ssize_t -+recvfrom (int __fd, void *__restrict const __clang_pass_object_size0 __buf, -+ size_t __n, int __flags, __SOCKADDR_ARG __addr, -+ socklen_t *__restrict __addr_len) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS0_LT (__recvfrom_warn, __n, __buf, -+ "recvfrom called with bigger length " -+ "than size of destination buffer") - { -- if (__bos0 (__buf) != (size_t) -1) -- { -- if (!__builtin_constant_p (__n)) -- return __recvfrom_chk (__fd, __buf, __n, __bos0 (__buf), __flags, -- __addr, __addr_len); -- if (__n > __bos0 (__buf)) -- return __recvfrom_chk_warn (__fd, __buf, __n, __bos0 (__buf), __flags, -- __addr, __addr_len); -- } -+ if (__FORTIFY_CALL_CHK && __bos0 (__buf) != (size_t) -1) -+ return __recvfrom_chk (__fd, __buf, __n, __bos0 (__buf), __flags, __addr, -+ __addr_len); - return __recvfrom_alias (__fd, __buf, __n, __flags, __addr, __addr_len); - } -+__FORTIFY_FUNCTION_END ---- a/stdlib/bits/stdlib.h -+++ b/stdlib/bits/stdlib.h -@@ -26,27 +26,27 @@ extern char *__realpath_chk (const char - extern char *__REDIRECT_NTH (__realpath_alias, - (const char *__restrict __name, - char *__restrict __resolved), realpath) __wur; --extern char *__REDIRECT_NTH (__realpath_chk_warn, -- (const char *__restrict __name, -- char *__restrict __resolved, -- size_t __resolvedlen), __realpath_chk) __wur -- __warnattr ("second argument of realpath must be either NULL or at " -- "least PATH_MAX bytes long buffer"); - --__fortify_function __wur char * --__NTH (realpath (const char *__restrict __name, char *__restrict __resolved)) -+__fortify_potential_overload __wur char * -+__NTH (realpath (const char *__restrict __name, -+ char *__restrict const __clang_pass_object_size __resolved)) -+__FORTIFY_PRECONDITIONS -+#if defined _LIBC_LIMITS_H_ && defined PATH_MAX -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__realpath_warn, PATH_MAX, __resolved, -+ "second argument of realpath must be " -+ "either NULL or at least PATH_MAX " -+ "bytes long buffer") -+#endif - { -- if (__bos (__resolved) != (size_t) -1) -- { -+ if ( - #if defined _LIBC_LIMITS_H_ && defined PATH_MAX -- if (__bos (__resolved) < PATH_MAX) -- return __realpath_chk_warn (__name, __resolved, __bos (__resolved)); -+ __FORTIFY_CALL_CHK && - #endif -- return __realpath_chk (__name, __resolved, __bos (__resolved)); -- } -- -+ __bos (__resolved) != (size_t) -1) -+ return __realpath_chk (__name, __resolved, __bos (__resolved)); - return __realpath_alias (__name, __resolved); - } -+__FORTIFY_FUNCTION_END - - - extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen, -@@ -54,33 +54,28 @@ extern int __ptsname_r_chk (int __fd, ch - extern int __REDIRECT_NTH (__ptsname_r_alias, (int __fd, char *__buf, - size_t __buflen), ptsname_r) - __nonnull ((2)); --extern int __REDIRECT_NTH (__ptsname_r_chk_warn, -- (int __fd, char *__buf, size_t __buflen, -- size_t __nreal), __ptsname_r_chk) -- __nonnull ((2)) __warnattr ("ptsname_r called with buflen bigger than " -- "size of buf"); - --__fortify_function int --__NTH (ptsname_r (int __fd, char *__buf, size_t __buflen)) -+__fortify_potential_overload int -+__NTH (ptsname_r (int __fd, char *const __clang_pass_object_size __buf, -+ size_t __buflen)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__ptsname_r_warn, __buflen, __buf, -+ "ptsname_r called with buflen " -+ "bigger than size of buf") - { -- if (__bos (__buf) != (size_t) -1) -- { -- if (!__builtin_constant_p (__buflen)) -- return __ptsname_r_chk (__fd, __buf, __buflen, __bos (__buf)); -- if (__buflen > __bos (__buf)) -- return __ptsname_r_chk_warn (__fd, __buf, __buflen, __bos (__buf)); -- } -+ if (__FORTIFY_CALL_CHK && __bos (__buf) != (size_t) -1) -+ return __ptsname_r_chk (__fd, __buf, __buflen, __bos (__buf)); - return __ptsname_r_alias (__fd, __buf, __buflen); - } -- -+__FORTIFY_FUNCTION_END - - extern int __wctomb_chk (char *__s, wchar_t __wchar, size_t __buflen) - __THROW __wur; - extern int __REDIRECT_NTH (__wctomb_alias, (char *__s, wchar_t __wchar), - wctomb) __wur; - --__fortify_function __wur int --__NTH (wctomb (char *__s, wchar_t __wchar)) -+__fortify_potential_overload __wur int -+__NTH (wctomb (char *const __clang_pass_object_size __s, wchar_t __wchar)) - { - /* We would have to include to get a definition of MB_LEN_MAX. - But this would only disturb the namespace. So we define our own -@@ -102,29 +97,22 @@ extern size_t __REDIRECT_NTH (__mbstowcs - (wchar_t *__restrict __dst, - const char *__restrict __src, - size_t __len), mbstowcs); --extern size_t __REDIRECT_NTH (__mbstowcs_chk_warn, -- (wchar_t *__restrict __dst, -- const char *__restrict __src, -- size_t __len, size_t __dstlen), __mbstowcs_chk) -- __warnattr ("mbstowcs called with dst buffer smaller than len " -- "* sizeof (wchar_t)"); -- --__fortify_function size_t --__NTH (mbstowcs (wchar_t *__restrict __dst, const char *__restrict __src, -- size_t __len)) -+ -+__fortify_potential_overload size_t -+__NTH (mbstowcs (wchar_t *__restrict const __clang_pass_object_size __dst, -+ const char *__restrict __src, size_t __len)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT2 (__mbstowcs_warn, __len, __dst, -+ sizeof (wchar_t), -+ "mbstowcs called with dst buffer " -+ "smaller than len * sizeof (wchar_t)") - { -- if (__bos (__dst) != (size_t) -1) -- { -- if (!__builtin_constant_p (__len)) -- return __mbstowcs_chk (__dst, __src, __len, -- __bos (__dst) / sizeof (wchar_t)); -- -- if (__len > __bos (__dst) / sizeof (wchar_t)) -- return __mbstowcs_chk_warn (__dst, __src, __len, -- __bos (__dst) / sizeof (wchar_t)); -- } -+ if (__FORTIFY_CALL_CHK && __bos (__dst) != (size_t) -1) -+ return __mbstowcs_chk (__dst, __src, __len, -+ __bos (__dst) / sizeof (wchar_t)); - return __mbstowcs_alias (__dst, __src, __len); - } -+__FORTIFY_FUNCTION_END - - - extern size_t __wcstombs_chk (char *__restrict __dst, -@@ -134,22 +122,17 @@ extern size_t __REDIRECT_NTH (__wcstombs - (char *__restrict __dst, - const wchar_t *__restrict __src, - size_t __len), wcstombs); --extern size_t __REDIRECT_NTH (__wcstombs_chk_warn, -- (char *__restrict __dst, -- const wchar_t *__restrict __src, -- size_t __len, size_t __dstlen), __wcstombs_chk) -- __warnattr ("wcstombs called with dst buffer smaller than len"); - --__fortify_function size_t --__NTH (wcstombs (char *__restrict __dst, const wchar_t *__restrict __src, -- size_t __len)) -+__fortify_potential_overload size_t -+__NTH (wcstombs (char *__restrict const __clang_pass_object_size __dst, -+ const wchar_t *__restrict __src, size_t __len)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__wcstombs_warn, __len, __dst, -+ "wcstombs called with dst buffer " -+ "smaller than len") - { -- if (__bos (__dst) != (size_t) -1) -- { -- if (!__builtin_constant_p (__len)) -- return __wcstombs_chk (__dst, __src, __len, __bos (__dst)); -- if (__len > __bos (__dst)) -- return __wcstombs_chk_warn (__dst, __src, __len, __bos (__dst)); -- } -+ if (__FORTIFY_CALL_CHK && __bos (__dst) != (size_t) -1) -+ return __wcstombs_chk (__dst, __src, __len, __bos (__dst)); - return __wcstombs_alias (__dst, __src, __len); - } -+__FORTIFY_FUNCTION_END ---- a/string/bits/string_fortified.h -+++ b/string/bits/string_fortified.h -@@ -22,45 +22,82 @@ - # error "Never use directly; include instead." - #endif - --#if !__GNUC_PREREQ (5,0) --__warndecl (__warn_memset_zero_len, -- "memset used with constant zero length parameter; this could be due to transposed parameters"); --#endif -- --__fortify_function void * --__NTH (memcpy (void *__restrict __dest, const void *__restrict __src, -- size_t __len)) --{ -- return __builtin___memcpy_chk (__dest, __src, __len, __bos0 (__dest)); --} -- --__fortify_function void * --__NTH (memmove (void *__dest, const void *__src, size_t __len)) --{ -- return __builtin___memmove_chk (__dest, __src, __len, __bos0 (__dest)); -+#define __warn_len_too_large \ -+ "function called with bigger length than the destination buffer" -+/* Repeat bodies here to reduce 'note's if we detect a problem. */ -+#define __size_too_small(bos, dest, len) \ -+ (bos (dest) != (size_t) -1 && bos (dest) < len) -+#define __warn_if_dest_too_small(dest, len) \ -+ __clang_warning_if (__size_too_small (__bos, dest, len), \ -+ __warn_len_too_large) -+#define __warn_if_dest_too_small0(dest, len) \ -+ __clang_warning_if (__size_too_small (__bos0, dest, len), \ -+ __warn_len_too_large) -+ -+#define __warn_input_str_too_large \ -+ "destination buffer will always be overflown by source" -+#define __warn_if_src_too_large(dest, src) \ -+ __clang_warning_if (__size_too_small (__bos, dest, __builtin_strlen (src) + 1), \ -+ __warn_input_str_too_large) -+ -+__fortify_potential_overload void * -+__NTH (memcpy (void *__restrict const __clang_pass_object_size0 __dest, -+ const void *__restrict __src, size_t __len)) -+ __warn_if_dest_too_small0 (__dest, __len) -+{ -+ size_t __bos_dst = __bos0 (__dest); -+ if (__bos_dst == (size_t) -1 || (__builtin_constant_p (__len) -+ && __bos_dst >= __len)) -+ return __builtin_memcpy (__dest, __src, __len); -+ return __builtin___memcpy_chk (__dest, __src, __len, __bos_dst); -+} -+ -+__fortify_potential_overload void * -+__NTH (memmove (void *const __clang_pass_object_size0 __dest, -+ const void *__src, size_t __len)) -+ __warn_if_dest_too_small0 (__dest, __len) -+{ -+ size_t __bos_dst = __bos0 (__dest); -+ if (__bos_dst == (size_t) -1 || (__builtin_constant_p (__len) -+ && __bos_dst >= __len)) -+ return __builtin_memmove (__dest, __src, __len); -+ return __builtin___memmove_chk (__dest, __src, __len, __bos_dst); - } - - #ifdef __USE_GNU --__fortify_function void * --__NTH (mempcpy (void *__restrict __dest, const void *__restrict __src, -- size_t __len)) --{ -- return __builtin___mempcpy_chk (__dest, __src, __len, __bos0 (__dest)); -+__fortify_potential_overload void * -+__NTH (mempcpy (void *__restrict const __clang_pass_object_size0 __dest, -+ const void *__restrict __src, size_t __len)) -+ __warn_if_dest_too_small0 (__dest, __len) -+{ -+ size_t __bos_dst = __bos0 (__dest); -+ if (__bos_dst == (size_t) -1 || (__builtin_constant_p (__len) -+ && __bos_dst >= __len)) -+ return __builtin_mempcpy (__dest, __src, __len); -+ return __builtin___mempcpy_chk (__dest, __src, __len, __bos_dst); - } - #endif - -- - /* The first two tests here help to catch a somewhat common problem - where the second and third parameter are transposed. This is - especially problematic if the intended fill value is zero. In this - case no work is done at all. We detect these problems by referring - non-existing functions. */ --__fortify_function void * --__NTH (memset (void *__dest, int __ch, size_t __len)) -+#define __warn_memset_zero_len_msg \ -+ "memset used with constant zero length parameter; this could be due to " \ -+ "transposed parameters" -+#if !__GNUC_PREREQ (5,0) -+__warndecl (__warn_memset_zero_len, __warn_memset_zero_len_msg); -+#endif -+__fortify_potential_overload void * -+__NTH (memset (void *const __clang_pass_object_size0 __dest, int __ch, -+ size_t __len)) -+ __warn_if_dest_too_small0 (__dest, __len) -+ __clang_warning_if (__len == 0 && __ch != 0, __warn_memset_zero_len_msg) - { - /* GCC-5.0 and newer implements these checks in the compiler, so we don't - need them here. */ --#if !__GNUC_PREREQ (5,0) -+#if !__GNUC_PREREQ (5,0) && !defined __use_clang_fortify - if (__builtin_constant_p (__len) && __len == 0 - && (!__builtin_constant_p (__ch) || __ch != 0)) - { -@@ -68,8 +105,13 @@ __NTH (memset (void *__dest, int __ch, s - return __dest; - } - #endif -- return __builtin___memset_chk (__dest, __ch, __len, __bos0 (__dest)); -+ size_t __bos_dst = __bos0 (__dest); -+ if (__bos_dst == (size_t) -1 || (__builtin_constant_p (__len) -+ && __bos_dst >= __len)) -+ return __builtin_memset (__dest, __ch, __len); -+ return __builtin___memset_chk (__dest, __ch, __len, __bos_dst); - } -+#undef __warn_memset_zero_len_msg - - #ifdef __USE_MISC - # include -@@ -84,24 +126,30 @@ __NTH (explicit_bzero (void *__dest, siz - } - #endif - --__fortify_function char * --__NTH (strcpy (char *__restrict __dest, const char *__restrict __src)) -+__fortify_potential_overload char * -+__NTH (strcpy (char *__restrict const __clang_pass_object_size __dest, -+ const char *__restrict __src)) -+ __warn_if_src_too_large (__dest, __src) - { - return __builtin___strcpy_chk (__dest, __src, __bos (__dest)); - } - - #ifdef __USE_GNU --__fortify_function char * --__NTH (stpcpy (char *__restrict __dest, const char *__restrict __src)) -+__fortify_potential_overload char * -+__NTH (stpcpy (char *__restrict const __clang_pass_object_size __dest, -+ const char *__restrict __src)) -+ __warn_if_src_too_large (__dest, __src) - { - return __builtin___stpcpy_chk (__dest, __src, __bos (__dest)); - } - #endif - -- --__fortify_function char * --__NTH (strncpy (char *__restrict __dest, const char *__restrict __src, -- size_t __len)) -+__fortify_potential_overload char * -+__NTH (strncpy (char *__restrict const __clang_pass_object_size __dest, -+ const char *__restrict __src, size_t __len)) -+/* clang: Don't warn when __builtin_strlen (__src) < __bos (__dest), -+ but __len > __bos (__dest). The user should fix their code instead. */ -+ __warn_if_dest_too_small (__dest, __len) - { - return __builtin___strncpy_chk (__dest, __src, __len, __bos (__dest)); - } -@@ -112,28 +160,36 @@ extern char *__stpncpy_chk (char *__dest - extern char *__REDIRECT_NTH (__stpncpy_alias, (char *__dest, const char *__src, - size_t __n), stpncpy); - --__fortify_function char * --__NTH (stpncpy (char *__dest, const char *__src, size_t __n)) -+__fortify_potential_overload char * -+__NTH (stpncpy (char *const __clang_pass_object_size __dest, const char *__src, -+ size_t __n)) -+ __warn_if_dest_too_small (__dest, __n) - { -- if (__bos (__dest) != (size_t) -1 -- && (!__builtin_constant_p (__n) || __n > __bos (__dest))) -+ if (__bos (__dest) != (size_t) -1) - return __stpncpy_chk (__dest, __src, __n, __bos (__dest)); - return __stpncpy_alias (__dest, __src, __n); - } - -- --__fortify_function char * --__NTH (strcat (char *__restrict __dest, const char *__restrict __src)) -+__fortify_potential_overload char * -+__NTH (strcat (char *__restrict const __clang_pass_object_size __dest, -+ const char *__restrict __src)) -+ __warn_if_src_too_large (__dest, __src) - { - return __builtin___strcat_chk (__dest, __src, __bos (__dest)); - } - -- --__fortify_function char * --__NTH (strncat (char *__restrict __dest, const char *__restrict __src, -- size_t __len)) -+__fortify_potential_overload char * -+__NTH (strncat (char *__restrict const __clang_pass_object_size __dest, -+ const char *__restrict __src, size_t __len)) -+ __warn_if_src_too_large (__dest, __src) - { - return __builtin___strncat_chk (__dest, __src, __len, __bos (__dest)); - } - -+#undef __warn_len_too_large -+#undef __size_too_small -+#undef __warn_if_dest_too_small -+#undef __warn_if_dest_too_small0 -+#undef __warn_input_str_too_large -+#undef __warn_if_src_too_large - #endif /* bits/string_fortified.h */ ---- a/string/bits/strings_fortified.h -+++ b/string/bits/strings_fortified.h -@@ -19,16 +19,40 @@ - #ifndef __STRINGS_FORTIFIED - # define __STRINGS_FORTIFIED 1 - --__fortify_function void --__NTH (bcopy (const void *__src, void *__dest, size_t __len)) -+#define __strings_warn_len_too_large \ -+ "function called with bigger length than the destination buffer" -+ -+#define __strings_size_too_small(dest, len) \ -+ (__bos0 (dest) != (size_t) -1 && __bos0 (dest) < len) -+ -+__fortify_potential_overload void -+__NTH (bcopy (const void *__src, void *const __clang_pass_object_size0 __dest, -+ size_t __len)) -+ __clang_warning_if (__strings_size_too_small (__dest, __len), -+ __strings_warn_len_too_large) - { -- (void) __builtin___memmove_chk (__dest, __src, __len, __bos0 (__dest)); -+ size_t __bos_dst = __bos0 (__dest); -+ if (__bos_dst == (size_t) -1 || (__builtin_constant_p (__len) -+ && __bos_dst >= __len)) -+ (void) __builtin_memmove (__dest, __src, __len); -+ else -+ (void) __builtin___memmove_chk (__dest, __src, __len, __bos_dst); - } - --__fortify_function void --__NTH (bzero (void *__dest, size_t __len)) -+__fortify_potential_overload void -+__NTH (bzero (void *const __clang_pass_object_size0 __dest, size_t __len)) -+ __clang_warning_if (__strings_size_too_small (__dest, __len), -+ __strings_warn_len_too_large) - { -- (void) __builtin___memset_chk (__dest, '\0', __len, __bos0 (__dest)); -+ size_t __bos_dst = __bos0 (__dest); -+ if (__bos_dst == (size_t) -1 || (__builtin_constant_p (__len) -+ && __bos_dst >= __len)) -+ (void) __builtin_memset (__dest, '\0', __len); -+ else -+ (void) __builtin___memset_chk (__dest, '\0', __len, __bos_dst); - } - -+ -+#undef __strings_size_too_small -+#undef __strings_warn_len_too_large - #endif ---- a/wcsmbs/bits/wchar2.h -+++ b/wcsmbs/bits/wchar2.h -@@ -20,7 +20,6 @@ - # error "Never include directly; use instead." - #endif - -- - extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n, - size_t __ns1) __THROW; -@@ -28,57 +27,42 @@ extern wchar_t *__REDIRECT_NTH (__wmemcp - (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n), - wmemcpy); --extern wchar_t *__REDIRECT_NTH (__wmemcpy_chk_warn, -- (wchar_t *__restrict __s1, -- const wchar_t *__restrict __s2, size_t __n, -- size_t __ns1), __wmemcpy_chk) -- __warnattr ("wmemcpy called with length bigger than size of destination " -- "buffer"); - --__fortify_function wchar_t * --__NTH (wmemcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, -- size_t __n)) --{ -- if (__bos0 (__s1) != (size_t) -1) -- { -- if (!__builtin_constant_p (__n)) -- return __wmemcpy_chk (__s1, __s2, __n, -- __bos0 (__s1) / sizeof (wchar_t)); -- -- if (__n > __bos0 (__s1) / sizeof (wchar_t)) -- return __wmemcpy_chk_warn (__s1, __s2, __n, -- __bos0 (__s1) / sizeof (wchar_t)); -- } -- return __wmemcpy_alias (__s1, __s2, __n); -+__fortify_potential_overload wchar_t * -+__NTH (wmemcpy (wchar_t *__restrict const __clang_pass_object_size0 __s1, -+ const wchar_t *__restrict __s2, size_t __n)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS0_LT2 (__wmemcpy_warn, __n, __s1, -+ sizeof (wchar_t), -+ "wmemcpy called with length bigger " -+ "than size of destination buffer") -+{ -+ if (__FORTIFY_CALL_CHK && __bos0 (__s1) != (size_t)-1) -+ return __wmemcpy_chk(__s1, __s2, __n, __bos0(__s1) / sizeof (wchar_t)); -+ return __wmemcpy_alias(__s1, __s2, __n); - } -- -+__FORTIFY_FUNCTION_END - - extern wchar_t *__wmemmove_chk (wchar_t *__s1, const wchar_t *__s2, - size_t __n, size_t __ns1) __THROW; - extern wchar_t *__REDIRECT_NTH (__wmemmove_alias, (wchar_t *__s1, - const wchar_t *__s2, - size_t __n), wmemmove); --extern wchar_t *__REDIRECT_NTH (__wmemmove_chk_warn, -- (wchar_t *__s1, const wchar_t *__s2, -- size_t __n, size_t __ns1), __wmemmove_chk) -- __warnattr ("wmemmove called with length bigger than size of destination " -- "buffer"); -- --__fortify_function wchar_t * --__NTH (wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)) --{ -- if (__bos0 (__s1) != (size_t) -1) -- { -- if (!__builtin_constant_p (__n)) -- return __wmemmove_chk (__s1, __s2, __n, -- __bos0 (__s1) / sizeof (wchar_t)); -- -- if (__n > __bos0 (__s1) / sizeof (wchar_t)) -- return __wmemmove_chk_warn (__s1, __s2, __n, -- __bos0 (__s1) / sizeof (wchar_t)); -- } -+ -+__fortify_potential_overload wchar_t * -+__NTH (wmemmove (wchar_t *const __clang_pass_object_size0 __s1, -+ const wchar_t *__s2, size_t __n)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS0_LT2 (__wmemmove_warn, __n, __s1, -+ sizeof (wchar_t), -+ "wmemmove called with length bigger " -+ "than size of destination buffer") -+{ -+ if (__FORTIFY_CALL_CHK && __bos0 (__s1) != (size_t) -1) -+ return __wmemmove_chk (__s1, __s2, __n, __bos0 (__s1) / sizeof (wchar_t)); - return __wmemmove_alias (__s1, __s2, __n); - } -+__FORTIFY_FUNCTION_END - - - #ifdef __USE_GNU -@@ -89,29 +73,21 @@ extern wchar_t *__REDIRECT_NTH (__wmempc - (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, - size_t __n), wmempcpy); --extern wchar_t *__REDIRECT_NTH (__wmempcpy_chk_warn, -- (wchar_t *__restrict __s1, -- const wchar_t *__restrict __s2, size_t __n, -- size_t __ns1), __wmempcpy_chk) -- __warnattr ("wmempcpy called with length bigger than size of destination " -- "buffer"); -- --__fortify_function wchar_t * --__NTH (wmempcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, -- size_t __n)) --{ -- if (__bos0 (__s1) != (size_t) -1) -- { -- if (!__builtin_constant_p (__n)) -- return __wmempcpy_chk (__s1, __s2, __n, -- __bos0 (__s1) / sizeof (wchar_t)); -- -- if (__n > __bos0 (__s1) / sizeof (wchar_t)) -- return __wmempcpy_chk_warn (__s1, __s2, __n, -- __bos0 (__s1) / sizeof (wchar_t)); -- } -- return __wmempcpy_alias (__s1, __s2, __n); -+ -+__fortify_potential_overload wchar_t * -+__NTH(wmempcpy(wchar_t *__restrict const __clang_pass_object_size0 __s1, -+ const wchar_t *__restrict __s2, size_t __n)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS0_LT2 (__wmempcpy_warn, __n, __s1, -+ sizeof (wchar_t), -+ "wmempcpy called with length bigger " -+ "than size of destination buffer") -+{ -+ if (__FORTIFY_CALL_CHK && __bos0 (__s1) != (size_t)-1) -+ return __wmempcpy_chk(__s1, __s2, __n, __bos0(__s1) / sizeof (wchar_t)); -+ return __wmempcpy_alias(__s1, __s2, __n); - } -+__FORTIFY_FUNCTION_END - #endif - - -@@ -119,26 +95,21 @@ extern wchar_t *__wmemset_chk (wchar_t * - size_t __ns) __THROW; - extern wchar_t *__REDIRECT_NTH (__wmemset_alias, (wchar_t *__s, wchar_t __c, - size_t __n), wmemset); --extern wchar_t *__REDIRECT_NTH (__wmemset_chk_warn, -- (wchar_t *__s, wchar_t __c, size_t __n, -- size_t __ns), __wmemset_chk) -- __warnattr ("wmemset called with length bigger than size of destination " -- "buffer"); -- --__fortify_function wchar_t * --__NTH (wmemset (wchar_t *__s, wchar_t __c, size_t __n)) --{ -- if (__bos0 (__s) != (size_t) -1) -- { -- if (!__builtin_constant_p (__n)) -- return __wmemset_chk (__s, __c, __n, __bos0 (__s) / sizeof (wchar_t)); -- -- if (__n > __bos0 (__s) / sizeof (wchar_t)) -- return __wmemset_chk_warn (__s, __c, __n, -- __bos0 (__s) / sizeof (wchar_t)); -- } -+ -+__fortify_potential_overload wchar_t * -+__NTH (wmemset (wchar_t *const __clang_pass_object_size0 __s, wchar_t __c, -+ size_t __n)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS0_LT2 (__wmemset_warn, __n, __s, -+ sizeof (wchar_t), -+ "wmemset called with length bigger " -+ "than size of destination buffer") -+{ -+ if (__FORTIFY_CALL_CHK && __bos0 (__s) != (size_t) -1) -+ return __wmemset_chk (__s, __c, __n, __bos0 (__s) / sizeof (wchar_t)); - return __wmemset_alias (__s, __c, __n); - } -+__FORTIFY_FUNCTION_END - - - extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest, -@@ -148,8 +119,9 @@ extern wchar_t *__REDIRECT_NTH (__wcscpy - (wchar_t *__restrict __dest, - const wchar_t *__restrict __src), wcscpy); - --__fortify_function wchar_t * --__NTH (wcscpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src)) -+__fortify_potential_overload wchar_t * -+__NTH (wcscpy (wchar_t *__restrict const __clang_pass_object_size __dest, -+ const wchar_t *__restrict __src)) - { - if (__bos (__dest) != (size_t) -1) - return __wcscpy_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t)); -@@ -164,8 +136,9 @@ extern wchar_t *__REDIRECT_NTH (__wcpcpy - (wchar_t *__restrict __dest, - const wchar_t *__restrict __src), wcpcpy); - --__fortify_function wchar_t * --__NTH (wcpcpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src)) -+__fortify_potential_overload wchar_t * -+__NTH (wcpcpy (wchar_t *__restrict const __clang_pass_object_size __dest, -+ const wchar_t *__restrict __src)) - { - if (__bos (__dest) != (size_t) -1) - return __wcpcpy_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t)); -@@ -180,28 +153,22 @@ extern wchar_t *__REDIRECT_NTH (__wcsncp - (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, - size_t __n), wcsncpy); --extern wchar_t *__REDIRECT_NTH (__wcsncpy_chk_warn, -- (wchar_t *__restrict __dest, -- const wchar_t *__restrict __src, -- size_t __n, size_t __destlen), __wcsncpy_chk) -- __warnattr ("wcsncpy called with length bigger than size of destination " -- "buffer"); - --__fortify_function wchar_t * --__NTH (wcsncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, -- size_t __n)) -+__fortify_potential_overload wchar_t * -+__NTH (wcsncpy (wchar_t *__restrict const __clang_pass_object_size __dest, -+ const wchar_t *__restrict __src, size_t __n)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT2 (__wcsncpy_warn, __n, __dest, -+ sizeof (wchar_t), -+ "wcsncpy called with length bigger " -+ "than size of destination buffer") - { -- if (__bos (__dest) != (size_t) -1) -- { -- if (!__builtin_constant_p (__n)) -- return __wcsncpy_chk (__dest, __src, __n, -- __bos (__dest) / sizeof (wchar_t)); -- if (__n > __bos (__dest) / sizeof (wchar_t)) -- return __wcsncpy_chk_warn (__dest, __src, __n, -- __bos (__dest) / sizeof (wchar_t)); -- } -+ if (__FORTIFY_CALL_CHK && __bos (__dest) != (size_t) -1) -+ return __wcsncpy_chk (__dest, __src, __n, -+ __bos (__dest) / sizeof (wchar_t)); - return __wcsncpy_alias (__dest, __src, __n); - } -+__FORTIFY_FUNCTION_END - - - extern wchar_t *__wcpncpy_chk (wchar_t *__restrict __dest, -@@ -211,29 +178,22 @@ extern wchar_t *__REDIRECT_NTH (__wcpncp - (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, - size_t __n), wcpncpy); --extern wchar_t *__REDIRECT_NTH (__wcpncpy_chk_warn, -- (wchar_t *__restrict __dest, -- const wchar_t *__restrict __src, -- size_t __n, size_t __destlen), __wcpncpy_chk) -- __warnattr ("wcpncpy called with length bigger than size of destination " -- "buffer"); - --__fortify_function wchar_t * --__NTH (wcpncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, -- size_t __n)) -+__fortify_potential_overload wchar_t * -+__NTH (wcpncpy (wchar_t *__restrict const __clang_pass_object_size __dest, -+ const wchar_t *__restrict __src, size_t __n)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT2 (__wcpncpy_warn, __n, __dest, -+ sizeof (wchar_t), -+ "wcpncpy called with length bigger " -+ "than size of destination buffer") - { -- if (__bos (__dest) != (size_t) -1) -- { -- if (!__builtin_constant_p (__n)) -- return __wcpncpy_chk (__dest, __src, __n, -- __bos (__dest) / sizeof (wchar_t)); -- if (__n > __bos (__dest) / sizeof (wchar_t)) -- return __wcpncpy_chk_warn (__dest, __src, __n, -- __bos (__dest) / sizeof (wchar_t)); -- } -+ if (__FORTIFY_CALL_CHK && __bos (__dest) != (size_t) -1) -+ return __wcpncpy_chk (__dest, __src, __n, -+ __bos (__dest) / sizeof (wchar_t)); - return __wcpncpy_alias (__dest, __src, __n); - } -- -+__FORTIFY_FUNCTION_END - - extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, -@@ -242,8 +202,9 @@ extern wchar_t *__REDIRECT_NTH (__wcscat - (wchar_t *__restrict __dest, - const wchar_t *__restrict __src), wcscat); - --__fortify_function wchar_t * --__NTH (wcscat (wchar_t *__restrict __dest, const wchar_t *__restrict __src)) -+__fortify_potential_overload wchar_t * -+__NTH (wcscat (wchar_t *__restrict const __clang_pass_object_size __dest, -+ const wchar_t *__restrict __src)) - { - if (__bos (__dest) != (size_t) -1) - return __wcscat_chk (__dest, __src, __bos (__dest) / sizeof (wchar_t)); -@@ -259,9 +220,9 @@ extern wchar_t *__REDIRECT_NTH (__wcsnca - const wchar_t *__restrict __src, - size_t __n), wcsncat); - --__fortify_function wchar_t * --__NTH (wcsncat (wchar_t *__restrict __dest, const wchar_t *__restrict __src, -- size_t __n)) -+__fortify_potential_overload wchar_t * -+__NTH (wcsncat (wchar_t *__restrict const __clang_pass_object_size __dest, -+ const wchar_t *__restrict __src, size_t __n)) - { - if (__bos (__dest) != (size_t) -1) - return __wcsncat_chk (__dest, __src, __n, -@@ -280,16 +241,34 @@ extern int __REDIRECT_NTH_LDBL (__swprin - const wchar_t *__restrict __fmt, ...), - swprintf); - --#ifdef __va_arg_pack --__fortify_function int --__NTH (swprintf (wchar_t *__restrict __s, size_t __n, -- const wchar_t *__restrict __fmt, ...)) -+extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n, -+ int __flag, size_t __s_len, -+ const wchar_t *__restrict __format, -+ __gnuc_va_list __arg) -+ __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 0))) */; -+ -+extern int __REDIRECT_NTH_LDBL (__vswprintf_alias, -+ (wchar_t *__restrict __s, size_t __n, -+ const wchar_t *__restrict __fmt, -+ __gnuc_va_list __ap), vswprintf); -+ -+#ifdef __FORTIFY_ARG_PACK_OK -+__fortify_potential_overload int -+__NTH (swprintf (wchar_t *__restrict const __clang_pass_object_size __s, -+ size_t __n, const wchar_t *__restrict __fmt, ...)) - { -+ __FORTIFY_INIT_ARG_PACK(__fmt); -+ int __result; - if (__bos (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1) -- return __swprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, -- __bos (__s) / sizeof (wchar_t), -- __fmt, __va_arg_pack ()); -- return __swprintf_alias (__s, __n, __fmt, __va_arg_pack ()); -+ __result = __FORTIFY_CALL_VA_CHK(swprintf, __s, __n, -+ __USE_FORTIFY_LEVEL - 1, -+ __bos (__s) / sizeof (wchar_t), __fmt, -+ __FORTIFY_ARG_PACK); -+ else -+ __result = __FORTIFY_CALL_VA_ALIAS(swprintf, __s, __n, __fmt, -+ __FORTIFY_ARG_PACK); -+ __FORTIFY_FREE_ARG_PACK(); -+ return __result; - } - #elif !defined __cplusplus - /* XXX We might want to have support in gcc for swprintf. */ -@@ -300,20 +279,10 @@ __NTH (swprintf (wchar_t *__restrict __s - : swprintf (s, n, __VA_ARGS__)) - #endif - --extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n, -- int __flag, size_t __s_len, -- const wchar_t *__restrict __format, -- __gnuc_va_list __arg) -- __THROW /* __attribute__ ((__format__ (__wprintf__, 5, 0))) */; -- --extern int __REDIRECT_NTH_LDBL (__vswprintf_alias, -- (wchar_t *__restrict __s, size_t __n, -- const wchar_t *__restrict __fmt, -- __gnuc_va_list __ap), vswprintf); -- --__fortify_function int --__NTH (vswprintf (wchar_t *__restrict __s, size_t __n, -- const wchar_t *__restrict __fmt, __gnuc_va_list __ap)) -+__fortify_potential_overload int -+__NTH (vswprintf (wchar_t *__restrict const __clang_pass_object_size __s, -+ size_t __n, const wchar_t *__restrict __fmt, -+ __gnuc_va_list __ap)) - { - if (__bos (__s) != (size_t) -1 || __USE_FORTIFY_LEVEL > 1) - return __vswprintf_chk (__s, __n, __USE_FORTIFY_LEVEL - 1, -@@ -334,18 +303,27 @@ extern int __vfwprintf_chk (__FILE *__re - extern int __vwprintf_chk (int __flag, const wchar_t *__restrict __format, - __gnuc_va_list __ap); - --# ifdef __va_arg_pack --__fortify_function int --wprintf (const wchar_t *__restrict __fmt, ...) --{ -- return __wprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __va_arg_pack ()); --} - --__fortify_function int --fwprintf (__FILE *__restrict __stream, const wchar_t *__restrict __fmt, ...) --{ -- return __fwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, -- __va_arg_pack ()); -+#ifdef __FORTIFY_ARG_PACK_OK -+__fortify_potential_overload int -+wprintf (const wchar_t *__restrict const __clang_pass_object_size __fmt, ...) -+{ -+ __FORTIFY_INIT_ARG_PACK(__fmt); -+ int __r = __FORTIFY_CALL_VA_CHK (wprintf, __USE_FORTIFY_LEVEL - 1, __fmt, -+ __FORTIFY_ARG_PACK); -+ __FORTIFY_FREE_ARG_PACK(); -+ return __r; -+} -+ -+__fortify_potential_overload int -+fwprintf (__FILE *__restrict const __clang_pass_object_size __stream, -+ const wchar_t *__restrict __fmt, ...) -+{ -+ __FORTIFY_INIT_ARG_PACK(__fmt); -+ int __r = __FORTIFY_CALL_VA_CHK (fwprintf, __stream, __USE_FORTIFY_LEVEL - 1, -+ __fmt, __FORTIFY_ARG_PACK); -+ __FORTIFY_FREE_ARG_PACK(); -+ return __r; - } - # elif !defined __cplusplus - # define wprintf(...) \ -@@ -354,14 +332,15 @@ fwprintf (__FILE *__restrict __stream, c - __fwprintf_chk (stream, __USE_FORTIFY_LEVEL - 1, __VA_ARGS__) - # endif - --__fortify_function int --vwprintf (const wchar_t *__restrict __fmt, __gnuc_va_list __ap) -+__fortify_potential_overload int -+vwprintf (const wchar_t *__restrict const __clang_pass_object_size __fmt, -+ __gnuc_va_list __ap) - { - return __vwprintf_chk (__USE_FORTIFY_LEVEL - 1, __fmt, __ap); - } - --__fortify_function int --vfwprintf (__FILE *__restrict __stream, -+__fortify_potential_overload int -+vfwprintf (__FILE *__restrict const __clang_pass_object_size __stream, - const wchar_t *__restrict __fmt, __gnuc_va_list __ap) - { - return __vfwprintf_chk (__stream, __USE_FORTIFY_LEVEL - 1, __fmt, __ap); -@@ -374,27 +353,21 @@ extern wchar_t *__fgetws_chk (wchar_t *_ - extern wchar_t *__REDIRECT (__fgetws_alias, - (wchar_t *__restrict __s, int __n, - __FILE *__restrict __stream), fgetws) __wur; --extern wchar_t *__REDIRECT (__fgetws_chk_warn, -- (wchar_t *__restrict __s, size_t __size, int __n, -- __FILE *__restrict __stream), __fgetws_chk) -- __wur __warnattr ("fgetws called with bigger size than length " -- "of destination buffer"); - --__fortify_function __wur wchar_t * --fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) -+__fortify_potential_overload __wur wchar_t * -+fgetws (wchar_t *__restrict const __clang_pass_object_size __s, int __n, -+ __FILE *__restrict __stream) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT2 (__fgetws_warn, __n, __s, -+ sizeof (wchar_t), -+ "fgetws called with length bigger " -+ "than size of destination buffer") - { -- if (__bos (__s) != (size_t) -1) -- { -- if (!__builtin_constant_p (__n) || __n <= 0) -- return __fgetws_chk (__s, __bos (__s) / sizeof (wchar_t), -- __n, __stream); -- -- if ((size_t) __n > __bos (__s) / sizeof (wchar_t)) -- return __fgetws_chk_warn (__s, __bos (__s) / sizeof (wchar_t), -- __n, __stream); -- } -+ if (__FORTIFY_CALL_CHK && __bos (__s) != (size_t) -1) -+ return __fgetws_chk (__s, __bos (__s) / sizeof (wchar_t), __n, __stream); - return __fgetws_alias (__s, __n, __stream); - } -+__FORTIFY_FUNCTION_END - - #ifdef __USE_GNU - extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size, -@@ -404,28 +377,23 @@ extern wchar_t *__REDIRECT (__fgetws_unl - (wchar_t *__restrict __s, int __n, - __FILE *__restrict __stream), fgetws_unlocked) - __wur; --extern wchar_t *__REDIRECT (__fgetws_unlocked_chk_warn, -- (wchar_t *__restrict __s, size_t __size, int __n, -- __FILE *__restrict __stream), -- __fgetws_unlocked_chk) -- __wur __warnattr ("fgetws_unlocked called with bigger size than length " -- "of destination buffer"); - --__fortify_function __wur wchar_t * --fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) -+__fortify_potential_overload __wur wchar_t * -+fgetws_unlocked (wchar_t *__restrict const __clang_pass_object_size __s, -+ int __n, __FILE *__restrict __stream) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_IF (__fgetws_unlocked_warn, -+ __n > 0 -+ && __bos_static_lt2 (__n, __s, sizeof (wchar_t)), -+ "fgetws_unlocked called with bigger size than " -+ "length of destination buffer") - { - if (__bos (__s) != (size_t) -1) -- { -- if (!__builtin_constant_p (__n) || __n <= 0) -- return __fgetws_unlocked_chk (__s, __bos (__s) / sizeof (wchar_t), -- __n, __stream); -- -- if ((size_t) __n > __bos (__s) / sizeof (wchar_t)) -- return __fgetws_unlocked_chk_warn (__s, __bos (__s) / sizeof (wchar_t), -- __n, __stream); -- } -+ return __fgetws_unlocked_chk (__s, __bos (__s) / sizeof (wchar_t), -+ __n, __stream); - return __fgetws_unlocked_alias (__s, __n, __stream); - } -+__FORTIFY_FUNCTION_END - #endif - - -@@ -436,9 +404,9 @@ extern size_t __REDIRECT_NTH (__wcrtomb_ - (char *__restrict __s, wchar_t __wchar, - mbstate_t *__restrict __ps), wcrtomb) __wur; - --__fortify_function __wur size_t --__NTH (wcrtomb (char *__restrict __s, wchar_t __wchar, -- mbstate_t *__restrict __ps)) -+__fortify_potential_overload __wur size_t -+__NTH (wcrtomb (char *__restrict const __clang_pass_object_size __s, -+ wchar_t __wchar, mbstate_t *__restrict __ps)) - { - /* We would have to include to get a definition of MB_LEN_MAX. - But this would only disturb the namespace. So we define our own -@@ -462,30 +430,23 @@ extern size_t __REDIRECT_NTH (__mbsrtowc - const char **__restrict __src, - size_t __len, mbstate_t *__restrict __ps), - mbsrtowcs); --extern size_t __REDIRECT_NTH (__mbsrtowcs_chk_warn, -- (wchar_t *__restrict __dst, -- const char **__restrict __src, -- size_t __len, mbstate_t *__restrict __ps, -- size_t __dstlen), __mbsrtowcs_chk) -- __warnattr ("mbsrtowcs called with dst buffer smaller than len " -- "* sizeof (wchar_t)"); -- --__fortify_function size_t --__NTH (mbsrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, -- size_t __len, mbstate_t *__restrict __ps)) --{ -- if (__bos (__dst) != (size_t) -1) -- { -- if (!__builtin_constant_p (__len)) -- return __mbsrtowcs_chk (__dst, __src, __len, __ps, -- __bos (__dst) / sizeof (wchar_t)); -- -- if (__len > __bos (__dst) / sizeof (wchar_t)) -- return __mbsrtowcs_chk_warn (__dst, __src, __len, __ps, -- __bos (__dst) / sizeof (wchar_t)); -- } -+ -+__fortify_potential_overload size_t -+__NTH (mbsrtowcs (wchar_t *__restrict const __clang_pass_object_size __dst, -+ const char **__restrict __src, size_t __len, -+ mbstate_t *__restrict __ps)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT2 (__mbsrtowcs_warn, __len, __dst, -+ sizeof (wchar_t), -+ "mbsrtowcs called with dst buffer " -+ "smaller than len * sizeof (wchar_t)") -+{ -+ if (__FORTIFY_CALL_CHK && __bos (__dst) != (size_t) -1) -+ return __mbsrtowcs_chk (__dst, __src, __len, __ps, -+ __bos (__dst) / sizeof (wchar_t)); - return __mbsrtowcs_alias (__dst, __src, __len, __ps); - } -+__FORTIFY_FUNCTION_END - - - extern size_t __wcsrtombs_chk (char *__restrict __dst, -@@ -497,27 +458,21 @@ extern size_t __REDIRECT_NTH (__wcsrtomb - const wchar_t **__restrict __src, - size_t __len, mbstate_t *__restrict __ps), - wcsrtombs); --extern size_t __REDIRECT_NTH (__wcsrtombs_chk_warn, -- (char *__restrict __dst, -- const wchar_t **__restrict __src, -- size_t __len, mbstate_t *__restrict __ps, -- size_t __dstlen), __wcsrtombs_chk) -- __warnattr ("wcsrtombs called with dst buffer smaller than len"); - --__fortify_function size_t --__NTH (wcsrtombs (char *__restrict __dst, const wchar_t **__restrict __src, -- size_t __len, mbstate_t *__restrict __ps)) --{ -- if (__bos (__dst) != (size_t) -1) -- { -- if (!__builtin_constant_p (__len)) -- return __wcsrtombs_chk (__dst, __src, __len, __ps, __bos (__dst)); -- -- if (__len > __bos (__dst)) -- return __wcsrtombs_chk_warn (__dst, __src, __len, __ps, __bos (__dst)); -- } -+__fortify_potential_overload size_t -+__NTH (wcsrtombs (char *__restrict const __clang_pass_object_size __dst, -+ const wchar_t **__restrict __src, size_t __len, -+ mbstate_t *__restrict __ps)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__wcsrtombs_warn, __len, __dst, -+ "wcsrtombs called with dst buffer " -+ "smaller than len") -+{ -+ if (__FORTIFY_CALL_CHK && __bos (__dst) != (size_t) -1) -+ return __wcsrtombs_chk (__dst, __src, __len, __ps, __bos (__dst)); - return __wcsrtombs_alias (__dst, __src, __len, __ps); - } -+__FORTIFY_FUNCTION_END - - - #ifdef __USE_GNU -@@ -530,30 +485,23 @@ extern size_t __REDIRECT_NTH (__mbsnrtow - const char **__restrict __src, size_t __nmc, - size_t __len, mbstate_t *__restrict __ps), - mbsnrtowcs); --extern size_t __REDIRECT_NTH (__mbsnrtowcs_chk_warn, -- (wchar_t *__restrict __dst, -- const char **__restrict __src, size_t __nmc, -- size_t __len, mbstate_t *__restrict __ps, -- size_t __dstlen), __mbsnrtowcs_chk) -- __warnattr ("mbsnrtowcs called with dst buffer smaller than len " -- "* sizeof (wchar_t)"); -- --__fortify_function size_t --__NTH (mbsnrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, -- size_t __nmc, size_t __len, mbstate_t *__restrict __ps)) --{ -- if (__bos (__dst) != (size_t) -1) -- { -- if (!__builtin_constant_p (__len)) -- return __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps, -- __bos (__dst) / sizeof (wchar_t)); -- -- if (__len > __bos (__dst) / sizeof (wchar_t)) -- return __mbsnrtowcs_chk_warn (__dst, __src, __nmc, __len, __ps, -- __bos (__dst) / sizeof (wchar_t)); -- } -+ -+__fortify_potential_overload size_t -+__NTH (mbsnrtowcs (wchar_t *__restrict const __clang_pass_object_size __dst, -+ const char **__restrict __src, size_t __nmc, size_t __len, -+ mbstate_t *__restrict __ps)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__mbsnrtowcs_warn, -+ sizeof (wchar_t) * __len, __dst, -+ "mbsnrtowcs called with dst buffer " -+ "smaller than len * sizeof (wchar_t)") -+{ -+ if (__FORTIFY_CALL_CHK && __bos (__dst) != (size_t) -1) -+ return __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps, -+ __bos (__dst) / sizeof (wchar_t)); - return __mbsnrtowcs_alias (__dst, __src, __nmc, __len, __ps); - } -+__FORTIFY_FUNCTION_END - - - extern size_t __wcsnrtombs_chk (char *__restrict __dst, -@@ -566,28 +514,19 @@ extern size_t __REDIRECT_NTH (__wcsnrtom - const wchar_t **__restrict __src, - size_t __nwc, size_t __len, - mbstate_t *__restrict __ps), wcsnrtombs); --extern size_t __REDIRECT_NTH (__wcsnrtombs_chk_warn, -- (char *__restrict __dst, -- const wchar_t **__restrict __src, -- size_t __nwc, size_t __len, -- mbstate_t *__restrict __ps, -- size_t __dstlen), __wcsnrtombs_chk) -- __warnattr ("wcsnrtombs called with dst buffer smaller than len"); -- --__fortify_function size_t --__NTH (wcsnrtombs (char *__restrict __dst, const wchar_t **__restrict __src, -- size_t __nwc, size_t __len, mbstate_t *__restrict __ps)) --{ -- if (__bos (__dst) != (size_t) -1) -- { -- if (!__builtin_constant_p (__len)) -- return __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps, -- __bos (__dst)); -- -- if (__len > __bos (__dst)) -- return __wcsnrtombs_chk_warn (__dst, __src, __nwc, __len, __ps, -- __bos (__dst)); -- } -+ -+__fortify_potential_overload size_t -+__NTH (wcsnrtombs (char *__restrict const __clang_pass_object_size __dst, -+ const wchar_t **__restrict __src, size_t __nwc, size_t __len, -+ mbstate_t *__restrict __ps)) -+__FORTIFY_PRECONDITIONS -+ __FORTIFY_WARNING_ONLY_IF_BOS_LT (__wcsnrtombs_warn, __len, __dst, -+ "wcsnrtombs called with dst buffer " -+ "smaller than len") -+{ -+ if (__FORTIFY_CALL_CHK && __bos (__dst) != (size_t) -1) -+ return __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps, __bos (__dst)); - return __wcsnrtombs_alias (__dst, __src, __nwc, __len, __ps); - } -+__FORTIFY_FUNCTION_END - #endif diff --git a/meta/recipes-core/glibc/glibc_2.31.bb b/meta/recipes-core/glibc/glibc_2.31.bb index b8c570db52..3dec43e537 100644 --- a/meta/recipes-core/glibc/glibc_2.31.bb +++ b/meta/recipes-core/glibc/glibc_2.31.bb @@ -32,16 +32,15 @@ SRC_URI = "${GLIBC_GIT_URI};branch=${SRCBRANCH};name=glibc \ file://0019-Remove-bash-dependency-for-nscd-init-script.patch \ file://0020-eglibc-Cross-building-and-testing-instructions.patch \ file://0021-eglibc-Help-bootstrap-cross-toolchain.patch \ - file://0022-eglibc-Clear-cache-lines-on-ppc8xx.patch \ - file://0023-eglibc-Resolve-__fpscr_values-on-SH4.patch \ - file://0024-eglibc-Forward-port-cross-locale-generation-support.patch \ - file://0025-Define-DUMMY_LOCALE_T-if-not-defined.patch \ - file://0026-localedef-add-to-archive-uses-a-hard-coded-locale-pa.patch \ - file://0027-elf-dl-deps.c-Make-_dl_build_local_scope-breadth-fir.patch \ - file://0028-intl-Emit-no-lines-in-bison-generated-files.patch \ - file://0029-inject-file-assembly-directives.patch \ - file://0030-locale-prevent-maybe-uninitialized-errors-with-Os-BZ.patch \ - file://0031-Refactor-FORTIFY-in-glibc.patch \ + file://0022-eglibc-Resolve-__fpscr_values-on-SH4.patch \ + file://0023-eglibc-Forward-port-cross-locale-generation-support.patch \ + file://0024-Define-DUMMY_LOCALE_T-if-not-defined.patch \ + file://0025-localedef-add-to-archive-uses-a-hard-coded-locale-pa.patch \ + file://0026-elf-dl-deps.c-Make-_dl_build_local_scope-breadth-fir.patch \ + file://0027-intl-Emit-no-lines-in-bison-generated-files.patch \ + file://0028-inject-file-assembly-directives.patch \ + file://0029-locale-prevent-maybe-uninitialized-errors-with-Os-BZ.patch \ + file://0030-Refactor-FORTIFY-in-glibc.patch \ " S = "${WORKDIR}/git" B = "${WORKDIR}/build-${TARGET_SYS}" -- cgit v1.2.3-54-g00ecf