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

Re: [PATCH] misra: consider conversion from UL or (void*) to function pointer as safe


  • To: Dmytro Prokopchuk1 <dmytro_prokopchuk1@xxxxxxxx>
  • From: Nicola Vetrini <nicola.vetrini@xxxxxxxxxxx>
  • Date: Fri, 29 Aug 2025 07:43:30 +0200
  • Arc-authentication-results: i=1; bugseng.com; arc=none smtp.remote-ip=162.55.131.47
  • Arc-message-signature: i=1; d=bugseng.com; s=openarc; a=rsa-sha256; c=relaxed/relaxed; t=1756446210; h=DKIM-Signature:MIME-Version:Date:From:To:Cc:Subject:In-Reply-To: References:Message-ID:X-Sender:Organization:Content-Type: Content-Transfer-Encoding; bh=M/pl1D0HoTbrkXKeJQRj59Agn1yMB9bXAaWmtMKEvP8=; b=vFYqWJWdur5SvqriAlXxydxD3xaZBSwIhEL8GKtCxLGaHXDx+zQY1cneK9aCTSNFsTLU H24BGWXHXr0m2zpw9zhlm8sLQbULGgcJVwKmYCOuD6R+3+eLODzuX9ot89P9RVNAPF9pb YQCuB0QM67HE8B1x/UX4WayDkrd9MTnhdwhd17GCLa2dVAASAL2X7lm9646AoCt/O6uG4 PN8qXr3qia3gQWDnLTg/gBjSa8RUWh5uNf2/O14iVds2v8LqrR0WMYdr/7wpIdfR6Iojw 5L9wvF2nHh9OlGnbv+jwe4TvudcUlhyrZZMUMGRhcZkXcjJf5cmdbJkeHM7DLeg5Gdowc hQDW/t83u3eobwsccyPAVyG+sfl6mhKOnN3xlI0W7xoCI1XGTCd+cXEr0kfYvtMFShjYN pCIwzRKmwlWn7bCvoBTMxFBo9MxB33kYhqmXpZzNirikTBXqR402mdEDns78t3PCueDmA qvjAgJcDN2pLL3+H7otQJZRBn22/PweGt25WLQb4NvbAVeKEFZWxGBhLLQ+Bh/xdu4MsT yP3pBDdL8Dy1Ph+FBiUxc+6/iek6Vu2jMe5wU+E+mXsucpGRRMF+0PPctjWA0BIa/pxx1 FOhTY8YyHcQ/++nzKsNsivkfcX1XxBoFHRD0TfM/hz6lhTPoiD/+Jk0vCWo9XvY=
  • Arc-seal: i=1; d=bugseng.com; s=openarc; a=rsa-sha256; cv=none; t=1756446210; b=EwU7H6flSghzegfLGZHs5Vq2FY4kNnwfHhrwrEdONgE+V5ofXl0AncipZTFPXvTZ9qa6 4V5oiy16H47bM/UYoShUT28XjrEddCccIMAAEXwwixK32rmvM/Yg5TmA4eslFxksNdWRb HXexzXzJLWwWAQyvBACNl/T36ugM9F+uUXGUuxvBRmg+KVTAelLkas2GDoFyZ/H3RyEfW CTMEk3gpmfFJVPxGkBC+Uw5rK3j3k0snPhwYG/Gt1hApmPkvW6tW7BNm0/FLYgyijOQti ZAFjy0gU1hgTcP9blAUuOgjHKLymyAVcMR9FNV3/oSf3WEeeBhFKA+mzcrE7df795TVMh xa9jiLlk81aFVo34Mv2ka8J/d+kwLpEupZKEssscOxv0q0I/r8QGzRQ8l8y/CD/1NKP5H D0QeEj2kfhCqMWDy5kU9Hhi6TAoX9sg9n52dBL1mmyLwBOoRkIAh+rvSWeeiKxMZu18MW 4YjirWtwr97GuNPh1c8p/RwW5AFIAh7nRQsCh4ojfZ/OfQvLXWTHduJi2dHECCqpj62N3 zyFLyX4zbbLC1KU8pXbCJVml7S+ykg8fwwwjrqPEW6KCsFh/oobMuO4VDDnxemGaWZAsK 1aQAXCvq92QJFyCBIEGTASN/esvGLgY8NTry7QTFR7iZedqUvYcAdloApiG9fgg=
  • Authentication-results: bugseng.com; arc=none smtp.remote-ip=162.55.131.47
  • Cc: Jan Beulich <jbeulich@xxxxxxxx>, Stefano Stabellini <sstabellini@xxxxxxxxxx>, Doug Goldstein <cardoe@xxxxxxxxxx>, Andrew Cooper <andrew.cooper3@xxxxxxxxxx>, Anthony PERARD <anthony.perard@xxxxxxxxxx>, Michal Orzel <michal.orzel@xxxxxxx>, Julien Grall <julien@xxxxxxx>, Roger Pau Monné <roger.pau@xxxxxxxxxx>, xen-devel@xxxxxxxxxxxxxxxxxxxx
  • Delivery-date: Fri, 29 Aug 2025 05:43:49 +0000
  • List-id: Xen developer discussion <xen-devel.lists.xenproject.org>

