From e0dc6bb4b80d4c38608c7f03dc036b96f569206c Mon Sep 17 00:00:00 2001 From: "Brian C. Lane" Date: Thu, 17 Feb 2022 15:46:48 -0800 Subject: [PATCH] - gnulib: Use newer cdefs.h from gnulib (bcl) - Update parted.spec to allow flatpak builds --- ...gnulib-Use-newer-cdefs.h-from-gnulib.patch | 542 ++++++++++++++++++ parted.spec | 7 +- 2 files changed, 548 insertions(+), 1 deletion(-) create mode 100644 0045-gnulib-Use-newer-cdefs.h-from-gnulib.patch diff --git a/0045-gnulib-Use-newer-cdefs.h-from-gnulib.patch b/0045-gnulib-Use-newer-cdefs.h-from-gnulib.patch new file mode 100644 index 0000000..e8b9a2b --- /dev/null +++ b/0045-gnulib-Use-newer-cdefs.h-from-gnulib.patch @@ -0,0 +1,542 @@ +From f6b9e09e7207f54a491de827640bb08501d91f91 Mon Sep 17 00:00:00 2001 +From: rpm-build +Date: Thu, 17 Feb 2022 15:34:41 -0800 +Subject: [PATCH] gnulib: Use newer cdefs.h from gnulib + +This uses the one from gnulib commit 9f48fb992a3d7e96 on 2022-02-14 + +This is a temporary workaround for gcc 12 problems on ppc64le, the build +will be filled with errors that look like: + +/usr/include/bits/stdio-ldbl.h:86:1: error: storage class specified for parameter '__sprintf_chk' + 86 | __LDBL_REDIR2_DECL (sprintf_chk) + +without it. +--- + lib/cdefs.h | 307 +++++++++++++++++++++++++++++++++++++++------------- + 1 file changed, 232 insertions(+), 75 deletions(-) + +diff --git a/lib/cdefs.h b/lib/cdefs.h +index 1a2805d..44d3826 100644 +--- a/lib/cdefs.h ++++ b/lib/cdefs.h +@@ -1,17 +1,18 @@ +-/* Copyright (C) 1992-2020 Free Software Foundation, Inc. ++/* Copyright (C) 1992-2022 Free Software Foundation, Inc. ++ Copyright The GNU Toolchain Authors. + 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 General Public ++ modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either +- version 3 of the License, or (at your option) any later version. ++ 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 +- General Public License for more details. ++ Lesser General Public License for more details. + +- You should have received a copy of the GNU General Public ++ You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +@@ -25,7 +26,7 @@ + + /* The GNU libc does not support any K&R compilers or the traditional mode + of ISO C compilers anymore. Check for some of the combinations not +- anymore supported. */ ++ supported anymore. */ + #if defined __GNUC__ && !defined __STDC__ + # error "You need a ISO C conforming compiler to use the glibc headers" + #endif +@@ -34,31 +35,26 @@ + #undef __P + #undef __PMT + +-/* Compilers that are not clang may object to +- #if defined __clang__ && __has_attribute(...) +- even though they do not need to evaluate the right-hand side of the &&. */ +-#if defined __clang__ && defined __has_attribute +-# define __glibc_clang_has_attribute(name) __has_attribute (name) ++/* Compilers that lack __has_attribute may object to ++ #if defined __has_attribute && __has_attribute (...) ++ even though they do not need to evaluate the right-hand side of the &&. ++ Similarly for __has_builtin, etc. */ ++#if (defined __has_attribute \ ++ && (!defined __clang_minor__ \ ++ || 3 < __clang_major__ + (5 <= __clang_minor__))) ++# define __glibc_has_attribute(attr) __has_attribute (attr) + #else +-# define __glibc_clang_has_attribute(name) 0 ++# define __glibc_has_attribute(attr) 0 + #endif +- +-/* Compilers that are not clang may object to +- #if defined __clang__ && __has_builtin(...) +- even though they do not need to evaluate the right-hand side of the &&. */ +-#if defined __clang__ && defined __has_builtin +-# define __glibc_clang_has_builtin(name) __has_builtin (name) ++#ifdef __has_builtin ++# define __glibc_has_builtin(name) __has_builtin (name) + #else +-# define __glibc_clang_has_builtin(name) 0 ++# define __glibc_has_builtin(name) 0 + #endif +- +-/* Compilers that are not clang may object to +- #if defined __clang__ && __has_extension(...) +- even though they do not need to evaluate the right-hand side of the &&. */ +-#if defined __clang__ && defined __has_extension +-# define __glibc_clang_has_extension(ext) __has_extension (ext) ++#ifdef __has_extension ++# define __glibc_has_extension(ext) __has_extension (ext) + #else +-# define __glibc_clang_has_extension(ext) 0 ++# define __glibc_has_extension(ext) 0 + #endif + + #if defined __GNUC__ || defined __clang__ +@@ -74,22 +70,26 @@ + # endif + + /* GCC can always grok prototypes. For C++ programs we add throw() +- to help it optimize the function calls. But this works only with ++ to help it optimize the function calls. But this only works with + gcc 2.8.x and egcs. For gcc 3.4 and up we even mark C functions + as non-throwing using a function attribute since programs can use + the -fexceptions options for C code as well. */ + # if !defined __cplusplus \ +- && (__GNUC_PREREQ (3, 4) || __glibc_clang_has_attribute (__nothrow__)) ++ && (__GNUC_PREREQ (3, 4) || __glibc_has_attribute (__nothrow__)) + # define __THROW __attribute__ ((__nothrow__ __LEAF)) + # define __THROWNL __attribute__ ((__nothrow__)) + # define __NTH(fct) __attribute__ ((__nothrow__ __LEAF)) fct + # define __NTHNL(fct) __attribute__ ((__nothrow__)) fct + # else + # if defined __cplusplus && (__GNUC_PREREQ (2,8) || __clang_major >= 4) +-# define __THROW throw () +-# define __THROWNL throw () +-# define __NTH(fct) __LEAF_ATTR fct throw () +-# define __NTHNL(fct) fct throw () ++# if __cplusplus >= 201103L ++# define __THROW noexcept (true) ++# else ++# define __THROW throw () ++# endif ++# define __THROWNL __THROW ++# define __NTH(fct) __LEAF_ATTR fct __THROW ++# define __NTHNL(fct) fct __THROW + # else + # define __THROW + # define __THROWNL +@@ -142,24 +142,68 @@ + #define __bos(ptr) __builtin_object_size (ptr, __USE_FORTIFY_LEVEL > 1) + #define __bos0(ptr) __builtin_object_size (ptr, 0) + ++/* Use __builtin_dynamic_object_size at _FORTIFY_SOURCE=3 when available. */ ++#if __USE_FORTIFY_LEVEL == 3 && (__glibc_clang_prereq (9, 0) \ ++ || __GNUC_PREREQ (12, 0)) ++# define __glibc_objsize0(__o) __builtin_dynamic_object_size (__o, 0) ++# define __glibc_objsize(__o) __builtin_dynamic_object_size (__o, 1) ++#else ++# define __glibc_objsize0(__o) __bos0 (__o) ++# define __glibc_objsize(__o) __bos (__o) ++#endif ++ ++/* Compile time conditions to choose between the regular, _chk and _chk_warn ++ variants. These conditions should get evaluated to constant and optimized ++ away. */ ++ ++#define __glibc_safe_len_cond(__l, __s, __osz) ((__l) <= (__osz) / (__s)) ++#define __glibc_unsigned_or_positive(__l) \ ++ ((__typeof (__l)) 0 < (__typeof (__l)) -1 \ ++ || (__builtin_constant_p (__l) && (__l) > 0)) ++ ++/* Length is known to be safe at compile time if the __L * __S <= __OBJSZ ++ condition can be folded to a constant and if it is true. The -1 check is ++ redundant because since it implies that __glibc_safe_len_cond is true. */ ++#define __glibc_safe_or_unknown_len(__l, __s, __osz) \ ++ (__glibc_unsigned_or_positive (__l) \ ++ && __builtin_constant_p (__glibc_safe_len_cond ((__SIZE_TYPE__) (__l), \ ++ __s, __osz)) \ ++ && __glibc_safe_len_cond ((__SIZE_TYPE__) (__l), __s, __osz)) ++ ++/* Conversely, we know at compile time that the length is unsafe if the ++ __L * __S <= __OBJSZ condition can be folded to a constant and if it is ++ false. */ ++#define __glibc_unsafe_len(__l, __s, __osz) \ ++ (__glibc_unsigned_or_positive (__l) \ ++ && __builtin_constant_p (__glibc_safe_len_cond ((__SIZE_TYPE__) (__l), \ ++ __s, __osz)) \ ++ && !__glibc_safe_len_cond ((__SIZE_TYPE__) (__l), __s, __osz)) ++ ++/* Fortify function f. __f_alias, __f_chk and __f_chk_warn must be ++ declared. */ ++ ++#define __glibc_fortify(f, __l, __s, __osz, ...) \ ++ (__glibc_safe_or_unknown_len (__l, __s, __osz) \ ++ ? __ ## f ## _alias (__VA_ARGS__) \ ++ : (__glibc_unsafe_len (__l, __s, __osz) \ ++ ? __ ## f ## _chk_warn (__VA_ARGS__, __osz) \ ++ : __ ## f ## _chk (__VA_ARGS__, __osz))) \ ++ ++/* Fortify function f, where object size argument passed to f is the number of ++ elements and not total size. */ ++ ++#define __glibc_fortify_n(f, __l, __s, __osz, ...) \ ++ (__glibc_safe_or_unknown_len (__l, __s, __osz) \ ++ ? __ ## f ## _alias (__VA_ARGS__) \ ++ : (__glibc_unsafe_len (__l, __s, __osz) \ ++ ? __ ## f ## _chk_warn (__VA_ARGS__, (__osz) / (__s)) \ ++ : __ ## f ## _chk (__VA_ARGS__, (__osz) / (__s)))) \ ++ + #if __GNUC_PREREQ (4,3) +-# define __warndecl(name, msg) \ +- extern void name (void) __attribute__((__warning__ (msg))) + # define __warnattr(msg) __attribute__((__warning__ (msg))) + # define __errordecl(name, msg) \ + extern void name (void) __attribute__((__error__ (msg))) +-#elif __glibc_clang_has_attribute (__diagnose_if__) && 0 +-/* These definitions are not enabled, because they produce bogus warnings +- in the glibc Fortify functions. These functions are written in a style +- that works with GCC. In order to work with clang, these functions would +- need to be modified. */ +-# define __warndecl(name, msg) \ +- extern void name (void) __attribute__((__diagnose_if__ (1, msg, "warning"))) +-# define __warnattr(msg) __attribute__((__diagnose_if__ (1, msg, "warning"))) +-# define __errordecl(name, msg) \ +- extern void name (void) __attribute__((__diagnose_if__ (1, msg, "error"))) + #else +-# define __warndecl(name, msg) extern void name (void) + # define __warnattr(msg) + # define __errordecl(name, msg) extern void name (void) + #endif +@@ -233,7 +277,7 @@ + /* At some point during the gcc 2.96 development the `malloc' attribute + for functions was introduced. We don't want to use it unconditionally + (although this would be possible) since it generates warnings. */ +-#if __GNUC_PREREQ (2,96) || __glibc_clang_has_attribute (__malloc__) ++#if __GNUC_PREREQ (2,96) || __glibc_has_attribute (__malloc__) + # define __attribute_malloc__ __attribute__ ((__malloc__)) + #else + # define __attribute_malloc__ /* Ignore */ +@@ -248,26 +292,41 @@ + # define __attribute_alloc_size__(params) /* Ignore. */ + #endif + ++/* Tell the compiler which argument to an allocation function ++ indicates the alignment of the allocation. */ ++#if __GNUC_PREREQ (4, 9) || __glibc_has_attribute (__alloc_align__) ++# define __attribute_alloc_align__(param) \ ++ __attribute__ ((__alloc_align__ param)) ++#else ++# define __attribute_alloc_align__(param) /* Ignore. */ ++#endif ++ + /* At some point during the gcc 2.96 development the `pure' attribute + for functions was introduced. We don't want to use it unconditionally + (although this would be possible) since it generates warnings. */ +-#if __GNUC_PREREQ (2,96) || __glibc_clang_has_attribute (__pure__) ++#if __GNUC_PREREQ (2,96) || __glibc_has_attribute (__pure__) + # define __attribute_pure__ __attribute__ ((__pure__)) + #else + # define __attribute_pure__ /* Ignore */ + #endif + + /* This declaration tells the compiler that the value is constant. */ +-#if __GNUC_PREREQ (2,5) || __glibc_clang_has_attribute (__const__) ++#if __GNUC_PREREQ (2,5) || __glibc_has_attribute (__const__) + # define __attribute_const__ __attribute__ ((__const__)) + #else + # define __attribute_const__ /* Ignore */ + #endif + ++#if __GNUC_PREREQ (2,7) || __glibc_has_attribute (__unused__) ++# define __attribute_maybe_unused__ __attribute__ ((__unused__)) ++#else ++# define __attribute_maybe_unused__ /* Ignore */ ++#endif ++ + /* At some point during the gcc 3.1 development the `used' attribute + for functions was introduced. We don't want to use it unconditionally + (although this would be possible) since it generates warnings. */ +-#if __GNUC_PREREQ (3,1) || __glibc_clang_has_attribute (__used__) ++#if __GNUC_PREREQ (3,1) || __glibc_has_attribute (__used__) + # define __attribute_used__ __attribute__ ((__used__)) + # define __attribute_noinline__ __attribute__ ((__noinline__)) + #else +@@ -276,7 +335,7 @@ + #endif + + /* Since version 3.2, gcc allows marking deprecated functions. */ +-#if __GNUC_PREREQ (3,2) || __glibc_clang_has_attribute (__deprecated__) ++#if __GNUC_PREREQ (3,2) || __glibc_has_attribute (__deprecated__) + # define __attribute_deprecated__ __attribute__ ((__deprecated__)) + #else + # define __attribute_deprecated__ /* Ignore */ +@@ -285,8 +344,8 @@ + /* Since version 4.5, gcc also allows one to specify the message printed + when a deprecated function is used. clang claims to be gcc 4.2, but + may also support this feature. */ +-#if __GNUC_PREREQ (4,5) || \ +- __glibc_clang_has_extension (__attribute_deprecated_with_message__) ++#if __GNUC_PREREQ (4,5) \ ++ || __glibc_has_extension (__attribute_deprecated_with_message__) + # define __attribute_deprecated_msg__(msg) \ + __attribute__ ((__deprecated__ (msg))) + #else +@@ -299,7 +358,7 @@ + If several `format_arg' attributes are given for the same function, in + gcc-3.0 and older, all but the last one are ignored. In newer gccs, + all designated arguments are considered. */ +-#if __GNUC_PREREQ (2,8) || __glibc_clang_has_attribute (__format_arg__) ++#if __GNUC_PREREQ (2,8) || __glibc_has_attribute (__format_arg__) + # define __attribute_format_arg__(x) __attribute__ ((__format_arg__ (x))) + #else + # define __attribute_format_arg__(x) /* Ignore */ +@@ -309,7 +368,7 @@ + attribute for functions was introduced. We don't want to use it + unconditionally (although this would be possible) since it + generates warnings. */ +-#if __GNUC_PREREQ (2,97) || __glibc_clang_has_attribute (__format__) ++#if __GNUC_PREREQ (2,97) || __glibc_has_attribute (__format__) + # define __attribute_format_strfmon__(a,b) \ + __attribute__ ((__format__ (__strfmon__, a, b))) + #else +@@ -317,19 +376,33 @@ + #endif + + /* The nonnull function attribute marks pointer parameters that +- must not be NULL. Do not define __nonnull if it is already defined, +- for portability when this file is used in Gnulib. */ ++ must not be NULL. This has the name __nonnull in glibc, ++ and __attribute_nonnull__ in files shared with Gnulib to avoid ++ collision with a different __nonnull in DragonFlyBSD 5.9. */ ++#ifndef __attribute_nonnull__ ++# if __GNUC_PREREQ (3,3) || __glibc_has_attribute (__nonnull__) ++# define __attribute_nonnull__(params) __attribute__ ((__nonnull__ params)) ++# else ++# define __attribute_nonnull__(params) ++# endif ++#endif + #ifndef __nonnull +-# if __GNUC_PREREQ (3,3) || __glibc_clang_has_attribute (__nonnull__) +-# define __nonnull(params) __attribute__ ((__nonnull__ params)) ++# define __nonnull(params) __attribute_nonnull__ (params) ++#endif ++ ++/* The returns_nonnull function attribute marks the return type of the function ++ as always being non-null. */ ++#ifndef __returns_nonnull ++# if __GNUC_PREREQ (4, 9) || __glibc_has_attribute (__returns_nonnull__) ++# define __returns_nonnull __attribute__ ((__returns_nonnull__)) + # else +-# define __nonnull(params) ++# define __returns_nonnull + # endif + #endif + + /* If fortification mode, we warn about unused results of certain + function calls which can lead to problems. */ +-#if __GNUC_PREREQ (3,4) || __glibc_clang_has_attribute (__warn_unused_result__) ++#if __GNUC_PREREQ (3,4) || __glibc_has_attribute (__warn_unused_result__) + # define __attribute_warn_unused_result__ \ + __attribute__ ((__warn_unused_result__)) + # if defined __USE_FORTIFY_LEVEL && __USE_FORTIFY_LEVEL > 0 +@@ -343,7 +416,7 @@ + #endif + + /* Forces a function to be always inlined. */ +-#if __GNUC_PREREQ (3,2) || __glibc_clang_has_attribute (__always_inline__) ++#if __GNUC_PREREQ (3,2) || __glibc_has_attribute (__always_inline__) + /* The Linux kernel defines __always_inline in stddef.h (283d7573), and + it conflicts with this definition. Therefore undefine it first to + allow either header to be included first. */ +@@ -356,7 +429,7 @@ + + /* Associate error messages with the source location of the call site rather + than with the source location inside the function. */ +-#if __GNUC_PREREQ (4,3) || __glibc_clang_has_attribute (__artificial__) ++#if __GNUC_PREREQ (4,3) || __glibc_has_attribute (__artificial__) + # define __attribute_artificial__ __attribute__ ((__artificial__)) + #else + # define __attribute_artificial__ /* Ignore */ +@@ -433,7 +506,7 @@ + # endif + #endif + +-#if (__GNUC__ >= 3) || __glibc_clang_has_builtin (__builtin_expect) ++#if (__GNUC__ >= 3) || __glibc_has_builtin (__builtin_expect) + # define __glibc_unlikely(cond) __builtin_expect ((cond), 0) + # define __glibc_likely(cond) __builtin_expect ((cond), 1) + #else +@@ -441,12 +514,6 @@ + # define __glibc_likely(cond) (cond) + #endif + +-#ifdef __has_attribute +-# define __glibc_has_attribute(attr) __has_attribute (attr) +-#else +-# define __glibc_has_attribute(attr) 0 +-#endif +- + #if (!defined _Noreturn \ + && (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) < 201112 \ + && !(__GNUC_PREREQ (4,7) \ +@@ -467,6 +534,16 @@ + # define __attribute_nonstring__ + #endif + ++/* Undefine (also defined in libc-symbols.h). */ ++#undef __attribute_copy__ ++#if __GNUC_PREREQ (9, 0) ++/* Copies attributes from the declaration or type referenced by ++ the argument. */ ++# define __attribute_copy__(arg) __attribute__ ((__copy__ (arg))) ++#else ++# define __attribute_copy__(arg) ++#endif ++ + #if (!defined _Static_assert && !defined __cplusplus \ + && (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) < 201112 \ + && (!(__GNUC_PREREQ (4, 6) || __clang_major__ >= 4) \ +@@ -476,14 +553,44 @@ + [!!sizeof (struct { int __error_if_negative: (expr) ? 2 : -1; })] + #endif + +-/* The #ifndef lets Gnulib avoid including these on non-glibc +- platforms, where the includes typically do not exist. */ +-#ifndef __WORDSIZE ++/* Gnulib avoids including these, as they don't work on non-glibc or ++ older glibc platforms. */ ++#ifndef __GNULIB_CDEFS + # include + # include + #endif + +-#if defined __LONG_DOUBLE_MATH_OPTIONAL && defined __NO_LONG_DOUBLE_MATH ++#if __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 1 ++# ifdef __REDIRECT ++ ++/* Alias name defined automatically. */ ++# define __LDBL_REDIR(name, proto) ... unused__ldbl_redir ++# define __LDBL_REDIR_DECL(name) \ ++ extern __typeof (name) name __asm (__ASMNAME ("__" #name "ieee128")); ++ ++/* Alias name defined automatically, with leading underscores. */ ++# define __LDBL_REDIR2_DECL(name) \ ++ extern __typeof (__##name) __##name \ ++ __asm (__ASMNAME ("__" #name "ieee128")); ++ ++/* Alias name defined manually. */ ++# define __LDBL_REDIR1(name, proto, alias) ... unused__ldbl_redir1 ++# define __LDBL_REDIR1_DECL(name, alias) \ ++ extern __typeof (name) name __asm (__ASMNAME (#alias)); ++ ++# define __LDBL_REDIR1_NTH(name, proto, alias) \ ++ __REDIRECT_NTH (name, proto, alias) ++# define __REDIRECT_NTH_LDBL(name, proto, alias) \ ++ __LDBL_REDIR1_NTH (name, proto, __##alias##ieee128) ++ ++/* Unused. */ ++# define __REDIRECT_LDBL(name, proto, alias) ... unused__redirect_ldbl ++# define __LDBL_REDIR_NTH(name, proto) ... unused__ldbl_redir_nth ++ ++# else ++_Static_assert (0, "IEEE 128-bits long double requires redirection on this platform"); ++# endif ++#elif defined __LONG_DOUBLE_MATH_OPTIONAL && defined __NO_LONG_DOUBLE_MATH + # define __LDBL_COMPAT 1 + # ifdef __REDIRECT + # define __LDBL_REDIR1(name, proto, alias) __REDIRECT (name, proto, alias) +@@ -492,6 +599,8 @@ + # define __LDBL_REDIR1_NTH(name, proto, alias) __REDIRECT_NTH (name, proto, alias) + # define __LDBL_REDIR_NTH(name, proto) \ + __LDBL_REDIR1_NTH (name, proto, __nldbl_##name) ++# define __LDBL_REDIR2_DECL(name) \ ++ extern __typeof (__##name) __##name __asm (__ASMNAME ("__nldbl___" #name)); + # define __LDBL_REDIR1_DECL(name, alias) \ + extern __typeof (name) name __asm (__ASMNAME (#alias)); + # define __LDBL_REDIR_DECL(name) \ +@@ -502,11 +611,13 @@ + __LDBL_REDIR1_NTH (name, proto, __nldbl_##alias) + # endif + #endif +-#if !defined __LDBL_COMPAT || !defined __REDIRECT ++#if (!defined __LDBL_COMPAT && __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI == 0) \ ++ || !defined __REDIRECT + # define __LDBL_REDIR1(name, proto, alias) name proto + # define __LDBL_REDIR(name, proto) name proto + # define __LDBL_REDIR1_NTH(name, proto, alias) name proto __THROW + # define __LDBL_REDIR_NTH(name, proto) name proto __THROW ++# define __LDBL_REDIR2_DECL(name) + # define __LDBL_REDIR_DECL(name) + # ifdef __REDIRECT + # define __REDIRECT_LDBL(name, proto, alias) __REDIRECT (name, proto, alias) +@@ -537,7 +648,7 @@ + check is required to enable the use of generic selection. */ + #if !defined __cplusplus \ + && (__GNUC_PREREQ (4, 9) \ +- || __glibc_clang_has_extension (c_generic_selections) \ ++ || __glibc_has_extension (c_generic_selections) \ + || (!defined __GNUC__ && defined __STDC_VERSION__ \ + && __STDC_VERSION__ >= 201112L)) + # define __HAVE_GENERIC_SELECTION 1 +@@ -545,4 +656,50 @@ + # define __HAVE_GENERIC_SELECTION 0 + #endif + ++#if __GNUC_PREREQ (10, 0) ++/* Designates a 1-based positional argument ref-index of pointer type ++ that can be used to access size-index elements of the pointed-to ++ array according to access mode, or at least one element when ++ size-index is not provided: ++ access (access-mode, [, ]) */ ++# define __attr_access(x) __attribute__ ((__access__ x)) ++/* For _FORTIFY_SOURCE == 3 we use __builtin_dynamic_object_size, which may ++ use the access attribute to get object sizes from function definition ++ arguments, so we can't use them on functions we fortify. Drop the object ++ size hints for such functions. */ ++# if __USE_FORTIFY_LEVEL == 3 ++# define __fortified_attr_access(a, o, s) __attribute__ ((__access__ (a, o))) ++# else ++# define __fortified_attr_access(a, o, s) __attr_access ((a, o, s)) ++# endif ++# if __GNUC_PREREQ (11, 0) ++# define __attr_access_none(argno) __attribute__ ((__access__ (__none__, argno))) ++# else ++# define __attr_access_none(argno) ++# endif ++#else ++# define __fortified_attr_access(a, o, s) ++# define __attr_access(x) ++# define __attr_access_none(argno) ++#endif ++ ++#if __GNUC_PREREQ (11, 0) ++/* Designates dealloc as a function to call to deallocate objects ++ allocated by the declared function. */ ++# define __attr_dealloc(dealloc, argno) \ ++ __attribute__ ((__malloc__ (dealloc, argno))) ++# define __attr_dealloc_free __attr_dealloc (__builtin_free, 1) ++#else ++# define __attr_dealloc(dealloc, argno) ++# define __attr_dealloc_free ++#endif ++ ++/* Specify that a function such as setjmp or vfork may return ++ twice. */ ++#if __GNUC_PREREQ (4, 1) ++# define __attribute_returns_twice__ __attribute__ ((__returns_twice__)) ++#else ++# define __attribute_returns_twice__ /* Ignore. */ ++#endif ++ + #endif /* sys/cdefs.h */ +-- +2.34.1 + diff --git a/parted.spec b/parted.spec index 4035c12..8320add 100644 --- a/parted.spec +++ b/parted.spec @@ -1,7 +1,7 @@ Summary: The GNU disk partition manipulation program Name: parted Version: 3.4 -Release: 11%{?dist} +Release: 12%{?dist} License: GPLv3+ URL: http://www.gnu.org/software/parted @@ -55,6 +55,7 @@ Patch0041: 0041-doc-Document-gpt-linux-home-flag.patch Patch0042: 0042-tests-Add-a-test-to-make-sure-GPT-GUIDs-default-to-f.patch Patch0043: 0043-gpt-Revert-to-filesystem-GUID-when-setting-flag-to-o.patch Patch0044: 0044-docs-Update-documentation-to-be-consistent.patch +Patch0045: 0045-gnulib-Use-newer-cdefs.h-from-gnulib.patch BuildRequires: gcc @@ -159,6 +160,10 @@ make check %changelog +* Thu Feb 17 2022 Brian C. Lane - 3.4-12 +- gnulib: Use newer cdefs.h from gnulib (bcl) +- Update parted.spec to allow flatpak builds + * Thu Jan 20 2022 Fedora Release Engineering - 3.4-11 - Rebuilt for https://fedoraproject.org/wiki/Fedora_36_Mass_Rebuild