Opened 2 years ago

Closed 2 years ago

Last modified 23 months ago

#10926 closed bug (fixed)

wrong signature of atomic builtins

Reported by: schwab Owned by:
Priority: normal Milestone: 8.0.1
Component: Compiler Version: 7.10.2
Keywords: Cc: bgamari
Operating System: Linux Architecture: aarch64
Type of failure: Building GHC failed Test Case:
Blocked By: Blocking:
Related Tickets: Differential Rev(s): Phab:D1300
Wiki Page:

Description

"inplace/bin/ghc-stage1" -hisuf hi -osuf  o -hcsuf hc -static  -O -H64m -optc-fno-builtin    -this-package-key ghcpr_8TmvWUcS1U1IKHT0levwg3 -hide-all-packages -i -ilibraries/ghc-prim/. -ilibraries/ghc-prim/dist-install/build -ilibraries/ghc-prim/dist-install/build/autogen -Ilibraries/ghc-prim/dist-install/build -Ilibraries/ghc-prim/dist-install/build/autogen -Ilibraries/ghc-prim/.    -optP-include -optPlibraries/ghc-prim/dist-install/build/autogen/cabal_macros.h -package-key rts -this-package-key ghc-prim -XHaskell2010 -O  -no-user-package-db -rtsopts      -odir libraries/ghc-prim/dist-install/build -hidir libraries/ghc-prim/dist-install/build -stubdir libraries/ghc-prim/dist-install/build  -dynamic-too -c libraries/ghc-prim/dist-install/build/GHC/PrimopWrappers.hs -o libraries/ghc-prim/dist-install/build/GHC/PrimopWrappers.o -dyno libraries/ghc-prim/dist-install/build/GHC/PrimopWrappers.dyn_o
/tmp/ghc1492_0/ghc_1.hc: In function 'ghczmprim_GHCziPrimopWrappers_fetchXorIntArrayzh_entry':

/tmp/ghc1492_0/ghc_1.hc:2844:25:
     warning: passing argument 1 of 'hs_atomic_xor64' makes pointer from integer without a cast [-Wint-conversion]
     _c1Ho = hs_atomic_xor64((*Sp) + (((Sp[1]) << 0x3UL) + 0x10UL), Sp[2]);
                             ^

In file included from /home/abuild/rpmbuild/BUILD/ghc-7.10.2/includes/Stg.h:273:0:
    0,
                     from /tmp/ghc1492_0/ghc_1.hc:3:

/home/abuild/rpmbuild/BUILD/ghc-7.10.2/includes/stg/Prim.h:41:11:
     note: expected 'volatile StgWord64 * {aka volatile long unsigned int *}' but argument is of type 'long unsigned int'
     StgWord64 hs_atomic_xor64(volatile StgWord64 *x, StgWord64 val);
               ^

Change History (5)

comment:1 Changed 2 years ago by schwab

From 970d13089f08bfd9a967524b8ab58ab1a1bed7a8 Mon Sep 17 00:00:00 2001
From: Andreas Schwab <schwab@suse.de>
Date: Fri, 2 Oct 2015 14:11:49 +0200
Subject: [PATCH] Fix signature of atomic builtins

---
 includes/stg/Prim.h               |  72 ++++++------
 libraries/ghc-prim/cbits/atomic.c | 224 +++++++++++++++++++-------------------
 2 files changed, 148 insertions(+), 148 deletions(-)

diff --git a/includes/stg/Prim.h b/includes/stg/Prim.h
index b07e177..9872512 100644
--- a/includes/stg/Prim.h
+++ b/includes/stg/Prim.h
@@ -15,42 +15,42 @@
 #define PRIM_H
 
 /* libraries/ghc-prim/cbits/atomic.c */
