Remove target dependent CPP for Word64/Int64 (#11470)

Primops types were dependent on the target word-size at *compiler*
compilation time. It's an issue for multi-target as GHC may not have the
correct primops types for the target.

This patch fixes some primops types: if they take or return fixed 64-bit
values they now always use `Int64#/Word64#`, even on 64-bit
architectures (where they used `Int#/Word#` before). Users of these
primops may now need to convert from Int64#/Word64# to Int#/Word# (a
no-op at runtime).

This is a stripped down version of !3658 which goes the all way of
changing the underlying primitive types of Word64/Int64. This is left
for future work.

T12545 allocations increase ~4% on some CI platforms and decrease ~3% on
AArch64.

Metric Increase:
    T12545

Metric Decrease:
    T12545

2 files changed, 48 insertions, 92 deletions

diff --git a/compiler/GHC/Builtin/bytearray-ops.txt.pp b/compiler/GHC/Builtin/bytearray-ops.txt.pp
index 6ed9028c6b..01652d7216 100644
--- a/compiler/GHC/Builtin/bytearray-ops.txt.pp
+++ b/compiler/GHC/Builtin/bytearray-ops.txt.pp
@@ -70,7 +70,7 @@ primop IndexByteArrayOp_Int32 "indexInt32Array#" GenPrimOp
    with can_fail = True
 
 primop IndexByteArrayOp_Int64 "indexInt64Array#" GenPrimOp
-   ByteArray# -> Int# -> INT64
+   ByteArray# -> Int# -> Int64#
    {Read a 64-bit signed integer; offset in 8-byte words.}
    with can_fail = True
 
@@ -90,7 +90,7 @@ primop IndexByteArrayOp_Word32 "indexWord32Array#" GenPrimOp
    with can_fail = True
 
 primop IndexByteArrayOp_Word64 "indexWord64Array#" GenPrimOp
-   ByteArray# -> Int# -> WORD64
+   ByteArray# -> Int# -> Word64#
    {Read a 64-bit unsigned integer; offset in 8-byte words.}
    with can_fail = True
 
@@ -150,7 +150,7 @@ primop IndexByteArrayOp_Word8AsInt32 "indexWord8ArrayAsInt32#" GenPrimOp
    with can_fail = True
 
 primop IndexByteArrayOp_Word8AsInt64 "indexWord8ArrayAsInt64#" GenPrimOp
-   ByteArray# -> Int# -> INT64
+   ByteArray# -> Int# -> Int64#
    {Read a 64-bit signed integer; offset in bytes.}
    with can_fail = True
 
@@ -165,7 +165,7 @@ primop IndexByteArrayOp_Word8AsWord32 "indexWord8ArrayAsWord32#" GenPrimOp
    with can_fail = True
 
 primop IndexByteArrayOp_Word8AsWord64 "indexWord8ArrayAsWord64#" GenPrimOp
-   ByteArray# -> Int# -> WORD64
+   ByteArray# -> Int# -> Word64#
    {Read a 64-bit unsigned integer; offset in bytes.}
    with can_fail = True
 
@@ -241,7 +241,7 @@ primop ReadByteArrayOp_Int32 "readInt32Array#" GenPrimOp
         can_fail = True
 
 primop ReadByteArrayOp_Int64 "readInt64Array#" GenPrimOp
-   MutableByteArray# s -> Int# -> State# s -> (# State# s, INT64 #)
+   MutableByteArray# s -> Int# -> State# s -> (# State# s, Int64# #)
    {Read a 64-bit signed integer; offset in 8-byte words.}
    with has_side_effects = True
         can_fail = True
@@ -265,7 +265,7 @@ primop ReadByteArrayOp_Word32 "readWord32Array#" GenPrimOp
         can_fail = True
 
 primop ReadByteArrayOp_Word64 "readWord64Array#" GenPrimOp
