[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[PATCH v3] misra: deviate MISRA C Rule 10.1 for boolean operands of arithmetic


  • To: "xen-devel@xxxxxxxxxxxxxxxxxxxx" <xen-devel@xxxxxxxxxxxxxxxxxxxx>
  • From: Dmytro Prokopchuk1 <dmytro_prokopchuk1@xxxxxxxx>
  • Date: Tue, 17 Nov 2026 19:35:47 +0000
  • Accept-language: en-US, uk-UA, ru-RU
  • Arc-authentication-results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=epam.com; dmarc=pass action=none header.from=epam.com; dkim=pass header.d=epam.com; arc=none
  • Arc-message-signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=qDDzvay385CUNjb72j2EhJns+cfktYW1MWGlf4e3lWs=; b=JdAkgvuOHLkNgDr7F7eDW0egA0EVrvh+l8whzpg9B8lTQP4nEJ9CvlOnZ0EocSm83jjjuCA7hnGHLf1gwGRAkCMtqzlKnNaH1RqoKk0cv208IIjjgvEfXzZSjwt81r+3I1zMEXmhCLjfOaYEiZuJlATSzZnC41IACqZW9B9qJzwW6Hh3RDKB/ZDElS+7eBc8i4YkL0rbqzHtsmzdia4ByRyZ6BK64RJm2d5wF1YzlG9HXbYMpGgpFqXktDWTrMx8cXhuHrUz8JZpRf1UOXEtf6KJ7W0yochZcRhOpuYebqKVkzxaHE7SH1DymVoSA+n/ZBComm1Se5v4DwiS2H62nw==
  • Arc-seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=fwTdfvYLYb4Gjq2U/YWnRA2oZa2KvSFMUL2iNfSY4BTQEBz0n3TSPNstIQFrlp0ypQHfxwTbyNV318SCUUiOZHoMZFpfY36Op3vPcon19Mv59RCPT4X1r1L3nmMC1Feplr2s3KjrpOpEfgZdVSHMeMA+26I7JqvQdRp+I0QnFAFomlkkvI9bLQeCiDbpNmVtDNBeH0NUWloRV2eJz/2+V7MD4vGajve6czsSt8zp7FASLlR3hbtdYKXDTlS480NfDX5NmD08CNLRTynTgtIAji/UvdRFOtKHJOroiC8O2M1kiN3FJarzVFNNWIif7dhwCBVMsD8bakrg4siyp//JiA==
  • Authentication-results: eu.smtp.expurgate.cloud; dkim=pass header.s=selector1 header.d=epam.com header.i="@epam.com" header.h="From:Date:Subject:Message-ID:Content-Type:MIME-Version:x-ms-exchange-senderadcheck"
  • Authentication-results: mx.microsoft.com 1; dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=epam.com;
  • Cc: Dmytro Prokopchuk1 <dmytro_prokopchuk1@xxxxxxxx>, Nicola Vetrini <nicola.vetrini@xxxxxxxxxxx>, Doug Goldstein <cardoe@xxxxxxxxxx>, Stefano Stabellini <sstabellini@xxxxxxxxxx>, Andrew Cooper <andrew.cooper3@xxxxxxxxxx>, Anthony PERARD <anthony.perard@xxxxxxxxxx>, Michal Orzel <michal.orzel@xxxxxxx>, Jan Beulich <jbeulich@xxxxxxxx>, Julien Grall <julien@xxxxxxx>, Roger Pau Monné <roger@xxxxxxxxxxxxxx>
  • Delivery-date: Tue, 17 Nov 2026 19:36:04 +0000
  • List-id: Xen developer discussion <xen-devel.lists.xenproject.org>
  • Thread-index: AQHddsrYLaVRJihQEUu25Hr3vcjlcw==
  • Thread-topic: [PATCH v3] misra: deviate MISRA C Rule 10.1 for boolean operands of arithmetic

MISRA C Rule 10.1 states: "Operands shall not be of an inappropriate
essential type".

The result of relational, equality and logical negation operators has
type int and value 0 or 1 (C99 6.5.8p6, 6.5.9p3, 6.5.3.3p5). An object
or function result of type bool has value 0 or 1 too, and it is
promoted to int (C99 6.3.1.2, 6.3.1.1p2). Using that value as an
operand of unary +, -, binary +, -, *, <<, >> and of +=, -=, *=,
<<=, >>= is well-defined. Division, remainder, the relational
operators, increment and decrement stay covered by the rule.

Update the ECLAIR configuration to tag the accepted uses as safe.
Update deviations.rst and rules.rst accordingly.

Signed-off-by: Dmytro Prokopchuk <dmytro_prokopchuk1@xxxxxxxx>
---
Test CI pipeline:
https://gitlab.com/xen-project/people/dimaprkp4k/xen/-/pipelines/3080459013

Changes in v3:
- include unary + and -
- drop relational operators
- split the ECLAIR config into one clause per operator group for
  readability
---
 .../eclair_analysis/ECLAIR/deviations.ecl     |  9 +++++++++
 docs/misra/deviations.rst                     | 20 +++++++++++++++++++
 docs/misra/rules.rst                          |  4 ++++
 3 files changed, 33 insertions(+)

diff --git a/automation/eclair_analysis/ECLAIR/deviations.ecl 
b/automation/eclair_analysis/ECLAIR/deviations.ecl
index d49af53055..e22a05a21b 100644
--- a/automation/eclair_analysis/ECLAIR/deviations.ecl
+++ b/automation/eclair_analysis/ECLAIR/deviations.ecl
@@ -341,6 +341,15 @@ still non-negative."
 -config=MC3A2.R10.1,etypes+={safe, 
"stmt(operator(logical)||node(conditional_operator||binary_conditional_operator))",
 "dst_type(ebool||boolean)"}
 -doc_end
 
+-doc_begin="A 0-or-1 Boolean operand of unary +, -, binary +, -, *, <<, >> and 
of +=, -=, *=, <<=, >>= is safe. See docs/misra/deviations.rst for the full 
explanation."
+-config=MC3A2.R10.1,etypes+={safe, "stmt(operator(plus||minus))", 
"src_type(ebool||boolean)"}
+-config=MC3A2.R10.1,etypes+={safe, "stmt(operator(add||add_assign))", 
"src_type(ebool||boolean)"}
+-config=MC3A2.R10.1,etypes+={safe, "stmt(operator(sub||sub_assign))", 
"src_type(ebool||boolean)"}
+-config=MC3A2.R10.1,etypes+={safe, "stmt(operator(mul||mul_assign))", 
"src_type(ebool||boolean)"}
+-config=MC3A2.R10.1,etypes+={safe, "stmt(operator(shl||shl_assign))", 
"src_type(ebool||boolean)"}
+-config=MC3A2.R10.1,etypes+={safe, "stmt(operator(shr||shr_assign))", 
"src_type(ebool||boolean)"}
+-doc_end
+
 -doc_begin="The macro ISOLATE_LSB encapsulates a well-known pattern to obtain
 a mask where only the lowest bit set in the argument is set, if any, for 
unsigned
 integers arguments on two's complement architectures
diff --git a/docs/misra/deviations.rst b/docs/misra/deviations.rst
index 7b983db264..6458a79a67 100644
--- a/docs/misra/deviations.rst
+++ b/docs/misra/deviations.rst
@@ -355,6 +355,26 @@ Deviations related to MISRA C:2012 Rules:
        well-known to all Xen developers to be a comparison with 0.
      - Tagged as `safe` for ECLAIR.
 
+   * - R10.1
+     - The result of relational, equality and logical negation operators has
+       type int and value 0 or 1 (C99 6.5.8p6, 6.5.9p3, 6.5.3.3p5). An object
+       or function result of type bool has value 0 or 1 too, and it is
+       promoted to int (C99 6.3.1.2, 6.3.1.1p2). Such a value is a
+       well-defined operand of the following operators. Unary + leaves it
+       unchanged. Unary - yields 0 or -1, all bits clear or, in two's
+       complement, all bits set. Binary + and - (and += and -=) count
+       something if the condition holds. \* (and \*=) yields the other operand
+       if the condition holds and 0 otherwise. << and >> (and <<= and >>=)
+       extend that selection to a shift: a Boolean left operand contributes 0
+       or 1, and a Boolean right operand is a shift count of 0 or 1. / and %
+       (and /= and %=) are excluded. A Boolean divisor is 0 when the condition
+       is false, and division or remainder by zero is undefined behavior
+       (C99 6.5.5p5). The relational operators are excluded as well: with
+       0-or-1 operands, whatever they express can be written with the equality
+       and logical operators, which already accept an essentially Boolean
+       operand. Increment and decrement stay under the rule.
+     - Tagged as `safe` for ECLAIR.
+
    * - R10.1
      - Xen only supports architectures where signed integers are representend
        using two's complement and all the Xen developers are aware of this. For
diff --git a/docs/misra/rules.rst b/docs/misra/rules.rst
index 7e191a0d4a..c075fe2391 100644
--- a/docs/misra/rules.rst
+++ b/docs/misra/rules.rst
@@ -387,6 +387,10 @@ maintainers if you want to suggest a change.
            compilers' extensions)
          - Implicit conversions to boolean for conditionals (?: if while
            for) and logical operators (! || &&)
+         - Operands of essentially Boolean type (results of relational,
+           equality and logical negation operators, objects and function
+           results of type bool) used only with unary +, -, binary +, -,
+           \*, <<, >>, +=, -=, \*=, <<= and >>=
          - The essential type model allows the constants defined by anonymous
            enums (e.g., enum { A, B, C }) to be used as operands to arithmetic
            operators, as they have a signed essential type.
-- 
2.43.0

 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.