This is an archive of the discontinued LLVM Phabricator instance.

Differential D106530

[PowerPC] Change altivec indexed load/store builtins argument type
ClosedPublic

Authored by qiucf on Jul 22 2021, 2:07 AM.

Details

Reviewers
jsji
nemanjai
shchenz
anhtuyen
Group Reviewers
Restricted Project
Commits
rG240dde948252: [PowerPC] Change altivec indexed load/store builtins argument type
Summary

This patch changes the index argument of lvxl?/lve[bhw]x/stvxl?/stve[bhw]x builtins from int to long. Because on 64-bit subtargets, an extra extsw will always been generated, which is incorrect.

Diff Detail

Unit TestsFailed

TimeTest
2,780 msx64 debian > libarcher.critical::critical.c
2,670 msx64 debian > libarcher.critical::lock-nested.c
2,830 msx64 debian > libarcher.critical::lock.c
2,530 msx64 debian > libarcher.parallel::parallel-firstprivate.c
2,550 msx64 debian > libarcher.races::critical-unrelated.c
View Full Test Results (20 Failed)

Event Timeline

qiucf created this revision.Jul 22 2021, 2:07 AM
Herald added subscribers: arphaman, kbarton. · View Herald TranscriptJul 22 2021, 2:07 AM
qiucf requested review of this revision.Jul 22 2021, 2:07 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 22 2021, 2:07 AM
Herald added a subscriber: cfe-commits. · View Herald Transcript
Harbormaster completed remote builds in B115512: Diff 360733.Jul 22 2021, 2:41 AM
nemanjai accepted this revision.Jul 26 2021, 4:29 AM

LGTM. Thanks for fixing this.
I am just curious, was this revealed from a real world test that used an offset that is so large that it doesn't fit into 32 bits?

This revision is now accepted and ready to land.Jul 26 2021, 4:29 AM
This revision was landed with ongoing or failed builds.Jul 26 2021, 9:27 AM
Closed by commit rG240dde948252: [PowerPC] Change altivec indexed load/store builtins argument type (authored by qiucf). · Explain Why
This revision was automatically updated to reflect the committed changes.
qiucf added a commit: rG240dde948252: [PowerPC] Change altivec indexed load/store builtins argument type.
qiucf added a comment.Jul 26 2021, 9:27 AM
In D106530#2903938, @nemanjai wrote:

LGTM. Thanks for fixing this.
I am just curious, was this revealed from a real world test that used an offset that is so large that it doesn't fit into 32 bits?

No :-) It's found in backend codegen (an unnecessary extsw).

Revision Contents

PathSize
clang/
include/
clang/
Basic/
28 lines
lib/
Headers/
336 lines
test/
CodeGen/
6 lines
6 lines

Diff 360733

clang/include/clang/Basic/BuiltinsPPC.def

Show First 20 Lines • Show All 190 Lines • ▼ Show 20 Lines
BUILTIN(__builtin_altivec_dstt, "vvC*iUIi", "") BUILTIN(__builtin_altivec_dstt, "vvC*iUIi", "")
BUILTIN(__builtin_altivec_dstst, "vvC*iUIi", "") BUILTIN(__builtin_altivec_dstst, "vvC*iUIi", "")
BUILTIN(__builtin_altivec_dststt, "vvC*iUIi", "") BUILTIN(__builtin_altivec_dststt, "vvC*iUIi", "")
BUILTIN(__builtin_altivec_vexptefp, "V4fV4f", "") BUILTIN(__builtin_altivec_vexptefp, "V4fV4f", "")
BUILTIN(__builtin_altivec_vrfim, "V4fV4f", "") BUILTIN(__builtin_altivec_vrfim, "V4fV4f", "")
BUILTIN(__builtin_altivec_lvx, "V4iivC*", "") BUILTIN(__builtin_altivec_lvx, "V4iLivC*", "")
BUILTIN(__builtin_altivec_lvxl, "V4iivC*", "") BUILTIN(__builtin_altivec_lvxl, "V4iLivC*", "")
BUILTIN(__builtin_altivec_lvebx, "V16civC*", "") BUILTIN(__builtin_altivec_lvebx, "V16cLivC*", "")
BUILTIN(__builtin_altivec_lvehx, "V8sivC*", "") BUILTIN(__builtin_altivec_lvehx, "V8sLivC*", "")
BUILTIN(__builtin_altivec_lvewx, "V4iivC*", "") BUILTIN(__builtin_altivec_lvewx, "V4iLivC*", "")
BUILTIN(__builtin_altivec_vlogefp, "V4fV4f", "") BUILTIN(__builtin_altivec_vlogefp, "V4fV4f", "")
BUILTIN(__builtin_altivec_lvsl, "V16cUcvC*", "") BUILTIN(__builtin_altivec_lvsl, "V16cUcvC*", "")
BUILTIN(__builtin_altivec_lvsr, "V16cUcvC*", "") BUILTIN(__builtin_altivec_lvsr, "V16cUcvC*", "")
BUILTIN(__builtin_altivec_vmaddfp, "V4fV4fV4fV4f", "") BUILTIN(__builtin_altivec_vmaddfp, "V4fV4fV4fV4f", "")
BUILTIN(__builtin_altivec_vmhaddshs, "V8sV8sV8sV8s", "") BUILTIN(__builtin_altivec_vmhaddshs, "V8sV8sV8sV8s", "")
Show All 35 Lines
BUILTIN(__builtin_altivec_vpkswus, "V8UsV4SiV4Si", "") BUILTIN(__builtin_altivec_vpkswus, "V8UsV4SiV4Si", "")
BUILTIN(__builtin_altivec_vpksdss, "V4SiV2SLLiV2SLLi", "") BUILTIN(__builtin_altivec_vpksdss, "V4SiV2SLLiV2SLLi", "")
BUILTIN(__builtin_altivec_vpksdus, "V4UiV2SLLiV2SLLi", "") BUILTIN(__builtin_altivec_vpksdus, "V4UiV2SLLiV2SLLi", "")
BUILTIN(__builtin_altivec_vpkudus, "V4UiV2ULLiV2ULLi", "") BUILTIN(__builtin_altivec_vpkudus, "V4UiV2ULLiV2ULLi", "")
BUILTIN(__builtin_altivec_vpkudum, "V4UiV2ULLiV2ULLi", "") BUILTIN(__builtin_altivec_vpkudum, "V4UiV2ULLiV2ULLi", "")
BUILTIN(__builtin_altivec_vperm_4si, "V4iV4iV4iV16Uc", "") BUILTIN(__builtin_altivec_vperm_4si, "V4iV4iV4iV16Uc", "")
BUILTIN(__builtin_altivec_stvx, "vV4iiv*", "") BUILTIN(__builtin_altivec_stvx, "vV4iLiv*", "")
BUILTIN(__builtin_altivec_stvxl, "vV4iiv*", "") BUILTIN(__builtin_altivec_stvxl, "vV4iLiv*", "")
BUILTIN(__builtin_altivec_stvebx, "vV16civ*", "") BUILTIN(__builtin_altivec_stvebx, "vV16cLiv*", "")
BUILTIN(__builtin_altivec_stvehx, "vV8siv*", "") BUILTIN(__builtin_altivec_stvehx, "vV8sLiv*", "")
BUILTIN(__builtin_altivec_stvewx, "vV4iiv*", "") BUILTIN(__builtin_altivec_stvewx, "vV4iLiv*", "")
BUILTIN(__builtin_altivec_vcmpbfp, "V4iV4fV4f", "") BUILTIN(__builtin_altivec_vcmpbfp, "V4iV4fV4f", "")
BUILTIN(__builtin_altivec_vcmpgefp, "V4iV4fV4f", "") BUILTIN(__builtin_altivec_vcmpgefp, "V4iV4fV4f", "")
BUILTIN(__builtin_altivec_vcmpequb, "V16cV16cV16c", "") BUILTIN(__builtin_altivec_vcmpequb, "V16cV16cV16c", "")
BUILTIN(__builtin_altivec_vcmpequh, "V8sV8sV8s", "") BUILTIN(__builtin_altivec_vcmpequh, "V8sV8sV8s", "")
BUILTIN(__builtin_altivec_vcmpequw, "V4iV4iV4i", "") BUILTIN(__builtin_altivec_vcmpequw, "V4iV4iV4i", "")
▲ Show 20 Lines • Show All 285 Lines • ▼ Show 20 Lines
BUILTIN(__builtin_altivec_vextddvrx, "V2ULLiV2ULLiV2ULLiUi", "") BUILTIN(__builtin_altivec_vextddvrx, "V2ULLiV2ULLiV2ULLiUi", "")
// P10 Vector rotate built-ins. // P10 Vector rotate built-ins.
BUILTIN(__builtin_altivec_vrlqmi, "V1ULLLiV1ULLLiV1ULLLiV1ULLLi", "") BUILTIN(__builtin_altivec_vrlqmi, "V1ULLLiV1ULLLiV1ULLLiV1ULLLi", "")
BUILTIN(__builtin_altivec_vrlqnm, "V1ULLLiV1ULLLiV1ULLLi", "") BUILTIN(__builtin_altivec_vrlqnm, "V1ULLLiV1ULLLiV1ULLLi", "")
// VSX built-ins. // VSX built-ins.
BUILTIN(__builtin_vsx_lxvd2x, "V2divC*", "") BUILTIN(__builtin_vsx_lxvd2x, "V2dLivC*", "")
BUILTIN(__builtin_vsx_lxvw4x, "V4iivC*", "") BUILTIN(__builtin_vsx_lxvw4x, "V4iLivC*", "")
BUILTIN(__builtin_vsx_lxvd2x_be, "V2dSLLivC*", "") BUILTIN(__builtin_vsx_lxvd2x_be, "V2dSLLivC*", "")
BUILTIN(__builtin_vsx_lxvw4x_be, "V4iSLLivC*", "") BUILTIN(__builtin_vsx_lxvw4x_be, "V4iSLLivC*", "")
BUILTIN(__builtin_vsx_stxvd2x, "vV2div*", "") BUILTIN(__builtin_vsx_stxvd2x, "vV2dLiv*", "")
BUILTIN(__builtin_vsx_stxvw4x, "vV4iiv*", "") BUILTIN(__builtin_vsx_stxvw4x, "vV4iLiv*", "")
BUILTIN(__builtin_vsx_stxvd2x_be, "vV2dSLLivC*", "") BUILTIN(__builtin_vsx_stxvd2x_be, "vV2dSLLivC*", "")
BUILTIN(__builtin_vsx_stxvw4x_be, "vV4iSLLivC*", "") BUILTIN(__builtin_vsx_stxvw4x_be, "vV4iSLLivC*", "")
BUILTIN(__builtin_vsx_lxvl, "V4ivC*ULLi", "") BUILTIN(__builtin_vsx_lxvl, "V4ivC*ULLi", "")
BUILTIN(__builtin_vsx_lxvll, "V4ivC*ULLi", "") BUILTIN(__builtin_vsx_lxvll, "V4ivC*ULLi", "")
BUILTIN(__builtin_vsx_stxvl, "vV4iv*ULLi", "") BUILTIN(__builtin_vsx_stxvl, "vV4iv*ULLi", "")
BUILTIN(__builtin_vsx_stxvll, "vV4iv*ULLi", "") BUILTIN(__builtin_vsx_stxvll, "vV4iv*ULLi", "")
▲ Show 20 Lines • Show All 320 Lines • Show Last 20 Lines