On 2025-08-28 17:54, Dmytro Prokopchuk1 wrote:
On 8/25/25 16:08, Nicola Vetrini wrote:
On 2025-08-25 14:53, Nicola Vetrini wrote:
On 2025-08-22 18:34, Dmytro Prokopchuk1 wrote:
On 8/21/25 11:25, Nicola Vetrini wrote:
On 2025-08-21 10:01, Jan Beulich wrote:
On 19.08.2025 20:55, Dmytro Prokopchuk1 wrote:
Rule 11.1 states as following: "Conversions shall not be performed
between a pointer to a function and any other type."

The conversion from unsigned long or (void *) to a function pointer is safe in Xen because the architectures it supports (e.g., x86 and
ARM) guarantee compatible representations between these types.

I think we need to be as precise as possible here. The architectures
guarantee nothing, they only offer necessary fundamentals. In the
Windows x86 ABI, for example, you can't convert pointers to/from longs without losing data. What we build upon is what respective ABIs say, possibly in combination of implementation specifics left to compilers.


+1, a mention of the compilers and targets this deviation relies
upon is
needed.

Maybe with this wording:

This deviation is based on the guarantees provided by the specific ABIs (e.g., ARM AAPCS) and compilers (e.g., GCC) supported in Xen. These ABIs

s/supported in/supported by/

guarantee compatible representations for 'void *', 'unsigned long' and function pointers for the supported target platforms. This behavior is

It's not just about the guarantees of the ABIs: it's the behavior of
the compiler for those ABIs that makes this safe or unsafe. If
present, such documentation should be included


In any case, provided that the wording can be adjusted:

Reviewed-by: Nicola Vetrini <nicola.vetrini@xxxxxxxxxxx>

Updated wording:

This deviation from Rule 11.1 relies on both ABI definitions and compiler implementations supported by Xen. The System V x86_64 ABI and the AArch64
ELF ABI define consistent and compatible representations (i.e., having
the same size and memory layout) for 'void *', 'unsigned long', and function pointers, enabling safe conversions between these types without data loss or corruption. Additionally, GCC and Clang, faithfully implement the ABI specifications, ensuring that the generated machine code conforms to these guarantees. Developers must note that this behavior is not universal and
depends on platform-specific ABIs and compiler implementations.


LGTM.

References:
- System V x86_64 ABI:
https://gitlab.com/x86-psABIs/x86-64-ABI/-/jobs/artifacts/master/raw/x86-64-ABI/abi.pdf?job=build
- AArch64 ELF ABI: https://github.com/ARM-software/abi-aa/releases
- GCC: https://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html
- Clang: https://clang.llvm.org/docs/CrossCompilation.html

Thanks,
Dmytro.

architecture-specific and may not be portable outside of supported
environments.


--- a/docs/misra/deviations.rst
+++ b/docs/misra/deviations.rst
@@ -370,6 +370,16 @@ Deviations related to MISRA C:2012 Rules:
        to store it.
      - Tagged as `safe` for ECLAIR.

+   * - R11.1
+     - The conversion from unsigned long or (void \*) to a function
pointer does
+       not lose any information or violate type safety assumptions
if unsigned
+       long or (void \*) type is guaranteed to be the same bit size
as a
+       function pointer. This ensures that the function pointer can
be fully
+       represented without truncation or corruption. The macro
BUILD_BUG_ON is
+       integrated into xen/common/version.c to confirm conversion
compatibility
+       across all target platforms.
+     - Tagged as `safe` for ECLAIR.

Why the escaping of * here, when ...

--- a/docs/misra/rules.rst
+++ b/docs/misra/rules.rst
@@ -431,7 +431,13 @@ maintainers if you want to suggest a change.
      - All conversions to integer types are permitted if the
destination
        type has enough bits to hold the entire value. Conversions to
bool
        and void* are permitted. Conversions from 'void noreturn (*)
(...)'
-       to 'void (*)(...)' are permitted.
+       to 'void (*)(...)' are permitted. Conversions from unsigned
long or
+       (void \*) to a function pointer are permitted if the source
type has
+       enough bits to restore function pointer without truncation or
corruption.
+       Example::
+
+           unsigned long func_addr = (unsigned long)&some_function; +           void (*restored_func)(void) = (void (*)(void))func_addr;

... context here suggests they work fine un-escaped, and you even add
some un-
escaped instances as well. Perhaps I'm simply unaware of some
peculiarity?


This is a literal rst block, while the other is not (* acts as a bullet
point in rst iirc)

This is how "sphinx-build" tool interprets this.
1. * inside single quotes '' -> looks normal, e.g. ‘void (*)(…)’
2. * without quotes -> warning
deviations.rst:369: WARNING: Inline emphasis start-string without
end-string. [docutils]
3. \* -> looks normal, e.g. (void *)

Because that we need such format: \*

Dmytro.


Jan



--
Nicola Vetrini, B.Sc.
Software Engineer
BUGSENG (https://bugseng.com)
LinkedIn: https://www.linkedin.com/in/nicola-vetrini-a42471253



 


Rackspace

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