-StgWord hs_atomic_add8(volatile StgWord8 *x, StgWord val);
-StgWord hs_atomic_add16(volatile StgWord16 *x, StgWord val);
-StgWord hs_atomic_add32(volatile StgWord32 *x, StgWord val);
-StgWord64 hs_atomic_add64(volatile StgWord64 *x, StgWord64 val);
-StgWord hs_atomic_sub8(volatile StgWord8 *x, StgWord val);
-StgWord hs_atomic_sub16(volatile StgWord16 *x, StgWord val);
-StgWord hs_atomic_sub32(volatile StgWord32 *x, StgWord val);
-StgWord64 hs_atomic_sub64(volatile StgWord64 *x, StgWord64 val);
-StgWord hs_atomic_and8(volatile StgWord8 *x, StgWord val);
-StgWord hs_atomic_and16(volatile StgWord16 *x, StgWord val);
-StgWord hs_atomic_and32(volatile StgWord32 *x, StgWord val);
-StgWord64 hs_atomic_and64(volatile StgWord64 *x, StgWord64 val);
-StgWord hs_atomic_nand8(volatile StgWord8 *x, StgWord val);
-StgWord hs_atomic_nand16(volatile StgWord16 *x, StgWord val);
-StgWord hs_atomic_nand32(volatile StgWord32 *x, StgWord val);
-StgWord64 hs_atomic_nand64(volatile StgWord64 *x, StgWord64 val);
-StgWord hs_atomic_or8(volatile StgWord8 *x, StgWord val);
-StgWord hs_atomic_or16(volatile StgWord16 *x, StgWord val);
-StgWord hs_atomic_or32(volatile StgWord32 *x, StgWord val);
-StgWord64 hs_atomic_or64(volatile StgWord64 *x, StgWord64 val);
-StgWord hs_atomic_xor8(volatile StgWord8 *x, StgWord val);
-StgWord hs_atomic_xor16(volatile StgWord16 *x, StgWord val);
-StgWord hs_atomic_xor32(volatile StgWord32 *x, StgWord val);
-StgWord64 hs_atomic_xor64(volatile StgWord64 *x, StgWord64 val);
-StgWord hs_cmpxchg8(volatile StgWord8 *x, StgWord old, StgWord new_);
-StgWord hs_cmpxchg16(volatile StgWord16 *x, StgWord old, StgWord new_);
-StgWord hs_cmpxchg32(volatile StgWord32 *x, StgWord old, StgWord new_);
-StgWord hs_cmpxchg64(volatile StgWord64 *x, StgWord64 old, StgWord64 new_);
-StgWord hs_atomicread8(volatile StgWord8 *x);
-StgWord hs_atomicread16(volatile StgWord16 *x);
-StgWord hs_atomicread32(volatile StgWord32 *x);
-StgWord64 hs_atomicread64(volatile StgWord64 *x);
-void hs_atomicwrite8(volatile StgWord8 *x, StgWord val);
-void hs_atomicwrite16(volatile StgWord16 *x, StgWord val);
-void hs_atomicwrite32(volatile StgWord32 *x, StgWord val);
-void hs_atomicwrite64(volatile StgWord64 *x, StgWord64 val);
+StgWord hs_atomic_add8(StgWord x, StgWord val);
+StgWord hs_atomic_add16(StgWord x, StgWord val);
+StgWord hs_atomic_add32(StgWord x, StgWord val);
+StgWord64 hs_atomic_add64(StgWord x, StgWord64 val);
+StgWord hs_atomic_sub8(StgWord x, StgWord val);
+StgWord hs_atomic_sub16(StgWord x, StgWord val);
+StgWord hs_atomic_sub32(StgWord x, StgWord val);
+StgWord64 hs_atomic_sub64(StgWord x, StgWord64 val);
+StgWord hs_atomic_and8(StgWord x, StgWord val);
+StgWord hs_atomic_and16(StgWord x, StgWord val);
+StgWord hs_atomic_and32(StgWord x, StgWord val);
+StgWord64 hs_atomic_and64(StgWord x, StgWord64 val);
+StgWord hs_atomic_nand8(StgWord x, StgWord val);
+StgWord hs_atomic_nand16(StgWord x, StgWord val);
+StgWord hs_atomic_nand32(StgWord x, StgWord val);
+StgWord64 hs_atomic_nand64(StgWord x, StgWord64 val);
+StgWord hs_atomic_or8(StgWord x, StgWord val);
+StgWord hs_atomic_or16(StgWord x, StgWord val);
+StgWord hs_atomic_or32(StgWord x, StgWord val);
+StgWord64 hs_atomic_or64(StgWord x, StgWord64 val);
+StgWord hs_atomic_xor8(StgWord x, StgWord val);
+StgWord hs_atomic_xor16(StgWord x, StgWord val);
+StgWord hs_atomic_xor32(StgWord x, StgWord val);
+StgWord64 hs_atomic_xor64(StgWord x, StgWord64 val);
+StgWord hs_cmpxchg8(StgWord x, StgWord old, StgWord new_);
+StgWord hs_cmpxchg16(StgWord x, StgWord old, StgWord new_);
+StgWord hs_cmpxchg32(StgWord x, StgWord old, StgWord new_);
+StgWord hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new_);
+StgWord hs_atomicread8(StgWord x);
+StgWord hs_atomicread16(StgWord x);
+StgWord hs_atomicread32(StgWord x);
+StgWord64 hs_atomicread64(StgWord x);
+void hs_atomicwrite8(StgWord x, StgWord val);
+void hs_atomicwrite16(StgWord x, StgWord val);
+void hs_atomicwrite32(StgWord x, StgWord val);
+void hs_atomicwrite64(StgWord x, StgWord64 val);
 
 /* libraries/ghc-prim/cbits/bswap.c */
 StgWord16 hs_bswap16(StgWord16 x);