-   MutableByteArray# s -> Int# -> State# s -> (# State# s, WORD64 #)
+   MutableByteArray# s -> Int# -> State# s -> (# State# s, Word64# #)
    {Read a 64-bit unsigned integer; offset in 8-byte words.}
    with has_side_effects = True
         can_fail = True
@@ -336,7 +336,7 @@ primop ReadByteArrayOp_Word8AsInt32 "readWord8ArrayAsInt32#" GenPrimOp
         can_fail = True
 
 primop ReadByteArrayOp_Word8AsInt64 "readWord8ArrayAsInt64#" GenPrimOp
-   MutableByteArray# s -> Int# -> State# s -> (# State# s, INT64 #)
+   MutableByteArray# s -> Int# -> State# s -> (# State# s, Int64# #)
    {Read a 64-bit signed integer; offset in bytes.}
    with has_side_effects = True
         can_fail = True
@@ -354,7 +354,7 @@ primop ReadByteArrayOp_Word8AsWord32 "readWord8ArrayAsWord32#" GenPrimOp
         can_fail = True
 
 primop ReadByteArrayOp_Word8AsWord64 "readWord8ArrayAsWord64#" GenPrimOp
-   MutableByteArray# s -> Int# -> State# s -> (# State# s, WORD64 #)
+   MutableByteArray# s -> Int# -> State# s -> (# State# s, Word64# #)
    {Read a 64-bit unsigned integer; offset in bytes.}
    with has_side_effects = True
         can_fail = True
@@ -431,7 +431,7 @@ primop WriteByteArrayOp_Int32 "writeInt32Array#" GenPrimOp
         can_fail = True
 
 primop WriteByteArrayOp_Int64 "writeInt64Array#" GenPrimOp
-   MutableByteArray# s -> Int# -> INT64 -> State# s -> State# s
+   MutableByteArray# s -> Int# -> Int64# -> State# s -> State# s
    {Write a 64-bit signed integer; offset in 8-byte words.}
    with has_side_effects = True
         can_fail = True
@@ -455,7 +455,7 @@ primop WriteByteArrayOp_Word32 "writeWord32Array#" GenPrimOp
         can_fail = True
 
 primop WriteByteArrayOp_Word64 "writeWord64Array#" GenPrimOp
-   MutableByteArray# s -> Int# -> WORD64 -> State# s -> State# s
+   MutableByteArray# s -> Int# -> Word64# -> State# s -> State# s
    {Write a 64-bit unsigned integer; offset in 8-byte words.}
    with has_side_effects = True
         can_fail = True
@@ -526,7 +526,7 @@ primop WriteByteArrayOp_Word8AsInt32 "writeWord8ArrayAsInt32#" GenPrimOp
         can_fail = True
 
 primop WriteByteArrayOp_Word8AsInt64 "writeWord8ArrayAsInt64#" GenPrimOp
-   MutableByteArray# s -> Int# -> INT64 -> State# s -> State# s
+   MutableByteArray# s -> Int# -> Int64# -> State# s -> State# s
    {Write a 64-bit signed integer; offset in bytes.}
    with has_side_effects = True
         can_fail = True
@@ -544,7 +544,7 @@ primop WriteByteArrayOp_Word8AsWord32 "writeWord8ArrayAsWord32#" GenPrimOp
         can_fail = True
 
 primop WriteByteArrayOp_Word8AsWord64 "writeWord8ArrayAsWord64#" GenPrimOp
-   MutableByteArray# s -> Int# -> WORD64 -> State# s -> State# s
+   MutableByteArray# s -> Int# -> Word64# -> State# s -> State# s
    {Write a 64-bit unsigned integer; offset in bytes.}
    with has_side_effects = True
         can_fail = True
diff --git a/compiler/GHC/Builtin/primops.txt.pp b/compiler/GHC/Builtin/primops.txt.pp
index 2aa1eefb4b..b2a45ad79f 100644
--- a/compiler/GHC/Builtin/primops.txt.pp
+++ b/compiler/GHC/Builtin/primops.txt.pp
@@ -132,9 +132,8 @@
 -- 3-tuple in the list of 3-tuples. That is, the vector attribute allows us to
 -- define a family of types or primops. Vector support also adds three new
 -- keywords: VECTOR, SCALAR, and VECTUPLE. These keywords are expanded to types
