maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/lib/Headers/arm_acle.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

717 lines
23 KiB
C
Raw Normal View History

Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
/*===---- arm_acle.h - ARM Non-Neon intrinsics -----------------------------===
*
Move the builtin headers to use the new license file header. Summary: These all had somewhat custom file headers with different text from the ones I searched for previously, and so I missed them. Thanks to Hal and Kristina and others who prompted me to fix this, and sorry it took so long. Reviewers: hfinkel Subscribers: mcrosier, javed.absar, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D60406 llvm-svn: 357941
2019-04-09 04:51:30 +08:00
* 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
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
*
*===-----------------------------------------------------------------------===
*/
#ifndef __ARM_ACLE_H
#define __ARM_ACLE_H
#ifndef __ARM_ACLE
#error "ACLE intrinsics support not enabled."
#endif
#include <stdint.h>
Headers: mark arm_acle.h with extern "C" Although the functions are marked as always_inline, the compiler with which they are used may not honour the extended attributes and emit them as functions. In such a case, indicate that they should have extern "C" linkage and should not be mangled in C++ style if used within C++. llvm-svn: 212511
2014-07-08 13:46:00 +08:00
#if defined(__cplusplus)
extern "C" {
#endif
ARM: Add ACLE memory barrier intrinsic mapping llvm-svn: 213261
2014-07-17 20:45:17 +08:00
ARM: Add NOP intrinsic mapping in arm_acle.h llvm-svn: 212950
2014-07-14 23:32:29 +08:00
/* 8 SYNCHRONIZATION, BARRIER AND HINT INTRINSICS */
ARM: Add ACLE memory barrier intrinsic mapping llvm-svn: 213261
2014-07-17 20:45:17 +08:00
/* 8.3 Memory barriers */
[clang][Headers] Use __has_builtin instead of _MSC_VER. arm_acle.h relied on `_MSC_VER` to determine if a given function was already defined as a builtin. This was incorrect because `-fms-extensions` enables these builtins, but is not responsible for defining `_MSC_VER` on any target. The next closest thing is `_MSC_EXTENSIONS`, which is only defined on Windows targets, but even this is suboptimal. What this conditional is actually trying to determine is if the given functions are defined as builtins, so just check that directly. I also attempted to do this for `__nop`, but in that case intrin.h, which is only includable if `_MSC_VER` is defined, has its own definition. So in that case `_MSC_VER` is correct. Differential Revision: https://reviews.llvm.org/D75719 rdar://60102353
2020-03-06 09:56:13 +08:00
#if !__has_builtin(__dmb)
ARM: Add ACLE memory barrier intrinsic mapping llvm-svn: 213261
2014-07-17 20:45:17 +08:00
#define __dmb(i) __builtin_arm_dmb(i)
[clang][Headers] Use __has_builtin instead of _MSC_VER. arm_acle.h relied on `_MSC_VER` to determine if a given function was already defined as a builtin. This was incorrect because `-fms-extensions` enables these builtins, but is not responsible for defining `_MSC_VER` on any target. The next closest thing is `_MSC_EXTENSIONS`, which is only defined on Windows targets, but even this is suboptimal. What this conditional is actually trying to determine is if the given functions are defined as builtins, so just check that directly. I also attempted to do this for `__nop`, but in that case intrin.h, which is only includable if `_MSC_VER` is defined, has its own definition. So in that case `_MSC_VER` is correct. Differential Revision: https://reviews.llvm.org/D75719 rdar://60102353
2020-03-06 09:56:13 +08:00
#endif
#if !__has_builtin(__dsb)
ARM: Add ACLE memory barrier intrinsic mapping llvm-svn: 213261
2014-07-17 20:45:17 +08:00
#define __dsb(i) __builtin_arm_dsb(i)
[clang][Headers] Use __has_builtin instead of _MSC_VER. arm_acle.h relied on `_MSC_VER` to determine if a given function was already defined as a builtin. This was incorrect because `-fms-extensions` enables these builtins, but is not responsible for defining `_MSC_VER` on any target. The next closest thing is `_MSC_EXTENSIONS`, which is only defined on Windows targets, but even this is suboptimal. What this conditional is actually trying to determine is if the given functions are defined as builtins, so just check that directly. I also attempted to do this for `__nop`, but in that case intrin.h, which is only includable if `_MSC_VER` is defined, has its own definition. So in that case `_MSC_VER` is correct. Differential Revision: https://reviews.llvm.org/D75719 rdar://60102353
2020-03-06 09:56:13 +08:00
#endif
#if !__has_builtin(__isb)
ARM: Add ACLE memory barrier intrinsic mapping llvm-svn: 213261
2014-07-17 20:45:17 +08:00
#define __isb(i) __builtin_arm_isb(i)
#endif
ARM: Add NOP intrinsic mapping in arm_acle.h llvm-svn: 212950
2014-07-14 23:32:29 +08:00
/* 8.4 Hints */
Headers: add hint intrinsics to arm_acle.h This adds the ARM ACLE hint intrinsic wrappers to arm_acle.h. These need to be protected with a !defined(_MSC_VER) since MSVC (and thus clang in compatibility mode) provide these wrappers as proper builtin intrinsics. llvm-svn: 212891
2014-07-13 07:27:26 +08:00
[clang][Headers] Use __has_builtin instead of _MSC_VER. arm_acle.h relied on `_MSC_VER` to determine if a given function was already defined as a builtin. This was incorrect because `-fms-extensions` enables these builtins, but is not responsible for defining `_MSC_VER` on any target. The next closest thing is `_MSC_EXTENSIONS`, which is only defined on Windows targets, but even this is suboptimal. What this conditional is actually trying to determine is if the given functions are defined as builtins, so just check that directly. I also attempted to do this for `__nop`, but in that case intrin.h, which is only includable if `_MSC_VER` is defined, has its own definition. So in that case `_MSC_VER` is correct. Differential Revision: https://reviews.llvm.org/D75719 rdar://60102353
2020-03-06 09:56:13 +08:00
#if !__has_builtin(__wfi)
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ void __attribute__((__always_inline__, __nodebug__)) __wfi(void) {
Headers: add hint intrinsics to arm_acle.h This adds the ARM ACLE hint intrinsic wrappers to arm_acle.h. These need to be protected with a !defined(_MSC_VER) since MSVC (and thus clang in compatibility mode) provide these wrappers as proper builtin intrinsics. llvm-svn: 212891
2014-07-13 07:27:26 +08:00
__builtin_arm_wfi();
}
[clang][Headers] Use __has_builtin instead of _MSC_VER. arm_acle.h relied on `_MSC_VER` to determine if a given function was already defined as a builtin. This was incorrect because `-fms-extensions` enables these builtins, but is not responsible for defining `_MSC_VER` on any target. The next closest thing is `_MSC_EXTENSIONS`, which is only defined on Windows targets, but even this is suboptimal. What this conditional is actually trying to determine is if the given functions are defined as builtins, so just check that directly. I also attempted to do this for `__nop`, but in that case intrin.h, which is only includable if `_MSC_VER` is defined, has its own definition. So in that case `_MSC_VER` is correct. Differential Revision: https://reviews.llvm.org/D75719 rdar://60102353
2020-03-06 09:56:13 +08:00
#endif
Headers: add hint intrinsics to arm_acle.h This adds the ARM ACLE hint intrinsic wrappers to arm_acle.h. These need to be protected with a !defined(_MSC_VER) since MSVC (and thus clang in compatibility mode) provide these wrappers as proper builtin intrinsics. llvm-svn: 212891
2014-07-13 07:27:26 +08:00
[clang][Headers] Use __has_builtin instead of _MSC_VER. arm_acle.h relied on `_MSC_VER` to determine if a given function was already defined as a builtin. This was incorrect because `-fms-extensions` enables these builtins, but is not responsible for defining `_MSC_VER` on any target. The next closest thing is `_MSC_EXTENSIONS`, which is only defined on Windows targets, but even this is suboptimal. What this conditional is actually trying to determine is if the given functions are defined as builtins, so just check that directly. I also attempted to do this for `__nop`, but in that case intrin.h, which is only includable if `_MSC_VER` is defined, has its own definition. So in that case `_MSC_VER` is correct. Differential Revision: https://reviews.llvm.org/D75719 rdar://60102353
2020-03-06 09:56:13 +08:00
#if !__has_builtin(__wfe)
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ void __attribute__((__always_inline__, __nodebug__)) __wfe(void) {
Headers: add hint intrinsics to arm_acle.h This adds the ARM ACLE hint intrinsic wrappers to arm_acle.h. These need to be protected with a !defined(_MSC_VER) since MSVC (and thus clang in compatibility mode) provide these wrappers as proper builtin intrinsics. llvm-svn: 212891
2014-07-13 07:27:26 +08:00
__builtin_arm_wfe();
}
[clang][Headers] Use __has_builtin instead of _MSC_VER. arm_acle.h relied on `_MSC_VER` to determine if a given function was already defined as a builtin. This was incorrect because `-fms-extensions` enables these builtins, but is not responsible for defining `_MSC_VER` on any target. The next closest thing is `_MSC_EXTENSIONS`, which is only defined on Windows targets, but even this is suboptimal. What this conditional is actually trying to determine is if the given functions are defined as builtins, so just check that directly. I also attempted to do this for `__nop`, but in that case intrin.h, which is only includable if `_MSC_VER` is defined, has its own definition. So in that case `_MSC_VER` is correct. Differential Revision: https://reviews.llvm.org/D75719 rdar://60102353
2020-03-06 09:56:13 +08:00
#endif
Headers: add hint intrinsics to arm_acle.h This adds the ARM ACLE hint intrinsic wrappers to arm_acle.h. These need to be protected with a !defined(_MSC_VER) since MSVC (and thus clang in compatibility mode) provide these wrappers as proper builtin intrinsics. llvm-svn: 212891
2014-07-13 07:27:26 +08:00
[clang][Headers] Use __has_builtin instead of _MSC_VER. arm_acle.h relied on `_MSC_VER` to determine if a given function was already defined as a builtin. This was incorrect because `-fms-extensions` enables these builtins, but is not responsible for defining `_MSC_VER` on any target. The next closest thing is `_MSC_EXTENSIONS`, which is only defined on Windows targets, but even this is suboptimal. What this conditional is actually trying to determine is if the given functions are defined as builtins, so just check that directly. I also attempted to do this for `__nop`, but in that case intrin.h, which is only includable if `_MSC_VER` is defined, has its own definition. So in that case `_MSC_VER` is correct. Differential Revision: https://reviews.llvm.org/D75719 rdar://60102353
2020-03-06 09:56:13 +08:00
#if !__has_builtin(__sev)
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ void __attribute__((__always_inline__, __nodebug__)) __sev(void) {
Headers: add hint intrinsics to arm_acle.h This adds the ARM ACLE hint intrinsic wrappers to arm_acle.h. These need to be protected with a !defined(_MSC_VER) since MSVC (and thus clang in compatibility mode) provide these wrappers as proper builtin intrinsics. llvm-svn: 212891
2014-07-13 07:27:26 +08:00
__builtin_arm_sev();
}
[clang][Headers] Use __has_builtin instead of _MSC_VER. arm_acle.h relied on `_MSC_VER` to determine if a given function was already defined as a builtin. This was incorrect because `-fms-extensions` enables these builtins, but is not responsible for defining `_MSC_VER` on any target. The next closest thing is `_MSC_EXTENSIONS`, which is only defined on Windows targets, but even this is suboptimal. What this conditional is actually trying to determine is if the given functions are defined as builtins, so just check that directly. I also attempted to do this for `__nop`, but in that case intrin.h, which is only includable if `_MSC_VER` is defined, has its own definition. So in that case `_MSC_VER` is correct. Differential Revision: https://reviews.llvm.org/D75719 rdar://60102353
2020-03-06 09:56:13 +08:00
#endif
Headers: add hint intrinsics to arm_acle.h This adds the ARM ACLE hint intrinsic wrappers to arm_acle.h. These need to be protected with a !defined(_MSC_VER) since MSVC (and thus clang in compatibility mode) provide these wrappers as proper builtin intrinsics. llvm-svn: 212891
2014-07-13 07:27:26 +08:00
[clang][Headers] Use __has_builtin instead of _MSC_VER. arm_acle.h relied on `_MSC_VER` to determine if a given function was already defined as a builtin. This was incorrect because `-fms-extensions` enables these builtins, but is not responsible for defining `_MSC_VER` on any target. The next closest thing is `_MSC_EXTENSIONS`, which is only defined on Windows targets, but even this is suboptimal. What this conditional is actually trying to determine is if the given functions are defined as builtins, so just check that directly. I also attempted to do this for `__nop`, but in that case intrin.h, which is only includable if `_MSC_VER` is defined, has its own definition. So in that case `_MSC_VER` is correct. Differential Revision: https://reviews.llvm.org/D75719 rdar://60102353
2020-03-06 09:56:13 +08:00
#if !__has_builtin(__sevl)
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ void __attribute__((__always_inline__, __nodebug__)) __sevl(void) {
Headers: add hint intrinsics to arm_acle.h This adds the ARM ACLE hint intrinsic wrappers to arm_acle.h. These need to be protected with a !defined(_MSC_VER) since MSVC (and thus clang in compatibility mode) provide these wrappers as proper builtin intrinsics. llvm-svn: 212891
2014-07-13 07:27:26 +08:00
__builtin_arm_sevl();
}
[clang][Headers] Use __has_builtin instead of _MSC_VER. arm_acle.h relied on `_MSC_VER` to determine if a given function was already defined as a builtin. This was incorrect because `-fms-extensions` enables these builtins, but is not responsible for defining `_MSC_VER` on any target. The next closest thing is `_MSC_EXTENSIONS`, which is only defined on Windows targets, but even this is suboptimal. What this conditional is actually trying to determine is if the given functions are defined as builtins, so just check that directly. I also attempted to do this for `__nop`, but in that case intrin.h, which is only includable if `_MSC_VER` is defined, has its own definition. So in that case `_MSC_VER` is correct. Differential Revision: https://reviews.llvm.org/D75719 rdar://60102353
2020-03-06 09:56:13 +08:00
#endif
Headers: add hint intrinsics to arm_acle.h This adds the ARM ACLE hint intrinsic wrappers to arm_acle.h. These need to be protected with a !defined(_MSC_VER) since MSVC (and thus clang in compatibility mode) provide these wrappers as proper builtin intrinsics. llvm-svn: 212891
2014-07-13 07:27:26 +08:00
[clang][Headers] Use __has_builtin instead of _MSC_VER. arm_acle.h relied on `_MSC_VER` to determine if a given function was already defined as a builtin. This was incorrect because `-fms-extensions` enables these builtins, but is not responsible for defining `_MSC_VER` on any target. The next closest thing is `_MSC_EXTENSIONS`, which is only defined on Windows targets, but even this is suboptimal. What this conditional is actually trying to determine is if the given functions are defined as builtins, so just check that directly. I also attempted to do this for `__nop`, but in that case intrin.h, which is only includable if `_MSC_VER` is defined, has its own definition. So in that case `_MSC_VER` is correct. Differential Revision: https://reviews.llvm.org/D75719 rdar://60102353
2020-03-06 09:56:13 +08:00
#if !__has_builtin(__yield)
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ void __attribute__((__always_inline__, __nodebug__)) __yield(void) {
Headers: add hint intrinsics to arm_acle.h This adds the ARM ACLE hint intrinsic wrappers to arm_acle.h. These need to be protected with a !defined(_MSC_VER) since MSVC (and thus clang in compatibility mode) provide these wrappers as proper builtin intrinsics. llvm-svn: 212891
2014-07-13 07:27:26 +08:00
__builtin_arm_yield();
}
#endif
arm_acle: Add mappings for dbg intrinsic This completes all ACLE hint intrinsics. llvm-svn: 216453
2014-08-26 20:48:11 +08:00
#if __ARM_32BIT_STATE
#define __dbg(t) __builtin_arm_dbg(t)
#endif
arm_acle: Implement swap intrinsic Insert the LDREX/STREX instruction sequence specified in ARM ACLE 2.0, as SWP instruction is deprecated since ARMv6. llvm-svn: 216446
2014-08-26 17:50:54 +08:00
/* 8.5 Swap */
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__swp(uint32_t __x, volatile uint32_t *__p) {
arm_acle: Implement swap intrinsic Insert the LDREX/STREX instruction sequence specified in ARM ACLE 2.0, as SWP instruction is deprecated since ARMv6. llvm-svn: 216446
2014-08-26 17:50:54 +08:00
uint32_t v;
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
do
v = __builtin_arm_ldrex(__p);
while (__builtin_arm_strex(__x, __p));
arm_acle: Implement swap intrinsic Insert the LDREX/STREX instruction sequence specified in ARM ACLE 2.0, as SWP instruction is deprecated since ARMv6. llvm-svn: 216446
2014-08-26 17:50:54 +08:00
return v;
}
ARM: Add mappings for ACLE prefetch intrinsics Implement __pld, __pldx, __pli and __plix builtin intrinsics as specified in ARM ACLE 2.0. llvm-svn: 215599
2014-08-14 07:20:15 +08:00
/* 8.6 Memory prefetch intrinsics */
/* 8.6.1 Data prefetch */
#define __pld(addr) __pldx(0, 0, 0, addr)
#if __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
/* 8.6.2 Instruction prefetch */
#define __pli(addr) __plix(0, 0, addr)
#if __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
ARM: Add NOP intrinsic mapping in arm_acle.h llvm-svn: 212950
2014-07-14 23:32:29 +08:00
/* 8.7 NOP */
[Headers] Fix compatibility between arm_acle.h and intrin.h Make sure they don't both define __nop. Differential Revision: https://reviews.llvm.org/D69012
2019-10-30 05:52:56 +08:00
#if !defined(_MSC_VER) || !defined(__aarch64__)
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ void __attribute__((__always_inline__, __nodebug__)) __nop(void) {
ARM: Add NOP intrinsic mapping in arm_acle.h llvm-svn: 212950
2014-07-14 23:32:29 +08:00
__builtin_arm_nop();
}
[Headers] Fix compatibility between arm_acle.h and intrin.h Make sure they don't both define __nop. Differential Revision: https://reviews.llvm.org/D69012
2019-10-30 05:52:56 +08:00
#endif
ARM: Add NOP intrinsic mapping in arm_acle.h llvm-svn: 212950
2014-07-14 23:32:29 +08:00
Improve comments of ARM ACLE header file and tests Include section number in ARM ACLE specification for easier navigation. llvm-svn: 212887
2014-07-13 06:48:13 +08:00
/* 9 DATA-PROCESSING INTRINSICS */
/* 9.2 Miscellaneous data-processing intrinsics */
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
/* ROR */
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__ror(uint32_t __x, uint32_t __y) {
__y %= 32;
if (__y == 0)
return __x;
return (__x >> __y) | (__x << (32 - __y));
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__rorll(uint64_t __x, uint32_t __y) {
__y %= 64;
if (__y == 0)
return __x;
return (__x >> __y) | (__x << (64 - __y));
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__rorl(unsigned long __x, uint32_t __y) {
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
#if __SIZEOF_LONG__ == 4
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
return __ror(__x, __y);
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
#else
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
return __rorll(__x, __y);
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
#endif
}
/* CLZ */
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__clz(uint32_t __t) {
return __builtin_clz(__t);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__clzl(unsigned long __t) {
return __builtin_clzl(__t);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__clzll(uint64_t __t) {
return __builtin_clzll(__t);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
}
[ARM][AArch64] Implement __cls, __clsl and __clsll intrinsics from ACLE Summary: Writing support for three ACLE functions: unsigned int __cls(uint32_t x) unsigned int __clsl(unsigned long x) unsigned int __clsll(uint64_t x) CLS stands for "Count number of leading sign bits". In AArch64, these two intrinsics can be translated into the 'cls' instruction directly. In AArch32, on the other hand, this functionality is achieved by implementing it in terms of clz (count number of leading zeros). Reviewers: compnerd Reviewed By: compnerd Subscribers: kristof.beyls, hiraditya, cfe-commits, llvm-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D69250
2019-10-17 21:10:30 +08:00
/* CLS */
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
__cls(uint32_t __t) {
return __builtin_arm_cls(__t);
}
static __inline__ uint32_t __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__ uint32_t __attribute__((__always_inline__, __nodebug__))
__clsll(uint64_t __t) {
return __builtin_arm_cls64(__t);
}
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
/* REV */
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__rev(uint32_t __t) {
return __builtin_bswap32(__t);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__revl(unsigned long __t) {
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
#if __SIZEOF_LONG__ == 4
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
return __builtin_bswap32(__t);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
#else
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
return __builtin_bswap64(__t);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
#endif
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__revll(uint64_t __t) {
return __builtin_bswap64(__t);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
}
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
/* REV16 */
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__rev16(uint32_t __t) {
return __ror(__rev(__t), 16);
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__rev16ll(uint64_t __t) {
return (((uint64_t)__rev16(__t >> 32)) << 32) | __rev16(__t);
[ARM,AArch64] Fix __rev16l and __rev16ll intrinsics These two intrinsics are defined in arm_acle.h. __rev16l needs to rotate by 16 bits, bit it was actually rotating by 2 bits. For AArch64, where long is 64 bits, this would still be wrong. __rev16ll was incorrect, it reversed the bytes in each 32-bit word, rather than each 16-bit halfword. The correct implementation is to apply __rev16 to the top and bottom words of the 64-bit value. For AArch32 targets, these get compiled down to the hardware rev16 instruction at -O1 and above. For AArch64 targets, the 64-bit ones get compiled to two 32-bit rev16 instructions, because there is not currently a pattern for the 64-bit rev16 instruction. Differential Revision: http://reviews.llvm.org/D14609 llvm-svn: 253211
2015-11-16 22:58:50 +08:00
}
static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__rev16l(unsigned long __t) {
[ARM,AArch64] Fix __rev16l and __rev16ll intrinsics These two intrinsics are defined in arm_acle.h. __rev16l needs to rotate by 16 bits, bit it was actually rotating by 2 bits. For AArch64, where long is 64 bits, this would still be wrong. __rev16ll was incorrect, it reversed the bytes in each 32-bit word, rather than each 16-bit halfword. The correct implementation is to apply __rev16 to the top and bottom words of the 64-bit value. For AArch32 targets, these get compiled down to the hardware rev16 instruction at -O1 and above. For AArch64 targets, the 64-bit ones get compiled to two 32-bit rev16 instructions, because there is not currently a pattern for the 64-bit rev16 instruction. Differential Revision: http://reviews.llvm.org/D14609 llvm-svn: 253211
2015-11-16 22:58:50 +08:00
#if __SIZEOF_LONG__ == 4
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
return __rev16(__t);
[ARM,AArch64] Fix __rev16l and __rev16ll intrinsics These two intrinsics are defined in arm_acle.h. __rev16l needs to rotate by 16 bits, bit it was actually rotating by 2 bits. For AArch64, where long is 64 bits, this would still be wrong. __rev16ll was incorrect, it reversed the bytes in each 32-bit word, rather than each 16-bit halfword. The correct implementation is to apply __rev16 to the top and bottom words of the 64-bit value. For AArch32 targets, these get compiled down to the hardware rev16 instruction at -O1 and above. For AArch64 targets, the 64-bit ones get compiled to two 32-bit rev16 instructions, because there is not currently a pattern for the 64-bit rev16 instruction. Differential Revision: http://reviews.llvm.org/D14609 llvm-svn: 253211
2015-11-16 22:58:50 +08:00
#else
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
return __rev16ll(__t);
[ARM,AArch64] Fix __rev16l and __rev16ll intrinsics These two intrinsics are defined in arm_acle.h. __rev16l needs to rotate by 16 bits, bit it was actually rotating by 2 bits. For AArch64, where long is 64 bits, this would still be wrong. __rev16ll was incorrect, it reversed the bytes in each 32-bit word, rather than each 16-bit halfword. The correct implementation is to apply __rev16 to the top and bottom words of the 64-bit value. For AArch32 targets, these get compiled down to the hardware rev16 instruction at -O1 and above. For AArch64 targets, the 64-bit ones get compiled to two 32-bit rev16 instructions, because there is not currently a pattern for the 64-bit rev16 instruction. Differential Revision: http://reviews.llvm.org/D14609 llvm-svn: 253211
2015-11-16 22:58:50 +08:00
#endif
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
}
/* REVSH */
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ int16_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__revsh(int16_t __t) {
return __builtin_bswap16(__t);
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
}
/* RBIT */
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__rbit(uint32_t __t) {
return __builtin_arm_rbit(__t);
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__rbitll(uint64_t __t) {
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
#if __ARM_32BIT_STATE
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
return (((uint64_t)__builtin_arm_rbit(__t)) << 32) |
__builtin_arm_rbit(__t >> 32);
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
#else
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
return __builtin_arm_rbit64(__t);
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
#endif
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__rbitl(unsigned long __t) {
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
#if __SIZEOF_LONG__ == 4
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
return __rbit(__t);
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
#else
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
return __rbitll(__t);
arm_acle: Implement data processing intrinsics Summary: ACLE 2.0 section 9.2 defines the following "miscellaneous data processing intrinsics": `__clz`, `__cls`, `__ror`, `__rev`, `__rev16`, `__revsh` and `__rbit`. `__clz` has already been implemented in the arm_acle.h header file. The rest are not supported yet. This patch completes ACLE data processing intrinsics. Reviewers: t.p.northover, rengolin Reviewed By: rengolin Subscribers: aemerson, mroth, llvm-commits Differential Revision: http://reviews.llvm.org/D4983 llvm-svn: 216658
2014-08-28 17:44:07 +08:00
#endif
}
[ARM] ACLE Chapter 9 intrinsics Implemented the remaining integer data processing intrinsics from the ARM ACLE v2.1 spec, such as parallel arithemtic and DSP style multiplications. Differential Revision: https://reviews.llvm.org/D32282 llvm-svn: 302131
2017-05-04 16:37:59 +08:00
/*
* 9.3 16-bit multiplications
*/
#if __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
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
/*
Improve comments of ARM ACLE header file and tests Include section number in ARM ACLE specification for easier navigation. llvm-svn: 212887
2014-07-13 06:48:13 +08:00
* 9.4 Saturating intrinsics
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
*
* FIXME: Change guard to their corrosponding __ARM_FEATURE flag when Q flag
* intrinsics are implemented and the flag is enabled.
*/
Improve comments of ARM ACLE header file and tests Include section number in ARM ACLE specification for easier navigation. llvm-svn: 212887
2014-07-13 06:48:13 +08:00
/* 9.4.1 Width-specified saturation intrinsics */
[ARM] ACLE Chapter 9 intrinsics Implemented the remaining integer data processing intrinsics from the ARM ACLE v2.1 spec, such as parallel arithemtic and DSP style multiplications. Differential Revision: https://reviews.llvm.org/D32282 llvm-svn: 302131
2017-05-04 16:37:59 +08:00
#if __ARM_FEATURE_SAT
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
#define __ssat(x, y) __builtin_arm_ssat(x, y)
#define __usat(x, y) __builtin_arm_usat(x, y)
Improve comments of ARM ACLE header file and tests Include section number in ARM ACLE specification for easier navigation. llvm-svn: 212887
2014-07-13 06:48:13 +08:00
#endif
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
Improve comments of ARM ACLE header file and tests Include section number in ARM ACLE specification for easier navigation. llvm-svn: 212887
2014-07-13 06:48:13 +08:00
/* 9.4.2 Saturating addition and subtraction intrinsics */
[ARM] ACLE Chapter 9 intrinsics Implemented the remaining integer data processing intrinsics from the ARM ACLE v2.1 spec, such as parallel arithemtic and DSP style multiplications. Differential Revision: https://reviews.llvm.org/D32282 llvm-svn: 302131
2017-05-04 16:37:59 +08:00
#if __ARM_FEATURE_DSP
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__qadd(int32_t __t, int32_t __v) {
return __builtin_arm_qadd(__t, __v);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__qsub(int32_t __t, int32_t __v) {
return __builtin_arm_qsub(__t, __v);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
}
Add the __qdbl intrinsic to the arm_acle.h header Patch by: Moritz Roth llvm-svn: 212264
2014-07-03 18:14:52 +08:00
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__qdbl(int32_t __t) {
return __builtin_arm_qadd(__t, __t);
Add the __qdbl intrinsic to the arm_acle.h header Patch by: Moritz Roth llvm-svn: 212264
2014-07-03 18:14:52 +08:00
}
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
#endif
[ARM] ACLE Chapter 9 intrinsics Implemented the remaining integer data processing intrinsics from the ARM ACLE v2.1 spec, such as parallel arithemtic and DSP style multiplications. Differential Revision: https://reviews.llvm.org/D32282 llvm-svn: 302131
2017-05-04 16:37:59 +08:00
/* 9.4.3 Accumultating multiplications */
#if __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
/* 9.5.4 Parallel 16-bit saturation */
#if __ARM_FEATURE_SIMD32
#define __ssat16(x, y) __builtin_arm_ssat16(x, y)
#define __usat16(x, y) __builtin_arm_usat16(x, y)
#endif
/* 9.5.5 Packing and unpacking */
#if __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
/* 9.5.6 Parallel selection */
#if __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
/* 9.5.7 Parallel 8-bit addition and subtraction */
#if __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
/* 9.5.8 Sum of 8-bit absolute differences */
#if __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
/* 9.5.9 Parallel 16-bit addition and subtraction */
#if __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
/* 9.5.10 Parallel 16-bit multiplications */
#if __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
Improve comments of ARM ACLE header file and tests Include section number in ARM ACLE specification for easier navigation. llvm-svn: 212887
2014-07-13 06:48:13 +08:00
/* 9.7 CRC32 intrinsics */
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
#if __ARM_FEATURE_CRC32
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__crc32b(uint32_t __a, uint8_t __b) {
return __builtin_arm_crc32b(__a, __b);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__crc32h(uint32_t __a, uint16_t __b) {
return __builtin_arm_crc32h(__a, __b);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__crc32w(uint32_t __a, uint32_t __b) {
return __builtin_arm_crc32w(__a, __b);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__crc32d(uint32_t __a, uint64_t __b) {
return __builtin_arm_crc32d(__a, __b);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__crc32cb(uint32_t __a, uint8_t __b) {
return __builtin_arm_crc32cb(__a, __b);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__crc32ch(uint32_t __a, uint16_t __b) {
return __builtin_arm_crc32ch(__a, __b);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__crc32cw(uint32_t __a, uint32_t __b) {
return __builtin_arm_crc32cw(__a, __b);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
}
Headers: Don't use attribute keywords which aren't reserved Instead of using 'unavailable', use '__unavailable__' llvm-svn: 228087
2015-02-04 08:26:10 +08:00
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
Update functions in clang supplied headers to use the compiler reserved namespace for arguments. llvm-svn: 260647
2016-02-12 10:22:53 +08:00
__crc32cd(uint32_t __a, uint64_t __b) {
return __builtin_arm_crc32cd(__a, __b);
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
}
#endif
[AArch64] Implement __jcvt intrinsic from Armv8.3-A The jcvt intrinsic defined in ACLE [1] is available when ARM_FEATURE_JCVT is defined. This change introduces the AArch64 intrinsic, wires it up to the instruction and a new clang builtin function. The __ARM_FEATURE_JCVT macro is now defined when an Armv8.3-A or higher target is used. I've implemented the target detection logic in Clang so that this feature is enabled for architectures from armv8.3-a onwards (so -march=armv8.4-a also enables this, for example). make check-all didn't show any new failures. [1] https://developer.arm.com/docs/101028/latest/data-processing-intrinsics Differential Revision: https://reviews.llvm.org/D64495 llvm-svn: 366197
2019-07-16 17:27:39 +08:00
/* Armv8.3-A Javascript conversion intrinsic */
#if __ARM_64BIT_STATE && defined(__ARM_FEATURE_JCVT)
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
__jcvt(double __a) {
return __builtin_arm_jcvt(__a);
}
#endif
[AArch64] Adding ACLE intrinsics for the LS64 extension This introduces the ARMv8.7-A LS64 extension's intrinsics for 64 bytes atomic loads and stores: `__arm_ld64b`, `__arm_st64b`, `__arm_st64bv`, and `__arm_st64bv0`. These are selected into the LS64 instructions LD64B, ST64B, ST64BV and ST64BV0, respectively. Based on patches written by Simon Tatham. Reviewed By: tmatheson Differential Revision: https://reviews.llvm.org/D93232
2020-12-11 00:43:36 +08:00
/* Armv8.7-A load/store 64-byte intrinsics */
#if __ARM_64BIT_STATE && defined(__ARM_FEATURE_LS64)
typedef struct {
uint64_t val[8];
} data512_t;
static __inline__ data512_t __attribute__((__always_inline__, __nodebug__))
__arm_ld64b(const void *__addr) {
data512_t __value;
__builtin_arm_ld64b(__addr, __value.val);
return __value;
}
static __inline__ void __attribute__((__always_inline__, __nodebug__))
__arm_st64b(void *__addr, data512_t __value) {
__builtin_arm_st64b(__addr, __value.val);
}
static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
__arm_st64bv(void *__addr, data512_t __value) {
return __builtin_arm_st64bv(__addr, __value.val);
}
static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
__arm_st64bv0(void *__addr, data512_t __value) {
return __builtin_arm_st64bv0(__addr, __value.val);
}
#endif
This patch implements clang support for the ACLE special register intrinsics in section 10.1, __arm_{w,r}sr{,p,64}. This includes arm_acle.h definitions with builtins and codegen to support these, the intrinsics are implemented by generating read/write_register calls which get appropriately lowered in the backend based on the register string provided. SemaChecking is also implemented to fault invalid parameters. Differential Revision: http://reviews.llvm.org/D9697 llvm-svn: 239737
2015-06-16 01:51:01 +08:00
/* 10.1 Special register intrinsics */
#define __arm_rsr(sysreg) __builtin_arm_rsr(sysreg)
#define __arm_rsr64(sysreg) __builtin_arm_rsr64(sysreg)
#define __arm_rsrp(sysreg) __builtin_arm_rsrp(sysreg)
[ARM][AArch64] Implement __arm_rsrf, __arm_rsrf64, __arm_wsrf & __arm_wsrf64 Summary: Adding support for ACLE intrinsics. Patch by Michael Platings. Reviewers: chill, t.p.northover, efriedma Reviewed By: chill Subscribers: kristof.beyls, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D69297
2019-10-22 18:43:51 +08:00
#define __arm_rsrf(sysreg) __builtin_bit_cast(float, __arm_rsr(sysreg))
#define __arm_rsrf64(sysreg) __builtin_bit_cast(double, __arm_rsr64(sysreg))
This patch implements clang support for the ACLE special register intrinsics in section 10.1, __arm_{w,r}sr{,p,64}. This includes arm_acle.h definitions with builtins and codegen to support these, the intrinsics are implemented by generating read/write_register calls which get appropriately lowered in the backend based on the register string provided. SemaChecking is also implemented to fault invalid parameters. Differential Revision: http://reviews.llvm.org/D9697 llvm-svn: 239737
2015-06-16 01:51:01 +08:00
#define __arm_wsr(sysreg, v) __builtin_arm_wsr(sysreg, v)
#define __arm_wsr64(sysreg, v) __builtin_arm_wsr64(sysreg, v)
#define __arm_wsrp(sysreg, v) __builtin_arm_wsrp(sysreg, v)
[ARM][AArch64] Implement __arm_rsrf, __arm_rsrf64, __arm_wsrf & __arm_wsrf64 Summary: Adding support for ACLE intrinsics. Patch by Michael Platings. Reviewers: chill, t.p.northover, efriedma Reviewed By: chill Subscribers: kristof.beyls, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D69297
2019-10-22 18:43:51 +08:00
#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))
This patch implements clang support for the ACLE special register intrinsics in section 10.1, __arm_{w,r}sr{,p,64}. This includes arm_acle.h definitions with builtins and codegen to support these, the intrinsics are implemented by generating read/write_register calls which get appropriately lowered in the backend based on the register string provided. SemaChecking is also implemented to fault invalid parameters. Differential Revision: http://reviews.llvm.org/D9697 llvm-svn: 239737
2015-06-16 01:51:01 +08:00
[AArch64] Add support for Transactional Memory Extension (TME) Re-commit r366322 after some fixes TME is a future architecture technology, documented in https://developer.arm.com/architectures/cpu-architecture/a-profile/exploration-tools https://developer.arm.com/docs/ddi0601/a More about the future architectures: https://community.arm.com/developer/ip-products/processors/b/processors-ip-blog/posts/new-technologies-for-the-arm-a-profile-architecture This patch adds support for the TME instructions TSTART, TTEST, TCOMMIT, and TCANCEL and the target feature/arch extension "tme". It also implements TME builtin functions, defined in ACLE Q2 2019 (https://developer.arm.com/docs/101028/latest) Differential Revision: https://reviews.llvm.org/D64416 Patch by Javed Absar and Momchil Velikov llvm-svn: 367428
2019-07-31 20:52:17 +08:00
/* Memory Tagging Extensions (MTE) Intrinsics */
[AArch64] Add support for MTE intrinsics This provides intrinsics support for Memory Tagging Extension (MTE), which was introduced with the Armv8.5-a architecture. These intrinsics are available when __ARM_FEATURE_MEMORY_TAGGING is defined. Each intrinsic is described in detail in the ACLE Q1 2019 documentation: https://developer.arm.com/docs/101028/latest Reviewed By: Tim Nortover, David Spickett Differential Revision: https://reviews.llvm.org/D60485 llvm-svn: 359348
2019-04-27 05:08:11 +08:00
#if __ARM_FEATURE_MEMORY_TAGGING
#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)
#endif
[AArch64] Add support for Transactional Memory Extension (TME) Re-commit r366322 after some fixes TME is a future architecture technology, documented in https://developer.arm.com/architectures/cpu-architecture/a-profile/exploration-tools https://developer.arm.com/docs/ddi0601/a More about the future architectures: https://community.arm.com/developer/ip-products/processors/b/processors-ip-blog/posts/new-technologies-for-the-arm-a-profile-architecture This patch adds support for the TME instructions TSTART, TTEST, TCOMMIT, and TCANCEL and the target feature/arch extension "tme". It also implements TME builtin functions, defined in ACLE Q2 2019 (https://developer.arm.com/docs/101028/latest) Differential Revision: https://reviews.llvm.org/D64416 Patch by Javed Absar and Momchil Velikov llvm-svn: 367428
2019-07-31 20:52:17 +08:00
/* Transactional Memory Extension (TME) Intrinsics */
#if __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 */
Headers: mark arm_acle.h with extern "C" Although the functions are marked as always_inline, the compiler with which they are used may not honour the extended attributes and emit them as functions. In such a case, indicate that they should have extern "C" linkage and should not be mangled in C++ style if used within C++. llvm-svn: 212511
2014-07-08 13:46:00 +08:00
#if defined(__cplusplus)
}
#endif
Introduce arm_acle.h supporting existing LLVM builtin intrinsics Summary: This patch introduces ACLE header file, implementing extensions that can be directly mapped to existing Clang intrinsics. It implements for both AArch32 and AArch64. Reviewers: t.p.northover, compnerd, rengolin Reviewed By: compnerd, rengolin Subscribers: rnk, echristo, compnerd, aemerson, mroth, cfe-commits Differential Revision: http://reviews.llvm.org/D4296 llvm-svn: 211962
2014-06-28 05:25:42 +08:00
#endif /* __ARM_ACLE_H */