diff --git a/libraries/ghc-prim/cbits/atomic.c b/libraries/ghc-prim/cbits/atomic.c
index 01cc458..2ecbf34 100644
--- a/libraries/ghc-prim/cbits/atomic.c
+++ b/libraries/ghc-prim/cbits/atomic.c
@@ -11,97 +11,97 @@
 
 // FetchAddByteArrayOp_Int
 
-extern StgWord hs_atomic_add8(volatile StgWord8 *x, StgWord val);
+extern StgWord hs_atomic_add8(StgWord x, StgWord val);
 StgWord
-hs_atomic_add8(volatile StgWord8 *x, StgWord val)
+hs_atomic_add8(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_add(x, (StgWord8) val);
+  return __sync_fetch_and_add((volatile StgWord8 *) x, (StgWord8) val);
 }
 
-extern StgWord hs_atomic_add16(volatile StgWord16 *x, StgWord val);
+extern StgWord hs_atomic_add16(StgWord x, StgWord val);
 StgWord
-hs_atomic_add16(volatile StgWord16 *x, StgWord val)
+hs_atomic_add16(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_add(x, (StgWord16) val);
+  return __sync_fetch_and_add((volatile StgWord16 *) x, (StgWord16) val);
 }
 
-extern StgWord hs_atomic_add32(volatile StgWord32 *x, StgWord val);
+extern StgWord hs_atomic_add32(StgWord x, StgWord val);
 StgWord
-hs_atomic_add32(volatile StgWord32 *x, StgWord val)
+hs_atomic_add32(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_add(x, (StgWord32) val);
+  return __sync_fetch_and_add((volatile StgWord32 *) x, (StgWord32) val);
 }
 
 #if WORD_SIZE_IN_BITS == 64
-extern StgWord64 hs_atomic_add64(volatile StgWord64 *x, StgWord64 val);
+extern StgWord64 hs_atomic_add64(StgWord x, StgWord64 val);
 StgWord64
-hs_atomic_add64(volatile StgWord64 *x, StgWord64 val)
+hs_atomic_add64(StgWord x, StgWord64 val)
 {
-  return __sync_fetch_and_add(x, val);
+  return __sync_fetch_and_add((volatile StgWord64 *) x, val);
 }
 #endif
 
 // FetchSubByteArrayOp_Int
 
-extern StgWord hs_atomic_sub8(volatile StgWord8 *x, StgWord val);
+extern StgWord hs_atomic_sub8(StgWord x, StgWord val);
 StgWord
-hs_atomic_sub8(volatile StgWord8 *x, StgWord val)
+hs_atomic_sub8(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_sub(x, (StgWord8) val);
+  return __sync_fetch_and_sub((volatile StgWord8 *) x, (StgWord8) val);
 }
 
-extern StgWord hs_atomic_sub16(volatile StgWord16 *x, StgWord val);
+extern StgWord hs_atomic_sub16(StgWord x, StgWord val);
 StgWord
-hs_atomic_sub16(volatile StgWord16 *x, StgWord val)
+hs_atomic_sub16(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_sub(x, (StgWord16) val);
+  return __sync_fetch_and_sub((volatile StgWord16 *) x, (StgWord16) val);
 }
 
-extern StgWord hs_atomic_sub32(volatile StgWord32 *x, StgWord val);
+extern StgWord hs_atomic_sub32(StgWord x, StgWord val);
 StgWord
