From patchwork Sat Sep 16 05:10:44 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Masahiro Yamada X-Patchwork-Id: 112779 Delivered-To: patch@linaro.org Received: by 10.140.106.117 with SMTP id d108csp1391293qgf; Fri, 15 Sep 2017 22:13:58 -0700 (PDT) X-Google-Smtp-Source: ADKCNb42jprC3vVQESZKNRtFxu5zPH1uklV376qTj9riar9lA+g3ySIYtSru2vUIDnjHg+C0fUZv X-Received: by 10.80.220.202 with SMTP id v10mr14752585edk.226.1505538838432; Fri, 15 Sep 2017 22:13:58 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1505538838; cv=none; d=google.com; s=arc-20160816; b=qRQetVFCag5exOKMaGU8cjJYVdyZiobOsXB7DtyA5SctgeVXohU6pzxPw213J7CsAT +l8YfoHaNxxLAr2SELmnNrfHIFz2erpM/F1U0xocqqQaSIdJSU4kt1b/iG0+UxDUxy7p DV4XZWF58azEiaJb7I5pmgO6HEUxF1lDqi9f6f0Lbfuf1NC1BdMrfxKVRsdVPRIryzCz f3YSQmRI4s8EDzGb3AjgWFsxnNSlHJTk7B74Em4P+btOIYhg4kV80oMsGxb3oP6dPZFK 9kL8NviTYL2zHLHSLII2CeQR/krQNTlrfyLEnAUX9sNP1A0+cMJZFWvyzYxi3jCX8ip6 tBPw== 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=h5GUEKsiiJQ8sxG+bjffeAcGi97wgCvMl0rOkOPhfh8=; b=OmxkbBsHwxhUjPtpMOG+NZlWlTKTBlnH6CxlukzdLmb82dCuF4w4Pw/LnolsC8S/p3 rjR+SDT5LSHmE3XRMHS8MBHKHb7tcMYAFl1hV/qgkA/px5afxWVBe/dpStRRTBbW8Tig OuCVEIQQPgfFVGSSYIyy/VbSVvp9rl94vhFPSGrvfObk/mrjzu8ZJJAAa81I8BGUZLj6 rvE3m6bc9pRgSEFo3Ru56XU/nmgFviZL8uK5SCb6g4lMTvtFVgoKvxNGzKTeBTM518aI puLO2WgEeqVCrIT2lgdzbVp1x3PISAzHph7M0xYg4DB1KwIohS75BnRggC/R4kE0GDas fNEw== ARC-Authentication-Results: i=1; mx.google.com; dkim=neutral (body hash did not verify) header.i=@nifty.com header.s=dec2015msa header.b=UTlJOvw2; 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 28si2718460edv.243.2017.09.15.22.13.58; Fri, 15 Sep 2017 22:13:58 -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=UTlJOvw2; 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 F1A5CC21F54; Sat, 16 Sep 2017 05:12:28 +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 D8512C21FA9; Sat, 16 Sep 2017 05:11:23 +0000 (UTC) Received: by lists.denx.de (Postfix, from userid 105) id B9FB0C21C8F; Sat, 16 Sep 2017 05:11:18 +0000 (UTC) Received: from conuserg-09.nifty.com (conuserg-09.nifty.com [210.131.2.76]) by lists.denx.de (Postfix) with ESMTPS id D306DC21D75 for ; Sat, 16 Sep 2017 05:11:16 +0000 (UTC) Received: from grover.sesame (FL1-122-131-185-176.osk.mesh.ad.jp [122.131.185.176]) (authenticated) by conuserg-09.nifty.com with ESMTP id v8G5Asoq028761; Sat, 16 Sep 2017 14:10:59 +0900 DKIM-Filter: OpenDKIM Filter v2.10.3 conuserg-09.nifty.com v8G5Asoq028761 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nifty.com; s=dec2015msa; t=1505538659; bh=Z8tpfk4MDXbT++gKREjTetQMSvWDgZ1/QaDPyQQRTbw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=UTlJOvw2mohfSVPFvT1vNQutwHAM41wbmdOkyS2lGN2D/CgOROaGeSxzUPnvtxdZ7 ncs8dZ1q+qhtj7EnbBukhrNAdH/wGkiK4IiFyyUHv+qfjrrxERpjT4LNGBBFtmZrGo D7+IHEToai9Z5q5bAdEFOKqPZ1oVsxdMNFYATS6Zo8E+pDuWz2DJZvneK6attSWloF mC7dq6slWcW+wAQkxdgqpKrWXg/gQ2QsU7Xw8FbgZy51GT/OEqJKpj2vXk21zBZ+MU l2npcp6QYK3onxPQlnFjTQ+EU68LTMDL51zdXssiBGPkAFxBUNdIPFgmNqNoKOSWuA TaSZC1wNYQwfg== X-Nifty-SrcIP: [122.131.185.176] From: Masahiro Yamada To: u-boot@lists.denx.de Date: Sat, 16 Sep 2017 14:10:44 +0900 Message-Id: <1505538646-19191-7-git-send-email-yamada.masahiro@socionext.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1505538646-19191-1-git-send-email-yamada.masahiro@socionext.com> References: <1505538646-19191-1-git-send-email-yamada.masahiro@socionext.com> Subject: [U-Boot] [PATCH v2 6/8] 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 depends on platform code, so it should make 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 --- Changes in v2: None 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 920e3796c38d..133544ca46f0 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 000000000000..b7d22d60008a --- /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 020ad16a0493..0ea6c8fccaab 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)