Rodrigo Mesquita pushed to branch wip/romes/26166-move-prims at Glasgow Haskell Compiler / GHC

Commits:

18 changed files:

Changes:

  • hadrian/src/Settings/Packages.hs
    ... ... @@ -287,9 +287,6 @@ ghcInternalArgs = package ghcInternal ? do
    287 287
    288 288 
               , builder (Cabal Flags) ? flag NeedLibatomic `cabalFlag` "need-atomic"
    289 289
    290 
    -          , builder (Cc CompileC) ? (not <$> flag CcLlvmBackend) ?
    291 
    -              input "**/cbits/atomic.c"  ? arg "-Wno-sync-nand"
    292 
    -
    293 290 
               ]
    294 291
    295 292 
     -- | RTS-specific command line arguments.
    ... ... @@ -413,6 +410,9 @@ rtsPackageArgs = package rts ? do
    413 410
    414 411 
               , input "**/RetainerProfile.c" ? flag CcLlvmBackend ?
    415 412 
                 arg "-Wno-incompatible-pointer-types"
    413 
    +
    414 
    +          , input "**/prim/atomic.c"  ? (not <$> flag CcLlvmBackend) ?
    415 
    +            arg "-Wno-sync-nand"
    416 416 
               ]
    417 417
    418 418 
         mconcat

  • libraries/ghc-internal/ghc-internal.cabal.in
    ... ... @@ -442,20 +442,7 @@ Library
    442 442 
               cbits/sysconf.c
    443 443 
               cbits/fs.c
    444 444 
               cbits/strerror.c
    445 
    -          cbits/atomic.c
    446 
    -          cbits/bswap.c
    447 
    -          cbits/bitrev.c
    448 
    -          cbits/clz.c
    449 
    -          cbits/ctz.c
    450 445 
               cbits/debug.c
    451 
    -          cbits/int64x2minmax.c
    452 
    -          cbits/longlong.c
    453 
    -          cbits/mulIntMayOflo.c
    454 
    -          cbits/pdep.c
    455 
    -          cbits/pext.c
    456 
    -          cbits/popcnt.c
    457 
    -          cbits/vectorQuotRem.c
    458 
    -          cbits/word2float.c
    459 446 
               cbits/Stack_c.c
    460 447
    461 448 
           cmm-sources:

  • rts/RtsSymbols.c
    ... ... @@ -1016,6 +1016,116 @@ extern char **environ;
    1016 1016 
     #define RTS_FINI_ARRAY_SYMBOLS
    1017 1017 
     #endif
    1018 1018
    1019 
    +#define SymI_NeedsProtoAllSizes(symbol)                \
    1020 
    +      SymI_NeedsProto(##symbol##8)                     \
    1021 
    +      SymI_NeedsProto(##symbol##16)                    \
    1022 
    +      SymI_NeedsProto(##symbol##32)                    \
    1023 
    +      SymI_NeedsProto(##symbol##64)
    1024 
    +
    1025 
    +#if !defined(arm_HOST_ARCH)
    1026 
    +#define RTS_ATOMICS_SYMBOLS                            \
    1027 
    +      SymI_NeedsProtoAllSizes(hs_atomic_add)           \
    1028 
    +      SymI_NeedsProtoAllSizes(hs_atomic_sub)           \
    1029 
    +      SymI_NeedsProtoAllSizes(hs_atomic_and)           \
    1030 
    +      SymI_NeedsProtoAllSizes(hs_atomic_nand)          \
    1031 
    +      SymI_NeedsProtoAllSizes(hs_atomic_or)            \
    1032 
    +      SymI_NeedsProtoAllSizes(hs_atomic_xor)           \
    1033 
    +      SymI_NeedsProtoAllSizes(hs_cmpxchg)              \
    1034 
    +      SymI_NeedsProtoAllSizes(hs_xchg)                 \
    1035 
    +      SymI_NeedsProtoAllSizes(hs_atomicread)           \
    1036 
    +      SymI_NeedsProtoAllSizes(hs_atomicwrite)
    1037 
    +#else
    1038 
    +// No atomics on arm32. See e9abcad4cc3
    1039 
    +#define RTS_ATOMICS_SYMBOLS
    1040 
    +#endif
    1041 
    +
    1042 
    +// In rts/longlong.c
    1043 
    +#if WORD_SIZE_IN_BITS < 64
    1044 
    +#define RTS_SYMBOLS_LONGLONG                          \
    1045 
    +      SymI_NeedsProto(hs_eq64)                        \
    1046 
    +      SymI_NeedsProto(hs_ne64)                        \
    1047 
    +      SymI_NeedsProto(hs_gtWord64)                    \
    1048 
    +      SymI_NeedsProto(hs_geWord64)                    \
    1049 
    +      SymI_NeedsProto(hs_ltWord64)                    \
    1050 
    +      SymI_NeedsProto(hs_leWord64)                    \
    1051 
    +      SymI_NeedsProto(hs_gtInt64)                     \
    1052 
    +      SymI_NeedsProto(hs_geInt64)                     \
    1053 
    +      SymI_NeedsProto(hs_ltInt64)                     \
    1054 
    +      SymI_NeedsProto(hs_leInt64)                     \
    1055 
    +      SymI_NeedsProto(hs_neg64)                       \
    1056 
    +      SymI_NeedsProto(hs_add64)                       \
    1057 
    +      SymI_NeedsProto(hs_sub64)                       \
    1058 
    +      SymI_NeedsProto(hs_mul64)                       \
    1059 
    +      SymI_NeedsProto(hs_remWord64)                   \
    1060 
    +      SymI_NeedsProto(hs_quotWord64)                  \
    1061 
    +      SymI_NeedsProto(hs_remInt64)                    \
    1062 
    +      SymI_NeedsProto(hs_quotInt64)                   \
    1063 
    +      SymI_NeedsProto(hs_and64)                       \
    1064 
    +      SymI_NeedsProto(hs_or64)                        \
    1065 
    +      SymI_NeedsProto(hs_xor64)                       \
    1066 
    +      SymI_NeedsProto(hs_not64)                       \
    1067 
    +      SymI_NeedsProto(hs_uncheckedShiftL64)           \
    1068 
    +      SymI_NeedsProto(hs_uncheckedShiftRL64)          \
    1069 
    +      SymI_NeedsProto(hs_uncheckedIShiftRA64)         \
    1070 
    +      SymI_NeedsProto(hs_intToInt64)                  \
    1071 
    +      SymI_NeedsProto(hs_int64ToInt)                  \
    1072 
    +      SymI_NeedsProto(hs_wordToWord64)                \
    1073 
    +      SymI_NeedsProto(hs_word64ToWord)
    1074 
    +#else
    1075 
    +#define RTS_SYMBOLS_LONGLONG
    1076 
    +#endif
    1077 
    +
    1078 
    +// rts/prim/vectorQuotRem.c and rts/prim/int64x2minmax
    1079 
    +#if defined(__SSE2__)                                  \
    1080 
    +#define RTS_SYMBOLS_VECTORQUOTREM                      \
    1081 
    +      SymI_NeedsProto(hs_quotInt8X16)                  \
    1082 
    +      SymI_NeedsProto(hs_quotInt16X8)                  \
    1083 
    +      SymI_NeedsProto(hs_quotInt32X4)                  \
    1084 
    +      SymI_NeedsProto(hs_quotInt64X2)                  \
    1085 
    +      SymI_NeedsProto(hs_quotWord8X16)                 \
    1086 
    +      SymI_NeedsProto(hs_quotWord16X8)                 \
    1087 
    +      SymI_NeedsProto(hs_quotWord32X4)                 \
    1088 
    +      SymI_NeedsProto(hs_quotWord64X2)                 \
    1089 
    +      SymI_NeedsProto(hs_remInt8X16)                   \
    1090 
    +      SymI_NeedsProto(hs_remInt16X8)                   \
    1091 
    +      SymI_NeedsProto(hs_remInt32X4)                   \
    1092 
    +      SymI_NeedsProto(hs_remInt64X2)                   \
    1093 
    +      SymI_NeedsProto(hs_remWord8X16)                  \
    1094 
    +      SymI_NeedsProto(hs_remWord16X8)                  \
    1095 
    +      SymI_NeedsProto(hs_remWord32X4)                  \
    1096 
    +      SymI_NeedsProto(hs_remWord64X2)
    1097 
    +#define RTS_SYMBOLS_INT64X2MINMAX                      \
    1098 
    +      SymI_NeedsProto(hs_minInt64X2)                   \
    1099 
    +      SymI_NeedsProto(hs_maxInt64X2)                   \
    1100 
    +      SymI_NeedsProto(hs_minWord64X2)                  \
    1101 
    +      SymI_NeedsProto(hs_maxWord64X2)
    1102 
    +#else
    1103 
    +#define RTS_SYMBOLS_VECTORQUOTREM
    1104 
    +#define RTS_SYMBOLS_INT64X2MINMAX
    1105 
    +#endif
    1106 
    +
    1107 
    +// Symbols on files in rts/prim/*
    1108 
    +#define RTS_SYMBOLS_PRIM                               \
    1109 
    +      RTS_ATOMICS_SYMBOLS                              \
    1110 
    +      RTS_SYMBOLS_INT64X2MINMAX                        \
    1111 
    +      RTS_SYMBOLS_LONGLONG                             \
    1112 
    +      RTS_SYMBOLS_VECTORQUOTREM                        \
    1113 
    +      SymI_NeedsProtoAllSizes(hs_bitrev)               \
    1114 
    +      SymI_NeedsProto(hs_bswap16)                      \
    1115 
    +      SymI_NeedsProto(hs_bswap32)                      \
    1116 
    +      SymI_NeedsProto(hs_bswap64)                      \
    1117 
    +      SymI_NeedsProtoAllSizes(hs_clz)                  \
    1118 
    +      SymI_NeedsProtoAllSizes(hs_ctz)                  \
    1119 
    +      SymI_NeedsProto(hs_mulIntMayOflo)                \
    1120 
    +      SymI_NeedsProtoAllSizes(hs_pdep)                 \
    1121 
    +      SymI_NeedsProtoAllSizes(hs_pext)                 \
    1122 
    +      SymI_NeedsProtoAllSizes(hs_pext)                 \
    1123 
    +      SymI_NeedsProto(hs_popcnt)                       \
    1124 
    +      SymI_NeedsProtoAllSizes(hs_popcnt)               \
    1125 
    +      SymI_NeedsProto(hs_word2float32)                 \
    1126 
    +      SymI_NeedsProto(hs_word2float64)
    1127 
    +
    1128 
    +
    1019 1129 
     /* entirely bogus claims about types of these symbols */
    1020 1130 
     #define SymI_NeedsProto(vvv)  extern void vvv(void);
    1021 1131 
     #define SymI_NeedsDataProto(vvv)  extern StgWord vvv[];
    ... ... @@ -1038,6 +1148,7 @@ RTS_ARCH_LIBGCC_SYMBOLS
    1038 1148 
     RTS_FINI_ARRAY_SYMBOLS
    1039 1149 
     RTS_LIBFFI_SYMBOLS
    1040 1150 
     RTS_ARM_OUTLINE_ATOMIC_SYMBOLS
    1151 
    +RTS_SYMBOLS_PRIM
    1041 1152
    1042 1153 
     #undef SymI_NeedsProto
    1043 1154 
     #undef SymI_NeedsDataProto
    ... ... @@ -1081,6 +1192,7 @@ RtsSymbolVal rtsSyms[] = {
    1081 1192 
           RTS_FINI_ARRAY_SYMBOLS
    1082 1193 
           RTS_LIBFFI_SYMBOLS
    1083 1194 
           RTS_ARM_OUTLINE_ATOMIC_SYMBOLS
    1195 
    +      RTS_SYMBOLS_PRIM
    1084 1196 
           SymI_HasDataProto(nonmoving_write_barrier_enabled)
    1085 1197 
           { 0, 0, STRENGTH_NORMAL, SYM_TYPE_CODE } /* sentinel */
    1086 1198 
     };

  • rts/include/stg/Prim.h
    ... ... @@ -13,7 +13,7 @@
    13 13
    14 14 
     #pragma once
    15 15
    16 
    -/* libraries/ghc-internal/cbits/atomic.c */
    16 
    +/* rts/prim/atomic.c */
    17 17 
     StgWord hs_atomic_add8(StgWord x, StgWord val);
    18 18 
     StgWord hs_atomic_add16(StgWord x, StgWord val);
    19 19 
     StgWord hs_atomic_add32(StgWord x, StgWord val);

  • libraries/ghc-internal/cbits/atomic.c → rts/prim/atomic.c
    ... ... @@ -12,90 +12,66 @@
    12 12
    13 13 
     // FetchAddByteArrayOp_Int
    14 14
    15 
    -extern StgWord hs_atomic_add8(StgWord x, StgWord val);
    16 
    -StgWord
    17 
    -hs_atomic_add8(StgWord x, StgWord val)
    15 
    +StgWord hs_atomic_add8(StgWord x, StgWord val)
    18 16 
     {
    19 17 
       return __sync_fetch_and_add((volatile StgWord8 *) x, (StgWord8) val);
    20 18 
     }
    21 19
    22 
    -extern StgWord hs_atomic_add16(StgWord x, StgWord val);
    23 
    -StgWord
    24 
    -hs_atomic_add16(StgWord x, StgWord val)
    20 
    +StgWord hs_atomic_add16(StgWord x, StgWord val)
    25 21 
     {
    26 22 
       return __sync_fetch_and_add((volatile StgWord16 *) x, (StgWord16) val);
    27 23 
     }
    28 24
    29 
    -extern StgWord hs_atomic_add32(StgWord x, StgWord val);
    30 
    -StgWord
    31 
    -hs_atomic_add32(StgWord x, StgWord val)
    25 
    +StgWord hs_atomic_add32(StgWord x, StgWord val)
    32 26 
     {
    33 27 
       return __sync_fetch_and_add((volatile StgWord32 *) x, (StgWord32) val);
    34 28 
     }
    35 29
    36 
    -extern StgWord64 hs_atomic_add64(StgWord x, StgWord64 val);
    37 
    -StgWord64
    38 
    -hs_atomic_add64(StgWord x, StgWord64 val)
    30 
    +StgWord64 hs_atomic_add64(StgWord x, StgWord64 val)
    39 31 
     {
    40 32 
       return __sync_fetch_and_add((volatile StgWord64 *) x, val);
    41 33 
     }
    42 34
    43 35 
     // FetchSubByteArrayOp_Int
    44 36
    45 
    -extern StgWord hs_atomic_sub8(StgWord x, StgWord val);
    46 
    -StgWord
    47 
    -hs_atomic_sub8(StgWord x, StgWord val)
    37 
    +StgWord hs_atomic_sub8(StgWord x, StgWord val)
    48 38 
     {
    49 39 
       return __sync_fetch_and_sub((volatile StgWord8 *) x, (StgWord8) val);
    50 40 
     }
    51 41
    52 
    -extern StgWord hs_atomic_sub16(StgWord x, StgWord val);
    53 
    -StgWord
    54 
    -hs_atomic_sub16(StgWord x, StgWord val)
    42 
    +StgWord hs_atomic_sub16(StgWord x, StgWord val)
    55 43 
     {
    56 44 
       return __sync_fetch_and_sub((volatile StgWord16 *) x, (StgWord16) val);
    57 45 
     }
    58 46
    59 
    -extern StgWord hs_atomic_sub32(StgWord x, StgWord val);
    60 
    -StgWord
    61 
    -hs_atomic_sub32(StgWord x, StgWord val)
    47 
    +StgWord hs_atomic_sub32(StgWord x, StgWord val)
    62 48 
     {
    63 49 
       return __sync_fetch_and_sub((volatile StgWord32 *) x, (StgWord32) val);
    64 50 
     }
    65 51
    66 
    -extern StgWord64 hs_atomic_sub64(StgWord x, StgWord64 val);
    67 
    -StgWord64
    68 
    -hs_atomic_sub64(StgWord x, StgWord64 val)
    52 
    +StgWord64 hs_atomic_sub64(StgWord x, StgWord64 val)
    69 53 
     {
    70 54 
       return __sync_fetch_and_sub((volatile StgWord64 *) x, val);
    71 55 
     }
    72 56
    73 57 
     // FetchAndByteArrayOp_Int
    74 58
    75 
    -extern StgWord hs_atomic_and8(StgWord x, StgWord val);
    76 
    -StgWord
    77 
    -hs_atomic_and8(StgWord x, StgWord val)
    59 
    +StgWord hs_atomic_and8(StgWord x, StgWord val)
    78 60 
     {
    79 61 
       return __sync_fetch_and_and((volatile StgWord8 *) x, (StgWord8) val);
    80 62 
     }
    81 63
    82 
    -extern StgWord hs_atomic_and16(StgWord x, StgWord val);
    83 
    -StgWord
    84 
    -hs_atomic_and16(StgWord x, StgWord val)
    64 
    +StgWord hs_atomic_and16(StgWord x, StgWord val)
    85 65 
     {
    86 66 
       return __sync_fetch_and_and((volatile StgWord16 *) x, (StgWord16) val);
    87 67 
     }
    88 68
    89 
    -extern StgWord hs_atomic_and32(StgWord x, StgWord val);
    90 
    -StgWord
    91 
    -hs_atomic_and32(StgWord x, StgWord val)
    69 
    +StgWord hs_atomic_and32(StgWord x, StgWord val)
    92 70 
     {
    93 71 
       return __sync_fetch_and_and((volatile StgWord32 *) x, (StgWord32) val);
    94 72 
     }
    95 73
    96 
    -extern StgWord64 hs_atomic_and64(StgWord x, StgWord64 val);
    97 
    -StgWord64
    98 
    -hs_atomic_and64(StgWord x, StgWord64 val)
    74 
    +StgWord64 hs_atomic_and64(StgWord x, StgWord64 val)
    99 75 
     {
    100 76 
       return __sync_fetch_and_and((volatile StgWord64 *) x, val);
    101 77 
     }
    ... ... @@ -167,9 +143,7 @@ hs_atomic_and64(StgWord x, StgWord64 val)
    167 143 
     #pragma GCC diagnostic ignored "-Wsync-nand"
    168 144 
     #endif
    169 145
    170 
    -extern StgWord hs_atomic_nand8(StgWord x, StgWord val);
    171 
    -StgWord
    172 
    -hs_atomic_nand8(StgWord x, StgWord val)
    146 
    +StgWord hs_atomic_nand8(StgWord x, StgWord val)
    173 147 
     {
    174 148 
     #if USE_SYNC_FETCH_AND_NAND
    175 149 
       return __sync_fetch_and_nand((volatile StgWord8 *) x, (StgWord8) val);
    ... ... @@ -178,9 +152,7 @@ hs_atomic_nand8(StgWord x, StgWord val)
    178 152 
     #endif
    179 153 
     }
    180 154
    181 
    -extern StgWord hs_atomic_nand16(StgWord x, StgWord val);
    182 
    -StgWord
    183 
    -hs_atomic_nand16(StgWord x, StgWord val)
    155 
    +StgWord hs_atomic_nand16(StgWord x, StgWord val)
    184 156 
     {
    185 157 
     #if USE_SYNC_FETCH_AND_NAND
    186 158 
       return __sync_fetch_and_nand((volatile StgWord16 *) x, (StgWord16) val);
    ... ... @@ -189,9 +161,7 @@ hs_atomic_nand16(StgWord x, StgWord val)
    189 161 
     #endif
    190 162 
     }
    191 163
    192 
    -extern StgWord hs_atomic_nand32(StgWord x, StgWord val);
    193 
    -StgWord
    194 
    -hs_atomic_nand32(StgWord x, StgWord val)
    164 
    +StgWord hs_atomic_nand32(StgWord x, StgWord val)
    195 165 
     {
    196 166 
     #if USE_SYNC_FETCH_AND_NAND
    197 167 
       return __sync_fetch_and_nand((volatile StgWord32 *) x, (StgWord32) val);
    ... ... @@ -200,9 +170,7 @@ hs_atomic_nand32(StgWord x, StgWord val)
    200 170 
     #endif
    201 171 
     }
    202 172
    203 
    -extern StgWord64 hs_atomic_nand64(StgWord x, StgWord64 val);
    204 
    -StgWord64
    205 
    -hs_atomic_nand64(StgWord x, StgWord64 val)
    173 
    +StgWord64 hs_atomic_nand64(StgWord x, StgWord64 val)
    206 174 
     {
    207 175 
     #if USE_SYNC_FETCH_AND_NAND
    208 176 
       return __sync_fetch_and_nand((volatile StgWord64 *) x, val);
    ... ... @@ -215,96 +183,72 @@ hs_atomic_nand64(StgWord x, StgWord64 val)
    215 183
    216 184 
     // FetchOrByteArrayOp_Int
    217 185
    218 
    -extern StgWord hs_atomic_or8(StgWord x, StgWord val);
    219 
    -StgWord
    220 
    -hs_atomic_or8(StgWord x, StgWord val)
    186 
    +StgWord hs_atomic_or8(StgWord x, StgWord val)
    221 187 
     {
    222 188 
       return __sync_fetch_and_or((volatile StgWord8 *) x, (StgWord8) val);
    223 189 
     }
    224 190
    225 
    -extern StgWord hs_atomic_or16(StgWord x, StgWord val);
    226 
    -StgWord
    227 
    -hs_atomic_or16(StgWord x, StgWord val)
    191 
    +StgWord hs_atomic_or16(StgWord x, StgWord val)
    228 192 
     {
    229 193 
       return __sync_fetch_and_or((volatile StgWord16 *) x, (StgWord16) val);
    230 194 
     }
    231 195
    232 
    -extern StgWord hs_atomic_or32(StgWord x, StgWord val);
    233 
    -StgWord
    234 
    -hs_atomic_or32(StgWord x, StgWord val)
    196 
    +StgWord hs_atomic_or32(StgWord x, StgWord val)
    235 197 
     {
    236 198 
       return __sync_fetch_and_or((volatile StgWord32 *) x, (StgWord32) val);
    237 199 
     }
    238 200
    239 
    -extern StgWord64 hs_atomic_or64(StgWord x, StgWord64 val);
    240 
    -StgWord64
    241 
    -hs_atomic_or64(StgWord x, StgWord64 val)
    201 
    +StgWord64 hs_atomic_or64(StgWord x, StgWord64 val)
    242 202 
     {
    243 203 
       return __sync_fetch_and_or((volatile StgWord64 *) x, val);
    244 204 
     }
    245 205
    246 206 
     // FetchXorByteArrayOp_Int
    247 207
    248 
    -extern StgWord hs_atomic_xor8(StgWord x, StgWord val);
    249 
    -StgWord
    250 
    -hs_atomic_xor8(StgWord x, StgWord val)
    208 
    +StgWord hs_atomic_xor8(StgWord x, StgWord val)
    251 209 
     {
    252 210 
       return __sync_fetch_and_xor((volatile StgWord8 *) x, (StgWord8) val);
    253 211 
     }
    254 212
    255 
    -extern StgWord hs_atomic_xor16(StgWord x, StgWord val);
    256 
    -StgWord
    257 
    -hs_atomic_xor16(StgWord x, StgWord val)
    213 
    +StgWord hs_atomic_xor16(StgWord x, StgWord val)
    258 214 
     {
    259 215 
       return __sync_fetch_and_xor((volatile StgWord16 *) x, (StgWord16) val);
    260 216 
     }
    261 217
    262 
    -extern StgWord hs_atomic_xor32(StgWord x, StgWord val);
    263 
    -StgWord
    264 
    -hs_atomic_xor32(StgWord x, StgWord val)
    218 
    +StgWord hs_atomic_xor32(StgWord x, StgWord val)
    265 219 
     {
    266 220 
       return __sync_fetch_and_xor((volatile StgWord32 *) x, (StgWord32) val);
    267 221 
     }
    268 222
    269 
    -extern StgWord64 hs_atomic_xor64(StgWord x, StgWord64 val);
    270 
    -StgWord64
    271 
    -hs_atomic_xor64(StgWord x, StgWord64 val)
    223 
    +StgWord64 hs_atomic_xor64(StgWord x, StgWord64 val)
    272 224 
     {
    273 225 
       return __sync_fetch_and_xor((volatile StgWord64 *) x, val);
    274 226 
     }
    275 227
    276 228 
     // CasByteArrayOp_Int
    277 229
    278 
    -extern StgWord hs_cmpxchg8(StgWord x, StgWord old, StgWord new);
    279 
    -StgWord
    280 
    -hs_cmpxchg8(StgWord x, StgWord old, StgWord new)
    230 
    +StgWord hs_cmpxchg8(StgWord x, StgWord old, StgWord new)
    281 231 
     {
    282 232 
       StgWord8 expected = (StgWord8) old;
    283 233 
       __atomic_compare_exchange_n((StgWord8 *) x, &expected, (StgWord8) new, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
    284 234 
       return expected;
    285 235 
     }
    286 236
    287 
    -extern StgWord hs_cmpxchg16(StgWord x, StgWord old, StgWord new);
    288 
    -StgWord
    289 
    -hs_cmpxchg16(StgWord x, StgWord old, StgWord new)
    237 
    +StgWord hs_cmpxchg16(StgWord x, StgWord old, StgWord new)
    290 238 
     {
    291 239 
       StgWord16 expected = (StgWord16) old;
    292 240 
       __atomic_compare_exchange_n((StgWord16 *) x, &expected, (StgWord16) new, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
    293 241 
       return expected;
    294 242 
     }
    295 243
    296 
    -extern StgWord hs_cmpxchg32(StgWord x, StgWord old, StgWord new);
    297 
    -StgWord
    298 
    -hs_cmpxchg32(StgWord x, StgWord old, StgWord new)
    244 
    +StgWord hs_cmpxchg32(StgWord x, StgWord old, StgWord new)
    299 245 
     {
    300 246 
       StgWord32 expected = (StgWord32) old;
    301 247 
       __atomic_compare_exchange_n((StgWord32 *) x, &expected, (StgWord32) new, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
    302 248 
       return expected;
    303 249 
     }
    304 250
    305 
    -extern StgWord64 hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new);
    306 
    -StgWord64
    307 
    -hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new)
    251 
    +StgWord64 hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new)
    308 252 
     {
    309 253 
       StgWord64 expected = (StgWord64) old;
    310 254 
       __atomic_compare_exchange_n((StgWord64 *) x, &expected, (StgWord64) new, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
    ... ... @@ -313,31 +257,23 @@ hs_cmpxchg64(StgWord x, StgWord64 old, StgWord64 new)
    313 257
    314 258 
     // Atomic exchange operations
    315 259
    316 
    -extern StgWord hs_xchg8(StgWord x, StgWord val);
    317 
    -StgWord
    318 
    -hs_xchg8(StgWord x, StgWord val)
    260 
    +StgWord hs_xchg8(StgWord x, StgWord val)
    319 261 
     {
    320 262 
       return (StgWord) __atomic_exchange_n((StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);
    321 263 
     }
    322 264
    323 
    -extern StgWord hs_xchg16(StgWord x, StgWord val);
    324 
    -StgWord
    325 
    -hs_xchg16(StgWord x, StgWord val)
    265 
    +StgWord hs_xchg16(StgWord x, StgWord val)
    326 266 
     {
    327 267 
       return (StgWord) __atomic_exchange_n((StgWord16 *)x, (StgWord16) val, __ATOMIC_SEQ_CST);
    328 268 
     }
    329 269
    330 
    -extern StgWord hs_xchg32(StgWord x, StgWord val);
    331 
    -StgWord
    332 
    -hs_xchg32(StgWord x, StgWord val)
    270 
    +StgWord hs_xchg32(StgWord x, StgWord val)
    333 271 
     {
    334 272 
       return (StgWord) __atomic_exchange_n((StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);
    335 273 
     }
    336 274
    337 275 
     //GCC provides this even on 32bit, but StgWord is still 32 bits.
    338 
    -extern StgWord64 hs_xchg64(StgWord x, StgWord64 val);
    339 
    -StgWord64
    340 
    -hs_xchg64(StgWord x, StgWord64 val)
    276 
    +StgWord64 hs_xchg64(StgWord x, StgWord64 val)
    341 277 
     {
    342 278 
       return (StgWord64) __atomic_exchange_n((StgWord64 *) x, (StgWord64) val, __ATOMIC_SEQ_CST);
    343 279 
     }
    ... ... @@ -352,30 +288,22 @@ hs_xchg64(StgWord x, StgWord64 val)
    352 288 
     // primitives which the GCC documentation claims "usually" implies a full
    353 289 
     // barrier.
    354 290
    355 
    -extern StgWord hs_atomicread8(StgWord x);
    356 
    -StgWord
    357 
    -hs_atomicread8(StgWord x)
    291 
    +StgWord hs_atomicread8(StgWord x)
    358 292 
     {
    359 293 
       return __atomic_load_n((StgWord8 *) x, __ATOMIC_SEQ_CST);
    360 294 
     }
    361 295
    362 
    -extern StgWord hs_atomicread16(StgWord x);
    363 
    -StgWord
    364 
    -hs_atomicread16(StgWord x)
    296 
    +StgWord hs_atomicread16(StgWord x)
    365 297 
     {
    366 298 
       return __atomic_load_n((StgWord16 *) x, __ATOMIC_SEQ_CST);
    367 299 
     }
    368 300
    369 
    -extern StgWord hs_atomicread32(StgWord x);
    370 
    -StgWord
    371 
    -hs_atomicread32(StgWord x)
    301 
    +StgWord hs_atomicread32(StgWord x)
    372 302 
     {
    373 303 
       return __atomic_load_n((StgWord32 *) x, __ATOMIC_SEQ_CST);
    374 304 
     }
    375 305
    376 
    -extern StgWord64 hs_atomicread64(StgWord x);
    377 
    -StgWord64
    378 
    -hs_atomicread64(StgWord x)
    306 
    +StgWord64 hs_atomicread64(StgWord x)
    379 307 
     {
    380 308 
       return __atomic_load_n((StgWord64 *) x, __ATOMIC_SEQ_CST);
    381 309 
     }
    ... ... @@ -384,30 +312,22 @@ hs_atomicread64(StgWord x)
    384 312 
     // Implies a full memory barrier (see compiler/GHC/Builtin/primops.txt.pp)
    385 313 
     // __ATOMIC_SEQ_CST: Full barrier (see hs_atomicread8 above).
    386 314
    387 
    -extern void hs_atomicwrite8(StgWord x, StgWord val);
    388 
    -void
    389 
    -hs_atomicwrite8(StgWord x, StgWord val)
    315 
    +void hs_atomicwrite8(StgWord x, StgWord val)
    390 316 
     {
    391 317 
       __atomic_store_n((StgWord8 *) x, (StgWord8) val, __ATOMIC_SEQ_CST);
    392 318 
     }
    393 319
    394 
    -extern void hs_atomicwrite16(StgWord x, StgWord val);
    395 
    -void
    396 
    -hs_atomicwrite16(StgWord x, StgWord val)
    320 
    +void hs_atomicwrite16(StgWord x, StgWord val)
    397 321 
     {
    398 322 
       __atomic_store_n((StgWord16 *) x, (StgWord16) val, __ATOMIC_SEQ_CST);
    399 323 
     }
    400 324
    401 
    -extern void hs_atomicwrite32(StgWord x, StgWord val);
    402 
    -void
    403 
    -hs_atomicwrite32(StgWord x, StgWord val)
    325 
    +void hs_atomicwrite32(StgWord x, StgWord val)
    404 326 
     {
    405 327 
       __atomic_store_n((StgWord32 *) x, (StgWord32) val, __ATOMIC_SEQ_CST);
    406 328 
     }
    407 329
    408 
    -extern void hs_atomicwrite64(StgWord x, StgWord64 val);
    409 
    -void
    410 
    -hs_atomicwrite64(StgWord x, StgWord64 val)
    330 
    +void hs_atomicwrite64(StgWord x, StgWord64 val)
    411 331 
     {
    412 332 
       __atomic_store_n((StgWord64 *) x, (StgWord64) val, __ATOMIC_SEQ_CST);
    413 333 
     }

  • libraries/ghc-internal/cbits/bitrev.c → rts/prim/bitrev.c

  • libraries/ghc-internal/cbits/bswap.c → rts/prim/bswap.c

  • libraries/ghc-internal/cbits/clz.c → rts/prim/clz.c

  • libraries/ghc-internal/cbits/ctz.c → rts/prim/ctz.c

  • libraries/ghc-internal/cbits/int64x2minmax.c → rts/prim/int64x2minmax.c

  • libraries/ghc-internal/cbits/longlong.c → rts/prim/longlong.c

  • libraries/ghc-internal/cbits/mulIntMayOflo.c → rts/prim/mulIntMayOflo.c

  • libraries/ghc-internal/cbits/pdep.c → rts/prim/pdep.c

  • libraries/ghc-internal/cbits/pext.c → rts/prim/pext.c

  • libraries/ghc-internal/cbits/popcnt.c → rts/prim/popcnt.c

  • libraries/ghc-internal/cbits/vectorQuotRem.c → rts/prim/vectorQuotRem.c

  • libraries/ghc-internal/cbits/word2float.c → rts/prim/word2float.c

  • rts/rts.cabal
    ... ... @@ -529,6 +529,19 @@ library
    529 529 
                      sm/Storage.c
    530 530 
                      sm/Sweep.c
    531 531 
                      fs.c
    532 
    +                 prim/atomic.c
    533 
    +                 prim/bitrev.c
    534 
    +                 prim/bswap.c
    535 
    +                 prim/clz.c
    536 
    +                 prim/ctz.c
    537 
    +                 prim/int64x2minmax.c
    538 
    +                 prim/longlong.c
    539 
    +                 prim/mulIntMayOflo.c
    540 
    +                 prim/pdep.c
    541 
    +                 prim/pext.c
    542 
    +                 prim/popcnt.c
    543 
    +                 prim/vectorQuotRem.c
    544 
    +                 prim/word2float.c
    532 545 
                      -- I wish we had wildcards..., this would be:
    533 546 
                      -- *.c hooks/**/*.c sm/**/*.c eventlog/**/*.c linker/**/*.c
    534 547

    • —
    View it on GitLab.
    You're receiving this email because of your account on gitlab.haskell.org. Manage all notifications · Help