-hs_atomic_sub32(volatile StgWord32 *x, StgWord val)
+hs_atomic_sub32(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_sub(x, (StgWord32) val);
+  return __sync_fetch_and_sub((volatile StgWord32 *) x, (StgWord32) val);
 }
 
 #if WORD_SIZE_IN_BITS == 64
-extern StgWord64 hs_atomic_sub64(volatile StgWord64 *x, StgWord64 val);
+extern StgWord64 hs_atomic_sub64(StgWord x, StgWord64 val);
 StgWord64
-hs_atomic_sub64(volatile StgWord64 *x, StgWord64 val)
+hs_atomic_sub64(StgWord x, StgWord64 val)
 {
-  return __sync_fetch_and_sub(x, val);
+  return __sync_fetch_and_sub((volatile StgWord64 *) x, val);
 }
 #endif
 
 // FetchAndByteArrayOp_Int
 
-extern StgWord hs_atomic_and8(volatile StgWord8 *x, StgWord val);
+extern StgWord hs_atomic_and8(StgWord x, StgWord val);
 StgWord
-hs_atomic_and8(volatile StgWord8 *x, StgWord val)
+hs_atomic_and8(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_and(x, (StgWord8) val);
+  return __sync_fetch_and_and((volatile StgWord8 *) x, (StgWord8) val);
 }
 
-extern StgWord hs_atomic_and16(volatile StgWord16 *x, StgWord val);
+extern StgWord hs_atomic_and16(StgWord x, StgWord val);
 StgWord
-hs_atomic_and16(volatile StgWord16 *x, StgWord val)
+hs_atomic_and16(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_and(x, (StgWord16) val);
+  return __sync_fetch_and_and((volatile StgWord16 *) x, (StgWord16) val);
 }
 
-extern StgWord hs_atomic_and32(volatile StgWord32 *x, StgWord val);
+extern StgWord hs_atomic_and32(StgWord x, StgWord val);
 StgWord
-hs_atomic_and32(volatile StgWord32 *x, StgWord val)
+hs_atomic_and32(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_and(x, (StgWord32) val);
+  return __sync_fetch_and_and((volatile StgWord32 *) x, (StgWord32) val);
 }
 
 #if WORD_SIZE_IN_BITS == 64
-extern StgWord64 hs_atomic_and64(volatile StgWord64 *x, StgWord64 val);
+extern StgWord64 hs_atomic_and64(StgWord x, StgWord64 val);
 StgWord64
-hs_atomic_and64(volatile StgWord64 *x, StgWord64 val)
+hs_atomic_and64(StgWord x, StgWord64 val)
 {
-  return __sync_fetch_and_and(x, val);
+  return __sync_fetch_and_and((volatile StgWord64 *) x, val);
 }
 #endif
 
@@ -117,204 +117,204 @@ hs_atomic_and64(volatile StgWord64 *x, StgWord64 val)
     return tmp;                                                     \
   }
 
-extern StgWord hs_atomic_nand8(volatile StgWord8 *x, StgWord val);
+extern StgWord hs_atomic_nand8(StgWord x, StgWord val);
 StgWord
-hs_atomic_nand8(volatile StgWord8 *x, StgWord val)
+hs_atomic_nand8(StgWord x, StgWord val)
 {
 #ifdef __clang__
-  CAS_NAND(x, (StgWord8) val)
+  CAS_NAND((volatile StgWord8 *) x, (StgWord8) val)
 #else
-  return __sync_fetch_and_nand(x, (StgWord8) val);
+  return __sync_fetch_and_nand((volatile StgWord8 *) x, (StgWord8) val);
 #endif
 }
 
-extern StgWord hs_atomic_nand16(volatile StgWord16 *x, StgWord val);
+extern StgWord hs_atomic_nand16(StgWord x, StgWord val);
 StgWord
-hs_atomic_nand16(volatile StgWord16 *x, StgWord val)
+hs_atomic_nand16(StgWord x, StgWord val)
 {
 #ifdef __clang__
-  CAS_NAND(x, (StgWord16) val);
+  CAS_NAND((volatile StgWord16 *) x, (StgWord16) val);
 #else
-  return __sync_fetch_and_nand(x, (StgWord16) val);
+  return __sync_fetch_and_nand((volatile StgWord16 *) x, (StgWord16) val);
 #endif
 }
 
