From patchwork Wed Sep 13 11:45:05 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Masahiro Yamada X-Patchwork-Id: 112438 Delivered-To: patch@linaro.org Received: by 10.140.106.117 with SMTP id d108csp847609qgf; Wed, 13 Sep 2017 04:46:47 -0700 (PDT) X-Google-Smtp-Source: ADKCNb4Up54+RinlVynuGTPXNIuKckn2AgYvHlD/KmebstSmZL1bxQn0AmpxTeMqDOL5L8kyAgLB X-Received: by 10.80.174.208 with SMTP id f16mr15062084edd.196.1505303207631; Wed, 13 Sep 2017 04:46:47 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1505303207; cv=none; d=google.com; s=arc-20160816; b=JD6533vD/pL9RunaRfztA3QwPvVs5jyjAf/3DVu1X1B2MT8iZzSuTicMr4WKy5FiWx tvzGXHFzHDK6gpu62k57UkT8zjgoK0gXaGfafcZI0rO06mv9QZE4QJKlU+vW/QQiUtVH gDQ/q7XVQ8JFbS1vJcNPUdgCOpXWESjkW5jn2bEQhJKde8r3JoYJocn+F84ZV8TuNuHq BmO07CZ6Wm3X/W8qwIQBPA8dqrWmVf8QN8rOOy4AJazfz2vrnMgjQDuOs3bLrXeMxcy6 /PjWxEiosAv+dilTCF1Ln2ErAe5++YXyK6yQ23U32YzDaQQ9RfqJv+drF/NEamykTDbz UGQw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:content-transfer-encoding:mime-version :list-subscribe:list-help:list-post:list-archive:list-unsubscribe :list-id:precedence:subject:references:in-reply-to:message-id:date :to:from:dkim-signature:dkim-filter:arc-authentication-results; bh=3EImw6Dr2ck6ysy3wrOpJZm7DCn5ZesKkKqtvlWywVk=; b=HXRZm6fsdeo4hUoYUpHxR/DhKTGC6p1KsL996LXnSStioozTPQwresOAtck/RiUF0X SnFYAFhFaWiktvROJPFAQkL9/G7jF+h3cWd5x4dzihS1Cxw92xF048p3/B+eXzvNMrzB +loGvAo1RpeFQGtY28FWxznFSTfv2tcM8+K7W2ygHHERT5uBG0Hvz0rawCkS/ZAYTjrT HNKX6jP6F56YGPDwdnRujlW3gPUC1zR4NVh42e4hjoTnEUKnY5QeYpzUjndQIdmDJpQr AwJizcWHrvNhZHgdTL+Hi5oCLT1GlzkNFFu1xyJ63HQXwY/xla5x4AU98uMay8FxYqV3 Phfg== ARC-Authentication-Results: i=1; mx.google.com; dkim=neutral (body hash did not verify) header.i=@nifty.com header.s=dec2015msa header.b=OhCFZgBP; spf=pass (google.com: best guess record for domain of u-boot-bounces@lists.denx.de designates 81.169.180.215 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de Return-Path: Received: from lists.denx.de (dione.denx.de. [81.169.180.215]) by mx.google.com with ESMTP id t18si9944596edd.339.2017.09.13.04.46.47; Wed, 13 Sep 2017 04:46:47 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of u-boot-bounces@lists.denx.de designates 81.169.180.215 as permitted sender) client-ip=81.169.180.215; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@nifty.com header.s=dec2015msa header.b=OhCFZgBP; spf=pass (google.com: best guess record for domain of u-boot-bounces@lists.denx.de designates 81.169.180.215 as permitted sender) smtp.mailfrom=u-boot-bounces@lists.denx.de Received: by lists.denx.de (Postfix, from userid 105) id 2D63FC224D8; Wed, 13 Sep 2017 11:46:08 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on lists.denx.de X-Spam-Level: X-Spam-Status: No, score=0.0 required=5.0 tests=T_DKIM_INVALID autolearn=unavailable autolearn_force=no version=3.4.0 Received: from lists.denx.de (localhost [IPv6:::1]) by lists.denx.de (Postfix) with ESMTP id 88ED9C224D8; Wed, 13 Sep 2017 11:45:42 +0000 (UTC) Received: by lists.denx.de (Postfix, from userid 105) id 9DB9BC22531; Wed, 13 Sep 2017 11:45:32 +0000 (UTC) Received: from conuserg-10.nifty.com (conuserg-10.nifty.com [210.131.2.77]) by lists.denx.de (Postfix) with ESMTPS id 12E7FC220DF for ; Wed, 13 Sep 2017 11:45:31 +0000 (UTC) Received: from pug.e01.socionext.com (p14092-ipngnfx01kyoto.kyoto.ocn.ne.jp [153.142.97.92]) (authenticated) by conuserg-10.nifty.com with ESMTP id v8DBjE4s018351; Wed, 13 Sep 2017 20:45:19 +0900 DKIM-Filter: OpenDKIM Filter v2.10.3 conuserg-10.nifty.com v8DBjE4s018351 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nifty.com; s=dec2015msa; t=1505303120; bh=0NFn0QwgQ6PUqeK4c0hfIAUzA2LIW7IFbh0x/jFxz0g=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=OhCFZgBP9iDz1+Ds6NbuVN/xXMf1D0fX4PNqwkV0yW5dAOIYxDw1WgJlpcuZ/t5MN x0jxFcBi7YkojZv9I8UnD63tuWzGZ/b5rt061EABehQkffD3ECDwK3mQmxWArsljNk 3fHsJaDOHnmsS0gRfmbdBWSFY78zlV76wMJ9rhpdMJm1eFV7v7mVdCt+2iB3KyprDP BnrbsdPbJPIGFNjk1dPa8nt74qAJqQcUakMEyzXH+jojCcFBlvDFP9oY2+PfScb1R8 1OfI9Svqyw27BZfWt4qYN2DT0DYwr0H3GOdEn8USmLWpLYtbrF6d60LxR6yZDZ3HRe Ynct2p4T1NPoA== X-Nifty-SrcIP: [153.142.97.92] From: Masahiro Yamada To: u-boot@lists.denx.de Date: Wed, 13 Sep 2017 20:45:05 +0900 Message-Id: <1505303106-9780-6-git-send-email-yamada.masahiro@socionext.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1505303106-9780-1-git-send-email-yamada.masahiro@socionext.com> References: <1505303106-9780-1-git-send-email-yamada.masahiro@socionext.com> Subject: [U-Boot] [PATCH 5/6] bug.h: sync BUILD_BUG stuff with Linux 4.13 X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.18 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" As commit 84b8bf6d5d2a ("bug.h: move BUILD_BUG_* defines to include/linux/bug.h") noted, include/linux/bug.h was locally modified for U-Boot because the name conflict of error() caused build errors at that time. Now error() is gone, so we can fully sync BUILD_BUG* with Linux. These macros are just compile-time utilities. Nothing is related to platform code, so it makes sense to simply copy Linux's ones. Please note Linux split BUILD_BUG stuff out into by commit bc6245e5efd7. Let's follow it. Signed-off-by: Masahiro Yamada --- include/linux/bug.h | 51 +--------------------------- include/linux/build_bug.h | 84 +++++++++++++++++++++++++++++++++++++++++++++++ include/linux/compiler.h | 6 +++- 3 files changed, 90 insertions(+), 51 deletions(-) create mode 100644 include/linux/build_bug.h diff --git a/include/linux/bug.h b/include/linux/bug.h index 920e379..133544c 100644 --- a/include/linux/bug.h +++ b/include/linux/bug.h @@ -1,55 +1,6 @@ #ifndef _LINUX_BUG_H #define _LINUX_BUG_H -#include - -#ifdef __CHECKER__ -#define BUILD_BUG_ON_NOT_POWER_OF_2(n) (0) -#define BUILD_BUG_ON_ZERO(e) (0) -#define BUILD_BUG_ON_NULL(e) ((void*)0) -#define BUILD_BUG_ON_INVALID(e) (0) -#define BUILD_BUG_ON(condition) (0) -#define BUILD_BUG() (0) -#else /* __CHECKER__ */ - -/* Force a compilation error if a constant expression is not a power of 2 */ -#define BUILD_BUG_ON_NOT_POWER_OF_2(n) \ - BUILD_BUG_ON((n) == 0 || (((n) & ((n) - 1)) != 0)) - -/* Force a compilation error if condition is true, but also produce a - result (of value 0 and type size_t), so the expression can be used - e.g. in a structure initializer (or where-ever else comma expressions - aren't permitted). */ -#define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); })) -#define BUILD_BUG_ON_NULL(e) ((void *)sizeof(struct { int:-!!(e); })) - -/* - * BUILD_BUG_ON_INVALID() permits the compiler to check the validity of the - * expression but avoids the generation of any code, even if that expression - * has side-effects. - */ -#define BUILD_BUG_ON_INVALID(e) ((void)(sizeof((__force long)(e)))) - -/** - * BUILD_BUG_ON - break compile if a condition is true. - * @condition: the condition which the compiler should know is false. - * - * If you have some code which relies on certain constants being equal, or - * some other compile-time-evaluated condition, you should use BUILD_BUG_ON to - * detect if someone changes it. - * - * The implementation uses gcc's reluctance to create a negative array, but gcc - * (as of 4.4) only emits that error for obvious cases (e.g. not arguments to - * inline functions). Luckily, in 4.3 they added the "error" function - * attribute just for this type of case. Thus, we use a negative sized array - * (should always create an error on gcc versions older than 4.4) and then call - * an undefined function with the error attribute (should always create an - * error on gcc 4.3 and later). If for some reason, neither creates a - * compile-time error, we'll still have a link-time error, which is harder to - * track down. - */ -#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)])) - -#endif /* __CHECKER__ */ +#include #endif /* _LINUX_BUG_H */ diff --git a/include/linux/build_bug.h b/include/linux/build_bug.h new file mode 100644 index 0000000..b7d22d6 --- /dev/null +++ b/include/linux/build_bug.h @@ -0,0 +1,84 @@ +#ifndef _LINUX_BUILD_BUG_H +#define _LINUX_BUILD_BUG_H + +#include + +#ifdef __CHECKER__ +#define __BUILD_BUG_ON_NOT_POWER_OF_2(n) (0) +#define BUILD_BUG_ON_NOT_POWER_OF_2(n) (0) +#define BUILD_BUG_ON_ZERO(e) (0) +#define BUILD_BUG_ON_NULL(e) ((void *)0) +#define BUILD_BUG_ON_INVALID(e) (0) +#define BUILD_BUG_ON_MSG(cond, msg) (0) +#define BUILD_BUG_ON(condition) (0) +#define BUILD_BUG() (0) +#else /* __CHECKER__ */ + +/* Force a compilation error if a constant expression is not a power of 2 */ +#define __BUILD_BUG_ON_NOT_POWER_OF_2(n) \ + BUILD_BUG_ON(((n) & ((n) - 1)) != 0) +#define BUILD_BUG_ON_NOT_POWER_OF_2(n) \ + BUILD_BUG_ON((n) == 0 || (((n) & ((n) - 1)) != 0)) + +/* + * Force a compilation error if condition is true, but also produce a + * result (of value 0 and type size_t), so the expression can be used + * e.g. in a structure initializer (or where-ever else comma expressions + * aren't permitted). + */ +#define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:(-!!(e)); })) +#define BUILD_BUG_ON_NULL(e) ((void *)sizeof(struct { int:(-!!(e)); })) + +/* + * BUILD_BUG_ON_INVALID() permits the compiler to check the validity of the + * expression but avoids the generation of any code, even if that expression + * has side-effects. + */ +#define BUILD_BUG_ON_INVALID(e) ((void)(sizeof((__force long)(e)))) + +/** + * BUILD_BUG_ON_MSG - break compile if a condition is true & emit supplied + * error message. + * @condition: the condition which the compiler should know is false. + * + * See BUILD_BUG_ON for description. + */ +#define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) + +/** + * BUILD_BUG_ON - break compile if a condition is true. + * @condition: the condition which the compiler should know is false. + * + * If you have some code which relies on certain constants being equal, or + * some other compile-time-evaluated condition, you should use BUILD_BUG_ON to + * detect if someone changes it. + * + * The implementation uses gcc's reluctance to create a negative array, but gcc + * (as of 4.4) only emits that error for obvious cases (e.g. not arguments to + * inline functions). Luckily, in 4.3 they added the "error" function + * attribute just for this type of case. Thus, we use a negative sized array + * (should always create an error on gcc versions older than 4.4) and then call + * an undefined function with the error attribute (should always create an + * error on gcc 4.3 and later). If for some reason, neither creates a + * compile-time error, we'll still have a link-time error, which is harder to + * track down. + */ +#ifndef __OPTIMIZE__ +#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)])) +#else +#define BUILD_BUG_ON(condition) \ + BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) +#endif + +/** + * BUILD_BUG - break compile if used. + * + * If you have some code that you expect the compiler to eliminate at + * build time, you should use BUILD_BUG to detect if it is + * unexpectedly used. + */ +#define BUILD_BUG() BUILD_BUG_ON_MSG(1, "BUILD_BUG failed") + +#endif /* __CHECKER__ */ + +#endif /* _LINUX_BUILD_BUG_H */ diff --git a/include/linux/compiler.h b/include/linux/compiler.h index 020ad16..0ea6c8f 100644 --- a/include/linux/compiler.h +++ b/include/linux/compiler.h @@ -476,7 +476,8 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s # define __compiletime_error_fallback(condition) do { } while (0) #endif -#define __compiletime_assert(condition, msg, prefix, suffix) \ +#ifdef __OPTIMIZE__ +# define __compiletime_assert(condition, msg, prefix, suffix) \ do { \ bool __cond = !(condition); \ extern void prefix ## suffix(void) __compiletime_error(msg); \ @@ -484,6 +485,9 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s prefix ## suffix(); \ __compiletime_error_fallback(__cond); \ } while (0) +#else +# define __compiletime_assert(condition, msg, prefix, suffix) do { } while (0) +#endif #define _compiletime_assert(condition, msg, prefix, suffix) \ __compiletime_assert(condition, msg, prefix, suffix)