prfchwintrin.h: Make _m_prefetchw take a pointer to volatile (PR49124)

[hans]

Summary

For some reason, Microsoft declares _m_prefetch to take a const void*, but _m_prefetchw to take a /volatile/ const void*.

I can't think of any downside to just casting away the volatile here? (Besides having to suppress the warning in a somewhat ugly way.)

[rnk]

Does this match GCC? They also provide this Intel intrinsic.

Seems reasonable in principle, though.

[pengfei]

clang/lib/Headers/prfchwintrin.h

54

Can we declare __builtin_prefetch to volatile one in Builtins.def:

BUILTIN(__builtin_prefetch, "vvCD*.", "nc")

[hans]

In D106790#2905110, @rnk wrote:

Does this match GCC? They also provide this Intel intrinsic.

No, they define it without volatile (and also without const): https://github.com/gcc-mirror/gcc/blob/releases/gcc-11.1.0/gcc/config/i386/prfchwintrin.h#L32

But maybe their header doesn't get included together with Microsoft's header?

clang/lib/Headers/prfchwintrin.h

54

We could, and that would remove the need for the cast, but I'm not sure it would make sense in itself. Since _m_prefetchw is the odd one here, I think it makes sense to do the fix in its implementation.

[rnk]

In D106790#2906762, @hans wrote:

In D106790#2905110, @rnk wrote:

Does this match GCC? They also provide this Intel intrinsic.

No, they define it without volatile (and also without const): https://github.com/gcc-mirror/gcc/blob/releases/gcc-11.1.0/gcc/config/i386/prfchwintrin.h#L32

But maybe their header doesn't get included together with Microsoft's header?

Sure, they won't be included together, but will GCC users get warnings from passing non-volatile pointers to _mm_prefetchw? If we change these qualifiers to match MSVC, will GCC/Clang users be able to observe any change in behavior?

[hans]

Sure, they won't be included together, but will GCC users get warnings from passing non-volatile pointers to _mm_prefetchw? If we change these qualifiers to match MSVC, will GCC/Clang users be able to observe any change in behavior?

I don't think that should cause any problems. Passing a less qualified pointer to a more cv-qualified parameter should be fine, e.g.

void f(volatile void* p);

void g(void *p) {
  f(p);
}

[rnk]

In D106790#2909567, @hans wrote:

I don't think that should cause any problems. Passing a less qualified pointer to a more cv-qualified parameter should be fine, e.g.

OK, I'm happy then.

clang/lib/Headers/prfchwintrin.h

54

I agree with @hans, I think leaving the prototype of __builtin_prefetch as it is seems reasonable, since it is used elsewhere.

clang/lib/Headers/prfchwintrin.h

 /*===---- prfchwintrin.h - PREFETCHW intrinsic -----------------------------===
  *
  * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  * See https://llvm.org/LICENSE.txt for license information.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  *===-----------------------------------------------------------------------===
  */
 
 #if !defined(__X86INTRIN_H) && !defined(_MM3DNOW_H_INCLUDED)
 #error "Never use <prfchwintrin.h> directly; include <x86intrin.h> or <mm3dnow.h> instead."
 #endif
 
 #ifndef __PRFCHWINTRIN_H
 #define __PRFCHWINTRIN_H
 
 /// Loads a memory sequence containing the specified memory address into
 ///    all data cache levels. The cache-coherency state is set to exclusive.
 ///    Data can be read from and written to the cache line without additional

 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the \c PREFETCHW instruction.
 ///
 /// \param __P
 ///    A pointer specifying the memory address to be prefetched.
 static __inline__ void __attribute__((__always_inline__, __nodebug__))
-_m_prefetchw(void *__P)
+_m_prefetchw(volatile const void *__P)
 {
-  __builtin_prefetch (__P, 1, 3 /* _MM_HINT_T0 */);
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wcast-qual"
+  __builtin_prefetch ((const void*)__P, 1, 3 /* _MM_HINT_T0 */);
+#pragma clang diagnostic pop
 }
 
 #endif /* __PRFCHWINTRIN_H */