-extern StgWord hs_atomic_nand32(volatile StgWord32 *x, StgWord val);
+extern StgWord hs_atomic_nand32(StgWord x, StgWord val);
 StgWord
-hs_atomic_nand32(volatile StgWord32 *x, StgWord val)
+hs_atomic_nand32(StgWord x, StgWord val)
 {
 #ifdef __clang__
-  CAS_NAND(x, (StgWord32) val);
+  CAS_NAND((volatile StgWord32 *) x, (StgWord32) val);
 #else
-  return __sync_fetch_and_nand(x, (StgWord32) val);
+  return __sync_fetch_and_nand((volatile StgWord32 *) x, (StgWord32) val);
 #endif
 }
 
 #if WORD_SIZE_IN_BITS == 64
-extern StgWord64 hs_atomic_nand64(volatile StgWord64 *x, StgWord64 val);
+extern StgWord64 hs_atomic_nand64(StgWord x, StgWord64 val);
 StgWord64
-hs_atomic_nand64(volatile StgWord64 *x, StgWord64 val)
+hs_atomic_nand64(StgWord x, StgWord64 val)
 {
 #ifdef __clang__
-  CAS_NAND(x, val);
+  CAS_NAND((volatile StgWord64 *) x, val);
 #else
-  return __sync_fetch_and_nand(x, val);
+  return __sync_fetch_and_nand((volatile StgWord64 *) x, val);
 #endif
 }
 #endif
 
 // FetchOrByteArrayOp_Int
 
-extern StgWord hs_atomic_or8(volatile StgWord8 *x, StgWord val);
+extern StgWord hs_atomic_or8(StgWord x, StgWord val);
 StgWord
-hs_atomic_or8(volatile StgWord8 *x, StgWord val)
+hs_atomic_or8(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_or(x, (StgWord8) val);
+  return __sync_fetch_and_or((volatile StgWord8 *) x, (StgWord8) val);
 }
 
-extern StgWord hs_atomic_or16(volatile StgWord16 *x, StgWord val);
+extern StgWord hs_atomic_or16(StgWord x, StgWord val);
 StgWord
-hs_atomic_or16(volatile StgWord16 *x, StgWord val)
+hs_atomic_or16(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_or(x, (StgWord16) val);
+  return __sync_fetch_and_or((volatile StgWord16 *) x, (StgWord16) val);
 }
 
-extern StgWord hs_atomic_or32(volatile StgWord32 *x, StgWord val);
+extern StgWord hs_atomic_or32(StgWord x, StgWord val);
 StgWord
-hs_atomic_or32(volatile StgWord32 *x, StgWord val)
+hs_atomic_or32(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_or(x, (StgWord32) val);
+  return __sync_fetch_and_or((volatile StgWord32 *) x, (StgWord32) val);
 }
 
 #if WORD_SIZE_IN_BITS == 64
-extern StgWord64 hs_atomic_or64(volatile StgWord64 *x, StgWord64 val);
+extern StgWord64 hs_atomic_or64(StgWord x, StgWord64 val);
 StgWord64
-hs_atomic_or64(volatile StgWord64 *x, StgWord64 val)
+hs_atomic_or64(StgWord x, StgWord64 val)
 {
-  return __sync_fetch_and_or(x, val);
+  return __sync_fetch_and_or((volatile StgWord64 *) x, val);
 }
 #endif
 
 // FetchXorByteArrayOp_Int
 
-extern StgWord hs_atomic_xor8(volatile StgWord8 *x, StgWord val);
+extern StgWord hs_atomic_xor8(StgWord x, StgWord val);
 StgWord
-hs_atomic_xor8(volatile StgWord8 *x, StgWord val)
+hs_atomic_xor8(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_xor(x, (StgWord8) val);
+  return __sync_fetch_and_xor((volatile StgWord8 *) x, (StgWord8) val);
 }
 
-extern StgWord hs_atomic_xor16(volatile StgWord16 *x, StgWord val);
+extern StgWord hs_atomic_xor16(StgWord x, StgWord val);
 StgWord
-hs_atomic_xor16(volatile StgWord16 *x, StgWord val)
+hs_atomic_xor16(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_xor(x, (StgWord16) val);
+  return __sync_fetch_and_xor((volatile StgWord16 *) x, (StgWord16) val);
 }
 