--- derived from the 3-tuple. For the 3-tuple <Int64,INT64,2>, VECTOR expands to
--- Int64X2#, SCALAR expands to INT64, and VECTUPLE expands to (# INT64, INT64
--- #).
+-- derived from the 3-tuple. For the 3-tuple <Int64#,Int64#,2>, VECTOR expands to
+-- Int64X2#, SCALAR expands to Int64#, and VECTUPLE expands to (# Int64#, Int64# #).
 
 defaults
    has_side_effects = False
@@ -222,8 +221,6 @@ defaults
 --      This means one shouldn't write a type involving both `a` and `o`,
 --      nor `b` and `p`, nor `o` and `v`, etc.
 
-#include "MachDeps.h"
-
 section "The word size story."
         {Haskell98 specifies that signed integers (type {\tt Int})
          must contain at least 30 bits. GHC always implements {\tt
@@ -231,12 +228,7 @@ section "The word size story."
          the {\tt MachDeps.h} constant {\tt WORD\_SIZE\_IN\_BITS}.
          This is normally set based on the {\tt config.h} parameter
          {\tt SIZEOF\_HSWORD}, i.e., 32 bits on 32-bit machines, 64
-         bits on 64-bit machines.  However, it can also be explicitly
-         set to a smaller number than 64, e.g., 62 bits, to allow the
-         possibility of using tag bits. Currently GHC itself has only
-         32-bit and 64-bit variants, but 61, 62, or 63-bit code can be
-         exported as an external core file for use in other back ends.
-         30 and 31-bit code is no longer supported.
+         bits on 64-bit machines.
 
          GHC also implements a primitive unsigned integer type {\tt
          Word\#} which always has the same number of bits as {\tt
@@ -245,33 +237,7 @@ section "The word size story."
          In addition, GHC supports families of explicit-sized integers
          and words at 8, 16, 32, and 64 bits, with the usual
          arithmetic operations, comparisons, and a range of
-         conversions.  The 8-bit and 16-bit sizes are always
-         represented as {\tt Int\#} and {\tt Word\#}, and the
-         operations implemented in terms of the primops on these
-         types, with suitable range restrictions on the results (using
-         the {\tt narrow$n$Int\#} and {\tt narrow$n$Word\#} families of
-         primops.  The 64-bit sizes are represented using {\tt Int\#}
-         and {\tt Word\#} when {\tt WORD\_SIZE\_IN\_BITS} $\geq$ 64;
-         otherwise, these are represented using distinct primitive
-         types {\tt Int64\#} and {\tt Word64\#}. These (when needed)
-         have a complete set of corresponding operations; however,
-         nearly all of these are implemented as external C functions
-         rather than as primops.  All of these details are hidden
-         under the {\tt PrelInt} and {\tt PrelWord} modules, which use
-         {\tt \#if}-defs to invoke the appropriate types and operators.
-
-         Word size also matters for the families of primops for
-         indexing/reading/writing fixed-size quantities at offsets
-         from an array base, address, or foreign pointer.  Here, a
-         slightly different approach is taken.  The names of these
-         primops are fixed, but their {\it types} vary according to
-         the value of {\tt WORD\_SIZE\_IN\_BITS}. For example, if word
-         size is at least 32 bits then an operator like
-         \texttt{indexInt32Array\#} has type {\tt ByteArray\# -> Int\#
-         -> Int\#}; otherwise it has type {\tt ByteArray\# -> Int\# ->
-         Int32\#}.  This approach confines the necessary {\tt
-         \#if}-defs to this file; no conditional compilation is needed
-         in the files that expose these primops.
+         conversions.
 
          Finally, there are strongly deprecated primops for coercing
          between {\tt Addr\#}, the primitive type of machine
@@ -280,16 +246,6 @@ section "The word size story."
          are completely bogus when tag bits are used in {\tt Int\#},
          so are not available in this case.  }
 
--- Define synonyms for indexing ops.
-
-#if WORD_SIZE_IN_BITS < 64
-#define INT64 Int64#
-#define WORD64 Word64#
-#else
-#define INT64 Int#
-#define WORD64 Word#
-#endif
-
 ------------------------------------------------------------------------
 section "Char#"
         {Operations on 31-bit characters.}
@@ -981,7 +937,7 @@ primop   PopCnt16Op   "popCnt16#"   GenPrimOp   Word# -> Word#
     {Count the number of set bits in the lower 16 bits of a word.}
 primop   PopCnt32Op   "popCnt32#"   GenPrimOp   Word# -> Word#
     {Count the number of set bits in the lower 32 bits of a word.}
-primop   PopCnt64Op   "popCnt64#"   GenPrimOp   WORD64 -> Word#
+primop   PopCnt64Op   "popCnt64#"   GenPrimOp   Word64# -> Word#
     {Count the number of set bits in a 64-bit word.}
 primop   PopCntOp   "popCnt#"   GenPrimOp   Word# -> Word#
     {Count the number of set bits in a word.}
@@ -992,7 +948,7 @@ primop   Pdep16Op   "pdep16#"   GenPrimOp   Word# -> Word# -> Word#
     {Deposit bits to lower 16 bits of a word at locations specified by a mask.}
 primop   Pdep32Op   "pdep32#"   GenPrimOp   Word# -> Word# -> Word#
     {Deposit bits to lower 32 bits of a word at locations specified by a mask.}
-primop   Pdep64Op   "pdep64#"   GenPrimOp   WORD64 -> WORD64 -> WORD64
+primop   Pdep64Op   "pdep64#"   GenPrimOp   Word64# -> Word64# -> Word64#
     {Deposit bits to a word at locations specified by a mask.}
 primop   PdepOp   "pdep#"   GenPrimOp   Word# -> Word# -> Word#
     {Deposit bits to a word at locations specified by a mask.}
@@ -1003,7 +959,7 @@ primop   Pext16Op   "pext16#"   GenPrimOp   Word# -> Word# -> Word#
     {Extract bits from lower 16 bits of a word at locations specified by a mask.}
 primop   Pext32Op   "pext32#"   GenPrimOp   Word# -> Word# -> Word#
     {Extract bits from lower 32 bits of a word at locations specified by a mask.}
-primop   Pext64Op   "pext64#"   GenPrimOp   WORD64 -> WORD64 -> WORD64
+primop   Pext64Op   "pext64#"   GenPrimOp   Word64# -> Word64# -> Word64#
     {Extract bits from a word at locations specified by a mask.}
 primop   PextOp   "pext#"   GenPrimOp   Word# -> Word# -> Word#
     {Extract bits from a word at locations specified by a mask.}
@@ -1014,7 +970,7 @@ primop   Clz16Op   "clz16#" GenPrimOp   Word# -> Word#
     {Count leading zeros in the lower 16 bits of a word.}
 primop   Clz32Op   "clz32#" GenPrimOp   Word# -> Word#
     {Count leading zeros in the lower 32 bits of a word.}
-primop   Clz64Op   "clz64#" GenPrimOp WORD64 -> Word#
+primop   Clz64Op   "clz64#" GenPrimOp Word64# -> Word#
     {Count leading zeros in a 64-bit word.}
 primop   ClzOp     "clz#"   GenPrimOp   Word# -> Word#
     {Count leading zeros in a word.}
@@ -1025,7 +981,7 @@ primop   Ctz16Op   "ctz16#" GenPrimOp   Word# -> Word#
     {Count trailing zeros in the lower 16 bits of a word.}
 primop   Ctz32Op   "ctz32#" GenPrimOp   Word# -> Word#
     {Count trailing zeros in the lower 32 bits of a word.}
-primop   Ctz64Op   "ctz64#" GenPrimOp WORD64 -> Word#
+primop   Ctz64Op   "ctz64#" GenPrimOp Word64# -> Word#
     {Count trailing zeros in a 64-bit word.}
 primop   CtzOp     "ctz#"   GenPrimOp   Word# -> Word#
     {Count trailing zeros in a word.}
@@ -1034,7 +990,7 @@ primop   BSwap16Op   "byteSwap16#"   GenPrimOp   Word# -> Word#
     {Swap bytes in the lower 16 bits of a word. The higher bytes are undefined. }
 primop   BSwap32Op   "byteSwap32#"   GenPrimOp   Word# -> Word#
     {Swap bytes in the lower 32 bits of a word. The higher bytes are undefined. }
-primop   BSwap64Op   "byteSwap64#"   GenPrimOp   WORD64 -> WORD64
+primop   BSwap64Op   "byteSwap64#"   GenPrimOp   Word64# -> Word64#
     {Swap bytes in a 64 bits of a word.}
 primop   BSwapOp     "byteSwap#"     GenPrimOp   Word# -> Word#
     {Swap bytes in a word.}
@@ -1045,7 +1001,7 @@ primop   BRev16Op   "bitReverse16#"   GenPrimOp   Word# -> Word#
     {Reverse the order of the bits in a 16-bit word.}
 primop   BRev32Op   "bitReverse32#"   GenPrimOp   Word# -> Word#
     {Reverse the order of the bits in a 32-bit word.}
-primop   BRev64Op   "bitReverse64#"   GenPrimOp   WORD64 -> WORD64
+primop   BRev64Op   "bitReverse64#"   GenPrimOp   Word64# -> Word64#
     {Reverse the order of the bits in a 64-bit word.}
 primop   BRevOp     "bitReverse#"     GenPrimOp   Word# -> Word#
     {Reverse the order of the bits in a word.}
@@ -1224,7 +1180,7 @@ primop   DoubleDecode_2IntOp   "decodeDouble_2Int#" GenPrimOp
    with out_of_line = True
 
 primop   DoubleDecode_Int64Op   "decodeDouble_Int64#" GenPrimOp
-   Double# -> (# INT64, Int# #)
+   Double# -> (# Int64#, Int# #)
    {Decode {\tt Double\#} into mantissa and base-2 exponent.}
    with out_of_line = True
 
@@ -1957,7 +1913,7 @@ primop CasByteArrayOp_Int32 "casInt32Array#" GenPrimOp
         can_fail = True
 
 primop CasByteArrayOp_Int64 "casInt64Array#" GenPrimOp
-   MutableByteArray# s -> Int# -> INT64 -> INT64 -> State# s -> (# State# s, INT64 #)
+   MutableByteArray# s -> Int# -> Int64# -> Int64# -> State# s -> (# State# s, Int64# #)
    {Given an array, an offset in 64 bit units, the expected old value, and
     the new value, perform an atomic compare and swap i.e. write the new
     value if the current value matches the provided old value. Returns
@@ -2203,7 +2159,7 @@ primop IndexOffAddrOp_Int32 "indexInt32OffAddr#" GenPrimOp
    with can_fail = True
 
 primop IndexOffAddrOp_Int64 "indexInt64OffAddr#" GenPrimOp
-   Addr# -> Int# -> INT64
+   Addr# -> Int# -> Int64#
    with can_fail = True
 
 primop IndexOffAddrOp_Word8 "indexWord8OffAddr#" GenPrimOp
@@ -2219,7 +2175,7 @@ primop IndexOffAddrOp_Word32 "indexWord32OffAddr#" GenPrimOp
    with can_fail = True
 
 primop IndexOffAddrOp_Word64 "indexWord64OffAddr#" GenPrimOp
-   Addr# -> Int# -> WORD64
+   Addr# -> Int# -> Word64#
    with can_fail = True
 
 primop ReadOffAddrOp_Char "readCharOffAddr#" GenPrimOp
@@ -2280,7 +2236,7 @@ primop ReadOffAddrOp_Int32 "readInt32OffAddr#" GenPrimOp
         can_fail         = True
 
 primop ReadOffAddrOp_Int64 "readInt64OffAddr#" GenPrimOp
-   Addr# -> Int# -> State# s -> (# State# s, INT64 #)
+   Addr# -> Int# -> State# s -> (# State# s, Int64# #)
    with has_side_effects = True
         can_fail         = True
 
@@ -2300,7 +2256,7 @@ primop ReadOffAddrOp_Word32 "readWord32OffAddr#" GenPrimOp
         can_fail         = True
 
 primop ReadOffAddrOp_Word64 "readWord64OffAddr#" GenPrimOp
-   Addr# -> Int# -> State# s -> (# State# s, WORD64 #)
+   Addr# -> Int# -> State# s -> (# State# s, Word64# #)
    with has_side_effects = True
         can_fail         = True
 
@@ -2360,7 +2316,7 @@ primop  WriteOffAddrOp_Int32 "writeInt32OffAddr#" GenPrimOp
         can_fail         = True
 
 primop  WriteOffAddrOp_Int64 "writeInt64OffAddr#" GenPrimOp
-   Addr# -> Int# -> INT64 -> State# s -> State# s
+   Addr# -> Int# -> Int64# -> State# s -> State# s
    with has_side_effects = True
         can_fail         = True
 
@@ -2380,7 +2336,7 @@ primop  WriteOffAddrOp_Word32 "writeWord32OffAddr#" GenPrimOp
         can_fail         = True
 
 primop  WriteOffAddrOp_Word64 "writeWord64OffAddr#" GenPrimOp
-   Addr# -> Int# -> WORD64 -> State# s -> State# s
+   Addr# -> Int# -> Word64# -> State# s -> State# s
    with has_side_effects = True
         can_fail         = True
 
@@ -2469,7 +2425,7 @@ primop  CasAddrOp_Word32 "atomicCasWord32Addr#" GenPrimOp
         can_fail         = True
 
 primop  CasAddrOp_Word64 "atomicCasWord64Addr#" GenPrimOp
-   Addr# -> WORD64 -> WORD64 -> State# s -> (# State# s, WORD64 #)
+   Addr# -> Word64# -> Word64# -> State# s -> (# State# s, Word64# #)
    { Compare and swap on a 64 bit-sized and aligned memory location.
 
      Use as: \s -> atomicCasWordAddr64# location expected desired s
@@ -3641,7 +3597,7 @@ primop  TraceMarkerOp "traceMarker#" GenPrimOp
    out_of_line      = True
 
 primop  SetThreadAllocationCounter "setThreadAllocationCounter#" GenPrimOp
-   INT64 -> State# RealWorld -> State# RealWorld
+   Int64# -> State# RealWorld -> State# RealWorld
    { Sets the allocation counter for the current thread to the given value. }
    with
    has_side_effects = True
@@ -3677,20 +3633,20 @@ section "SIMD Vectors"
 ------------------------------------------------------------------------
 
 #define ALL_VECTOR_TYPES \
-  [<Int8,Int8#,16>,<Int16,Int16#,8>,<Int32,Int32#,4>,<Int64,INT64,2> \
-  ,<Int8,Int8#,32>,<Int16,Int16#,16>,<Int32,Int32#,8>,<Int64,INT64,4> \
-  ,<Int8,Int8#,64>,<Int16,Int16#,32>,<Int32,Int32#,16>,<Int64,INT64,8> \
-  ,<Word8,Word#,16>,<Word16,Word#,8>,<Word32,Word32#,4>,<Word64,WORD64,2> \
-  ,<Word8,Word#,32>,<Word16,Word#,16>,<Word32,Word32#,8>,<Word64,WORD64,4> \
-  ,<Word8,Word#,64>,<Word16,Word#,32>,<Word32,Word32#,16>,<Word64,WORD64,8> \
+  [<Int8,Int8#,16>,<Int16,Int16#,8>,<Int32,Int32#,4>,<Int64,Int64#,2> \
+  ,<Int8,Int8#,32>,<Int16,Int16#,16>,<Int32,Int32#,8>,<Int64,Int64#,4> \
+  ,<Int8,Int8#,64>,<Int16,Int16#,32>,<Int32,Int32#,16>,<Int64,Int64#,8> \
+  ,<Word8,Word#,16>,<Word16,Word#,8>,<Word32,Word32#,4>,<Word64,Word64#,2> \
+  ,<Word8,Word#,32>,<Word16,Word#,16>,<Word32,Word32#,8>,<Word64,Word64#,4> \
+  ,<Word8,Word#,64>,<Word16,Word#,32>,<Word32,Word32#,16>,<Word64,Word64#,8> \
   ,<Float,Float#,4>,<Double,Double#,2> \
   ,<Float,Float#,8>,<Double,Double#,4> \
   ,<Float,Float#,16>,<Double,Double#,8>]
 
 #define SIGNED_VECTOR_TYPES \
-  [<Int8,Int8#,16>,<Int16,Int16#,8>,<Int32,Int32#,4>,<Int64,INT64,2> \
-  ,<Int8,Int8#,32>,<Int16,Int16#,16>,<Int32,Int32#,8>,<Int64,INT64,4> \
-  ,<Int8,Int8#,64>,<Int16,Int16#,32>,<Int32,Int32#,16>,<Int64,INT64,8> \
+  [<Int8,Int8#,16>,<Int16,Int16#,8>,<Int32,Int32#,4>,<Int64,Int64#,2> \
+  ,<Int8,Int8#,32>,<Int16,Int16#,16>,<Int32,Int32#,8>,<Int64,Int64#,4> \
+  ,<Int8,Int8#,64>,<Int16,Int16#,32>,<Int32,Int32#,16>,<Int64,Int64#,8> \
   ,<Float,Float#,4>,<Double,Double#,2> \
   ,<Float,Float#,8>,<Double,Double#,4> \
   ,<Float,Float#,16>,<Double,Double#,8>]
@@ -3701,12 +3657,12 @@ section "SIMD Vectors"
   ,<Float,Float#,16>,<Double,Double#,8>]
 
 #define INT_VECTOR_TYPES \
-  [<Int8,Int8#,16>,<Int16,Int16#,8>,<Int32,Int32#,4>,<Int64,INT64,2> \
-  ,<Int8,Int8#,32>,<Int16,Int16#,16>,<Int32,Int32#,8>,<Int64,INT64,4> \
-  ,<Int8,Int8#,64>,<Int16,Int16#,32>,<Int32,Int32#,16>,<Int64,INT64,8> \
-  ,<Word8,Word#,16>,<Word16,Word#,8>,<Word32,Word32#,4>,<Word64,WORD64,2> \
-  ,<Word8,Word#,32>,<Word16,Word#,16>,<Word32,Word32#,8>,<Word64,WORD64,4> \
-  ,<Word8,Word#,64>,<Word16,Word#,32>,<Word32,Word32#,16>,<Word64,WORD64,8>]
+  [<Int8,Int8#,16>,<Int16,Int16#,8>,<Int32,Int32#,4>,<Int64,Int64#,2> \
+  ,<Int8,Int8#,32>,<Int16,Int16#,16>,<Int32,Int32#,8>,<Int64,Int64#,4> \
+  ,<Int8,Int8#,64>,<Int16,Int16#,32>,<Int32,Int32#,16>,<Int64,Int64#,8> \
+  ,<Word8,Word#,16>,<Word16,Word#,8>,<Word32,Word32#,4>,<Word64,Word64#,2> \
+  ,<Word8,Word#,32>,<Word16,Word#,16>,<Word32,Word32#,8>,<Word64,Word64#,4> \
+  ,<Word8,Word#,64>,<Word16,Word#,32>,<Word32,Word32#,16>,<Word64,Word64#,8>]
 
 primtype VECTOR
    with llvm_only = True