mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-08-01 07:20:29 +00:00
Release Cosmopolitan v3.8.0
This change switches c++ exception handling from sjlj to standard dwarf. It's needed because clang for aarch64 doesn't support sjlj. It turns out that libunwind had a bare-metal configuration that made this easy to do. This change gets the new experimental cosmocc -mclang flag in a state of working so well that it can now be used to build all of llamafile and it goes 3x faster in terms of build latency, without trading away any perf. The int_fast16_t and int_fast32_t types are now always defined as 32-bit in the interest of having more abi consistency between cosmocc -mgcc and -mclang mode.
This commit is contained in:
Justine Tunney
parent
5b9862907c
commit
c9152b6f14
188 changed files with 199063 additions and 636 deletions
35
third_party/aarch64/clang/arm64intr.h
vendored
Normal file
35
third_party/aarch64/clang/arm64intr.h
vendored
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
/*===---- arm64intr.h - ARM64 Windows intrinsics -------------------------------===
|
||||
*
|
||||
* 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
|
||||
*
|
||||
*===-----------------------------------------------------------------------===
|
||||
*/
|
||||
|
||||
/* Only include this if we're compiling for the windows platform. */
|
||||
#ifndef _MSC_VER
|
||||
#include_next <arm64intr.h>
|
||||
#else
|
||||
|
||||
#ifndef __ARM64INTR_H
|
||||
#define __ARM64INTR_H
|
||||
|
||||
typedef enum
|
||||
{
|
||||
_ARM64_BARRIER_SY = 0xF,
|
||||
_ARM64_BARRIER_ST = 0xE,
|
||||
_ARM64_BARRIER_LD = 0xD,
|
||||
_ARM64_BARRIER_ISH = 0xB,
|
||||
_ARM64_BARRIER_ISHST = 0xA,
|
||||
_ARM64_BARRIER_ISHLD = 0x9,
|
||||
_ARM64_BARRIER_NSH = 0x7,
|
||||
_ARM64_BARRIER_NSHST = 0x6,
|
||||
_ARM64_BARRIER_NSHLD = 0x5,
|
||||
_ARM64_BARRIER_OSH = 0x3,
|
||||
_ARM64_BARRIER_OSHST = 0x2,
|
||||
_ARM64_BARRIER_OSHLD = 0x1
|
||||
} _ARM64INTR_BARRIER_TYPE;
|
||||
|
||||
#endif /* __ARM64INTR_H */
|
||||
#endif /* _MSC_VER */
|
||||
888
third_party/aarch64/clang/arm_acle.h
vendored
Normal file
888
third_party/aarch64/clang/arm_acle.h
vendored
Normal file
|
|
@ -0,0 +1,888 @@
|
|||
/*===---- arm_acle.h - ARM Non-Neon intrinsics -----------------------------===
|
||||
*
|
||||
* 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
|
||||
*
|
||||
* The Arm C Language Extensions specifications can be found in the following
|
||||
* link: https://github.com/ARM-software/acle/releases
|
||||
*
|
||||
* The ACLE section numbers are subject to change. When consulting the
|
||||
* specifications, it is recommended to search using section titles if
|
||||
* the section numbers look outdated.
|
||||
*
|
||||
*===-----------------------------------------------------------------------===
|
||||
*/
|
||||
|
||||
#ifndef __ARM_ACLE_H
|
||||
#define __ARM_ACLE_H
|
||||
|
||||
#ifndef __ARM_ACLE
|
||||
#error "ACLE intrinsics support not enabled."
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* 7 SYNCHRONIZATION, BARRIER AND HINT INTRINSICS */
|
||||
/* 7.3 Memory barriers */
|
||||
#if !__has_builtin(__dmb)
|
||||
#define __dmb(i) __builtin_arm_dmb(i)
|
||||
#endif
|
||||
#if !__has_builtin(__dsb)
|
||||
#define __dsb(i) __builtin_arm_dsb(i)
|
||||
#endif
|
||||
#if !__has_builtin(__isb)
|
||||
#define __isb(i) __builtin_arm_isb(i)
|
||||
#endif
|
||||
|
||||
/* 7.4 Hints */
|
||||
|
||||
#if !__has_builtin(__wfi)
|
||||
static __inline__ void __attribute__((__always_inline__, __nodebug__)) __wfi(void) {
|
||||
__builtin_arm_wfi();
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !__has_builtin(__wfe)
|
||||
static __inline__ void __attribute__((__always_inline__, __nodebug__)) __wfe(void) {
|
||||
__builtin_arm_wfe();
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !__has_builtin(__sev)
|
||||
static __inline__ void __attribute__((__always_inline__, __nodebug__)) __sev(void) {
|
||||
__builtin_arm_sev();
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !__has_builtin(__sevl)
|
||||
static __inline__ void __attribute__((__always_inline__, __nodebug__)) __sevl(void) {
|
||||
__builtin_arm_sevl();
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !__has_builtin(__yield)
|
||||
static __inline__ void __attribute__((__always_inline__, __nodebug__)) __yield(void) {
|
||||
__builtin_arm_yield();
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(__ARM_32BIT_STATE) && __ARM_32BIT_STATE
|
||||
#define __dbg(t) __builtin_arm_dbg(t)
|
||||
#endif
|
||||
|
||||
#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
|
||||
#define _CHKFEAT_GCS 1
|
||||
static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
|
||||
__chkfeat(uint64_t __features) {
|
||||
return __builtin_arm_chkfeat(__features) ^ __features;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 7.5 Swap */
|
||||
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__swp(uint32_t __x, volatile uint32_t *__p) {
|
||||
uint32_t v;
|
||||
do
|
||||
v = __builtin_arm_ldrex(__p);
|
||||
while (__builtin_arm_strex(__x, __p));
|
||||
return v;
|
||||
}
|
||||
|
||||
/* 7.6 Memory prefetch intrinsics */
|
||||
/* 7.6.1 Data prefetch */
|
||||
#define __pld(addr) __pldx(0, 0, 0, addr)
|
||||
|
||||
#if defined(__ARM_32BIT_STATE) && __ARM_32BIT_STATE
|
||||
#define __pldx(access_kind, cache_level, retention_policy, addr) \
|
||||
__builtin_arm_prefetch(addr, access_kind, 1)
|
||||
#else
|
||||
#define __pldx(access_kind, cache_level, retention_policy, addr) \
|
||||
__builtin_arm_prefetch(addr, access_kind, cache_level, retention_policy, 1)
|
||||
#endif
|
||||
|
||||
/* 7.6.2 Instruction prefetch */
|
||||
#define __pli(addr) __plix(0, 0, addr)
|
||||
|
||||
#if defined(__ARM_32BIT_STATE) && __ARM_32BIT_STATE
|
||||
#define __plix(cache_level, retention_policy, addr) \
|
||||
__builtin_arm_prefetch(addr, 0, 0)
|
||||
#else
|
||||
#define __plix(cache_level, retention_policy, addr) \
|
||||
__builtin_arm_prefetch(addr, 0, cache_level, retention_policy, 0)
|
||||
#endif
|
||||
|
||||
/* 7.7 NOP */
|
||||
#if !defined(_MSC_VER) || (!defined(__aarch64__) && !defined(__arm64ec__))
|
||||
static __inline__ void __attribute__((__always_inline__, __nodebug__)) __nop(void) {
|
||||
__builtin_arm_nop();
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 8 DATA-PROCESSING INTRINSICS */
|
||||
/* 8.2 Miscellaneous data-processing intrinsics */
|
||||
/* ROR */
|
||||
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__ror(uint32_t __x, uint32_t __y) {
|
||||
__y %= 32;
|
||||
if (__y == 0)
|
||||
return __x;
|
||||
return (__x >> __y) | (__x << (32 - __y));
|
||||
}
|
||||
|
||||
static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
|
||||
__rorll(uint64_t __x, uint32_t __y) {
|
||||
__y %= 64;
|
||||
if (__y == 0)
|
||||
return __x;
|
||||
return (__x >> __y) | (__x << (64 - __y));
|
||||
}
|
||||
|
||||
static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__))
|
||||
__rorl(unsigned long __x, uint32_t __y) {
|
||||
#if __SIZEOF_LONG__ == 4
|
||||
return __ror(__x, __y);
|
||||
#else
|
||||
return __rorll(__x, __y);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/* CLZ */
|
||||
static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__))
|
||||
__clz(uint32_t __t) {
|
||||
return __builtin_arm_clz(__t);
|
||||
}
|
||||
|
||||
static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__))
|
||||
__clzl(unsigned long __t) {
|
||||
#if __SIZEOF_LONG__ == 4
|
||||
return __builtin_arm_clz(__t);
|
||||
#else
|
||||
return __builtin_arm_clz64(__t);
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__))
|
||||
__clzll(uint64_t __t) {
|
||||
return __builtin_arm_clz64(__t);
|
||||
}
|
||||
|
||||
/* CLS */
|
||||
static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__))
|
||||
__cls(uint32_t __t) {
|
||||
return __builtin_arm_cls(__t);
|
||||
}
|
||||
|
||||
static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__))
|
||||
__clsl(unsigned long __t) {
|
||||
#if __SIZEOF_LONG__ == 4
|
||||
return __builtin_arm_cls(__t);
|
||||
#else
|
||||
return __builtin_arm_cls64(__t);
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__))
|
||||
__clsll(uint64_t __t) {
|
||||
return __builtin_arm_cls64(__t);
|
||||
}
|
||||
|
||||
/* REV */
|
||||
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__rev(uint32_t __t) {
|
||||
return __builtin_bswap32(__t);
|
||||
}
|
||||
|
||||
static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__))
|
||||
__revl(unsigned long __t) {
|
||||
#if __SIZEOF_LONG__ == 4
|
||||
return __builtin_bswap32(__t);
|
||||
#else
|
||||
return __builtin_bswap64(__t);
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
|
||||
__revll(uint64_t __t) {
|
||||
return __builtin_bswap64(__t);
|
||||
}
|
||||
|
||||
/* REV16 */
|
||||
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__rev16(uint32_t __t) {
|
||||
return __ror(__rev(__t), 16);
|
||||
}
|
||||
|
||||
static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
|
||||
__rev16ll(uint64_t __t) {
|
||||
return (((uint64_t)__rev16(__t >> 32)) << 32) | (uint64_t)__rev16((uint32_t)__t);
|
||||
}
|
||||
|
||||
static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__))
|
||||
__rev16l(unsigned long __t) {
|
||||
#if __SIZEOF_LONG__ == 4
|
||||
return __rev16(__t);
|
||||
#else
|
||||
return __rev16ll(__t);
|
||||
#endif
|
||||
}
|
||||
|
||||
/* REVSH */
|
||||
static __inline__ int16_t __attribute__((__always_inline__, __nodebug__))
|
||||
__revsh(int16_t __t) {
|
||||
return (int16_t)__builtin_bswap16((uint16_t)__t);
|
||||
}
|
||||
|
||||
/* RBIT */
|
||||
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__rbit(uint32_t __t) {
|
||||
return __builtin_arm_rbit(__t);
|
||||
}
|
||||
|
||||
static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
|
||||
__rbitll(uint64_t __t) {
|
||||
#if defined(__ARM_32BIT_STATE) && __ARM_32BIT_STATE
|
||||
return (((uint64_t)__builtin_arm_rbit(__t)) << 32) |
|
||||
__builtin_arm_rbit(__t >> 32);
|
||||
#else
|
||||
return __builtin_arm_rbit64(__t);
|
||||
#endif
|
||||
}
|
||||
|
||||
static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__))
|
||||
__rbitl(unsigned long __t) {
|
||||
#if __SIZEOF_LONG__ == 4
|
||||
return __rbit(__t);
|
||||
#else
|
||||
return __rbitll(__t);
|
||||
#endif
|
||||
}
|
||||
|
||||
/* 8.3 16-bit multiplications */
|
||||
#if defined(__ARM_FEATURE_DSP) && __ARM_FEATURE_DSP
|
||||
static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
|
||||
__smulbb(int32_t __a, int32_t __b) {
|
||||
return __builtin_arm_smulbb(__a, __b);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
|
||||
__smulbt(int32_t __a, int32_t __b) {
|
||||
return __builtin_arm_smulbt(__a, __b);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
|
||||
__smultb(int32_t __a, int32_t __b) {
|
||||
return __builtin_arm_smultb(__a, __b);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
|
||||
__smultt(int32_t __a, int32_t __b) {
|
||||
return __builtin_arm_smultt(__a, __b);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
|
||||
__smulwb(int32_t __a, int32_t __b) {
|
||||
return __builtin_arm_smulwb(__a, __b);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
|
||||
__smulwt(int32_t __a, int32_t __b) {
|
||||
return __builtin_arm_smulwt(__a, __b);
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* 8.4 Saturating intrinsics
|
||||
*
|
||||
* FIXME: Change guard to their corresponding __ARM_FEATURE flag when Q flag
|
||||
* intrinsics are implemented and the flag is enabled.
|
||||
*/
|
||||
/* 8.4.1 Width-specified saturation intrinsics */
|
||||
#if defined(__ARM_FEATURE_SAT) && __ARM_FEATURE_SAT
|
||||
#define __ssat(x, y) __builtin_arm_ssat(x, y)
|
||||
#define __usat(x, y) __builtin_arm_usat(x, y)
|
||||
#endif
|
||||
|
||||
/* 8.4.2 Saturating addition and subtraction intrinsics */
|
||||
#if defined(__ARM_FEATURE_DSP) && __ARM_FEATURE_DSP
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__qadd(int32_t __t, int32_t __v) {
|
||||
return __builtin_arm_qadd(__t, __v);
|
||||
}
|
||||
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__qsub(int32_t __t, int32_t __v) {
|
||||
return __builtin_arm_qsub(__t, __v);
|
||||
}
|
||||
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__qdbl(int32_t __t) {
|
||||
return __builtin_arm_qadd(__t, __t);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 8.4.3 Accumulating multiplications */
|
||||
#if defined(__ARM_FEATURE_DSP) && __ARM_FEATURE_DSP
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smlabb(int32_t __a, int32_t __b, int32_t __c) {
|
||||
return __builtin_arm_smlabb(__a, __b, __c);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smlabt(int32_t __a, int32_t __b, int32_t __c) {
|
||||
return __builtin_arm_smlabt(__a, __b, __c);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smlatb(int32_t __a, int32_t __b, int32_t __c) {
|
||||
return __builtin_arm_smlatb(__a, __b, __c);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smlatt(int32_t __a, int32_t __b, int32_t __c) {
|
||||
return __builtin_arm_smlatt(__a, __b, __c);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smlawb(int32_t __a, int32_t __b, int32_t __c) {
|
||||
return __builtin_arm_smlawb(__a, __b, __c);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smlawt(int32_t __a, int32_t __b, int32_t __c) {
|
||||
return __builtin_arm_smlawt(__a, __b, __c);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/* 8.5.4 Parallel 16-bit saturation */
|
||||
#if defined(__ARM_FEATURE_SIMD32) && __ARM_FEATURE_SIMD32
|
||||
#define __ssat16(x, y) __builtin_arm_ssat16(x, y)
|
||||
#define __usat16(x, y) __builtin_arm_usat16(x, y)
|
||||
#endif
|
||||
|
||||
/* 8.5.5 Packing and unpacking */
|
||||
#if defined(__ARM_FEATURE_SIMD32) && __ARM_FEATURE_SIMD32
|
||||
typedef int32_t int8x4_t;
|
||||
typedef int32_t int16x2_t;
|
||||
typedef uint32_t uint8x4_t;
|
||||
typedef uint32_t uint16x2_t;
|
||||
|
||||
static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__sxtab16(int16x2_t __a, int8x4_t __b) {
|
||||
return __builtin_arm_sxtab16(__a, __b);
|
||||
}
|
||||
static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__sxtb16(int8x4_t __a) {
|
||||
return __builtin_arm_sxtb16(__a);
|
||||
}
|
||||
static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uxtab16(int16x2_t __a, int8x4_t __b) {
|
||||
return __builtin_arm_uxtab16(__a, __b);
|
||||
}
|
||||
static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uxtb16(int8x4_t __a) {
|
||||
return __builtin_arm_uxtb16(__a);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 8.5.6 Parallel selection */
|
||||
#if defined(__ARM_FEATURE_SIMD32) && __ARM_FEATURE_SIMD32
|
||||
static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
|
||||
__sel(uint8x4_t __a, uint8x4_t __b) {
|
||||
return __builtin_arm_sel(__a, __b);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 8.5.7 Parallel 8-bit addition and subtraction */
|
||||
#if defined(__ARM_FEATURE_SIMD32) && __ARM_FEATURE_SIMD32
|
||||
static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
|
||||
__qadd8(int8x4_t __a, int8x4_t __b) {
|
||||
return __builtin_arm_qadd8(__a, __b);
|
||||
}
|
||||
static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
|
||||
__qsub8(int8x4_t __a, int8x4_t __b) {
|
||||
return __builtin_arm_qsub8(__a, __b);
|
||||
}
|
||||
static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
|
||||
__sadd8(int8x4_t __a, int8x4_t __b) {
|
||||
return __builtin_arm_sadd8(__a, __b);
|
||||
}
|
||||
static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
|
||||
__shadd8(int8x4_t __a, int8x4_t __b) {
|
||||
return __builtin_arm_shadd8(__a, __b);
|
||||
}
|
||||
static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
|
||||
__shsub8(int8x4_t __a, int8x4_t __b) {
|
||||
return __builtin_arm_shsub8(__a, __b);
|
||||
}
|
||||
static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
|
||||
__ssub8(int8x4_t __a, int8x4_t __b) {
|
||||
return __builtin_arm_ssub8(__a, __b);
|
||||
}
|
||||
static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uadd8(uint8x4_t __a, uint8x4_t __b) {
|
||||
return __builtin_arm_uadd8(__a, __b);
|
||||
}
|
||||
static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uhadd8(uint8x4_t __a, uint8x4_t __b) {
|
||||
return __builtin_arm_uhadd8(__a, __b);
|
||||
}
|
||||
static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uhsub8(uint8x4_t __a, uint8x4_t __b) {
|
||||
return __builtin_arm_uhsub8(__a, __b);
|
||||
}
|
||||
static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uqadd8(uint8x4_t __a, uint8x4_t __b) {
|
||||
return __builtin_arm_uqadd8(__a, __b);
|
||||
}
|
||||
static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uqsub8(uint8x4_t __a, uint8x4_t __b) {
|
||||
return __builtin_arm_uqsub8(__a, __b);
|
||||
}
|
||||
static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
|
||||
__usub8(uint8x4_t __a, uint8x4_t __b) {
|
||||
return __builtin_arm_usub8(__a, __b);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 8.5.8 Sum of 8-bit absolute differences */
|
||||
#if defined(__ARM_FEATURE_SIMD32) && __ARM_FEATURE_SIMD32
|
||||
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__usad8(uint8x4_t __a, uint8x4_t __b) {
|
||||
return __builtin_arm_usad8(__a, __b);
|
||||
}
|
||||
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__usada8(uint8x4_t __a, uint8x4_t __b, uint32_t __c) {
|
||||
return __builtin_arm_usada8(__a, __b, __c);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 8.5.9 Parallel 16-bit addition and subtraction */
|
||||
#if defined(__ARM_FEATURE_SIMD32) && __ARM_FEATURE_SIMD32
|
||||
static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__qadd16(int16x2_t __a, int16x2_t __b) {
|
||||
return __builtin_arm_qadd16(__a, __b);
|
||||
}
|
||||
static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__qasx(int16x2_t __a, int16x2_t __b) {
|
||||
return __builtin_arm_qasx(__a, __b);
|
||||
}
|
||||
static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__qsax(int16x2_t __a, int16x2_t __b) {
|
||||
return __builtin_arm_qsax(__a, __b);
|
||||
}
|
||||
static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__qsub16(int16x2_t __a, int16x2_t __b) {
|
||||
return __builtin_arm_qsub16(__a, __b);
|
||||
}
|
||||
static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__sadd16(int16x2_t __a, int16x2_t __b) {
|
||||
return __builtin_arm_sadd16(__a, __b);
|
||||
}
|
||||
static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__sasx(int16x2_t __a, int16x2_t __b) {
|
||||
return __builtin_arm_sasx(__a, __b);
|
||||
}
|
||||
static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__shadd16(int16x2_t __a, int16x2_t __b) {
|
||||
return __builtin_arm_shadd16(__a, __b);
|
||||
}
|
||||
static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__shasx(int16x2_t __a, int16x2_t __b) {
|
||||
return __builtin_arm_shasx(__a, __b);
|
||||
}
|
||||
static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__shsax(int16x2_t __a, int16x2_t __b) {
|
||||
return __builtin_arm_shsax(__a, __b);
|
||||
}
|
||||
static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__shsub16(int16x2_t __a, int16x2_t __b) {
|
||||
return __builtin_arm_shsub16(__a, __b);
|
||||
}
|
||||
static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__ssax(int16x2_t __a, int16x2_t __b) {
|
||||
return __builtin_arm_ssax(__a, __b);
|
||||
}
|
||||
static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__ssub16(int16x2_t __a, int16x2_t __b) {
|
||||
return __builtin_arm_ssub16(__a, __b);
|
||||
}
|
||||
static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uadd16(uint16x2_t __a, uint16x2_t __b) {
|
||||
return __builtin_arm_uadd16(__a, __b);
|
||||
}
|
||||
static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uasx(uint16x2_t __a, uint16x2_t __b) {
|
||||
return __builtin_arm_uasx(__a, __b);
|
||||
}
|
||||
static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uhadd16(uint16x2_t __a, uint16x2_t __b) {
|
||||
return __builtin_arm_uhadd16(__a, __b);
|
||||
}
|
||||
static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uhasx(uint16x2_t __a, uint16x2_t __b) {
|
||||
return __builtin_arm_uhasx(__a, __b);
|
||||
}
|
||||
static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uhsax(uint16x2_t __a, uint16x2_t __b) {
|
||||
return __builtin_arm_uhsax(__a, __b);
|
||||
}
|
||||
static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uhsub16(uint16x2_t __a, uint16x2_t __b) {
|
||||
return __builtin_arm_uhsub16(__a, __b);
|
||||
}
|
||||
static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uqadd16(uint16x2_t __a, uint16x2_t __b) {
|
||||
return __builtin_arm_uqadd16(__a, __b);
|
||||
}
|
||||
static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uqasx(uint16x2_t __a, uint16x2_t __b) {
|
||||
return __builtin_arm_uqasx(__a, __b);
|
||||
}
|
||||
static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uqsax(uint16x2_t __a, uint16x2_t __b) {
|
||||
return __builtin_arm_uqsax(__a, __b);
|
||||
}
|
||||
static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__uqsub16(uint16x2_t __a, uint16x2_t __b) {
|
||||
return __builtin_arm_uqsub16(__a, __b);
|
||||
}
|
||||
static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__usax(uint16x2_t __a, uint16x2_t __b) {
|
||||
return __builtin_arm_usax(__a, __b);
|
||||
}
|
||||
static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
|
||||
__usub16(uint16x2_t __a, uint16x2_t __b) {
|
||||
return __builtin_arm_usub16(__a, __b);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 8.5.10 Parallel 16-bit multiplication */
|
||||
#if defined(__ARM_FEATURE_SIMD32) && __ARM_FEATURE_SIMD32
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smlad(int16x2_t __a, int16x2_t __b, int32_t __c) {
|
||||
return __builtin_arm_smlad(__a, __b, __c);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smladx(int16x2_t __a, int16x2_t __b, int32_t __c) {
|
||||
return __builtin_arm_smladx(__a, __b, __c);
|
||||
}
|
||||
static __inline__ int64_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smlald(int16x2_t __a, int16x2_t __b, int64_t __c) {
|
||||
return __builtin_arm_smlald(__a, __b, __c);
|
||||
}
|
||||
static __inline__ int64_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smlaldx(int16x2_t __a, int16x2_t __b, int64_t __c) {
|
||||
return __builtin_arm_smlaldx(__a, __b, __c);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smlsd(int16x2_t __a, int16x2_t __b, int32_t __c) {
|
||||
return __builtin_arm_smlsd(__a, __b, __c);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smlsdx(int16x2_t __a, int16x2_t __b, int32_t __c) {
|
||||
return __builtin_arm_smlsdx(__a, __b, __c);
|
||||
}
|
||||
static __inline__ int64_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smlsld(int16x2_t __a, int16x2_t __b, int64_t __c) {
|
||||
return __builtin_arm_smlsld(__a, __b, __c);
|
||||
}
|
||||
static __inline__ int64_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smlsldx(int16x2_t __a, int16x2_t __b, int64_t __c) {
|
||||
return __builtin_arm_smlsldx(__a, __b, __c);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smuad(int16x2_t __a, int16x2_t __b) {
|
||||
return __builtin_arm_smuad(__a, __b);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smuadx(int16x2_t __a, int16x2_t __b) {
|
||||
return __builtin_arm_smuadx(__a, __b);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smusd(int16x2_t __a, int16x2_t __b) {
|
||||
return __builtin_arm_smusd(__a, __b);
|
||||
}
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
|
||||
__smusdx(int16x2_t __a, int16x2_t __b) {
|
||||
return __builtin_arm_smusdx(__a, __b);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 8.6 Floating-point data-processing intrinsics */
|
||||
#if (defined(__ARM_FEATURE_DIRECTED_ROUNDING) && \
|
||||
(__ARM_FEATURE_DIRECTED_ROUNDING)) && \
|
||||
(defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE)
|
||||
static __inline__ double __attribute__((__always_inline__, __nodebug__))
|
||||
__rintn(double __a) {
|
||||
return __builtin_roundeven(__a);
|
||||
}
|
||||
|
||||
static __inline__ float __attribute__((__always_inline__, __nodebug__))
|
||||
__rintnf(float __a) {
|
||||
return __builtin_roundevenf(__a);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 8.8 CRC32 intrinsics */
|
||||
#if (defined(__ARM_FEATURE_CRC32) && __ARM_FEATURE_CRC32) || \
|
||||
(defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE)
|
||||
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__, target("crc")))
|
||||
__crc32b(uint32_t __a, uint8_t __b) {
|
||||
return __builtin_arm_crc32b(__a, __b);
|
||||
}
|
||||
|
||||
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__, target("crc")))
|
||||
__crc32h(uint32_t __a, uint16_t __b) {
|
||||
return __builtin_arm_crc32h(__a, __b);
|
||||
}
|
||||
|
||||
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__, target("crc")))
|
||||
__crc32w(uint32_t __a, uint32_t __b) {
|
||||
return __builtin_arm_crc32w(__a, __b);
|
||||
}
|
||||
|
||||
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__, target("crc")))
|
||||
__crc32d(uint32_t __a, uint64_t __b) {
|
||||
return __builtin_arm_crc32d(__a, __b);
|
||||
}
|
||||
|
||||
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__, target("crc")))
|
||||
__crc32cb(uint32_t __a, uint8_t __b) {
|
||||
return __builtin_arm_crc32cb(__a, __b);
|
||||
}
|
||||
|
||||
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__, target("crc")))
|
||||
__crc32ch(uint32_t __a, uint16_t __b) {
|
||||
return __builtin_arm_crc32ch(__a, __b);
|
||||
}
|
||||
|
||||
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__, target("crc")))
|
||||
__crc32cw(uint32_t __a, uint32_t __b) {
|
||||
return __builtin_arm_crc32cw(__a, __b);
|
||||
}
|
||||
|
||||
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__, target("crc")))
|
||||
__crc32cd(uint32_t __a, uint64_t __b) {
|
||||
return __builtin_arm_crc32cd(__a, __b);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 8.6 Floating-point data-processing intrinsics */
|
||||
/* Armv8.3-A Javascript conversion intrinsic */
|
||||
#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
|
||||
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__, target("v8.3a")))
|
||||
__jcvt(double __a) {
|
||||
return __builtin_arm_jcvt(__a);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Armv8.5-A FP rounding intrinsics */
|
||||
#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
|
||||
static __inline__ float __attribute__((__always_inline__, __nodebug__, target("v8.5a")))
|
||||
__rint32zf(float __a) {
|
||||
return __builtin_arm_rint32zf(__a);
|
||||
}
|
||||
|
||||
static __inline__ double __attribute__((__always_inline__, __nodebug__, target("v8.5a")))
|
||||
__rint32z(double __a) {
|
||||
return __builtin_arm_rint32z(__a);
|
||||
}
|
||||
|
||||
static __inline__ float __attribute__((__always_inline__, __nodebug__, target("v8.5a")))
|
||||
__rint64zf(float __a) {
|
||||
return __builtin_arm_rint64zf(__a);
|
||||
}
|
||||
|
||||
static __inline__ double __attribute__((__always_inline__, __nodebug__, target("v8.5a")))
|
||||
__rint64z(double __a) {
|
||||
return __builtin_arm_rint64z(__a);
|
||||
}
|
||||
|
||||
static __inline__ float __attribute__((__always_inline__, __nodebug__, target("v8.5a")))
|
||||
__rint32xf(float __a) {
|
||||
return __builtin_arm_rint32xf(__a);
|
||||
}
|
||||
|
||||
static __inline__ double __attribute__((__always_inline__, __nodebug__, target("v8.5a")))
|
||||
__rint32x(double __a) {
|
||||
return __builtin_arm_rint32x(__a);
|
||||
}
|
||||
|
||||
static __inline__ float __attribute__((__always_inline__, __nodebug__, target("v8.5a")))
|
||||
__rint64xf(float __a) {
|
||||
return __builtin_arm_rint64xf(__a);
|
||||
}
|
||||
|
||||
static __inline__ double __attribute__((__always_inline__, __nodebug__, target("v8.5a")))
|
||||
__rint64x(double __a) {
|
||||
return __builtin_arm_rint64x(__a);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 8.9 Armv8.7-A load/store 64-byte intrinsics */
|
||||
#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
|
||||
typedef struct {
|
||||
uint64_t val[8];
|
||||
} data512_t;
|
||||
|
||||
static __inline__ data512_t __attribute__((__always_inline__, __nodebug__, target("ls64")))
|
||||
__arm_ld64b(const void *__addr) {
|
||||
data512_t __value;
|
||||
__builtin_arm_ld64b(__addr, __value.val);
|
||||
return __value;
|
||||
}
|
||||
static __inline__ void __attribute__((__always_inline__, __nodebug__, target("ls64")))
|
||||
__arm_st64b(void *__addr, data512_t __value) {
|
||||
__builtin_arm_st64b(__addr, __value.val);
|
||||
}
|
||||
static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__, target("ls64")))
|
||||
__arm_st64bv(void *__addr, data512_t __value) {
|
||||
return __builtin_arm_st64bv(__addr, __value.val);
|
||||
}
|
||||
static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__, target("ls64")))
|
||||
__arm_st64bv0(void *__addr, data512_t __value) {
|
||||
return __builtin_arm_st64bv0(__addr, __value.val);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 11.1 Special register intrinsics */
|
||||
#define __arm_rsr(sysreg) __builtin_arm_rsr(sysreg)
|
||||
#define __arm_rsr64(sysreg) __builtin_arm_rsr64(sysreg)
|
||||
#define __arm_rsr128(sysreg) __builtin_arm_rsr128(sysreg)
|
||||
#define __arm_rsrp(sysreg) __builtin_arm_rsrp(sysreg)
|
||||
#define __arm_rsrf(sysreg) __builtin_bit_cast(float, __arm_rsr(sysreg))
|
||||
#define __arm_rsrf64(sysreg) __builtin_bit_cast(double, __arm_rsr64(sysreg))
|
||||
#define __arm_wsr(sysreg, v) __builtin_arm_wsr(sysreg, v)
|
||||
#define __arm_wsr64(sysreg, v) __builtin_arm_wsr64(sysreg, v)
|
||||
#define __arm_wsr128(sysreg, v) __builtin_arm_wsr128(sysreg, v)
|
||||
#define __arm_wsrp(sysreg, v) __builtin_arm_wsrp(sysreg, v)
|
||||
#define __arm_wsrf(sysreg, v) __arm_wsr(sysreg, __builtin_bit_cast(uint32_t, v))
|
||||
#define __arm_wsrf64(sysreg, v) __arm_wsr64(sysreg, __builtin_bit_cast(uint64_t, v))
|
||||
|
||||
/* 10.3 MTE intrinsics */
|
||||
#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
|
||||
#define __arm_mte_create_random_tag(__ptr, __mask) __builtin_arm_irg(__ptr, __mask)
|
||||
#define __arm_mte_increment_tag(__ptr, __tag_offset) __builtin_arm_addg(__ptr, __tag_offset)
|
||||
#define __arm_mte_exclude_tag(__ptr, __excluded) __builtin_arm_gmi(__ptr, __excluded)
|
||||
#define __arm_mte_get_tag(__ptr) __builtin_arm_ldg(__ptr)
|
||||
#define __arm_mte_set_tag(__ptr) __builtin_arm_stg(__ptr)
|
||||
#define __arm_mte_ptrdiff(__ptra, __ptrb) __builtin_arm_subp(__ptra, __ptrb)
|
||||
|
||||
/* 18 memcpy family of operations intrinsics - MOPS */
|
||||
#define __arm_mops_memset_tag(__tagged_address, __value, __size) \
|
||||
__builtin_arm_mops_memset_tag(__tagged_address, __value, __size)
|
||||
#endif
|
||||
|
||||
/* 11.3 Coprocessor Intrinsics */
|
||||
#if defined(__ARM_FEATURE_COPROC)
|
||||
|
||||
#if (__ARM_FEATURE_COPROC & 0x1)
|
||||
|
||||
#if (__ARM_ARCH < 8)
|
||||
#define __arm_cdp(coproc, opc1, CRd, CRn, CRm, opc2) \
|
||||
__builtin_arm_cdp(coproc, opc1, CRd, CRn, CRm, opc2)
|
||||
#endif /* __ARM_ARCH < 8 */
|
||||
|
||||
#define __arm_ldc(coproc, CRd, p) __builtin_arm_ldc(coproc, CRd, p)
|
||||
#define __arm_stc(coproc, CRd, p) __builtin_arm_stc(coproc, CRd, p)
|
||||
|
||||
#define __arm_mcr(coproc, opc1, value, CRn, CRm, opc2) \
|
||||
__builtin_arm_mcr(coproc, opc1, value, CRn, CRm, opc2)
|
||||
#define __arm_mrc(coproc, opc1, CRn, CRm, opc2) \
|
||||
__builtin_arm_mrc(coproc, opc1, CRn, CRm, opc2)
|
||||
|
||||
#if (__ARM_ARCH != 4) && (__ARM_ARCH < 8)
|
||||
#define __arm_ldcl(coproc, CRd, p) __builtin_arm_ldcl(coproc, CRd, p)
|
||||
#define __arm_stcl(coproc, CRd, p) __builtin_arm_stcl(coproc, CRd, p)
|
||||
#endif /* (__ARM_ARCH != 4) && (__ARM_ARCH != 8) */
|
||||
|
||||
#if (__ARM_ARCH_8M_MAIN__) || (__ARM_ARCH_8_1M_MAIN__)
|
||||
#define __arm_cdp(coproc, opc1, CRd, CRn, CRm, opc2) \
|
||||
__builtin_arm_cdp(coproc, opc1, CRd, CRn, CRm, opc2)
|
||||
#define __arm_ldcl(coproc, CRd, p) __builtin_arm_ldcl(coproc, CRd, p)
|
||||
#define __arm_stcl(coproc, CRd, p) __builtin_arm_stcl(coproc, CRd, p)
|
||||
#endif /* ___ARM_ARCH_8M_MAIN__ */
|
||||
|
||||
#endif /* __ARM_FEATURE_COPROC & 0x1 */
|
||||
|
||||
#if (__ARM_FEATURE_COPROC & 0x2)
|
||||
#define __arm_cdp2(coproc, opc1, CRd, CRn, CRm, opc2) \
|
||||
__builtin_arm_cdp2(coproc, opc1, CRd, CRn, CRm, opc2)
|
||||
#define __arm_ldc2(coproc, CRd, p) __builtin_arm_ldc2(coproc, CRd, p)
|
||||
#define __arm_stc2(coproc, CRd, p) __builtin_arm_stc2(coproc, CRd, p)
|
||||
#define __arm_ldc2l(coproc, CRd, p) __builtin_arm_ldc2l(coproc, CRd, p)
|
||||
#define __arm_stc2l(coproc, CRd, p) __builtin_arm_stc2l(coproc, CRd, p)
|
||||
#define __arm_mcr2(coproc, opc1, value, CRn, CRm, opc2) \
|
||||
__builtin_arm_mcr2(coproc, opc1, value, CRn, CRm, opc2)
|
||||
#define __arm_mrc2(coproc, opc1, CRn, CRm, opc2) \
|
||||
__builtin_arm_mrc2(coproc, opc1, CRn, CRm, opc2)
|
||||
#endif
|
||||
|
||||
#if (__ARM_FEATURE_COPROC & 0x4)
|
||||
#define __arm_mcrr(coproc, opc1, value, CRm) \
|
||||
__builtin_arm_mcrr(coproc, opc1, value, CRm)
|
||||
#define __arm_mrrc(coproc, opc1, CRm) __builtin_arm_mrrc(coproc, opc1, CRm)
|
||||
#endif
|
||||
|
||||
#if (__ARM_FEATURE_COPROC & 0x8)
|
||||
#define __arm_mcrr2(coproc, opc1, value, CRm) \
|
||||
__builtin_arm_mcrr2(coproc, opc1, value, CRm)
|
||||
#define __arm_mrrc2(coproc, opc1, CRm) __builtin_arm_mrrc2(coproc, opc1, CRm)
|
||||
#endif
|
||||
|
||||
#endif // __ARM_FEATURE_COPROC
|
||||
|
||||
/* 17 Transactional Memory Extension (TME) Intrinsics */
|
||||
#if defined(__ARM_FEATURE_TME) && __ARM_FEATURE_TME
|
||||
|
||||
#define _TMFAILURE_REASON 0x00007fffu
|
||||
#define _TMFAILURE_RTRY 0x00008000u
|
||||
#define _TMFAILURE_CNCL 0x00010000u
|
||||
#define _TMFAILURE_MEM 0x00020000u
|
||||
#define _TMFAILURE_IMP 0x00040000u
|
||||
#define _TMFAILURE_ERR 0x00080000u
|
||||
#define _TMFAILURE_SIZE 0x00100000u
|
||||
#define _TMFAILURE_NEST 0x00200000u
|
||||
#define _TMFAILURE_DBG 0x00400000u
|
||||
#define _TMFAILURE_INT 0x00800000u
|
||||
#define _TMFAILURE_TRIVIAL 0x01000000u
|
||||
|
||||
#define __tstart() __builtin_arm_tstart()
|
||||
#define __tcommit() __builtin_arm_tcommit()
|
||||
#define __tcancel(__arg) __builtin_arm_tcancel(__arg)
|
||||
#define __ttest() __builtin_arm_ttest()
|
||||
|
||||
#endif /* __ARM_FEATURE_TME */
|
||||
|
||||
/* 8.7 Armv8.5-A Random number generation intrinsics */
|
||||
#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
|
||||
static __inline__ int __attribute__((__always_inline__, __nodebug__, target("rand")))
|
||||
__rndr(uint64_t *__p) {
|
||||
return __builtin_arm_rndr(__p);
|
||||
}
|
||||
static __inline__ int __attribute__((__always_inline__, __nodebug__, target("rand")))
|
||||
__rndrrs(uint64_t *__p) {
|
||||
return __builtin_arm_rndrrs(__p);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 11.2 Guarded Control Stack intrinsics */
|
||||
#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
|
||||
static __inline__ void * __attribute__((__always_inline__, __nodebug__))
|
||||
__gcspr() {
|
||||
return (void *)__builtin_arm_rsr64("gcspr_el0");
|
||||
}
|
||||
|
||||
static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__, target("gcs")))
|
||||
__gcspopm() {
|
||||
return __builtin_arm_gcspopm(0);
|
||||
}
|
||||
|
||||
static __inline__ const void * __attribute__((__always_inline__, __nodebug__, target("gcs")))
|
||||
__gcsss(const void *__stack) {
|
||||
return __builtin_arm_gcsss(__stack);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __ARM_ACLE_H */
|
||||
20
third_party/aarch64/clang/arm_bf16.h
vendored
Normal file
20
third_party/aarch64/clang/arm_bf16.h
vendored
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
/*===---- arm_bf16.h - ARM BF16 intrinsics -----------------------------------===
|
||||
*
|
||||
*
|
||||
* 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
|
||||
*
|
||||
*===-----------------------------------------------------------------------===
|
||||
*/
|
||||
|
||||
#ifndef __ARM_BF16_H
|
||||
#define __ARM_BF16_H
|
||||
|
||||
typedef __bf16 bfloat16_t;
|
||||
#define __ai static __inline__ __attribute__((__always_inline__, __nodebug__))
|
||||
|
||||
|
||||
#undef __ai
|
||||
|
||||
#endif
|
||||
410
third_party/aarch64/clang/arm_cde.h
vendored
Normal file
410
third_party/aarch64/clang/arm_cde.h
vendored
Normal file
|
|
@ -0,0 +1,410 @@
|
|||
/*===---- arm_cde.h - ARM CDE intrinsics -----------------------------------===
|
||||
*
|
||||
*
|
||||
* 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
|
||||
*
|
||||
*===-----------------------------------------------------------------------===
|
||||
*/
|
||||
|
||||
#ifndef __ARM_CDE_H
|
||||
#define __ARM_CDE_H
|
||||
|
||||
#if !__ARM_FEATURE_CDE
|
||||
#error "CDE support not enabled"
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx1)))
|
||||
uint32_t __arm_cx1(int, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx1a)))
|
||||
uint32_t __arm_cx1a(int, uint32_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx1d)))
|
||||
uint64_t __arm_cx1d(int, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx1da)))
|
||||
uint64_t __arm_cx1da(int, uint64_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx2)))
|
||||
uint32_t __arm_cx2(int, uint32_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx2a)))
|
||||
uint32_t __arm_cx2a(int, uint32_t, uint32_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx2d)))
|
||||
uint64_t __arm_cx2d(int, uint32_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx2da)))
|
||||
uint64_t __arm_cx2da(int, uint64_t, uint32_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx3)))
|
||||
uint32_t __arm_cx3(int, uint32_t, uint32_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx3a)))
|
||||
uint32_t __arm_cx3a(int, uint32_t, uint32_t, uint32_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx3d)))
|
||||
uint64_t __arm_cx3d(int, uint32_t, uint32_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx3da)))
|
||||
uint64_t __arm_cx3da(int, uint64_t, uint32_t, uint32_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx1_u32)))
|
||||
uint32_t __arm_vcx1_u32(int, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx1a_u32)))
|
||||
uint32_t __arm_vcx1a_u32(int, uint32_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx1d_u64)))
|
||||
uint64_t __arm_vcx1d_u64(int, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx1da_u64)))
|
||||
uint64_t __arm_vcx1da_u64(int, uint64_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx2_u32)))
|
||||
uint32_t __arm_vcx2_u32(int, uint32_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx2a_u32)))
|
||||
uint32_t __arm_vcx2a_u32(int, uint32_t, uint32_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx2d_u64)))
|
||||
uint64_t __arm_vcx2d_u64(int, uint64_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx2da_u64)))
|
||||
uint64_t __arm_vcx2da_u64(int, uint64_t, uint64_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx3_u32)))
|
||||
uint32_t __arm_vcx3_u32(int, uint32_t, uint32_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx3a_u32)))
|
||||
uint32_t __arm_vcx3a_u32(int, uint32_t, uint32_t, uint32_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx3d_u64)))
|
||||
uint64_t __arm_vcx3d_u64(int, uint64_t, uint64_t, uint32_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx3da_u64)))
|
||||
uint64_t __arm_vcx3da_u64(int, uint64_t, uint64_t, uint64_t, uint32_t);
|
||||
|
||||
#if __ARM_FEATURE_MVE
|
||||
|
||||
typedef uint16_t mve_pred16_t;
|
||||
typedef __attribute__((__neon_vector_type__(8), __clang_arm_mve_strict_polymorphism)) int16_t int16x8_t;
|
||||
typedef __attribute__((__neon_vector_type__(4), __clang_arm_mve_strict_polymorphism)) int32_t int32x4_t;
|
||||
typedef __attribute__((__neon_vector_type__(2), __clang_arm_mve_strict_polymorphism)) int64_t int64x2_t;
|
||||
typedef __attribute__((__neon_vector_type__(16), __clang_arm_mve_strict_polymorphism)) int8_t int8x16_t;
|
||||
typedef __attribute__((__neon_vector_type__(8), __clang_arm_mve_strict_polymorphism)) uint16_t uint16x8_t;
|
||||
typedef __attribute__((__neon_vector_type__(4), __clang_arm_mve_strict_polymorphism)) uint32_t uint32x4_t;
|
||||
typedef __attribute__((__neon_vector_type__(2), __clang_arm_mve_strict_polymorphism)) uint64_t uint64x2_t;
|
||||
typedef __attribute__((__neon_vector_type__(16), __clang_arm_mve_strict_polymorphism)) uint8_t uint8x16_t;
|
||||
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_s16)))
|
||||
int16x8_t __arm_vcx1q_m(int, int16x8_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_s32)))
|
||||
int32x4_t __arm_vcx1q_m(int, int32x4_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_s64)))
|
||||
int64x2_t __arm_vcx1q_m(int, int64x2_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_s8)))
|
||||
int8x16_t __arm_vcx1q_m(int, int8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_u16)))
|
||||
uint16x8_t __arm_vcx1q_m(int, uint16x8_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_u32)))
|
||||
uint32x4_t __arm_vcx1q_m(int, uint32x4_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_u64)))
|
||||
uint64x2_t __arm_vcx1q_m(int, uint64x2_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_u8)))
|
||||
uint8x16_t __arm_vcx1q_m(int, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_u8)))
|
||||
uint8x16_t __arm_vcx1q_u8(int, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_s16)))
|
||||
int16x8_t __arm_vcx1qa_m(int, int16x8_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_s32)))
|
||||
int32x4_t __arm_vcx1qa_m(int, int32x4_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_s64)))
|
||||
int64x2_t __arm_vcx1qa_m(int, int64x2_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_s8)))
|
||||
int8x16_t __arm_vcx1qa_m(int, int8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_u16)))
|
||||
uint16x8_t __arm_vcx1qa_m(int, uint16x8_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_u32)))
|
||||
uint32x4_t __arm_vcx1qa_m(int, uint32x4_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_u64)))
|
||||
uint64x2_t __arm_vcx1qa_m(int, uint64x2_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_u8)))
|
||||
uint8x16_t __arm_vcx1qa_m(int, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_s16)))
|
||||
int16x8_t __arm_vcx1qa(int, int16x8_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_s32)))
|
||||
int32x4_t __arm_vcx1qa(int, int32x4_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_s64)))
|
||||
int64x2_t __arm_vcx1qa(int, int64x2_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_s8)))
|
||||
int8x16_t __arm_vcx1qa(int, int8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_u16)))
|
||||
uint16x8_t __arm_vcx1qa(int, uint16x8_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_u32)))
|
||||
uint32x4_t __arm_vcx1qa(int, uint32x4_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_u64)))
|
||||
uint64x2_t __arm_vcx1qa(int, uint64x2_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_u8)))
|
||||
uint8x16_t __arm_vcx1qa(int, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_s16)))
|
||||
int16x8_t __arm_vcx2q_m_impl(int, int16x8_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_s32)))
|
||||
int32x4_t __arm_vcx2q_m_impl(int, int32x4_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_s64)))
|
||||
int64x2_t __arm_vcx2q_m_impl(int, int64x2_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_s8)))
|
||||
int8x16_t __arm_vcx2q_m_impl(int, int8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_u16)))
|
||||
uint16x8_t __arm_vcx2q_m_impl(int, uint16x8_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_u32)))
|
||||
uint32x4_t __arm_vcx2q_m_impl(int, uint32x4_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_u64)))
|
||||
uint64x2_t __arm_vcx2q_m_impl(int, uint64x2_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_u8)))
|
||||
uint8x16_t __arm_vcx2q_m_impl(int, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_s16)))
|
||||
int16x8_t __arm_vcx2q(int, int16x8_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_s32)))
|
||||
int32x4_t __arm_vcx2q(int, int32x4_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_s64)))
|
||||
int64x2_t __arm_vcx2q(int, int64x2_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_s8)))
|
||||
int8x16_t __arm_vcx2q(int, int8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u16)))
|
||||
uint16x8_t __arm_vcx2q(int, uint16x8_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u32)))
|
||||
uint32x4_t __arm_vcx2q(int, uint32x4_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u64)))
|
||||
uint64x2_t __arm_vcx2q(int, uint64x2_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8)))
|
||||
uint8x16_t __arm_vcx2q(int, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_s16)))
|
||||
uint8x16_t __arm_vcx2q_u8(int, int16x8_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_s32)))
|
||||
uint8x16_t __arm_vcx2q_u8(int, int32x4_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_s64)))
|
||||
uint8x16_t __arm_vcx2q_u8(int, int64x2_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_s8)))
|
||||
uint8x16_t __arm_vcx2q_u8(int, int8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_u16)))
|
||||
uint8x16_t __arm_vcx2q_u8(int, uint16x8_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_u32)))
|
||||
uint8x16_t __arm_vcx2q_u8(int, uint32x4_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_u64)))
|
||||
uint8x16_t __arm_vcx2q_u8(int, uint64x2_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_u8)))
|
||||
uint8x16_t __arm_vcx2q_u8(int, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_s16)))
|
||||
int16x8_t __arm_vcx2qa_impl(int, int16x8_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_s32)))
|
||||
int32x4_t __arm_vcx2qa_impl(int, int32x4_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_s64)))
|
||||
int64x2_t __arm_vcx2qa_impl(int, int64x2_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_s8)))
|
||||
int8x16_t __arm_vcx2qa_impl(int, int8x16_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_u16)))
|
||||
uint16x8_t __arm_vcx2qa_impl(int, uint16x8_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_u32)))
|
||||
uint32x4_t __arm_vcx2qa_impl(int, uint32x4_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_u64)))
|
||||
uint64x2_t __arm_vcx2qa_impl(int, uint64x2_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_u8)))
|
||||
uint8x16_t __arm_vcx2qa_impl(int, uint8x16_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_s16)))
|
||||
int16x8_t __arm_vcx2qa_m_impl(int, int16x8_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_s32)))
|
||||
int32x4_t __arm_vcx2qa_m_impl(int, int32x4_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_s64)))
|
||||
int64x2_t __arm_vcx2qa_m_impl(int, int64x2_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_s8)))
|
||||
int8x16_t __arm_vcx2qa_m_impl(int, int8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_u16)))
|
||||
uint16x8_t __arm_vcx2qa_m_impl(int, uint16x8_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_u32)))
|
||||
uint32x4_t __arm_vcx2qa_m_impl(int, uint32x4_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_u64)))
|
||||
uint64x2_t __arm_vcx2qa_m_impl(int, uint64x2_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_u8)))
|
||||
uint8x16_t __arm_vcx2qa_m_impl(int, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_s16)))
|
||||
int16x8_t __arm_vcx3q_impl(int, int16x8_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_s32)))
|
||||
int32x4_t __arm_vcx3q_impl(int, int32x4_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_s64)))
|
||||
int64x2_t __arm_vcx3q_impl(int, int64x2_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_s8)))
|
||||
int8x16_t __arm_vcx3q_impl(int, int8x16_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_u16)))
|
||||
uint16x8_t __arm_vcx3q_impl(int, uint16x8_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_u32)))
|
||||
uint32x4_t __arm_vcx3q_impl(int, uint32x4_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_u64)))
|
||||
uint64x2_t __arm_vcx3q_impl(int, uint64x2_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_u8)))
|
||||
uint8x16_t __arm_vcx3q_impl(int, uint8x16_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_s16)))
|
||||
int16x8_t __arm_vcx3q_m_impl(int, int16x8_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_s32)))
|
||||
int32x4_t __arm_vcx3q_m_impl(int, int32x4_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_s64)))
|
||||
int64x2_t __arm_vcx3q_m_impl(int, int64x2_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_s8)))
|
||||
int8x16_t __arm_vcx3q_m_impl(int, int8x16_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_u16)))
|
||||
uint16x8_t __arm_vcx3q_m_impl(int, uint16x8_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_u32)))
|
||||
uint32x4_t __arm_vcx3q_m_impl(int, uint32x4_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_u64)))
|
||||
uint64x2_t __arm_vcx3q_m_impl(int, uint64x2_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_u8)))
|
||||
uint8x16_t __arm_vcx3q_m_impl(int, uint8x16_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_s16)))
|
||||
uint8x16_t __arm_vcx3q_u8_impl(int, int16x8_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_s32)))
|
||||
uint8x16_t __arm_vcx3q_u8_impl(int, int32x4_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_s64)))
|
||||
uint8x16_t __arm_vcx3q_u8_impl(int, int64x2_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_s8)))
|
||||
uint8x16_t __arm_vcx3q_u8_impl(int, int8x16_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_u16)))
|
||||
uint8x16_t __arm_vcx3q_u8_impl(int, uint16x8_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_u32)))
|
||||
uint8x16_t __arm_vcx3q_u8_impl(int, uint32x4_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_u64)))
|
||||
uint8x16_t __arm_vcx3q_u8_impl(int, uint64x2_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_u8)))
|
||||
uint8x16_t __arm_vcx3q_u8_impl(int, uint8x16_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_s16)))
|
||||
int16x8_t __arm_vcx3qa_impl(int, int16x8_t, uint8x16_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_s32)))
|
||||
int32x4_t __arm_vcx3qa_impl(int, int32x4_t, uint8x16_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_s64)))
|
||||
int64x2_t __arm_vcx3qa_impl(int, int64x2_t, uint8x16_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_s8)))
|
||||
int8x16_t __arm_vcx3qa_impl(int, int8x16_t, uint8x16_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_u16)))
|
||||
uint16x8_t __arm_vcx3qa_impl(int, uint16x8_t, uint8x16_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_u32)))
|
||||
uint32x4_t __arm_vcx3qa_impl(int, uint32x4_t, uint8x16_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_u64)))
|
||||
uint64x2_t __arm_vcx3qa_impl(int, uint64x2_t, uint8x16_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_u8)))
|
||||
uint8x16_t __arm_vcx3qa_impl(int, uint8x16_t, uint8x16_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_s16)))
|
||||
int16x8_t __arm_vcx3qa_m_impl(int, int16x8_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_s32)))
|
||||
int32x4_t __arm_vcx3qa_m_impl(int, int32x4_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_s64)))
|
||||
int64x2_t __arm_vcx3qa_m_impl(int, int64x2_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_s8)))
|
||||
int8x16_t __arm_vcx3qa_m_impl(int, int8x16_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_u16)))
|
||||
uint16x8_t __arm_vcx3qa_m_impl(int, uint16x8_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_u32)))
|
||||
uint32x4_t __arm_vcx3qa_m_impl(int, uint32x4_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_u64)))
|
||||
uint64x2_t __arm_vcx3qa_m_impl(int, uint64x2_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_u8)))
|
||||
uint8x16_t __arm_vcx3qa_m_impl(int, uint8x16_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u8)))
|
||||
int16x8_t __arm_vreinterpretq_s16_u8(uint8x16_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u8)))
|
||||
int32x4_t __arm_vreinterpretq_s32_u8(uint8x16_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u8)))
|
||||
int64x2_t __arm_vreinterpretq_s64_u8(uint8x16_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u8)))
|
||||
int8x16_t __arm_vreinterpretq_s8_u8(uint8x16_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_u8)))
|
||||
uint16x8_t __arm_vreinterpretq_u16_u8(uint8x16_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_u8)))
|
||||
uint32x4_t __arm_vreinterpretq_u32_u8(uint8x16_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_u8)))
|
||||
uint64x2_t __arm_vreinterpretq_u64_u8(uint8x16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s16)))
|
||||
uint8x16_t __arm_vreinterpretq_u8(int16x8_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s32)))
|
||||
uint8x16_t __arm_vreinterpretq_u8(int32x4_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s64)))
|
||||
uint8x16_t __arm_vreinterpretq_u8(int64x2_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s8)))
|
||||
uint8x16_t __arm_vreinterpretq_u8(int8x16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u16)))
|
||||
uint8x16_t __arm_vreinterpretq_u8(uint16x8_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u32)))
|
||||
uint8x16_t __arm_vreinterpretq_u8(uint32x4_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u64)))
|
||||
uint8x16_t __arm_vreinterpretq_u8(uint64x2_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vreinterpretq_u8_u8)))
|
||||
uint8x16_t __arm_vreinterpretq_u8(uint8x16_t);
|
||||
#define __arm_vcx2q_m(cp, inactive, n, imm, pred) __arm_vcx2q_m_impl((cp), (inactive), __arm_vreinterpretq_u8(n), (imm), (pred))
|
||||
#define __arm_vcx2qa(cp, acc, n, imm) __arm_vcx2qa_impl((cp), (acc), __arm_vreinterpretq_u8(n), (imm))
|
||||
#define __arm_vcx2qa_m(cp, acc, n, imm, pred) __arm_vcx2qa_m_impl((cp), (acc), __arm_vreinterpretq_u8(n), (imm), (pred))
|
||||
#define __arm_vcx3q(cp, n, m, imm) __arm_vcx3q_impl((cp), (n), __arm_vreinterpretq_u8(m), (imm))
|
||||
#define __arm_vcx3q_m(cp, inactive, n, m, imm, pred) __arm_vcx3q_m_impl((cp), (inactive), __arm_vreinterpretq_u8(n), __arm_vreinterpretq_u8(m), (imm), (pred))
|
||||
#define __arm_vcx3q_u8(cp, n, m, imm) __arm_vcx3q_u8_impl((cp), (n), __arm_vreinterpretq_u8(m), (imm))
|
||||
#define __arm_vcx3qa(cp, acc, n, m, imm) __arm_vcx3qa_impl((cp), (acc), __arm_vreinterpretq_u8(n), __arm_vreinterpretq_u8(m), (imm))
|
||||
#define __arm_vcx3qa_m(cp, acc, n, m, imm, pred) __arm_vcx3qa_m_impl((cp), (acc), __arm_vreinterpretq_u8(n), __arm_vreinterpretq_u8(m), (imm), (pred))
|
||||
|
||||
#endif /* __ARM_FEATURE_MVE */
|
||||
|
||||
#if __ARM_FEATURE_MVE & 2
|
||||
|
||||
typedef __fp16 float16_t;
|
||||
typedef float float32_t;
|
||||
typedef __attribute__((__neon_vector_type__(8), __clang_arm_mve_strict_polymorphism)) float16_t float16x8_t;
|
||||
typedef __attribute__((__neon_vector_type__(4), __clang_arm_mve_strict_polymorphism)) float32_t float32x4_t;
|
||||
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_f16)))
|
||||
float16x8_t __arm_vcx1q_m(int, float16x8_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_f32)))
|
||||
float32x4_t __arm_vcx1q_m(int, float32x4_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_f16)))
|
||||
float16x8_t __arm_vcx1qa(int, float16x8_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_f32)))
|
||||
float32x4_t __arm_vcx1qa(int, float32x4_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_f16)))
|
||||
float16x8_t __arm_vcx1qa_m(int, float16x8_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_f32)))
|
||||
float32x4_t __arm_vcx1qa_m(int, float32x4_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_f16)))
|
||||
float16x8_t __arm_vcx2q(int, float16x8_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_f32)))
|
||||
float32x4_t __arm_vcx2q(int, float32x4_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_f16)))
|
||||
float16x8_t __arm_vcx2q_m_impl(int, float16x8_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_f32)))
|
||||
float32x4_t __arm_vcx2q_m_impl(int, float32x4_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_f16)))
|
||||
uint8x16_t __arm_vcx2q_u8(int, float16x8_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_f32)))
|
||||
uint8x16_t __arm_vcx2q_u8(int, float32x4_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_f16)))
|
||||
float16x8_t __arm_vcx2qa_impl(int, float16x8_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_f32)))
|
||||
float32x4_t __arm_vcx2qa_impl(int, float32x4_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_f16)))
|
||||
float16x8_t __arm_vcx2qa_m_impl(int, float16x8_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_f32)))
|
||||
float32x4_t __arm_vcx2qa_m_impl(int, float32x4_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_f16)))
|
||||
float16x8_t __arm_vcx3q_impl(int, float16x8_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_f32)))
|
||||
float32x4_t __arm_vcx3q_impl(int, float32x4_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_f16)))
|
||||
float16x8_t __arm_vcx3q_m_impl(int, float16x8_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_f32)))
|
||||
float32x4_t __arm_vcx3q_m_impl(int, float32x4_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_f16)))
|
||||
uint8x16_t __arm_vcx3q_u8_impl(int, float16x8_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_f32)))
|
||||
uint8x16_t __arm_vcx3q_u8_impl(int, float32x4_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_f16)))
|
||||
float16x8_t __arm_vcx3qa_impl(int, float16x8_t, uint8x16_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_f32)))
|
||||
float32x4_t __arm_vcx3qa_impl(int, float32x4_t, uint8x16_t, uint8x16_t, uint32_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_f16)))
|
||||
float16x8_t __arm_vcx3qa_m_impl(int, float16x8_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_f32)))
|
||||
float32x4_t __arm_vcx3qa_m_impl(int, float32x4_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u8)))
|
||||
float16x8_t __arm_vreinterpretq_f16_u8(uint8x16_t);
|
||||
static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u8)))
|
||||
float32x4_t __arm_vreinterpretq_f32_u8(uint8x16_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_f16)))
|
||||
uint8x16_t __arm_vreinterpretq_u8(float16x8_t);
|
||||
static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_f32)))
|
||||
uint8x16_t __arm_vreinterpretq_u8(float32x4_t);
|
||||
|
||||
#endif /* __ARM_FEATURE_MVE & 2 */
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* __ARM_CDE_H */
|
||||
217
third_party/aarch64/clang/arm_cmse.h
vendored
Normal file
217
third_party/aarch64/clang/arm_cmse.h
vendored
Normal file
|
|
@ -0,0 +1,217 @@
|
|||
//===---- arm_cmse.h - Arm CMSE support -----------------------------------===//
|
||||
//
|
||||
// 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef __ARM_CMSE_H
|
||||
#define __ARM_CMSE_H
|
||||
|
||||
#if (__ARM_FEATURE_CMSE & 0x1)
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#define __ARM_CMSE_SECURE_MODE (__ARM_FEATURE_CMSE & 0x2)
|
||||
#define CMSE_MPU_READWRITE 1 /* checks if readwrite_ok field is set */
|
||||
#define CMSE_AU_NONSECURE 2 /* checks if permissions have secure field unset */
|
||||
#define CMSE_MPU_UNPRIV 4 /* sets T flag on TT insrtuction */
|
||||
#define CMSE_MPU_READ 8 /* checks if read_ok field is set */
|
||||
#define CMSE_MPU_NONSECURE 16 /* sets A flag, checks if secure field unset */
|
||||
#define CMSE_NONSECURE (CMSE_AU_NONSECURE | CMSE_MPU_NONSECURE)
|
||||
|
||||
#define cmse_check_pointed_object(p, f) \
|
||||
cmse_check_address_range((p), sizeof(*(p)), (f))
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef union {
|
||||
struct cmse_address_info {
|
||||
#ifdef __ARM_BIG_ENDIAN
|
||||
/* __ARM_BIG_ENDIAN */
|
||||
#if (__ARM_CMSE_SECURE_MODE)
|
||||
unsigned idau_region : 8;
|
||||
unsigned idau_region_valid : 1;
|
||||
unsigned secure : 1;
|
||||
unsigned nonsecure_readwrite_ok : 1;
|
||||
unsigned nonsecure_read_ok : 1;
|
||||
#else
|
||||
unsigned : 12;
|
||||
#endif
|
||||
unsigned readwrite_ok : 1;
|
||||
unsigned read_ok : 1;
|
||||
#if (__ARM_CMSE_SECURE_MODE)
|
||||
unsigned sau_region_valid : 1;
|
||||
#else
|
||||
unsigned : 1;
|
||||
#endif
|
||||
unsigned mpu_region_valid : 1;
|
||||
#if (__ARM_CMSE_SECURE_MODE)
|
||||
unsigned sau_region : 8;
|
||||
#else
|
||||
unsigned : 8;
|
||||
#endif
|
||||
unsigned mpu_region : 8;
|
||||
|
||||
#else /* __ARM_LITTLE_ENDIAN */
|
||||
unsigned mpu_region : 8;
|
||||
#if (__ARM_CMSE_SECURE_MODE)
|
||||
unsigned sau_region : 8;
|
||||
#else
|
||||
unsigned : 8;
|
||||
#endif
|
||||
unsigned mpu_region_valid : 1;
|
||||
#if (__ARM_CMSE_SECURE_MODE)
|
||||
unsigned sau_region_valid : 1;
|
||||
#else
|
||||
unsigned : 1;
|
||||
#endif
|
||||
unsigned read_ok : 1;
|
||||
unsigned readwrite_ok : 1;
|
||||
#if (__ARM_CMSE_SECURE_MODE)
|
||||
unsigned nonsecure_read_ok : 1;
|
||||
unsigned nonsecure_readwrite_ok : 1;
|
||||
unsigned secure : 1;
|
||||
unsigned idau_region_valid : 1;
|
||||
unsigned idau_region : 8;
|
||||
#else
|
||||
unsigned : 12;
|
||||
#endif
|
||||
#endif /*__ARM_LITTLE_ENDIAN */
|
||||
} flags;
|
||||
unsigned value;
|
||||
} cmse_address_info_t;
|
||||
|
||||
static cmse_address_info_t __attribute__((__always_inline__, __nodebug__))
|
||||
cmse_TT(void *__p) {
|
||||
cmse_address_info_t __u;
|
||||
__u.value = __builtin_arm_cmse_TT(__p);
|
||||
return __u;
|
||||
}
|
||||
static cmse_address_info_t __attribute__((__always_inline__, __nodebug__))
|
||||
cmse_TTT(void *__p) {
|
||||
cmse_address_info_t __u;
|
||||
__u.value = __builtin_arm_cmse_TTT(__p);
|
||||
return __u;
|
||||
}
|
||||
|
||||
#if __ARM_CMSE_SECURE_MODE
|
||||
static cmse_address_info_t __attribute__((__always_inline__, __nodebug__))
|
||||
cmse_TTA(void *__p) {
|
||||
cmse_address_info_t __u;
|
||||
__u.value = __builtin_arm_cmse_TTA(__p);
|
||||
return __u;
|
||||
}
|
||||
static cmse_address_info_t __attribute__((__always_inline__, __nodebug__))
|
||||
cmse_TTAT(void *__p) {
|
||||
cmse_address_info_t __u;
|
||||
__u.value = __builtin_arm_cmse_TTAT(__p);
|
||||
return __u;
|
||||
}
|
||||
#endif
|
||||
|
||||
#define cmse_TT_fptr(p) cmse_TT(__builtin_bit_cast(void *, (p)))
|
||||
#define cmse_TTT_fptr(p) cmse_TTT(__builtin_bit_cast(void *, (p)))
|
||||
|
||||
#if __ARM_CMSE_SECURE_MODE
|
||||
#define cmse_TTA_fptr(p) cmse_TTA(__builtin_bit_cast(void *, (p)))
|
||||
#define cmse_TTAT_fptr(p) cmse_TTAT(__builtin_bit_cast(void *, (p)))
|
||||
#endif
|
||||
|
||||
static void *__attribute__((__always_inline__))
|
||||
cmse_check_address_range(void *__pb, size_t __s, int __flags) {
|
||||
uintptr_t __begin = (uintptr_t)__pb;
|
||||
uintptr_t __end = __begin + __s - 1;
|
||||
|
||||
if (__end < __begin)
|
||||
return NULL; /* wrap around check */
|
||||
|
||||
/* Check whether the range crosses a 32-bytes aligned address */
|
||||
const int __single_check = (__begin ^ __end) < 0x20u;
|
||||
|
||||
/* execute the right variant of the TT instructions */
|
||||
void *__pe = (void *)__end;
|
||||
cmse_address_info_t __permb, __perme;
|
||||
switch (__flags & (CMSE_MPU_UNPRIV | CMSE_MPU_NONSECURE)) {
|
||||
case 0:
|
||||
__permb = cmse_TT(__pb);
|
||||
__perme = __single_check ? __permb : cmse_TT(__pe);
|
||||
break;
|
||||
case CMSE_MPU_UNPRIV:
|
||||
__permb = cmse_TTT(__pb);
|
||||
__perme = __single_check ? __permb : cmse_TTT(__pe);
|
||||
break;
|
||||
#if __ARM_CMSE_SECURE_MODE
|
||||
case CMSE_MPU_NONSECURE:
|
||||
__permb = cmse_TTA(__pb);
|
||||
__perme = __single_check ? __permb : cmse_TTA(__pe);
|
||||
break;
|
||||
case CMSE_MPU_UNPRIV | CMSE_MPU_NONSECURE:
|
||||
__permb = cmse_TTAT(__pb);
|
||||
__perme = __single_check ? __permb : cmse_TTAT(__pe);
|
||||
break;
|
||||
#endif
|
||||
/* if CMSE_NONSECURE is specified w/o __ARM_CMSE_SECURE_MODE */
|
||||
default:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* check that the range does not cross MPU, SAU, or IDAU region boundaries */
|
||||
if (__permb.value != __perme.value)
|
||||
return NULL;
|
||||
#if !(__ARM_CMSE_SECURE_MODE)
|
||||
/* CMSE_AU_NONSECURE is only supported when __ARM_FEATURE_CMSE & 0x2 */
|
||||
if (__flags & CMSE_AU_NONSECURE)
|
||||
return NULL;
|
||||
#endif
|
||||
|
||||
/* check the permission on the range */
|
||||
switch (__flags & ~(CMSE_MPU_UNPRIV | CMSE_MPU_NONSECURE)) {
|
||||
#if (__ARM_CMSE_SECURE_MODE)
|
||||
case CMSE_MPU_READ | CMSE_MPU_READWRITE | CMSE_AU_NONSECURE:
|
||||
case CMSE_MPU_READWRITE | CMSE_AU_NONSECURE:
|
||||
return __permb.flags.nonsecure_readwrite_ok ? __pb : NULL;
|
||||
|
||||
case CMSE_MPU_READ | CMSE_AU_NONSECURE:
|
||||
return __permb.flags.nonsecure_read_ok ? __pb : NULL;
|
||||
|
||||
case CMSE_AU_NONSECURE:
|
||||
return __permb.flags.secure ? NULL : __pb;
|
||||
#endif
|
||||
case CMSE_MPU_READ | CMSE_MPU_READWRITE:
|
||||
case CMSE_MPU_READWRITE:
|
||||
return __permb.flags.readwrite_ok ? __pb : NULL;
|
||||
|
||||
case CMSE_MPU_READ:
|
||||
return __permb.flags.read_ok ? __pb : NULL;
|
||||
|
||||
default:
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
#if __ARM_CMSE_SECURE_MODE
|
||||
static int __attribute__((__always_inline__, __nodebug__))
|
||||
cmse_nonsecure_caller(void) {
|
||||
return !((uintptr_t)__builtin_return_address(0) & 1);
|
||||
}
|
||||
|
||||
#define cmse_nsfptr_create(p) \
|
||||
__builtin_bit_cast(__typeof__(p), \
|
||||
(__builtin_bit_cast(uintptr_t, p) & ~(uintptr_t)1))
|
||||
|
||||
#define cmse_is_nsfptr(p) ((__builtin_bit_cast(uintptr_t, p) & 1) == 0)
|
||||
|
||||
#endif /* __ARM_CMSE_SECURE_MODE */
|
||||
|
||||
void __attribute__((__noreturn__)) cmse_abort(void);
|
||||
#if defined(__cplusplus)
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* (__ARM_FEATURE_CMSE & 0x1) */
|
||||
|
||||
#endif /* __ARM_CMSE_H */
|
||||
596
third_party/aarch64/clang/arm_fp16.h
vendored
Normal file
596
third_party/aarch64/clang/arm_fp16.h
vendored
Normal file
|
|
@ -0,0 +1,596 @@
|
|||
/*===---- arm_fp16.h - ARM FP16 intrinsics ---------------------------------===
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*
|
||||
*===-----------------------------------------------------------------------===
|
||||
*/
|
||||
|
||||
#ifndef __ARM_FP16_H
|
||||
#define __ARM_FP16_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
typedef __fp16 float16_t;
|
||||
#define __ai static __inline__ __attribute__((__always_inline__, __nodebug__))
|
||||
|
||||
#if defined(__aarch64__) || defined(__arm64ec__)
|
||||
#define vabdh_f16(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (float16_t) __builtin_neon_vabdh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vabsh_f16(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vabsh_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vaddh_f16(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (float16_t) __builtin_neon_vaddh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcageh_f16(__p0, __p1) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (uint16_t) __builtin_neon_vcageh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcagth_f16(__p0, __p1) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (uint16_t) __builtin_neon_vcagth_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcaleh_f16(__p0, __p1) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (uint16_t) __builtin_neon_vcaleh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcalth_f16(__p0, __p1) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (uint16_t) __builtin_neon_vcalth_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vceqh_f16(__p0, __p1) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (uint16_t) __builtin_neon_vceqh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vceqzh_f16(__p0) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint16_t) __builtin_neon_vceqzh_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcgeh_f16(__p0, __p1) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (uint16_t) __builtin_neon_vcgeh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcgezh_f16(__p0) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint16_t) __builtin_neon_vcgezh_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcgth_f16(__p0, __p1) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (uint16_t) __builtin_neon_vcgth_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcgtzh_f16(__p0) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint16_t) __builtin_neon_vcgtzh_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcleh_f16(__p0, __p1) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (uint16_t) __builtin_neon_vcleh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vclezh_f16(__p0) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint16_t) __builtin_neon_vclezh_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vclth_f16(__p0, __p1) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (uint16_t) __builtin_neon_vclth_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcltzh_f16(__p0) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint16_t) __builtin_neon_vcltzh_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_n_s16_f16(__p0, __p1) __extension__ ({ \
|
||||
int16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int16_t) __builtin_neon_vcvth_n_s16_f16(__s0, __p1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_n_s32_f16(__p0, __p1) __extension__ ({ \
|
||||
int32_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int32_t) __builtin_neon_vcvth_n_s32_f16(__s0, __p1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_n_s64_f16(__p0, __p1) __extension__ ({ \
|
||||
int64_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int64_t) __builtin_neon_vcvth_n_s64_f16(__s0, __p1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_n_u16_f16(__p0, __p1) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint16_t) __builtin_neon_vcvth_n_u16_f16(__s0, __p1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_n_u32_f16(__p0, __p1) __extension__ ({ \
|
||||
uint32_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint32_t) __builtin_neon_vcvth_n_u32_f16(__s0, __p1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_n_u64_f16(__p0, __p1) __extension__ ({ \
|
||||
uint64_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint64_t) __builtin_neon_vcvth_n_u64_f16(__s0, __p1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_s16_f16(__p0) __extension__ ({ \
|
||||
int16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int16_t) __builtin_neon_vcvth_s16_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_s32_f16(__p0) __extension__ ({ \
|
||||
int32_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int32_t) __builtin_neon_vcvth_s32_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_s64_f16(__p0) __extension__ ({ \
|
||||
int64_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int64_t) __builtin_neon_vcvth_s64_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_u16_f16(__p0) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint16_t) __builtin_neon_vcvth_u16_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_u32_f16(__p0) __extension__ ({ \
|
||||
uint32_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint32_t) __builtin_neon_vcvth_u32_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_u64_f16(__p0) __extension__ ({ \
|
||||
uint64_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint64_t) __builtin_neon_vcvth_u64_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtah_s16_f16(__p0) __extension__ ({ \
|
||||
int16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int16_t) __builtin_neon_vcvtah_s16_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtah_s32_f16(__p0) __extension__ ({ \
|
||||
int32_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int32_t) __builtin_neon_vcvtah_s32_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtah_s64_f16(__p0) __extension__ ({ \
|
||||
int64_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int64_t) __builtin_neon_vcvtah_s64_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtah_u16_f16(__p0) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint16_t) __builtin_neon_vcvtah_u16_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtah_u32_f16(__p0) __extension__ ({ \
|
||||
uint32_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint32_t) __builtin_neon_vcvtah_u32_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtah_u64_f16(__p0) __extension__ ({ \
|
||||
uint64_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint64_t) __builtin_neon_vcvtah_u64_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_f16_u16(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
uint16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vcvth_f16_u16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_f16_s16(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
int16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vcvth_f16_s16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_f16_u32(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
uint32_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vcvth_f16_u32(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_f16_s32(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
int32_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vcvth_f16_s32(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_f16_u64(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
uint64_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vcvth_f16_u64(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_f16_s64(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
int64_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vcvth_f16_s64(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_n_f16_u32(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
uint32_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vcvth_n_f16_u32(__s0, __p1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_n_f16_s32(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
int32_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vcvth_n_f16_s32(__s0, __p1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_n_f16_u64(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
uint64_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vcvth_n_f16_u64(__s0, __p1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_n_f16_s64(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
int64_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vcvth_n_f16_s64(__s0, __p1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_n_f16_u16(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
uint16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vcvth_n_f16_u16(__s0, __p1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvth_n_f16_s16(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
int16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vcvth_n_f16_s16(__s0, __p1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtmh_s16_f16(__p0) __extension__ ({ \
|
||||
int16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int16_t) __builtin_neon_vcvtmh_s16_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtmh_s32_f16(__p0) __extension__ ({ \
|
||||
int32_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int32_t) __builtin_neon_vcvtmh_s32_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtmh_s64_f16(__p0) __extension__ ({ \
|
||||
int64_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int64_t) __builtin_neon_vcvtmh_s64_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtmh_u16_f16(__p0) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint16_t) __builtin_neon_vcvtmh_u16_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtmh_u32_f16(__p0) __extension__ ({ \
|
||||
uint32_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint32_t) __builtin_neon_vcvtmh_u32_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtmh_u64_f16(__p0) __extension__ ({ \
|
||||
uint64_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint64_t) __builtin_neon_vcvtmh_u64_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtnh_s16_f16(__p0) __extension__ ({ \
|
||||
int16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int16_t) __builtin_neon_vcvtnh_s16_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtnh_s32_f16(__p0) __extension__ ({ \
|
||||
int32_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int32_t) __builtin_neon_vcvtnh_s32_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtnh_s64_f16(__p0) __extension__ ({ \
|
||||
int64_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int64_t) __builtin_neon_vcvtnh_s64_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtnh_u16_f16(__p0) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint16_t) __builtin_neon_vcvtnh_u16_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtnh_u32_f16(__p0) __extension__ ({ \
|
||||
uint32_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint32_t) __builtin_neon_vcvtnh_u32_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtnh_u64_f16(__p0) __extension__ ({ \
|
||||
uint64_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint64_t) __builtin_neon_vcvtnh_u64_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtph_s16_f16(__p0) __extension__ ({ \
|
||||
int16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int16_t) __builtin_neon_vcvtph_s16_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtph_s32_f16(__p0) __extension__ ({ \
|
||||
int32_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int32_t) __builtin_neon_vcvtph_s32_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtph_s64_f16(__p0) __extension__ ({ \
|
||||
int64_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (int64_t) __builtin_neon_vcvtph_s64_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtph_u16_f16(__p0) __extension__ ({ \
|
||||
uint16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint16_t) __builtin_neon_vcvtph_u16_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtph_u32_f16(__p0) __extension__ ({ \
|
||||
uint32_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint32_t) __builtin_neon_vcvtph_u32_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vcvtph_u64_f16(__p0) __extension__ ({ \
|
||||
uint64_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (uint64_t) __builtin_neon_vcvtph_u64_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vdivh_f16(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (float16_t) __builtin_neon_vdivh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vfmah_f16(__p0, __p1, __p2) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
float16_t __s2 = __p2; \
|
||||
__ret = (float16_t) __builtin_neon_vfmah_f16(__s0, __s1, __s2); \
|
||||
__ret; \
|
||||
})
|
||||
#define vfmsh_f16(__p0, __p1, __p2) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
float16_t __s2 = __p2; \
|
||||
__ret = (float16_t) __builtin_neon_vfmsh_f16(__s0, __s1, __s2); \
|
||||
__ret; \
|
||||
})
|
||||
#define vmaxh_f16(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (float16_t) __builtin_neon_vmaxh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vmaxnmh_f16(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (float16_t) __builtin_neon_vmaxnmh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vminh_f16(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (float16_t) __builtin_neon_vminh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vminnmh_f16(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (float16_t) __builtin_neon_vminnmh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vmulh_f16(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (float16_t) __builtin_neon_vmulh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vmulxh_f16(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (float16_t) __builtin_neon_vmulxh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vnegh_f16(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vnegh_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vrecpeh_f16(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vrecpeh_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vrecpsh_f16(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (float16_t) __builtin_neon_vrecpsh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vrecpxh_f16(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vrecpxh_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vrndh_f16(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vrndh_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vrndah_f16(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vrndah_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vrndih_f16(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vrndih_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vrndmh_f16(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vrndmh_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vrndnh_f16(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vrndnh_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vrndph_f16(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vrndph_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vrndxh_f16(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vrndxh_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vrsqrteh_f16(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vrsqrteh_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vrsqrtsh_f16(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (float16_t) __builtin_neon_vrsqrtsh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#define vsqrth_f16(__p0) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
__ret = (float16_t) __builtin_neon_vsqrth_f16(__s0); \
|
||||
__ret; \
|
||||
})
|
||||
#define vsubh_f16(__p0, __p1) __extension__ ({ \
|
||||
float16_t __ret; \
|
||||
float16_t __s0 = __p0; \
|
||||
float16_t __s1 = __p1; \
|
||||
__ret = (float16_t) __builtin_neon_vsubh_f16(__s0, __s1); \
|
||||
__ret; \
|
||||
})
|
||||
#endif
|
||||
|
||||
#undef __ai
|
||||
|
||||
#endif /* __ARM_FP16_H */
|
||||
19187
third_party/aarch64/clang/arm_mve.h
vendored
Normal file
19187
third_party/aarch64/clang/arm_mve.h
vendored
Normal file
File diff suppressed because it is too large
Load diff
69638
third_party/aarch64/clang/arm_neon.h
vendored
Normal file
69638
third_party/aarch64/clang/arm_neon.h
vendored
Normal file
File diff suppressed because it is too large
Load diff
182
third_party/aarch64/clang/arm_neon_sve_bridge.h
vendored
Normal file
182
third_party/aarch64/clang/arm_neon_sve_bridge.h
vendored
Normal file
|
|
@ -0,0 +1,182 @@
|
|||
/*===---- arm_neon_sve_bridge.h - ARM NEON SVE Bridge intrinsics -----------===
|
||||
*
|
||||
*
|
||||
* 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
|
||||
*
|
||||
*===-----------------------------------------------------------------------===
|
||||
*/
|
||||
|
||||
#ifndef __ARM_NEON_SVE_BRIDGE_H
|
||||
#define __ARM_NEON_SVE_BRIDGE_H
|
||||
|
||||
#include <arm_neon.h>
|
||||
#include <arm_sve.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Function attributes */
|
||||
#define __ai static __inline__ __attribute__((__always_inline__, __nodebug__))
|
||||
#define __aio \
|
||||
static __inline__ \
|
||||
__attribute__((__always_inline__, __nodebug__, __overloadable__))
|
||||
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_s8)))
|
||||
svint8_t svset_neonq(svint8_t, int8x16_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_s16)))
|
||||
svint16_t svset_neonq(svint16_t, int16x8_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_s32)))
|
||||
svint32_t svset_neonq(svint32_t, int32x4_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_s64)))
|
||||
svint64_t svset_neonq(svint64_t, int64x2_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_u8)))
|
||||
svuint8_t svset_neonq(svuint8_t, uint8x16_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_u16)))
|
||||
svuint16_t svset_neonq(svuint16_t, uint16x8_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_u32)))
|
||||
svuint32_t svset_neonq(svuint32_t, uint32x4_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_u64)))
|
||||
svuint64_t svset_neonq(svuint64_t, uint64x2_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_f16)))
|
||||
svfloat16_t svset_neonq(svfloat16_t, float16x8_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_f32)))
|
||||
svfloat32_t svset_neonq(svfloat32_t, float32x4_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_f64)))
|
||||
svfloat64_t svset_neonq(svfloat64_t, float64x2_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_s8)))
|
||||
svint8_t svset_neonq_s8(svint8_t, int8x16_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_s16)))
|
||||
svint16_t svset_neonq_s16(svint16_t, int16x8_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_s32)))
|
||||
svint32_t svset_neonq_s32(svint32_t, int32x4_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_s64)))
|
||||
svint64_t svset_neonq_s64(svint64_t, int64x2_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_u8)))
|
||||
svuint8_t svset_neonq_u8(svuint8_t, uint8x16_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_u16)))
|
||||
svuint16_t svset_neonq_u16(svuint16_t, uint16x8_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_u32)))
|
||||
svuint32_t svset_neonq_u32(svuint32_t, uint32x4_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_u64)))
|
||||
svuint64_t svset_neonq_u64(svuint64_t, uint64x2_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_f16)))
|
||||
svfloat16_t svset_neonq_f16(svfloat16_t, float16x8_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_f32)))
|
||||
svfloat32_t svset_neonq_f32(svfloat32_t, float32x4_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_f64)))
|
||||
svfloat64_t svset_neonq_f64(svfloat64_t, float64x2_t);
|
||||
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_s8)))
|
||||
int8x16_t svget_neonq(svint8_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_s16)))
|
||||
int16x8_t svget_neonq(svint16_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_s32)))
|
||||
int32x4_t svget_neonq(svint32_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_s64)))
|
||||
int64x2_t svget_neonq(svint64_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_u8)))
|
||||
uint8x16_t svget_neonq(svuint8_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_u16)))
|
||||
uint16x8_t svget_neonq(svuint16_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_u32)))
|
||||
uint32x4_t svget_neonq(svuint32_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_u64)))
|
||||
uint64x2_t svget_neonq(svuint64_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_f16)))
|
||||
float16x8_t svget_neonq(svfloat16_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_f32)))
|
||||
float32x4_t svget_neonq(svfloat32_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_f64)))
|
||||
float64x2_t svget_neonq(svfloat64_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_s8)))
|
||||
int8x16_t svget_neonq_s8(svint8_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_s16)))
|
||||
int16x8_t svget_neonq_s16(svint16_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_s32)))
|
||||
int32x4_t svget_neonq_s32(svint32_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_s64)))
|
||||
int64x2_t svget_neonq_s64(svint64_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_u8)))
|
||||
uint8x16_t svget_neonq_u8(svuint8_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_u16)))
|
||||
uint16x8_t svget_neonq_u16(svuint16_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_u32)))
|
||||
uint32x4_t svget_neonq_u32(svuint32_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_u64)))
|
||||
uint64x2_t svget_neonq_u64(svuint64_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_f16)))
|
||||
float16x8_t svget_neonq_f16(svfloat16_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_f32)))
|
||||
float32x4_t svget_neonq_f32(svfloat32_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_f64)))
|
||||
float64x2_t svget_neonq_f64(svfloat64_t);
|
||||
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_s8)))
|
||||
svint8_t svdup_neonq(int8x16_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_s16)))
|
||||
svint16_t svdup_neonq(int16x8_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_s32)))
|
||||
svint32_t svdup_neonq(int32x4_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_s64)))
|
||||
svint64_t svdup_neonq(int64x2_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_u8)))
|
||||
svuint8_t svdup_neonq(uint8x16_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_u16)))
|
||||
svuint16_t svdup_neonq(uint16x8_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_u32)))
|
||||
svuint32_t svdup_neonq(uint32x4_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_u64)))
|
||||
svuint64_t svdup_neonq(uint64x2_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_f16)))
|
||||
svfloat16_t svdup_neonq(float16x8_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_f32)))
|
||||
svfloat32_t svdup_neonq(float32x4_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_f64)))
|
||||
svfloat64_t svdup_neonq(float64x2_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_s8)))
|
||||
svint8_t svdup_neonq_s8(int8x16_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_s16)))
|
||||
svint16_t svdup_neonq_s16(int16x8_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_s32)))
|
||||
svint32_t svdup_neonq_s32(int32x4_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_s64)))
|
||||
svint64_t svdup_neonq_s64(int64x2_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_u8)))
|
||||
svuint8_t svdup_neonq_u8(uint8x16_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_u16)))
|
||||
svuint16_t svdup_neonq_u16(uint16x8_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_u32)))
|
||||
svuint32_t svdup_neonq_u32(uint32x4_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_u64)))
|
||||
svuint64_t svdup_neonq_u64(uint64x2_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_f16)))
|
||||
svfloat16_t svdup_neonq_f16(float16x8_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_f32)))
|
||||
svfloat32_t svdup_neonq_f32(float32x4_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_f64)))
|
||||
svfloat64_t svdup_neonq_f64(float64x2_t);
|
||||
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_bf16)))
|
||||
svbfloat16_t svset_neonq(svbfloat16_t, bfloat16x8_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_bf16)))
|
||||
svbfloat16_t svset_neonq_bf16(svbfloat16_t, bfloat16x8_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_bf16)))
|
||||
bfloat16x8_t svget_neonq(svbfloat16_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_bf16)))
|
||||
bfloat16x8_t svget_neonq_bf16(svbfloat16_t);
|
||||
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_bf16)))
|
||||
svbfloat16_t svdup_neonq(bfloat16x8_t);
|
||||
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_bf16)))
|
||||
svbfloat16_t svdup_neonq_bf16(bfloat16x8_t);
|
||||
|
||||
#undef __ai
|
||||
#undef __aio
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
#endif //__ARM_NEON_SVE_BRIDGE_H
|
||||
2819
third_party/aarch64/clang/arm_sme.h
vendored
Normal file
2819
third_party/aarch64/clang/arm_sme.h
vendored
Normal file
File diff suppressed because it is too large
Load diff
30537
third_party/aarch64/clang/arm_sve.h
vendored
Normal file
30537
third_party/aarch64/clang/arm_sve.h
vendored
Normal file
File diff suppressed because it is too large
Load diff
345
third_party/aarch64/clang/arm_vector_types.h
vendored
Normal file
345
third_party/aarch64/clang/arm_vector_types.h
vendored
Normal file
|
|
@ -0,0 +1,345 @@
|
|||
/*===---- arm_vector_types - ARM vector type ------===
|
||||
*
|
||||
*
|
||||
* 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(__ARM_NEON_H) && !defined(__ARM_SVE_H)
|
||||
#error "This file should not be used standalone. Please include arm_neon.h or arm_sve.h instead"
|
||||
|
||||
#endif
|
||||
#ifndef __ARM_NEON_TYPES_H
|
||||
#define __ARM_NEON_TYPES_H
|
||||
typedef float float32_t;
|
||||
typedef __fp16 float16_t;
|
||||
#if defined(__aarch64__) || defined(__arm64ec__)
|
||||
typedef double float64_t;
|
||||
#endif
|
||||
|
||||
typedef __attribute__((neon_vector_type(8))) int8_t int8x8_t;
|
||||
typedef __attribute__((neon_vector_type(16))) int8_t int8x16_t;
|
||||
typedef __attribute__((neon_vector_type(4))) int16_t int16x4_t;
|
||||
typedef __attribute__((neon_vector_type(8))) int16_t int16x8_t;
|
||||
typedef __attribute__((neon_vector_type(2))) int32_t int32x2_t;
|
||||
typedef __attribute__((neon_vector_type(4))) int32_t int32x4_t;
|
||||
typedef __attribute__((neon_vector_type(1))) int64_t int64x1_t;
|
||||
typedef __attribute__((neon_vector_type(2))) int64_t int64x2_t;
|
||||
typedef __attribute__((neon_vector_type(8))) uint8_t uint8x8_t;
|
||||
typedef __attribute__((neon_vector_type(16))) uint8_t uint8x16_t;
|
||||
typedef __attribute__((neon_vector_type(4))) uint16_t uint16x4_t;
|
||||
typedef __attribute__((neon_vector_type(8))) uint16_t uint16x8_t;
|
||||
typedef __attribute__((neon_vector_type(2))) uint32_t uint32x2_t;
|
||||
typedef __attribute__((neon_vector_type(4))) uint32_t uint32x4_t;
|
||||
typedef __attribute__((neon_vector_type(1))) uint64_t uint64x1_t;
|
||||
typedef __attribute__((neon_vector_type(2))) uint64_t uint64x2_t;
|
||||
typedef __attribute__((neon_vector_type(4))) float16_t float16x4_t;
|
||||
typedef __attribute__((neon_vector_type(8))) float16_t float16x8_t;
|
||||
typedef __attribute__((neon_vector_type(2))) float32_t float32x2_t;
|
||||
typedef __attribute__((neon_vector_type(4))) float32_t float32x4_t;
|
||||
#if defined(__aarch64__) || defined(__arm64ec__)
|
||||
typedef __attribute__((neon_vector_type(1))) float64_t float64x1_t;
|
||||
typedef __attribute__((neon_vector_type(2))) float64_t float64x2_t;
|
||||
#endif
|
||||
|
||||
typedef struct int8x8x2_t {
|
||||
int8x8_t val[2];
|
||||
} int8x8x2_t;
|
||||
|
||||
typedef struct int8x16x2_t {
|
||||
int8x16_t val[2];
|
||||
} int8x16x2_t;
|
||||
|
||||
typedef struct int16x4x2_t {
|
||||
int16x4_t val[2];
|
||||
} int16x4x2_t;
|
||||
|
||||
typedef struct int16x8x2_t {
|
||||
int16x8_t val[2];
|
||||
} int16x8x2_t;
|
||||
|
||||
typedef struct int32x2x2_t {
|
||||
int32x2_t val[2];
|
||||
} int32x2x2_t;
|
||||
|
||||
typedef struct int32x4x2_t {
|
||||
int32x4_t val[2];
|
||||
} int32x4x2_t;
|
||||
|
||||
typedef struct int64x1x2_t {
|
||||
int64x1_t val[2];
|
||||
} int64x1x2_t;
|
||||
|
||||
typedef struct int64x2x2_t {
|
||||
int64x2_t val[2];
|
||||
} int64x2x2_t;
|
||||
|
||||
typedef struct uint8x8x2_t {
|
||||
uint8x8_t val[2];
|
||||
} uint8x8x2_t;
|
||||
|
||||
typedef struct uint8x16x2_t {
|
||||
uint8x16_t val[2];
|
||||
} uint8x16x2_t;
|
||||
|
||||
typedef struct uint16x4x2_t {
|
||||
uint16x4_t val[2];
|
||||
} uint16x4x2_t;
|
||||
|
||||
typedef struct uint16x8x2_t {
|
||||
uint16x8_t val[2];
|
||||
} uint16x8x2_t;
|
||||
|
||||
typedef struct uint32x2x2_t {
|
||||
uint32x2_t val[2];
|
||||
} uint32x2x2_t;
|
||||
|
||||
typedef struct uint32x4x2_t {
|
||||
uint32x4_t val[2];
|
||||
} uint32x4x2_t;
|
||||
|
||||
typedef struct uint64x1x2_t {
|
||||
uint64x1_t val[2];
|
||||
} uint64x1x2_t;
|
||||
|
||||
typedef struct uint64x2x2_t {
|
||||
uint64x2_t val[2];
|
||||
} uint64x2x2_t;
|
||||
|
||||
typedef struct float16x4x2_t {
|
||||
float16x4_t val[2];
|
||||
} float16x4x2_t;
|
||||
|
||||
typedef struct float16x8x2_t {
|
||||
float16x8_t val[2];
|
||||
} float16x8x2_t;
|
||||
|
||||
typedef struct float32x2x2_t {
|
||||
float32x2_t val[2];
|
||||
} float32x2x2_t;
|
||||
|
||||
typedef struct float32x4x2_t {
|
||||
float32x4_t val[2];
|
||||
} float32x4x2_t;
|
||||
|
||||
#if defined(__aarch64__) || defined(__arm64ec__)
|
||||
typedef struct float64x1x2_t {
|
||||
float64x1_t val[2];
|
||||
} float64x1x2_t;
|
||||
|
||||
typedef struct float64x2x2_t {
|
||||
float64x2_t val[2];
|
||||
} float64x2x2_t;
|
||||
|
||||
#endif
|
||||
typedef struct int8x8x3_t {
|
||||
int8x8_t val[3];
|
||||
} int8x8x3_t;
|
||||
|
||||
typedef struct int8x16x3_t {
|
||||
int8x16_t val[3];
|
||||
} int8x16x3_t;
|
||||
|
||||
typedef struct int16x4x3_t {
|
||||
int16x4_t val[3];
|
||||
} int16x4x3_t;
|
||||
|
||||
typedef struct int16x8x3_t {
|
||||
int16x8_t val[3];
|
||||
} int16x8x3_t;
|
||||
|
||||
typedef struct int32x2x3_t {
|
||||
int32x2_t val[3];
|
||||
} int32x2x3_t;
|
||||
|
||||
typedef struct int32x4x3_t {
|
||||
int32x4_t val[3];
|
||||
} int32x4x3_t;
|
||||
|
||||
typedef struct int64x1x3_t {
|
||||
int64x1_t val[3];
|
||||
} int64x1x3_t;
|
||||
|
||||
typedef struct int64x2x3_t {
|
||||
int64x2_t val[3];
|
||||
} int64x2x3_t;
|
||||
|
||||
typedef struct uint8x8x3_t {
|
||||
uint8x8_t val[3];
|
||||
} uint8x8x3_t;
|
||||
|
||||
typedef struct uint8x16x3_t {
|
||||
uint8x16_t val[3];
|
||||
} uint8x16x3_t;
|
||||
|
||||
typedef struct uint16x4x3_t {
|
||||
uint16x4_t val[3];
|
||||
} uint16x4x3_t;
|
||||
|
||||
typedef struct uint16x8x3_t {
|
||||
uint16x8_t val[3];
|
||||
} uint16x8x3_t;
|
||||
|
||||
typedef struct uint32x2x3_t {
|
||||
uint32x2_t val[3];
|
||||
} uint32x2x3_t;
|
||||
|
||||
typedef struct uint32x4x3_t {
|
||||
uint32x4_t val[3];
|
||||
} uint32x4x3_t;
|
||||
|
||||
typedef struct uint64x1x3_t {
|
||||
uint64x1_t val[3];
|
||||
} uint64x1x3_t;
|
||||
|
||||
typedef struct uint64x2x3_t {
|
||||
uint64x2_t val[3];
|
||||
} uint64x2x3_t;
|
||||
|
||||
typedef struct float16x4x3_t {
|
||||
float16x4_t val[3];
|
||||
} float16x4x3_t;
|
||||
|
||||
typedef struct float16x8x3_t {
|
||||
float16x8_t val[3];
|
||||
} float16x8x3_t;
|
||||
|
||||
typedef struct float32x2x3_t {
|
||||
float32x2_t val[3];
|
||||
} float32x2x3_t;
|
||||
|
||||
typedef struct float32x4x3_t {
|
||||
float32x4_t val[3];
|
||||
} float32x4x3_t;
|
||||
|
||||
#if defined(__aarch64__) || defined(__arm64ec__)
|
||||
typedef struct float64x1x3_t {
|
||||
float64x1_t val[3];
|
||||
} float64x1x3_t;
|
||||
|
||||
typedef struct float64x2x3_t {
|
||||
float64x2_t val[3];
|
||||
} float64x2x3_t;
|
||||
|
||||
#endif
|
||||
typedef struct int8x8x4_t {
|
||||
int8x8_t val[4];
|
||||
} int8x8x4_t;
|
||||
|
||||
typedef struct int8x16x4_t {
|
||||
int8x16_t val[4];
|
||||
} int8x16x4_t;
|
||||
|
||||
typedef struct int16x4x4_t {
|
||||
int16x4_t val[4];
|
||||
} int16x4x4_t;
|
||||
|
||||
typedef struct int16x8x4_t {
|
||||
int16x8_t val[4];
|
||||
} int16x8x4_t;
|
||||
|
||||
typedef struct int32x2x4_t {
|
||||
int32x2_t val[4];
|
||||
} int32x2x4_t;
|
||||
|
||||
typedef struct int32x4x4_t {
|
||||
int32x4_t val[4];
|
||||
} int32x4x4_t;
|
||||
|
||||
typedef struct int64x1x4_t {
|
||||
int64x1_t val[4];
|
||||
} int64x1x4_t;
|
||||
|
||||
typedef struct int64x2x4_t {
|
||||
int64x2_t val[4];
|
||||
} int64x2x4_t;
|
||||
|
||||
typedef struct uint8x8x4_t {
|
||||
uint8x8_t val[4];
|
||||
} uint8x8x4_t;
|
||||
|
||||
typedef struct uint8x16x4_t {
|
||||
uint8x16_t val[4];
|
||||
} uint8x16x4_t;
|
||||
|
||||
typedef struct uint16x4x4_t {
|
||||
uint16x4_t val[4];
|
||||
} uint16x4x4_t;
|
||||
|
||||
typedef struct uint16x8x4_t {
|
||||
uint16x8_t val[4];
|
||||
} uint16x8x4_t;
|
||||
|
||||
typedef struct uint32x2x4_t {
|
||||
uint32x2_t val[4];
|
||||
} uint32x2x4_t;
|
||||
|
||||
typedef struct uint32x4x4_t {
|
||||
uint32x4_t val[4];
|
||||
} uint32x4x4_t;
|
||||
|
||||
typedef struct uint64x1x4_t {
|
||||
uint64x1_t val[4];
|
||||
} uint64x1x4_t;
|
||||
|
||||
typedef struct uint64x2x4_t {
|
||||
uint64x2_t val[4];
|
||||
} uint64x2x4_t;
|
||||
|
||||
typedef struct float16x4x4_t {
|
||||
float16x4_t val[4];
|
||||
} float16x4x4_t;
|
||||
|
||||
typedef struct float16x8x4_t {
|
||||
float16x8_t val[4];
|
||||
} float16x8x4_t;
|
||||
|
||||
typedef struct float32x2x4_t {
|
||||
float32x2_t val[4];
|
||||
} float32x2x4_t;
|
||||
|
||||
typedef struct float32x4x4_t {
|
||||
float32x4_t val[4];
|
||||
} float32x4x4_t;
|
||||
|
||||
#if defined(__aarch64__) || defined(__arm64ec__)
|
||||
typedef struct float64x1x4_t {
|
||||
float64x1_t val[4];
|
||||
} float64x1x4_t;
|
||||
|
||||
typedef struct float64x2x4_t {
|
||||
float64x2_t val[4];
|
||||
} float64x2x4_t;
|
||||
|
||||
#endif
|
||||
typedef __attribute__((neon_vector_type(4))) bfloat16_t bfloat16x4_t;
|
||||
typedef __attribute__((neon_vector_type(8))) bfloat16_t bfloat16x8_t;
|
||||
|
||||
typedef struct bfloat16x4x2_t {
|
||||
bfloat16x4_t val[2];
|
||||
} bfloat16x4x2_t;
|
||||
|
||||
typedef struct bfloat16x8x2_t {
|
||||
bfloat16x8_t val[2];
|
||||
} bfloat16x8x2_t;
|
||||
|
||||
typedef struct bfloat16x4x3_t {
|
||||
bfloat16x4_t val[3];
|
||||
} bfloat16x4x3_t;
|
||||
|
||||
typedef struct bfloat16x8x3_t {
|
||||
bfloat16x8_t val[3];
|
||||
} bfloat16x8x3_t;
|
||||
|
||||
typedef struct bfloat16x4x4_t {
|
||||
bfloat16x4_t val[4];
|
||||
} bfloat16x4x4_t;
|
||||
|
||||
typedef struct bfloat16x8x4_t {
|
||||
bfloat16x8_t val[4];
|
||||
} bfloat16x8x4_t;
|
||||
|
||||
#endif // __ARM_NEON_TYPES_H
|
||||
31
third_party/aarch64/clang/armintr.h
vendored
Normal file
31
third_party/aarch64/clang/armintr.h
vendored
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
/*===---- armintr.h - ARM Windows intrinsics -------------------------------===
|
||||
*
|
||||
* 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
|
||||
*
|
||||
*===-----------------------------------------------------------------------===
|
||||
*/
|
||||
|
||||
/* Only include this if we're compiling for the windows platform. */
|
||||
#ifndef _MSC_VER
|
||||
#include_next <armintr.h>
|
||||
#else
|
||||
|
||||
#ifndef __ARMINTR_H
|
||||
#define __ARMINTR_H
|
||||
|
||||
typedef enum
|
||||
{
|
||||
_ARM_BARRIER_SY = 0xF,
|
||||
_ARM_BARRIER_ST = 0xE,
|
||||
_ARM_BARRIER_ISH = 0xB,
|
||||
_ARM_BARRIER_ISHST = 0xA,
|
||||
_ARM_BARRIER_NSH = 0x7,
|
||||
_ARM_BARRIER_NSHST = 0x6,
|
||||
_ARM_BARRIER_OSH = 0x3,
|
||||
_ARM_BARRIER_OSHST = 0x2
|
||||
} _ARMINTR_BARRIER_TYPE;
|
||||
|
||||
#endif /* __ARMINTR_H */
|
||||
#endif /* _MSC_VER */
|
||||
Loading…
Add table
Add a link
Reference in a new issue