-extern StgWord hs_atomic_xor32(volatile StgWord32 *x, StgWord val);
+extern StgWord hs_atomic_xor32(StgWord x, StgWord val);
 StgWord
-hs_atomic_xor32(volatile StgWord32 *x, StgWord val)
+hs_atomic_xor32(StgWord x, StgWord val)
 {
-  return __sync_fetch_and_xor(x, (StgWord32) val);
+  return __sync_fetch_and_xor((volatile StgWord32 *) x, (StgWord32) val);
 }
 
 #if WORD_SIZE_IN_BITS == 64
-extern StgWord64 hs_atomic_xor64(volatile StgWord64 *x, StgWord64 val);
+extern StgWord64 hs_atomic_xor64(StgWord x, StgWord64 val);
 StgWord64
-hs_atomic_xor64(volatile StgWord64 *x, StgWord64 val)
+hs_atomic_xor64(StgWord x, StgWord64 val)
 {
-  return __sync_fetch_and_xor(x, val);
+  return __sync_fetch_and_xor((volatile StgWord64 *) x, val);
 }
 #endif
 
 // CasByteArrayOp_Int
 
-extern StgWord hs_cmpxchg8(volatile StgWord8 *x, StgWord old, StgWord new);
+extern StgWord hs_cmpxchg8(StgWord x, StgWord old, StgWord new);
 StgWord
-hs_cmpxchg8(volatile StgWord8 *x, StgWord old, StgWord new)
+hs_cmpxchg8(StgWord x, StgWord old, StgWord new)
 {
-  return __sync_val_compare_and_swap(x, (StgWord8) old, (StgWord8) new);
+  return __sync_val_compare_and_swap((volatile StgWord8 *) x, (StgWord8) old, (StgWord8) new);
 }
 
-extern StgWord hs_cmpxchg16(volatile StgWord16 *x, StgWord old, StgWord new);
+extern StgWord hs_cmpxchg16(StgWord x, StgWord old, StgWord new);
 StgWord
-hs_cmpxchg16(volatile StgWord16 *x, StgWord old, StgWord new)
+hs_cmpxchg16(StgWord x, StgWord old, StgWord new)
 {
-  return __sync_val_compare_and_swap(x, (StgWord16) old, (StgWord16) new);
+  return __sync_val_compare_and_swap((volatile StgWord16 *) x, (StgWord16) old, (StgWord16) new);
 }
 
-extern StgWord hs_cmpxchg32(volatile StgWord32 *x, StgWord old, StgWord new);
+extern StgWord hs_cmpxchg32(StgWord x, StgWord old, StgWord new);
 StgWord
-hs_cmpxchg32(volatile StgWord32 *x, StgWord old, StgWord new)
+hs_cmpxchg32(StgWord x, StgWord old, StgWord new)
 {
-  return __sync_val_compare_and_swap(x, (StgWord32) old, (StgWord32) new);
+  return __sync_val_compare_and_swap((volatile StgWord32 *) x, (StgWord32) old, (StgWord32) new);
 }
 
 #if WORD_SIZE_IN_BITS == 64
-extern StgWord hs_cmpxchg64(volatile StgWord64 *x, StgWord64 old, StgWord64 new);
+extern StgWord hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new);
 StgWord
-hs_cmpxchg64(volatile StgWord64 *x, StgWord64 old, StgWord64 new)
+hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new)
 {
-  return __sync_val_compare_and_swap(x, old, new);
+  return __sync_val_compare_and_swap((volatile StgWord64 *) x, old, new);
 }
 #endif
 
 // AtomicReadByteArrayOp_Int
 
-extern StgWord hs_atomicread8(volatile StgWord8 *x);
+extern StgWord hs_atomicread8(StgWord x);
 StgWord
-hs_atomicread8(volatile StgWord8 *x)
+hs_atomicread8(StgWord x)
 {
-  return *x;
+  return *(volatile StgWord8 *) x;
 }
 
-extern StgWord hs_atomicread16(volatile StgWord16 *x);
+extern StgWord hs_atomicread16(StgWord x);
 StgWord
-hs_atomicread16(volatile StgWord16 *x)
+hs_atomicread16(StgWord x)
 {
-  return *x;
+  return *(volatile StgWord16 *) x;
 }
 