clang/lib/Headers/altivec.h

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
static __inline__ vector float __attribute__((__always_inline__)) static __inline__ vector float __attribute__((__always_inline__))
vec_vrfim(vector float __a) { vec_vrfim(vector float __a) {
return __builtin_altivec_vrfim(__a); return __builtin_altivec_vrfim(__a);
} }
/* vec_ld */ /* vec_ld */
static __inline__ vector signed char __ATTRS_o_ai static __inline__ vector signed char __ATTRS_o_ai
vec_ld(int __a, const vector signed char *__b) { vec_ld(long __a, const vector signed char *__b) {
return (vector signed char)__builtin_altivec_lvx(__a, __b); return (vector signed char)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector signed char __ATTRS_o_ai static __inline__ vector signed char __ATTRS_o_ai
vec_ld(int __a, const signed char *__b) { vec_ld(long __a, const signed char *__b) {
return (vector signed char)__builtin_altivec_lvx(__a, __b); return (vector signed char)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector unsigned char __ATTRS_o_ai static __inline__ vector unsigned char __ATTRS_o_ai
vec_ld(int __a, const vector unsigned char *__b) { vec_ld(long __a, const vector unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvx(__a, __b); return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector unsigned char __ATTRS_o_ai static __inline__ vector unsigned char __ATTRS_o_ai
vec_ld(int __a, const unsigned char *__b) { vec_ld(long __a, const unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvx(__a, __b); return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector bool char __ATTRS_o_ai static __inline__ vector bool char __ATTRS_o_ai
vec_ld(int __a, const vector bool char *__b) { vec_ld(long __a, const vector bool char *__b) {
return (vector bool char)__builtin_altivec_lvx(__a, __b); return (vector bool char)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector short __ATTRS_o_ai vec_ld(int __a, static __inline__ vector short __ATTRS_o_ai vec_ld(long __a,
const vector short *__b) { const vector short *__b) {
return (vector short)__builtin_altivec_lvx(__a, __b); return (vector short)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector short __ATTRS_o_ai vec_ld(int __a, const short *__b) { static __inline__ vector short __ATTRS_o_ai vec_ld(long __a, const short *__b) {
return (vector short)__builtin_altivec_lvx(__a, __b); return (vector short)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector unsigned short __ATTRS_o_ai static __inline__ vector unsigned short __ATTRS_o_ai
vec_ld(int __a, const vector unsigned short *__b) { vec_ld(long __a, const vector unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvx(__a, __b); return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector unsigned short __ATTRS_o_ai static __inline__ vector unsigned short __ATTRS_o_ai
vec_ld(int __a, const unsigned short *__b) { vec_ld(long __a, const unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvx(__a, __b); return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector bool short __ATTRS_o_ai static __inline__ vector bool short __ATTRS_o_ai
vec_ld(int __a, const vector bool short *__b) { vec_ld(long __a, const vector bool short *__b) {
return (vector bool short)__builtin_altivec_lvx(__a, __b); return (vector bool short)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector pixel __ATTRS_o_ai vec_ld(int __a, static __inline__ vector pixel __ATTRS_o_ai vec_ld(long __a,
const vector pixel *__b) { const vector pixel *__b) {
return (vector pixel)__builtin_altivec_lvx(__a, __b); return (vector pixel)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector int __ATTRS_o_ai vec_ld(int __a, static __inline__ vector int __ATTRS_o_ai vec_ld(long __a,
const vector int *__b) { const vector int *__b) {
return (vector int)__builtin_altivec_lvx(__a, __b); return (vector int)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector int __ATTRS_o_ai vec_ld(int __a, const int *__b) { static __inline__ vector int __ATTRS_o_ai vec_ld(long __a, const int *__b) {
return (vector int)__builtin_altivec_lvx(__a, __b); return (vector int)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector unsigned int __ATTRS_o_ai static __inline__ vector unsigned int __ATTRS_o_ai
vec_ld(int __a, const vector unsigned int *__b) { vec_ld(long __a, const vector unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvx(__a, __b); return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector unsigned int __ATTRS_o_ai static __inline__ vector unsigned int __ATTRS_o_ai
vec_ld(int __a, const unsigned int *__b) { vec_ld(long __a, const unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvx(__a, __b); return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector bool int __ATTRS_o_ai static __inline__ vector bool int __ATTRS_o_ai
vec_ld(int __a, const vector bool int *__b) { vec_ld(long __a, const vector bool int *__b) {
return (vector bool int)__builtin_altivec_lvx(__a, __b); return (vector bool int)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector float __ATTRS_o_ai vec_ld(int __a, static __inline__ vector float __ATTRS_o_ai vec_ld(long __a,
const vector float *__b) { const vector float *__b) {
return (vector float)__builtin_altivec_lvx(__a, __b); return (vector float)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector float __ATTRS_o_ai vec_ld(int __a, const float *__b) { static __inline__ vector float __ATTRS_o_ai vec_ld(long __a, const float *__b) {
return (vector float)__builtin_altivec_lvx(__a, __b); return (vector float)__builtin_altivec_lvx(__a, __b);
} }
/* vec_lvx */ /* vec_lvx */
static __inline__ vector signed char __ATTRS_o_ai static __inline__ vector signed char __ATTRS_o_ai
vec_lvx(int __a, const vector signed char *__b) { vec_lvx(long __a, const vector signed char *__b) {
return (vector signed char)__builtin_altivec_lvx(__a, __b); return (vector signed char)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector signed char __ATTRS_o_ai static __inline__ vector signed char __ATTRS_o_ai
vec_lvx(int __a, const signed char *__b) { vec_lvx(long __a, const signed char *__b) {
return (vector signed char)__builtin_altivec_lvx(__a, __b); return (vector signed char)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector unsigned char __ATTRS_o_ai static __inline__ vector unsigned char __ATTRS_o_ai
vec_lvx(int __a, const vector unsigned char *__b) { vec_lvx(long __a, const vector unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvx(__a, __b); return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector unsigned char __ATTRS_o_ai static __inline__ vector unsigned char __ATTRS_o_ai
vec_lvx(int __a, const unsigned char *__b) { vec_lvx(long __a, const unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvx(__a, __b); return (vector unsigned char)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector bool char __ATTRS_o_ai static __inline__ vector bool char __ATTRS_o_ai
vec_lvx(int __a, const vector bool char *__b) { vec_lvx(long __a, const vector bool char *__b) {
return (vector bool char)__builtin_altivec_lvx(__a, __b); return (vector bool char)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector short __ATTRS_o_ai vec_lvx(int __a, static __inline__ vector short __ATTRS_o_ai vec_lvx(long __a,
const vector short *__b) { const vector short *__b) {
return (vector short)__builtin_altivec_lvx(__a, __b); return (vector short)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector short __ATTRS_o_ai vec_lvx(int __a, const short *__b) { static __inline__ vector short __ATTRS_o_ai vec_lvx(long __a, const short *__b) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-static __inline__ vector short __ATTRS_o_ai vec_lvx(long __a, const short *__b) {
+static __inline__ vector short __ATTRS_o_ai vec_lvx(long __a,
+                                                    const short *__b) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` -static __inline__ vector short __ATTRS_o_ai vec_lvx…
return (vector short)__builtin_altivec_lvx(__a, __b); return (vector short)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector unsigned short __ATTRS_o_ai static __inline__ vector unsigned short __ATTRS_o_ai
vec_lvx(int __a, const vector unsigned short *__b) { vec_lvx(long __a, const vector unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvx(__a, __b); return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector unsigned short __ATTRS_o_ai static __inline__ vector unsigned short __ATTRS_o_ai
vec_lvx(int __a, const unsigned short *__b) { vec_lvx(long __a, const unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvx(__a, __b); return (vector unsigned short)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector bool short __ATTRS_o_ai static __inline__ vector bool short __ATTRS_o_ai
vec_lvx(int __a, const vector bool short *__b) { vec_lvx(long __a, const vector bool short *__b) {
return (vector bool short)__builtin_altivec_lvx(__a, __b); return (vector bool short)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector pixel __ATTRS_o_ai vec_lvx(int __a, static __inline__ vector pixel __ATTRS_o_ai vec_lvx(long __a,
const vector pixel *__b) { const vector pixel *__b) {
return (vector pixel)__builtin_altivec_lvx(__a, __b); return (vector pixel)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector int __ATTRS_o_ai vec_lvx(int __a, static __inline__ vector int __ATTRS_o_ai vec_lvx(long __a,
const vector int *__b) { const vector int *__b) {
return (vector int)__builtin_altivec_lvx(__a, __b); return (vector int)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector int __ATTRS_o_ai vec_lvx(int __a, const int *__b) { static __inline__ vector int __ATTRS_o_ai vec_lvx(long __a, const int *__b) {
return (vector int)__builtin_altivec_lvx(__a, __b); return (vector int)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector unsigned int __ATTRS_o_ai static __inline__ vector unsigned int __ATTRS_o_ai
vec_lvx(int __a, const vector unsigned int *__b) { vec_lvx(long __a, const vector unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvx(__a, __b); return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector unsigned int __ATTRS_o_ai static __inline__ vector unsigned int __ATTRS_o_ai
vec_lvx(int __a, const unsigned int *__b) { vec_lvx(long __a, const unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvx(__a, __b); return (vector unsigned int)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector bool int __ATTRS_o_ai static __inline__ vector bool int __ATTRS_o_ai
vec_lvx(int __a, const vector bool int *__b) { vec_lvx(long __a, const vector bool int *__b) {
return (vector bool int)__builtin_altivec_lvx(__a, __b); return (vector bool int)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector float __ATTRS_o_ai vec_lvx(int __a, static __inline__ vector float __ATTRS_o_ai vec_lvx(long __a,
const vector float *__b) { const vector float *__b) {
return (vector float)__builtin_altivec_lvx(__a, __b); return (vector float)__builtin_altivec_lvx(__a, __b);
} }
static __inline__ vector float __ATTRS_o_ai vec_lvx(int __a, const float *__b) { static __inline__ vector float __ATTRS_o_ai vec_lvx(long __a, const float *__b) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-static __inline__ vector float __ATTRS_o_ai vec_lvx(long __a, const float *__b) {
+static __inline__ vector float __ATTRS_o_ai vec_lvx(long __a,
+                                                    const float *__b) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` -static __inline__ vector float __ATTRS_o_ai vec_lvx…
return (vector float)__builtin_altivec_lvx(__a, __b); return (vector float)__builtin_altivec_lvx(__a, __b);
} }
/* vec_lde */ /* vec_lde */
static __inline__ vector signed char __ATTRS_o_ai static __inline__ vector signed char __ATTRS_o_ai
vec_lde(int __a, const signed char *__b) { vec_lde(long __a, const signed char *__b) {
return (vector signed char)__builtin_altivec_lvebx(__a, __b); return (vector signed char)__builtin_altivec_lvebx(__a, __b);
} }
static __inline__ vector unsigned char __ATTRS_o_ai static __inline__ vector unsigned char __ATTRS_o_ai
vec_lde(int __a, const unsigned char *__b) { vec_lde(long __a, const unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvebx(__a, __b); return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
} }
static __inline__ vector short __ATTRS_o_ai vec_lde(int __a, const short *__b) { static __inline__ vector short __ATTRS_o_ai vec_lde(long __a, const short *__b) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-static __inline__ vector short __ATTRS_o_ai vec_lde(long __a, const short *__b) {
+static __inline__ vector short __ATTRS_o_ai vec_lde(long __a,
+                                                    const short *__b) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` -static __inline__ vector short __ATTRS_o_ai vec_lde…
return (vector short)__builtin_altivec_lvehx(__a, __b); return (vector short)__builtin_altivec_lvehx(__a, __b);
} }
static __inline__ vector unsigned short __ATTRS_o_ai static __inline__ vector unsigned short __ATTRS_o_ai
vec_lde(int __a, const unsigned short *__b) { vec_lde(long __a, const unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvehx(__a, __b); return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
} }
static __inline__ vector int __ATTRS_o_ai vec_lde(int __a, const int *__b) { static __inline__ vector int __ATTRS_o_ai vec_lde(long __a, const int *__b) {
return (vector int)__builtin_altivec_lvewx(__a, __b); return (vector int)__builtin_altivec_lvewx(__a, __b);
} }
static __inline__ vector unsigned int __ATTRS_o_ai static __inline__ vector unsigned int __ATTRS_o_ai
vec_lde(int __a, const unsigned int *__b) { vec_lde(long __a, const unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvewx(__a, __b); return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
} }
static __inline__ vector float __ATTRS_o_ai vec_lde(int __a, const float *__b) { static __inline__ vector float __ATTRS_o_ai vec_lde(long __a, const float *__b) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-static __inline__ vector float __ATTRS_o_ai vec_lde(long __a, const float *__b) {
+static __inline__ vector float __ATTRS_o_ai vec_lde(long __a,
+                                                    const float *__b) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` -static __inline__ vector float __ATTRS_o_ai vec_lde…
return (vector float)__builtin_altivec_lvewx(__a, __b); return (vector float)__builtin_altivec_lvewx(__a, __b);
} }
/* vec_lvebx */ /* vec_lvebx */
static __inline__ vector signed char __ATTRS_o_ai static __inline__ vector signed char __ATTRS_o_ai
vec_lvebx(int __a, const signed char *__b) { vec_lvebx(long __a, const signed char *__b) {
return (vector signed char)__builtin_altivec_lvebx(__a, __b); return (vector signed char)__builtin_altivec_lvebx(__a, __b);
} }
static __inline__ vector unsigned char __ATTRS_o_ai static __inline__ vector unsigned char __ATTRS_o_ai
vec_lvebx(int __a, const unsigned char *__b) { vec_lvebx(long __a, const unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvebx(__a, __b); return (vector unsigned char)__builtin_altivec_lvebx(__a, __b);
} }
/* vec_lvehx */ /* vec_lvehx */
static __inline__ vector short __ATTRS_o_ai vec_lvehx(int __a, static __inline__ vector short __ATTRS_o_ai vec_lvehx(long __a,
const short *__b) { const short *__b) {
return (vector short)__builtin_altivec_lvehx(__a, __b); return (vector short)__builtin_altivec_lvehx(__a, __b);
} }
static __inline__ vector unsigned short __ATTRS_o_ai static __inline__ vector unsigned short __ATTRS_o_ai
vec_lvehx(int __a, const unsigned short *__b) { vec_lvehx(long __a, const unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvehx(__a, __b); return (vector unsigned short)__builtin_altivec_lvehx(__a, __b);
} }
/* vec_lvewx */ /* vec_lvewx */
static __inline__ vector int __ATTRS_o_ai vec_lvewx(int __a, const int *__b) { static __inline__ vector int __ATTRS_o_ai vec_lvewx(long __a, const int *__b) {
return (vector int)__builtin_altivec_lvewx(__a, __b); return (vector int)__builtin_altivec_lvewx(__a, __b);
} }
static __inline__ vector unsigned int __ATTRS_o_ai static __inline__ vector unsigned int __ATTRS_o_ai
vec_lvewx(int __a, const unsigned int *__b) { vec_lvewx(long __a, const unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvewx(__a, __b); return (vector unsigned int)__builtin_altivec_lvewx(__a, __b);
} }
static __inline__ vector float __ATTRS_o_ai vec_lvewx(int __a, static __inline__ vector float __ATTRS_o_ai vec_lvewx(long __a,
const float *__b) { const float *__b) {
return (vector float)__builtin_altivec_lvewx(__a, __b); return (vector float)__builtin_altivec_lvewx(__a, __b);
} }
/* vec_ldl */ /* vec_ldl */
static __inline__ vector signed char __ATTRS_o_ai static __inline__ vector signed char __ATTRS_o_ai
vec_ldl(int __a, const vector signed char *__b) { vec_ldl(long __a, const vector signed char *__b) {
return (vector signed char)__builtin_altivec_lvxl(__a, __b); return (vector signed char)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector signed char __ATTRS_o_ai static __inline__ vector signed char __ATTRS_o_ai
vec_ldl(int __a, const signed char *__b) { vec_ldl(long __a, const signed char *__b) {
return (vector signed char)__builtin_altivec_lvxl(__a, __b); return (vector signed char)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector unsigned char __ATTRS_o_ai static __inline__ vector unsigned char __ATTRS_o_ai
vec_ldl(int __a, const vector unsigned char *__b) { vec_ldl(long __a, const vector unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvxl(__a, __b); return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector unsigned char __ATTRS_o_ai static __inline__ vector unsigned char __ATTRS_o_ai
vec_ldl(int __a, const unsigned char *__b) { vec_ldl(long __a, const unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvxl(__a, __b); return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector bool char __ATTRS_o_ai static __inline__ vector bool char __ATTRS_o_ai
vec_ldl(int __a, const vector bool char *__b) { vec_ldl(long __a, const vector bool char *__b) {
return (vector bool char)__builtin_altivec_lvxl(__a, __b); return (vector bool char)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector short __ATTRS_o_ai vec_ldl(int __a, static __inline__ vector short __ATTRS_o_ai vec_ldl(long __a,
const vector short *__b) { const vector short *__b) {
return (vector short)__builtin_altivec_lvxl(__a, __b); return (vector short)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector short __ATTRS_o_ai vec_ldl(int __a, const short *__b) { static __inline__ vector short __ATTRS_o_ai vec_ldl(long __a, const short *__b) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-static __inline__ vector short __ATTRS_o_ai vec_ldl(long __a, const short *__b) {
+static __inline__ vector short __ATTRS_o_ai vec_ldl(long __a,
+                                                    const short *__b) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` -static __inline__ vector short __ATTRS_o_ai vec_ldl…
return (vector short)__builtin_altivec_lvxl(__a, __b); return (vector short)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector unsigned short __ATTRS_o_ai static __inline__ vector unsigned short __ATTRS_o_ai
vec_ldl(int __a, const vector unsigned short *__b) { vec_ldl(long __a, const vector unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvxl(__a, __b); return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector unsigned short __ATTRS_o_ai static __inline__ vector unsigned short __ATTRS_o_ai
vec_ldl(int __a, const unsigned short *__b) { vec_ldl(long __a, const unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvxl(__a, __b); return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector bool short __ATTRS_o_ai static __inline__ vector bool short __ATTRS_o_ai
vec_ldl(int __a, const vector bool short *__b) { vec_ldl(long __a, const vector bool short *__b) {
return (vector bool short)__builtin_altivec_lvxl(__a, __b); return (vector bool short)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector pixel __ATTRS_o_ai vec_ldl(int __a, static __inline__ vector pixel __ATTRS_o_ai vec_ldl(long __a,
const vector pixel *__b) { const vector pixel *__b) {
return (vector pixel short)__builtin_altivec_lvxl(__a, __b); return (vector pixel short)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector int __ATTRS_o_ai vec_ldl(int __a, static __inline__ vector int __ATTRS_o_ai vec_ldl(long __a,
const vector int *__b) { const vector int *__b) {
return (vector int)__builtin_altivec_lvxl(__a, __b); return (vector int)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector int __ATTRS_o_ai vec_ldl(int __a, const int *__b) { static __inline__ vector int __ATTRS_o_ai vec_ldl(long __a, const int *__b) {
return (vector int)__builtin_altivec_lvxl(__a, __b); return (vector int)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector unsigned int __ATTRS_o_ai static __inline__ vector unsigned int __ATTRS_o_ai
vec_ldl(int __a, const vector unsigned int *__b) { vec_ldl(long __a, const vector unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvxl(__a, __b); return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector unsigned int __ATTRS_o_ai static __inline__ vector unsigned int __ATTRS_o_ai
vec_ldl(int __a, const unsigned int *__b) { vec_ldl(long __a, const unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvxl(__a, __b); return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector bool int __ATTRS_o_ai static __inline__ vector bool int __ATTRS_o_ai
vec_ldl(int __a, const vector bool int *__b) { vec_ldl(long __a, const vector bool int *__b) {
return (vector bool int)__builtin_altivec_lvxl(__a, __b); return (vector bool int)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector float __ATTRS_o_ai vec_ldl(int __a, static __inline__ vector float __ATTRS_o_ai vec_ldl(long __a,
const vector float *__b) { const vector float *__b) {
return (vector float)__builtin_altivec_lvxl(__a, __b); return (vector float)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector float __ATTRS_o_ai vec_ldl(int __a, const float *__b) { static __inline__ vector float __ATTRS_o_ai vec_ldl(long __a, const float *__b) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-static __inline__ vector float __ATTRS_o_ai vec_ldl(long __a, const float *__b) {
+static __inline__ vector float __ATTRS_o_ai vec_ldl(long __a,
+                                                    const float *__b) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` -static __inline__ vector float __ATTRS_o_ai vec_ldl…
return (vector float)__builtin_altivec_lvxl(__a, __b); return (vector float)__builtin_altivec_lvxl(__a, __b);
} }
/* vec_lvxl */ /* vec_lvxl */
static __inline__ vector signed char __ATTRS_o_ai static __inline__ vector signed char __ATTRS_o_ai
vec_lvxl(int __a, const vector signed char *__b) { vec_lvxl(long __a, const vector signed char *__b) {
return (vector signed char)__builtin_altivec_lvxl(__a, __b); return (vector signed char)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector signed char __ATTRS_o_ai static __inline__ vector signed char __ATTRS_o_ai
vec_lvxl(int __a, const signed char *__b) { vec_lvxl(long __a, const signed char *__b) {
return (vector signed char)__builtin_altivec_lvxl(__a, __b); return (vector signed char)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector unsigned char __ATTRS_o_ai static __inline__ vector unsigned char __ATTRS_o_ai
vec_lvxl(int __a, const vector unsigned char *__b) { vec_lvxl(long __a, const vector unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvxl(__a, __b); return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector unsigned char __ATTRS_o_ai static __inline__ vector unsigned char __ATTRS_o_ai
vec_lvxl(int __a, const unsigned char *__b) { vec_lvxl(long __a, const unsigned char *__b) {
return (vector unsigned char)__builtin_altivec_lvxl(__a, __b); return (vector unsigned char)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector bool char __ATTRS_o_ai static __inline__ vector bool char __ATTRS_o_ai
vec_lvxl(int __a, const vector bool char *__b) { vec_lvxl(long __a, const vector bool char *__b) {
return (vector bool char)__builtin_altivec_lvxl(__a, __b); return (vector bool char)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector short __ATTRS_o_ai vec_lvxl(int __a, static __inline__ vector short __ATTRS_o_ai vec_lvxl(long __a,
const vector short *__b) { const vector short *__b) {
return (vector short)__builtin_altivec_lvxl(__a, __b); return (vector short)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector short __ATTRS_o_ai vec_lvxl(int __a, static __inline__ vector short __ATTRS_o_ai vec_lvxl(long __a,
const short *__b) { const short *__b) {
return (vector short)__builtin_altivec_lvxl(__a, __b); return (vector short)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector unsigned short __ATTRS_o_ai static __inline__ vector unsigned short __ATTRS_o_ai
vec_lvxl(int __a, const vector unsigned short *__b) { vec_lvxl(long __a, const vector unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvxl(__a, __b); return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector unsigned short __ATTRS_o_ai static __inline__ vector unsigned short __ATTRS_o_ai
vec_lvxl(int __a, const unsigned short *__b) { vec_lvxl(long __a, const unsigned short *__b) {
return (vector unsigned short)__builtin_altivec_lvxl(__a, __b); return (vector unsigned short)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector bool short __ATTRS_o_ai static __inline__ vector bool short __ATTRS_o_ai
vec_lvxl(int __a, const vector bool short *__b) { vec_lvxl(long __a, const vector bool short *__b) {
return (vector bool short)__builtin_altivec_lvxl(__a, __b); return (vector bool short)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector pixel __ATTRS_o_ai vec_lvxl(int __a, static __inline__ vector pixel __ATTRS_o_ai vec_lvxl(long __a,
const vector pixel *__b) { const vector pixel *__b) {
return (vector pixel)__builtin_altivec_lvxl(__a, __b); return (vector pixel)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector int __ATTRS_o_ai vec_lvxl(int __a, static __inline__ vector int __ATTRS_o_ai vec_lvxl(long __a,
const vector int *__b) { const vector int *__b) {
return (vector int)__builtin_altivec_lvxl(__a, __b); return (vector int)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector int __ATTRS_o_ai vec_lvxl(int __a, const int *__b) { static __inline__ vector int __ATTRS_o_ai vec_lvxl(long __a, const int *__b) {
return (vector int)__builtin_altivec_lvxl(__a, __b); return (vector int)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector unsigned int __ATTRS_o_ai static __inline__ vector unsigned int __ATTRS_o_ai
vec_lvxl(int __a, const vector unsigned int *__b) { vec_lvxl(long __a, const vector unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvxl(__a, __b); return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector unsigned int __ATTRS_o_ai static __inline__ vector unsigned int __ATTRS_o_ai
vec_lvxl(int __a, const unsigned int *__b) { vec_lvxl(long __a, const unsigned int *__b) {
return (vector unsigned int)__builtin_altivec_lvxl(__a, __b); return (vector unsigned int)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector bool int __ATTRS_o_ai static __inline__ vector bool int __ATTRS_o_ai
vec_lvxl(int __a, const vector bool int *__b) { vec_lvxl(long __a, const vector bool int *__b) {
return (vector bool int)__builtin_altivec_lvxl(__a, __b); return (vector bool int)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector float __ATTRS_o_ai vec_lvxl(int __a, static __inline__ vector float __ATTRS_o_ai vec_lvxl(long __a,
const vector float *__b) { const vector float *__b) {
return (vector float)__builtin_altivec_lvxl(__a, __b); return (vector float)__builtin_altivec_lvxl(__a, __b);
} }
static __inline__ vector float __ATTRS_o_ai vec_lvxl(int __a, static __inline__ vector float __ATTRS_o_ai vec_lvxl(long __a,
const float *__b) { const float *__b) {
return (vector float)__builtin_altivec_lvxl(__a, __b); return (vector float)__builtin_altivec_lvxl(__a, __b);
} }
/* vec_loge */ /* vec_loge */
static __inline__ vector float __attribute__((__always_inline__)) static __inline__ vector float __attribute__((__always_inline__))
vec_loge(vector float __a) { vec_loge(vector float __a) {
▲ Show 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines
static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a, static __inline__ vector float __ATTRS_o_ai vec_vsro(vector float __a,
vector unsigned char __b) { vector unsigned char __b) {
return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b); return (vector float)__builtin_altivec_vsro((vector int)__a, (vector int)__b);
} }
/* vec_st */ /* vec_st */
static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, long __b,
vector signed char *__c) { vector signed char *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector signed char __a, long __b,
signed char *__c) { signed char *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, long __b,
vector unsigned char *__c) { vector unsigned char *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector unsigned char __a, long __b,
unsigned char *__c) { unsigned char *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, long __b,
signed char *__c) { signed char *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, long __b,
unsigned char *__c) { unsigned char *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector bool char __a, long __b,
vector bool char *__c) { vector bool char *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector short __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector short __a, long __b,
vector short *__c) { vector short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector short __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector short __a, long __b,
short *__c) { short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, long __b,
vector unsigned short *__c) { vector unsigned short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector unsigned short __a, long __b,
unsigned short *__c) { unsigned short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, long __b,
short *__c) { short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, long __b,
unsigned short *__c) { unsigned short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector bool short __a, long __b,
vector bool short *__c) { vector bool short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, long __b,
short *__c) { short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, long __b,
unsigned short *__c) { unsigned short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector pixel __a, long __b,
vector pixel *__c) { vector pixel *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector int __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector int __a, long __b,
vector int *__c) { vector int *__c) {
__builtin_altivec_stvx(__a, __b, __c); __builtin_altivec_stvx(__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector int __a, int __b, int *__c) { static __inline__ void __ATTRS_o_ai vec_st(vector int __a, long __b, int *__c) {
__builtin_altivec_stvx(__a, __b, __c); __builtin_altivec_stvx(__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, long __b,
vector unsigned int *__c) { vector unsigned int *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector unsigned int __a, long __b,
unsigned int *__c) { unsigned int *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, long __b,
int *__c) { int *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, long __b,
unsigned int *__c) { unsigned int *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector bool int __a, long __b,
vector bool int *__c) { vector bool int *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector float __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector float __a, long __b,
vector float *__c) { vector float *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_st(vector float __a, int __b, static __inline__ void __ATTRS_o_ai vec_st(vector float __a, long __b,
float *__c) { float *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
/* vec_stvx */ /* vec_stvx */
static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, long __b,
vector signed char *__c) { vector signed char *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector signed char __a, long __b,
signed char *__c) { signed char *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, long __b,
vector unsigned char *__c) { vector unsigned char *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned char __a, long __b,
unsigned char *__c) { unsigned char *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, long __b,
signed char *__c) { signed char *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, long __b,
unsigned char *__c) { unsigned char *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector bool char __a, long __b,
vector bool char *__c) { vector bool char *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, long __b,
vector short *__c) { vector short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector short __a, long __b,
short *__c) { short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, long __b,
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, long __b,
+static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a,
+                                             long __b,
Lint: Pre-merge checks: clang-format: please reformat the code ``` -static __inline__ void __ATTRS_o_ai vec_stvx(vector…
vector unsigned short *__c) { vector unsigned short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, long __b,
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a, long __b,
-                                             unsigned short *__c) {
+static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned short __a,
+                                             long __b, unsigned short *__c) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` -static __inline__ void __ATTRS_o_ai vec_stvx(vector…
unsigned short *__c) { unsigned short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, long __b,
short *__c) { short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, long __b,
unsigned short *__c) { unsigned short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector bool short __a, long __b,
vector bool short *__c) { vector bool short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, long __b,
short *__c) { short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, long __b,
unsigned short *__c) { unsigned short *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector pixel __a, long __b,
vector pixel *__c) { vector pixel *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, long __b,
vector int *__c) { vector int *__c) {
__builtin_altivec_stvx(__a, __b, __c); __builtin_altivec_stvx(__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector int __a, long __b,
int *__c) { int *__c) {
__builtin_altivec_stvx(__a, __b, __c); __builtin_altivec_stvx(__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, long __b,
vector unsigned int *__c) { vector unsigned int *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector unsigned int __a, long __b,
unsigned int *__c) { unsigned int *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, long __b,
int *__c) { int *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, long __b,
unsigned int *__c) { unsigned int *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector bool int __a, long __b,
vector bool int *__c) { vector bool int *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, long __b,
vector float *__c) { vector float *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvx(vector float __a, long __b,
float *__c) { float *__c) {
__builtin_altivec_stvx((vector int)__a, __b, __c); __builtin_altivec_stvx((vector int)__a, __b, __c);
} }
/* vec_ste */ /* vec_ste */
static __inline__ void __ATTRS_o_ai vec_ste(vector signed char __a, int __b, static __inline__ void __ATTRS_o_ai vec_ste(vector signed char __a, long __b,
signed char *__c) { signed char *__c) {
__builtin_altivec_stvebx((vector char)__a, __b, __c); __builtin_altivec_stvebx((vector char)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned char __a, int __b, static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned char __a, long __b,
unsigned char *__c) { unsigned char *__c) {
__builtin_altivec_stvebx((vector char)__a, __b, __c); __builtin_altivec_stvebx((vector char)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, int __b, static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, long __b,
signed char *__c) { signed char *__c) {
__builtin_altivec_stvebx((vector char)__a, __b, __c); __builtin_altivec_stvebx((vector char)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, int __b, static __inline__ void __ATTRS_o_ai vec_ste(vector bool char __a, long __b,
unsigned char *__c) { unsigned char *__c) {
__builtin_altivec_stvebx((vector char)__a, __b, __c); __builtin_altivec_stvebx((vector char)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_ste(vector short __a, int __b, static __inline__ void __ATTRS_o_ai vec_ste(vector short __a, long __b,
short *__c) { short *__c) {
__builtin_altivec_stvehx(__a, __b, __c); __builtin_altivec_stvehx(__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned short __a, int __b, static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned short __a, long __b,
unsigned short *__c) { unsigned short *__c) {
__builtin_altivec_stvehx((vector short)__a, __b, __c); __builtin_altivec_stvehx((vector short)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, int __b, static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, long __b,
short *__c) { short *__c) {
__builtin_altivec_stvehx((vector short)__a, __b, __c); __builtin_altivec_stvehx((vector short)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, int __b, static __inline__ void __ATTRS_o_ai vec_ste(vector bool short __a, long __b,
unsigned short *__c) { unsigned short *__c) {
__builtin_altivec_stvehx((vector short)__a, __b, __c); __builtin_altivec_stvehx((vector short)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, int __b, static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, long __b,
short *__c) { short *__c) {
__builtin_altivec_stvehx((vector short)__a, __b, __c); __builtin_altivec_stvehx((vector short)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, int __b, static __inline__ void __ATTRS_o_ai vec_ste(vector pixel __a, long __b,
unsigned short *__c) { unsigned short *__c) {
__builtin_altivec_stvehx((vector short)__a, __b, __c); __builtin_altivec_stvehx((vector short)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_ste(vector int __a, int __b, int *__c) { static __inline__ void __ATTRS_o_ai vec_ste(vector int __a, long __b, int *__c) {
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-static __inline__ void __ATTRS_o_ai vec_ste(vector int __a, long __b, int *__c) {
+static __inline__ void __ATTRS_o_ai vec_ste(vector int __a, long __b,
+                                            int *__c) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` -static __inline__ void __ATTRS_o_ai vec_ste(vector…
__builtin_altivec_stvewx(__a, __b, __c); __builtin_altivec_stvewx(__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned int __a, int __b, static __inline__ void __ATTRS_o_ai vec_ste(vector unsigned int __a, long __b,
unsigned int *__c) { unsigned int *__c) {
__builtin_altivec_stvewx((vector int)__a, __b, __c); __builtin_altivec_stvewx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, int __b, static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, long __b,
int *__c) { int *__c) {
__builtin_altivec_stvewx((vector int)__a, __b, __c); __builtin_altivec_stvewx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, int __b, static __inline__ void __ATTRS_o_ai vec_ste(vector bool int __a, long __b,
unsigned int *__c) { unsigned int *__c) {
__builtin_altivec_stvewx((vector int)__a, __b, __c); __builtin_altivec_stvewx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_ste(vector float __a, int __b, static __inline__ void __ATTRS_o_ai vec_ste(vector float __a, long __b,
float *__c) { float *__c) {
__builtin_altivec_stvewx((vector int)__a, __b, __c); __builtin_altivec_stvewx((vector int)__a, __b, __c);
} }
/* vec_stvebx */ /* vec_stvebx */
static __inline__ void __ATTRS_o_ai vec_stvebx(vector signed char __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvebx(vector signed char __a, long __b,
signed char *__c) { signed char *__c) {
__builtin_altivec_stvebx((vector char)__a, __b, __c); __builtin_altivec_stvebx((vector char)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvebx(vector unsigned char __a, static __inline__ void __ATTRS_o_ai vec_stvebx(vector unsigned char __a,
int __b, unsigned char *__c) { long __b, unsigned char *__c) {
__builtin_altivec_stvebx((vector char)__a, __b, __c); __builtin_altivec_stvebx((vector char)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, long __b,
signed char *__c) { signed char *__c) {
__builtin_altivec_stvebx((vector char)__a, __b, __c); __builtin_altivec_stvebx((vector char)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvebx(vector bool char __a, long __b,
unsigned char *__c) { unsigned char *__c) {
__builtin_altivec_stvebx((vector char)__a, __b, __c); __builtin_altivec_stvebx((vector char)__a, __b, __c);
} }
/* vec_stvehx */ /* vec_stvehx */
static __inline__ void __ATTRS_o_ai vec_stvehx(vector short __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvehx(vector short __a, long __b,
short *__c) { short *__c) {
__builtin_altivec_stvehx(__a, __b, __c); __builtin_altivec_stvehx(__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvehx(vector unsigned short __a, static __inline__ void __ATTRS_o_ai vec_stvehx(vector unsigned short __a,
int __b, unsigned short *__c) { long __b, unsigned short *__c) {
__builtin_altivec_stvehx((vector short)__a, __b, __c); __builtin_altivec_stvehx((vector short)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, long __b,
short *__c) { short *__c) {
__builtin_altivec_stvehx((vector short)__a, __b, __c); __builtin_altivec_stvehx((vector short)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvehx(vector bool short __a, long __b,
unsigned short *__c) { unsigned short *__c) {
__builtin_altivec_stvehx((vector short)__a, __b, __c); __builtin_altivec_stvehx((vector short)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, long __b,
short *__c) { short *__c) {
__builtin_altivec_stvehx((vector short)__a, __b, __c); __builtin_altivec_stvehx((vector short)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvehx(vector pixel __a, long __b,
unsigned short *__c) { unsigned short *__c) {
__builtin_altivec_stvehx((vector short)__a, __b, __c); __builtin_altivec_stvehx((vector short)__a, __b, __c);
} }
/* vec_stvewx */ /* vec_stvewx */
static __inline__ void __ATTRS_o_ai vec_stvewx(vector int __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvewx(vector int __a, long __b,
int *__c) { int *__c) {
__builtin_altivec_stvewx(__a, __b, __c); __builtin_altivec_stvewx(__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvewx(vector unsigned int __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvewx(vector unsigned int __a, long __b,
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-static __inline__ void __ATTRS_o_ai vec_stvewx(vector unsigned int __a, long __b,
-                                               unsigned int *__c) {
+static __inline__ void __ATTRS_o_ai vec_stvewx(vector unsigned int __a,
+                                               long __b, unsigned int *__c) {
Lint: Pre-merge checks: clang-format: please reformat the code ``` -static __inline__ void __ATTRS_o_ai vec_stvewx…
unsigned int *__c) { unsigned int *__c) {
__builtin_altivec_stvewx((vector int)__a, __b, __c); __builtin_altivec_stvewx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, long __b,
int *__c) { int *__c) {
__builtin_altivec_stvewx((vector int)__a, __b, __c); __builtin_altivec_stvewx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvewx(vector bool int __a, long __b,
unsigned int *__c) { unsigned int *__c) {
__builtin_altivec_stvewx((vector int)__a, __b, __c); __builtin_altivec_stvewx((vector int)__a, __b, __c);
} }
static __inline__ void __ATTRS_o_ai vec_stvewx(vector float __a, int __b, static __inline__ void __ATTRS_o_ai vec_stvewx(vector float __a, long __b,
float *__c) { float *__c) {
__builtin_altivec_stvewx((vector int)__a, __b, __c); __builtin_altivec_stvewx((vector int)__a, __b, __c);
} }
/* vec_stl */ /* vec_stl */
static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b, static __inline__ void __ATTRS_o_ai vec_stl(vector signed char __a, int __b,
vector signed char *__c) { vector signed char *__c) {
▲ Show 20 Lines • Show All 991 Lines • Show Last 20 Lines

clang/test/CodeGen/ppc-emmintrin.c

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
} }
// CHECK-LABEL: @test_load // CHECK-LABEL: @test_load
// CHECK: define available_externally <2 x double> @_mm_load_pd(double* [[REG917:[0-9a-zA-Z_%.]+]]) // CHECK: define available_externally <2 x double> @_mm_load_pd(double* [[REG917:[0-9a-zA-Z_%.]+]])
// CHECK: store double* [[REG917]], double** [[REG918:[0-9a-zA-Z_%.]+]], align 8 // CHECK: store double* [[REG917]], double** [[REG918:[0-9a-zA-Z_%.]+]], align 8
// CHECK-NEXT: [[REG919:[0-9a-zA-Z_%.]+]] = load double*, double** [[REG918]], align 8 // CHECK-NEXT: [[REG919:[0-9a-zA-Z_%.]+]] = load double*, double** [[REG918]], align 8
// CHECK-NEXT: [[REG920:[0-9a-zA-Z_%.]+]] = bitcast double* [[REG919]] to <16 x i8>* // CHECK-NEXT: [[REG920:[0-9a-zA-Z_%.]+]] = bitcast double* [[REG919]] to <16 x i8>*
// CHECK-NEXT: [[REG921:[0-9a-zA-Z_%.]+]] = call <16 x i8> @vec_ld(int, unsigned char vector[16] const*)(i32 signext 0, <16 x i8>* [[REG920]]) // CHECK-NEXT: [[REG921:[0-9a-zA-Z_%.]+]] = call <16 x i8> @vec_ld(long, unsigned char vector[16] const*)(i64 0, <16 x i8>* [[REG920]])
// CHECK-NEXT: [[REG922:[0-9a-zA-Z_%.]+]] = bitcast <16 x i8> [[REG921]] to <2 x double> // CHECK-NEXT: [[REG922:[0-9a-zA-Z_%.]+]] = bitcast <16 x i8> [[REG921]] to <2 x double>
// CHECK-NEXT: ret <2 x double> [[REG922]] // CHECK-NEXT: ret <2 x double> [[REG922]]
// CHECK: define available_externally <2 x double> @_mm_load_pd1(double* [[REG923:[0-9a-zA-Z_%.]+]]) // CHECK: define available_externally <2 x double> @_mm_load_pd1(double* [[REG923:[0-9a-zA-Z_%.]+]])
// CHECK: store double* [[REG923]], double** [[REG924:[0-9a-zA-Z_%.]+]], align 8 // CHECK: store double* [[REG923]], double** [[REG924:[0-9a-zA-Z_%.]+]], align 8
// CHECK-NEXT: [[REG925:[0-9a-zA-Z_%.]+]] = load double*, double** [[REG924]], align 8 // CHECK-NEXT: [[REG925:[0-9a-zA-Z_%.]+]] = load double*, double** [[REG924]], align 8
// CHECK-NEXT: [[REG926:[0-9a-zA-Z_%.]+]] = call <2 x double> @_mm_load1_pd(double* [[REG925]]) // CHECK-NEXT: [[REG926:[0-9a-zA-Z_%.]+]] = call <2 x double> @_mm_load1_pd(double* [[REG925]])
// CHECK-NEXT: ret <2 x double> [[REG926]] // CHECK-NEXT: ret <2 x double> [[REG926]]
▲ Show 20 Lines • Show All 1,537 Lines • ▼ Show 20 Lines
// CHECK: define available_externally void @_mm_store_pd(double* [[REG1920:[0-9a-zA-Z_%.]+]], <2 x double> [[REG1921:[0-9a-zA-Z_%.]+]]) // CHECK: define available_externally void @_mm_store_pd(double* [[REG1920:[0-9a-zA-Z_%.]+]], <2 x double> [[REG1921:[0-9a-zA-Z_%.]+]])
// CHECK: store double* [[REG1920]], double** [[REG1922:[0-9a-zA-Z_%.]+]], align 8 // CHECK: store double* [[REG1920]], double** [[REG1922:[0-9a-zA-Z_%.]+]], align 8
// CHECK-NEXT: store <2 x double> [[REG1921]], <2 x double>* [[REG1923:[0-9a-zA-Z_%.]+]], align 16 // CHECK-NEXT: store <2 x double> [[REG1921]], <2 x double>* [[REG1923:[0-9a-zA-Z_%.]+]], align 16
// CHECK-NEXT: [[REG1924:[0-9a-zA-Z_%.]+]] = load <2 x double>, <2 x double>* [[REG1923]], align 16 // CHECK-NEXT: [[REG1924:[0-9a-zA-Z_%.]+]] = load <2 x double>, <2 x double>* [[REG1923]], align 16
// CHECK-NEXT: [[REG1925:[0-9a-zA-Z_%.]+]] = bitcast <2 x double> [[REG1924]] to <16 x i8> // CHECK-NEXT: [[REG1925:[0-9a-zA-Z_%.]+]] = bitcast <2 x double> [[REG1924]] to <16 x i8>
// CHECK-NEXT: [[REG1926:[0-9a-zA-Z_%.]+]] = load double*, double** [[REG1922]], align 8 // CHECK-NEXT: [[REG1926:[0-9a-zA-Z_%.]+]] = load double*, double** [[REG1922]], align 8
// CHECK-NEXT: [[REG1927:[0-9a-zA-Z_%.]+]] = bitcast double* [[REG1926]] to <16 x i8>* // CHECK-NEXT: [[REG1927:[0-9a-zA-Z_%.]+]] = bitcast double* [[REG1926]] to <16 x i8>*
// CHECK-NEXT: call void @vec_st(unsigned char vector[16], int, unsigned char vector[16]*)(<16 x i8> [[REG1925]], i32 signext 0, <16 x i8>* [[REG1927]]) // CHECK-NEXT: call void @vec_st(unsigned char vector[16], long, unsigned char vector[16]*)(<16 x i8> [[REG1925]], i64 0, <16 x i8>* [[REG1927]])
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// CHECK: define available_externally void @_mm_store_pd1(double* [[REG1928:[0-9a-zA-Z_%.]+]], <2 x double> [[REG1929:[0-9a-zA-Z_%.]+]]) // CHECK: define available_externally void @_mm_store_pd1(double* [[REG1928:[0-9a-zA-Z_%.]+]], <2 x double> [[REG1929:[0-9a-zA-Z_%.]+]])
// CHECK: store double* [[REG1928]], double** [[REG1930:[0-9a-zA-Z_%.]+]], align 8 // CHECK: store double* [[REG1928]], double** [[REG1930:[0-9a-zA-Z_%.]+]], align 8
// CHECK-NEXT: store <2 x double> [[REG1929]], <2 x double>* [[REG1931:[0-9a-zA-Z_%.]+]], align 16 // CHECK-NEXT: store <2 x double> [[REG1929]], <2 x double>* [[REG1931:[0-9a-zA-Z_%.]+]], align 16
// CHECK-NEXT: [[REG1932:[0-9a-zA-Z_%.]+]] = load double*, double** [[REG1930]], align 8 // CHECK-NEXT: [[REG1932:[0-9a-zA-Z_%.]+]] = load double*, double** [[REG1930]], align 8
// CHECK-NEXT: [[REG1933:[0-9a-zA-Z_%.]+]] = load <2 x double>, <2 x double>* [[REG1931]], align 16 // CHECK-NEXT: [[REG1933:[0-9a-zA-Z_%.]+]] = load <2 x double>, <2 x double>* [[REG1931]], align 16
// CHECK-NEXT: call void @_mm_store1_pd(double* [[REG1932]], <2 x double> [[REG1933]]) // CHECK-NEXT: call void @_mm_store1_pd(double* [[REG1932]], <2 x double> [[REG1933]])
Show All 10 Lines
// CHECK: define available_externally void @_mm_store_si128(<2 x i64>* [[REG1941:[0-9a-zA-Z_%.]+]], <2 x i64> [[REG1942:[0-9a-zA-Z_%.]+]]) // CHECK: define available_externally void @_mm_store_si128(<2 x i64>* [[REG1941:[0-9a-zA-Z_%.]+]], <2 x i64> [[REG1942:[0-9a-zA-Z_%.]+]])
// CHECK: store <2 x i64>* [[REG1941]], <2 x i64>** [[REG1943:[0-9a-zA-Z_%.]+]], align 8 // CHECK: store <2 x i64>* [[REG1941]], <2 x i64>** [[REG1943:[0-9a-zA-Z_%.]+]], align 8
// CHECK-NEXT: store <2 x i64> [[REG1942]], <2 x i64>* [[REG1944:[0-9a-zA-Z_%.]+]], align 16 // CHECK-NEXT: store <2 x i64> [[REG1942]], <2 x i64>* [[REG1944:[0-9a-zA-Z_%.]+]], align 16
// CHECK-NEXT: [[REG1945:[0-9a-zA-Z_%.]+]] = load <2 x i64>, <2 x i64>* [[REG1944]], align 16 // CHECK-NEXT: [[REG1945:[0-9a-zA-Z_%.]+]] = load <2 x i64>, <2 x i64>* [[REG1944]], align 16
// CHECK-NEXT: [[REG1946:[0-9a-zA-Z_%.]+]] = bitcast <2 x i64> [[REG1945]] to <16 x i8> // CHECK-NEXT: [[REG1946:[0-9a-zA-Z_%.]+]] = bitcast <2 x i64> [[REG1945]] to <16 x i8>
// CHECK-NEXT: [[REG1947:[0-9a-zA-Z_%.]+]] = load <2 x i64>*, <2 x i64>** [[REG1943]], align 8 // CHECK-NEXT: [[REG1947:[0-9a-zA-Z_%.]+]] = load <2 x i64>*, <2 x i64>** [[REG1943]], align 8
// CHECK-NEXT: [[REG1948:[0-9a-zA-Z_%.]+]] = bitcast <2 x i64>* [[REG1947]] to <16 x i8>* // CHECK-NEXT: [[REG1948:[0-9a-zA-Z_%.]+]] = bitcast <2 x i64>* [[REG1947]] to <16 x i8>*
// CHECK-NEXT: call void @vec_st(unsigned char vector[16], int, unsigned char vector[16]*)(<16 x i8> [[REG1946]], i32 signext 0, <16 x i8>* [[REG1948]]) // CHECK-NEXT: call void @vec_st(unsigned char vector[16], long, unsigned char vector[16]*)(<16 x i8> [[REG1946]], i64 0, <16 x i8>* [[REG1948]])
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// CHECK: define available_externally void @_mm_store1_pd(double* [[REG1949:[0-9a-zA-Z_%.]+]], <2 x double> [[REG1950:[0-9a-zA-Z_%.]+]]) // CHECK: define available_externally void @_mm_store1_pd(double* [[REG1949:[0-9a-zA-Z_%.]+]], <2 x double> [[REG1950:[0-9a-zA-Z_%.]+]])
// CHECK: store double* [[REG1949]], double** [[REG1951:[0-9a-zA-Z_%.]+]], align 8 // CHECK: store double* [[REG1949]], double** [[REG1951:[0-9a-zA-Z_%.]+]], align 8
// CHECK-NEXT: store <2 x double> [[REG1950]], <2 x double>* [[REG1952:[0-9a-zA-Z_%.]+]], align 16 // CHECK-NEXT: store <2 x double> [[REG1950]], <2 x double>* [[REG1952:[0-9a-zA-Z_%.]+]], align 16
// CHECK-NEXT: [[REG1953:[0-9a-zA-Z_%.]+]] = load double*, double** [[REG1951]], align 8 // CHECK-NEXT: [[REG1953:[0-9a-zA-Z_%.]+]] = load double*, double** [[REG1951]], align 8
// CHECK-NEXT: [[REG1954:[0-9a-zA-Z_%.]+]] = load <2 x double>, <2 x double>* [[REG1952]], align 16 // CHECK-NEXT: [[REG1954:[0-9a-zA-Z_%.]+]] = load <2 x double>, <2 x double>* [[REG1952]], align 16
// CHECK-NEXT: [[REG1955:[0-9a-zA-Z_%.]+]] = call <2 x double> @vec_splat(double vector[2], unsigned int)(<2 x double> [[REG1954]], i32 zeroext 0) // CHECK-NEXT: [[REG1955:[0-9a-zA-Z_%.]+]] = call <2 x double> @vec_splat(double vector[2], unsigned int)(<2 x double> [[REG1954]], i32 zeroext 0)
▲ Show 20 Lines • Show All 318 Lines • Show Last 20 Lines

clang/test/CodeGen/ppc-xmmintrin.c

Show First 20 Lines • Show All 947 Lines • ▼ Show 20 Linestest_load() {
res = _mm_loadl_pi(m1, &ms[0]); res = _mm_loadl_pi(m1, &ms[0]);
res = _mm_loadr_ps(fs); res = _mm_loadr_ps(fs);
res = _mm_loadu_ps(fs); res = _mm_loadu_ps(fs);
} }
// CHECK-LABEL: @test_load // CHECK-LABEL: @test_load
// CHECK: define available_externally <4 x float> @_mm_load_ps // CHECK: define available_externally <4 x float> @_mm_load_ps
// CHECK: [[REG469:[0-9a-zA-Z_%.]+]] = call <4 x float> @vec_ld(int, float vector[4] const*) // CHECK: [[REG469:[0-9a-zA-Z_%.]+]] = call <4 x float> @vec_ld(long, float vector[4] const*)
// CHECK-NEXT: ret <4 x float> [[REG469]] // CHECK-NEXT: ret <4 x float> [[REG469]]
// CHECK: define available_externally <4 x float> @_mm_load_ps1 // CHECK: define available_externally <4 x float> @_mm_load_ps1
// CHECK: [[REG470:[0-9a-zA-Z_%.]+]] = call <4 x float> @_mm_load1_ps // CHECK: [[REG470:[0-9a-zA-Z_%.]+]] = call <4 x float> @_mm_load1_ps
// CHECK-NEXT: ret <4 x float> [[REG470]] // CHECK-NEXT: ret <4 x float> [[REG470]]
// CHECK: define available_externally <4 x float> @_mm_load_ss // CHECK: define available_externally <4 x float> @_mm_load_ss
// CHECK: [[REG471:[0-9a-zA-Z_%.]+]] = call <4 x float> @_mm_set_ss // CHECK: [[REG471:[0-9a-zA-Z_%.]+]] = call <4 x float> @_mm_set_ss
Show All 23 Lines
// CHECK-NEXT: [[REG486:[0-9a-zA-Z_%.]+]] = load <2 x i64>, <2 x i64>* [[REG487:[0-9a-zA-Z_%.]+]], align 16 // CHECK-NEXT: [[REG486:[0-9a-zA-Z_%.]+]] = load <2 x i64>, <2 x i64>* [[REG487:[0-9a-zA-Z_%.]+]], align 16
// CHECK-NEXT: [[REG488:[0-9a-zA-Z_%.]+]] = insertelement <2 x i64> [[REG486]], i64 [[REG485]], i32 0 // CHECK-NEXT: [[REG488:[0-9a-zA-Z_%.]+]] = insertelement <2 x i64> [[REG486]], i64 [[REG485]], i32 0
// CHECK-NEXT: store <2 x i64> [[REG488]], <2 x i64>* [[REG487]], align 16 // CHECK-NEXT: store <2 x i64> [[REG488]], <2 x i64>* [[REG487]], align 16
// CHECK-NEXT: [[REG489:[0-9a-zA-Z_%.]+]] = load <2 x i64>, <2 x i64>* [[REG487]], align 16 // CHECK-NEXT: [[REG489:[0-9a-zA-Z_%.]+]] = load <2 x i64>, <2 x i64>* [[REG487]], align 16
// CHECK-NEXT: [[REG490:[0-9a-zA-Z_%.]+]] = bitcast <2 x i64> [[REG489]] to <4 x float> // CHECK-NEXT: [[REG490:[0-9a-zA-Z_%.]+]] = bitcast <2 x i64> [[REG489]] to <4 x float>
// CHECK-NEXT: ret <4 x float> [[REG490]] // CHECK-NEXT: ret <4 x float> [[REG490]]
// CHECK: define available_externally <4 x float> @_mm_loadr_ps // CHECK: define available_externally <4 x float> @_mm_loadr_ps
// CHECK: [[REG491:[0-9a-zA-Z_%.]+]] = call <4 x float> @vec_ld(int, float vector[4] const*) // CHECK: [[REG491:[0-9a-zA-Z_%.]+]] = call <4 x float> @vec_ld(long, float vector[4] const*)
// CHECK-NEXT: store <4 x float> [[REG491]], <4 x float>* [[REG492:[0-9a-zA-Z_%.]+]], align 16 // CHECK-NEXT: store <4 x float> [[REG491]], <4 x float>* [[REG492:[0-9a-zA-Z_%.]+]], align 16
// CHECK-NEXT: [[REG493:[0-9a-zA-Z_%.]+]] = load <4 x float>, <4 x float>* [[REG492]], align 16 // CHECK-NEXT: [[REG493:[0-9a-zA-Z_%.]+]] = load <4 x float>, <4 x float>* [[REG492]], align 16
// CHECK-NEXT: [[REG494:[0-9a-zA-Z_%.]+]] = load <4 x float>, <4 x float>* [[REG492]], align 16 // CHECK-NEXT: [[REG494:[0-9a-zA-Z_%.]+]] = load <4 x float>, <4 x float>* [[REG492]], align 16
// CHECK-NEXT: [[REG495:[0-9a-zA-Z_%.]+]] = call <4 x float> @vec_perm(float vector[4], float vector[4], unsigned char vector[16])(<4 x float> [[REG493]], <4 x float> [[REG494]], <16 x i8> <i8 28, i8 29, i8 30, i8 31, i8 24, i8 25, i8 26, i8 27, i8 20, i8 21, i8 22, i8 23, i8 16, i8 17, i8 18, i8 19>) // CHECK-NEXT: [[REG495:[0-9a-zA-Z_%.]+]] = call <4 x float> @vec_perm(float vector[4], float vector[4], unsigned char vector[16])(<4 x float> [[REG493]], <4 x float> [[REG494]], <16 x i8> <i8 28, i8 29, i8 30, i8 31, i8 24, i8 25, i8 26, i8 27, i8 20, i8 21, i8 22, i8 23, i8 16, i8 17, i8 18, i8 19>)
// CHECK-NEXT: store <4 x float> [[REG495]], <4 x float>* [[REG496:[0-9a-zA-Z_%.]+]], align 16 // CHECK-NEXT: store <4 x float> [[REG495]], <4 x float>* [[REG496:[0-9a-zA-Z_%.]+]], align 16
// CHECK-NEXT: [[REG497:[0-9a-zA-Z_%.]+]] = load <4 x float>, <4 x float>* [[REG496]], align 16 // CHECK-NEXT: [[REG497:[0-9a-zA-Z_%.]+]] = load <4 x float>, <4 x float>* [[REG496]], align 16
// CHECK-NEXT: ret <4 x float> [[REG497]] // CHECK-NEXT: ret <4 x float> [[REG497]]
▲ Show 20 Lines • Show All 818 Lines • ▼ Show 20 Lines
// CHECK-LABEL: @test_store // CHECK-LABEL: @test_store
// CHECK: define available_externally void @_mm_store_ps // CHECK: define available_externally void @_mm_store_ps
// CHECK: store float* {{[0-9a-zA-Z_%.]+}}, float** {{[0-9a-zA-Z_%.]+}}, align 8 // CHECK: store float* {{[0-9a-zA-Z_%.]+}}, float** {{[0-9a-zA-Z_%.]+}}, align 8
// CHECK-NEXT: store <4 x float> {{[0-9a-zA-Z_%.]+}}, <4 x float>* {{[0-9a-zA-Z_%.]+}}, align 16 // CHECK-NEXT: store <4 x float> {{[0-9a-zA-Z_%.]+}}, <4 x float>* {{[0-9a-zA-Z_%.]+}}, align 16
// CHECK-NEXT: [[REG939:[0-9a-zA-Z_%.]+]] = load <4 x float>, <4 x float>* {{[0-9a-zA-Z_%.]+}}, align 16 // CHECK-NEXT: [[REG939:[0-9a-zA-Z_%.]+]] = load <4 x float>, <4 x float>* {{[0-9a-zA-Z_%.]+}}, align 16
// CHECK-NEXT: [[REG940:[0-9a-zA-Z_%.]+]] = load float*, float** {{[0-9a-zA-Z_%.]+}}, align 8 // CHECK-NEXT: [[REG940:[0-9a-zA-Z_%.]+]] = load float*, float** {{[0-9a-zA-Z_%.]+}}, align 8
// CHECK-NEXT: [[REG941:[0-9a-zA-Z_%.]+]] = bitcast float* [[REG940]] to <4 x float>* // CHECK-NEXT: [[REG941:[0-9a-zA-Z_%.]+]] = bitcast float* [[REG940]] to <4 x float>*
// CHECK-NEXT: call void @vec_st(float vector[4], int, float vector[4]*)(<4 x float> [[REG939]], i32 signext 0, <4 x float>* [[REG941]]) // CHECK-NEXT: call void @vec_st(float vector[4], long, float vector[4]*)(<4 x float> [[REG939]], i64 0, <4 x float>* [[REG941]])
// CHECK-NEXT: ret void // CHECK-NEXT: ret void
// CHECK: define available_externally void @_mm_store_ps1 // CHECK: define available_externally void @_mm_store_ps1
// CHECK: store float* {{[0-9a-zA-Z_%.]+}}, float** {{[0-9a-zA-Z_%.]+}}, align 8 // CHECK: store float* {{[0-9a-zA-Z_%.]+}}, float** {{[0-9a-zA-Z_%.]+}}, align 8
// CHECK-NEXT: store <4 x float> {{[0-9a-zA-Z_%.]+}}, <4 x float>* {{[0-9a-zA-Z_%.]+}}, align 16 // CHECK-NEXT: store <4 x float> {{[0-9a-zA-Z_%.]+}}, <4 x float>* {{[0-9a-zA-Z_%.]+}}, align 16
// CHECK-NEXT: [[REG942:[0-9a-zA-Z_%.]+]] = load float*, float** {{[0-9a-zA-Z_%.]+}}, align 8 // CHECK-NEXT: [[REG942:[0-9a-zA-Z_%.]+]] = load float*, float** {{[0-9a-zA-Z_%.]+}}, align 8
// CHECK-NEXT: [[REG943:[0-9a-zA-Z_%.]+]] = load <4 x float>, <4 x float>* {{[0-9a-zA-Z_%.]+}}, align 16 // CHECK-NEXT: [[REG943:[0-9a-zA-Z_%.]+]] = load <4 x float>, <4 x float>* {{[0-9a-zA-Z_%.]+}}, align 16
// CHECK-NEXT: call void @_mm_store1_ps(float* [[REG942]], <4 x float> [[REG943]]) // CHECK-NEXT: call void @_mm_store1_ps(float* [[REG942]], <4 x float> [[REG943]])
▲ Show 20 Lines • Show All 255 Lines • Show Last 20 Lines