-extern StgWord hs_atomicread32(volatile StgWord32 *x);
+extern StgWord hs_atomicread32(StgWord x);
 StgWord
-hs_atomicread32(volatile StgWord32 *x)
+hs_atomicread32(StgWord x)
 {
-  return *x;
+  return *(volatile StgWord32 *) x;
 }
 
-extern StgWord64 hs_atomicread64(volatile StgWord64 *x);
+extern StgWord64 hs_atomicread64(StgWord x);
 StgWord64
-hs_atomicread64(volatile StgWord64 *x)
+hs_atomicread64(StgWord x)
 {
-  return *x;
+  return *(volatile StgWord64 *) x;
 }
 
 // AtomicWriteByteArrayOp_Int
 
-extern void hs_atomicwrite8(volatile StgWord8 *x, StgWord val);
+extern void hs_atomicwrite8(StgWord x, StgWord val);
 void
-hs_atomicwrite8(volatile StgWord8 *x, StgWord val)
+hs_atomicwrite8(StgWord x, StgWord val)
 {
-  *x = (StgWord8) val;
+  *(volatile StgWord8 *) x = (StgWord8) val;
 }
 
-extern void hs_atomicwrite16(volatile StgWord16 *x, StgWord val);
+extern void hs_atomicwrite16(StgWord x, StgWord val);
 void
-hs_atomicwrite16(volatile StgWord16 *x, StgWord val)
+hs_atomicwrite16(StgWord x, StgWord val)
 {
-  *x = (StgWord16) val;
+  *(volatile StgWord16 *) x = (StgWord16) val;
 }
 
-extern void hs_atomicwrite32(volatile StgWord32 *x, StgWord val);
+extern void hs_atomicwrite32(StgWord x, StgWord val);
 void
-hs_atomicwrite32(volatile StgWord32 *x, StgWord val)
+hs_atomicwrite32(StgWord x, StgWord val)
 {
-  *x = (StgWord32) val;
+  *(volatile StgWord32 *) x = (StgWord32) val;
 }
 
-extern void hs_atomicwrite64(volatile StgWord64 *x, StgWord64 val);
+extern void hs_atomicwrite64(StgWord x, StgWord64 val);
 void
-hs_atomicwrite64(volatile StgWord64 *x, StgWord64 val)
+hs_atomicwrite64(StgWord x, StgWord64 val)
 {
-  *x = (StgWord64) val;
+  *(volatile StgWord64 *) x = (StgWord64) val;
 }
-- 
2.6.0

comment:2 Changed 2 years ago by bgamari

Cc: bgamari added
Differential Rev(s): Phab:D1300
Status: newpatch

Andreas, I've posted this patch for review on Phabricator, Phab:D1300. Let's continue the process there.

comment:3 Changed 2 years ago by Ben Gamari <ben@…>

In e3d2bab8/ghc:

Fix signature of atomic builtins

This patch is due to Andreas Schwab.

This fixes #10926, which reports (on AArch64) errors of the form,

```
/tmp/ghc1492_0/ghc_1.hc:2844:25: warning: passing argument 1 of
'hs_atomic_xor64' makes pointer from integer without a cast
[-Wint-conversion]
     _c1Ho = hs_atomic_xor64((*Sp) + (((Sp[1]) << 0x3UL) + 0x10UL), Sp[2]);
                             ^

In file included from
/home/abuild/rpmbuild/BUILD/ghc-7.10.2/includes/Stg.h:273:0: 0,
                 from /tmp/ghc1492_0/ghc_1.hc:3:

/home/abuild/rpmbuild/BUILD/ghc-7.10.2/includes/stg/Prim.h:41:11:
     note: expected 'volatile StgWord64 *
           {aka volatile long unsigned int *}'
           but argument is of type 'long unsigned int'
     StgWord64 hs_atomic_xor64(volatile StgWord64 *x, StgWord64 val);
               ^
```

Test Plan: Validate

Reviewers: austin, simonmar

Reviewed By: simonmar

Subscribers: thomie

Differential Revision: https://phabricator.haskell.org/D1300

GHC Trac Issues: #10926

comment:4 Changed 2 years ago by bgamari

Resolution: fixed
Status: patchclosed

Merged. Thanks Andreas!

comment:5 Changed 23 months ago by thomie

Milestone: 8.0.1
Note: See TracTickets for help on using tickets.