// RUN: %clang -emit-llvm -S -o - %s | FileCheck %s typedef float float4 __attribute__((ext_vector_type(4))); typedef unsigned int uint4 __attribute__((ext_vector_type(4))); // CHECK-LABEL: define void @clang_shufflevector_v_v( void clang_shufflevector_v_v( float4* A, float4 x, uint4 mask ) { // CHECK: [[MASK:%.*]] = and <4 x i32> {{%.*}}, <i32 3, i32 3, i32 3, i32 3> // CHECK: [[I:%.*]] = extractelement <4 x i32> [[MASK]], i32 0 // CHECK: [[E:%.*]] = extractelement <4 x float> [[X:%.*]], i32 [[I]] // // Here is where ToT Clang code generation makes a mistake. // It uses [[I]] as the insertion index instead of 0. // Similarly on the remaining insertelement. // CHECK: [[V:%[a-zA-Z0-9._]+]] = insertelement <4 x float> undef, float [[E]], i32 0 // CHECK: [[I:%.*]] = extractelement <4 x i32> [[MASK]], i32 1 // CHECK: [[E:%.*]] = extractelement <4 x float> [[X]], i32 [[I]] // CHECK: [[V2:%.*]] = insertelement <4 x float> [[V]], float [[E]], i32 1 // CHECK: [[I:%.*]] = extractelement <4 x i32> [[MASK]], i32 2 // CHECK: [[E:%.*]] = extractelement <4 x float> [[X]], i32 [[I]] // CHECK: [[V3:%.*]] = insertelement <4 x float> [[V2]], float [[E]], i32 2 // CHECK: [[I:%.*]] = extractelement <4 x i32> [[MASK]], i32 3 // CHECK: [[E:%.*]] = extractelement <4 x float> [[X]], i32 [[I]] // CHECK: [[V4:%.*]] = insertelement <4 x float> [[V3]], float [[E]], i32 3 // CHECK: store <4 x float> [[V4]], <4 x float>* {{%.*}}, *A = __builtin_shufflevector( x, mask ); } // CHECK-LABEL: define void @clang_shufflevector_v_v_c( void clang_shufflevector_v_v_c( float4* A, float4 x, float4 y) {
void test(int i) { char c = (char __attribute__((aligned(8)))) i; // expected-warning {{'aligned' attribute ignored when parsing type}} } // http://llvm.org/PR11082 // // FIXME: This may or may not be the correct approach (no warning or error), // but large amounts of Linux and FreeBSD code need this attribute to not be // a hard error in order to work correctly. void test2(int i) { char c = (char __attribute__((may_alias))) i; } // vector size too large int __attribute__ ((vector_size(8192))) x1; // expected-error {{vector size too large}} typedef int __attribute__ ((ext_vector_type(8192))) x2; // expected-error {{vector size too large}} // no support for vector enum type enum { e_2 } x3 __attribute__((vector_size(64))); // expected-error {{invalid vector element type}} int x4 __attribute__((ext_vector_type(64))); // expected-error {{'ext_vector_type' attribute only applies to types}} // rdar://16492792 typedef __attribute__ ((ext_vector_type(32),__aligned__(32))) unsigned char uchar32; void convert() { uchar32 r = 0; r.s[ 1234 ] = 1; // expected-error {{illegal vector component name 's'}} }
// RUN: %clang_cc1 -fsyntax-only -verify %s typedef __attribute__(( ext_vector_type(2) )) float float2; typedef __attribute__(( ext_vector_type(3) )) float float3; typedef __attribute__(( ext_vector_type(4) )) float float4; typedef __attribute__(( ext_vector_type(16) )) float float16; static float4 vec4_0 = (float4)0.5f; static void test() { float2 vec2, vec2_2; float3 vec3; float4 vec4, vec4_2, *vec4p; float16 vec16; float f; vec2.z; // expected-error {{vector component access exceeds type 'float2'}} vec2.xyzw; // expected-error {{vector component access exceeds type 'float2'}} vec4.xyzw; // expected-warning {{expression result unused}} vec4.xyzc; // expected-error {{illegal vector component name 'c'}} vec4.s01z; // expected-error {{illegal vector component name 'z'}} vec2 = vec4.s01; // legal, shorten vec2 = vec4.S01; // legal, shorten vec3 = vec4.xyz; // legal, shorten f = vec2.x; // legal, shorten f = vec4.xy.x; // legal, shorten vec4_2.xyzx = vec4.xyzw; // expected-error {{vector is not assignable (contains duplicate components)}} vec4_2.xyzz = vec4.xyzw; // expected-error {{vector is not assignable (contains duplicate components)}} vec4_2.xyyw = vec4.xyzw; // expected-error {{vector is not assignable (contains duplicate components)}}
enum E8559831a a3 = value_d; a3 = value_d; } void test26(int si, long sl) { si = sl % sl; // expected-warning {{implicit conversion loses integer precision: 'long' to 'int'}} si = sl % si; si = si % sl; si = si / sl; si = sl / si; // expected-warning {{implicit conversion loses integer precision: 'long' to 'int'}} } // rdar://16502418 typedef unsigned short uint16_t; typedef unsigned int uint32_t; typedef __attribute__ ((ext_vector_type(16),__aligned__(32))) uint16_t ushort16; typedef __attribute__ ((ext_vector_type( 8),__aligned__( 32))) uint32_t uint8; void test27(ushort16 constants) { uint8 pairedConstants = (uint8) constants; ushort16 crCbScale = pairedConstants.s4; // expected-warning {{implicit conversion loses integer precision: 'uint32_t' (aka 'unsigned int') to 'ushort16'}} ushort16 brBias = pairedConstants.s6; // expected-warning {{implicit conversion loses integer precision: 'uint32_t' (aka 'unsigned int') to 'ushort16'}} } float double2float_test1(double a) { return a; // expected-warning {{implicit conversion loses floating-point precision: 'double' to 'float'}} } void double2float_test2(double a, float *b) { *b += a; // expected-warning {{implicit conversion when assigning computation result loses floating-point precision: 'double' to 'float'}}
struct { int x; } F2; volatile struct { int x; } vF2; volatile struct { int x; } *vpF2; struct { struct { int y; } x; } F3; volatile struct { struct { int y; } x; } vF3; struct { int x:3; } BF; struct { volatile int x:3; } vBF; typedef int v4si __attribute__ ((vector_size (16))); v4si V; volatile v4si vV; typedef __attribute__(( ext_vector_type(4) )) int extv4; extv4 VE; volatile extv4 vVE; volatile struct {int x;} aggFct(void); typedef volatile int volatile_int; volatile_int vtS; int main() { int i; // load i=S; i=vS; i=*pS;
void *ptrs[]; }; struct foo bar; // PR4143 struct foo2 { enum bar *bar; }; struct foo2 foo2; // Radar 7325611 // CHECK: !"0x16\00barfoo\00{{.*}}" typedef int barfoo; barfoo foo() { } // CHECK: __uint128_t __uint128_t foo128 () { __uint128_t int128 = 44; return int128; } // CHECK: uint64x2_t typedef unsigned long long uint64_t; typedef uint64_t uint64x2_t __attribute__((ext_vector_type(2))); uint64x2_t extvectbar[4];
int a : 14; } __attribute__ ((__packed__)) bfx3_packed; struct BitFields4 { short : 16; int a: 1; long b : 7; } bfx4; struct BitFields4_packed { short : 16; int a: 1; long b : 7; } __attribute__ ((__packed__)) bfx4_packed; typedef float float2 __attribute__((ext_vector_type(2))); float2 float2x; // Register "0" is currently an invalid register for global register variables. // Use "esp" instead of "0". // register int rix __asm__("0"); register int rix __asm__("esp"); int main() { // CHECK: store atomic i32 1, i32* getelementptr inbounds ({ i32, i32 }, { i32, i32 }* @civ, i32 0, i32 1) monotonic, #pragma omp atomic write __imag(civ) = 1; // CHECK: load i8, i8* // CHECK: store atomic i8 #pragma omp atomic write bx = bv;
typedef __attribute__((ext_vector_type(5))) __short5; fn1() { __short5 a; a.y; }
//===-- main.cpp ------------------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// typedef float float4 __attribute__((ext_vector_type(4))); typedef unsigned char vec __attribute__((ext_vector_type(16))); int main() { float4 f4 = {1.25, 1.25, 2.50, 2.50}; vec v = (vec)f4; return 0; // break here }
// RUN: %clang_cc1 -triple armv7-apple-darwin -target-abi aapcs -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple armv7-apple-darwin -target-abi apcs-gnu -emit-llvm -o - %s | FileCheck -check-prefix=APCS-GNU %s #include <stdarg.h> typedef __attribute__(( ext_vector_type(2) )) int __int2; typedef __attribute__(( ext_vector_type(3) )) char __char3; typedef __attribute__(( ext_vector_type(5) )) char __char5; typedef __attribute__(( ext_vector_type(9) )) char __char9; typedef __attribute__(( ext_vector_type(19) )) char __char19; typedef __attribute__(( ext_vector_type(3) )) short __short3; typedef __attribute__(( ext_vector_type(5) )) short __short5; // Passing legal vector types as varargs. double varargs_vec_2i(int fixed, ...) { // CHECK: varargs_vec_2i // CHECK: [[VAR:%.*]] = alloca <2 x i32>, align 8 // CHECK: [[ALIGN:%.*]] = and i32 {{%.*}}, -8 // CHECK: [[AP_ALIGN:%.*]] = inttoptr i32 [[ALIGN]] to i8* // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_ALIGN]], i32 8 // CHECK: [[AP_CAST:%.*]] = bitcast i8* [[AP_ALIGN]] to <2 x i32>* // CHECK: [[VEC:%.*]] = load <2 x i32>, <2 x i32>* [[AP_CAST]], align 8 // CHECK: store <2 x i32> [[VEC]], <2 x i32>* [[VAR]], align 8 // APCS-GNU: varargs_vec_2i // APCS-GNU: [[VAR:%.*]] = alloca <2 x i32>, align 8 // APCS-GNU: [[AP:%.*]] = load i8*, // APCS-GNU: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP]], i32 8 // APCS-GNU: [[AP_CAST:%.*]] = bitcast i8* [[AP]] to <2 x i32>* // APCS-GNU: [[VEC:%.*]] = load <2 x i32>, <2 x i32>* [[AP_CAST]], align 4 // APCS-GNU: store <2 x i32> [[VEC]], <2 x i32>* [[VAR]], align 8 va_list ap;
} // As a Clang extension, _Complex can be decomposed. float decompose_complex(_Complex float cf) { static _Complex float scf; auto &[sre, sim] = scf; // ok, this is references initialized by constant expressions all the way down static_assert(&sre == &__real scf); static_assert(&sim == &__imag scf); auto [re, im] = cf; return re*re + im*im; } // As a Clang extension, vector types can be decomposed. typedef float vf3 __attribute__((ext_vector_type(3))); float decompose_vector(vf3 v) { auto [x, y, z] = v; auto *p = &x; // expected-error {{address of vector element requested}} return x + y + z; } struct S { int a, b; }; constexpr int f(S s) { auto &[a, b] = s; return a * 10 + b; } static_assert(f({1, 2}) == 12); constexpr bool g(S &&s) { auto &[a, b] = s;
// RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -fsyntax-only -verify -fno-lax-vector-conversions -Wconversion %s typedef __attribute__(( ext_vector_type(2) )) float float2; typedef __attribute__(( ext_vector_type(3) )) float float3; typedef __attribute__(( ext_vector_type(4) )) int int4; typedef __attribute__(( ext_vector_type(8) )) short short8; typedef __attribute__(( ext_vector_type(4) )) float float4; typedef float t3 __attribute__ ((vector_size (16))); typedef __typeof__(sizeof(int)) size_t; typedef unsigned long ulong2 __attribute__ ((ext_vector_type(2))); typedef size_t stride4 __attribute__((ext_vector_type(4))); static void test() { float2 vec2; float3 vec3; float4 vec4, vec4_2; int4 ivec4; short8 ish8; t3 vec4_3; int *ptr; int i; vec3 += vec2; // expected-error {{can't convert between vector values of different size}} vec4 += vec3; // expected-error {{can't convert between vector values of different size}} vec4 = 5.0f; vec4 = (float4)5.0f; vec4 = (float4)5; vec4 = (float4)vec4_3; ivec4 = (int4)5.0f;
int j[42]; // expected-error {{redefinition of 'j' with a different type: 'int [42]' vs 'int [4]'}} // rdar://6880104 _Decimal32 x; // expected-error {{GNU decimal type extension not supported}} // rdar://6880951 int __attribute__ ((vector_size (8), vector_size (8))) v; // expected-error {{invalid vector element type}} void test(int i) { char c = (char __attribute__((aligned(8)))) i; // expected-warning {{'aligned' attribute ignored when parsing type}} } // http://llvm.org/PR11082 // // FIXME: This may or may not be the correct approach (no warning or error), // but large amounts of Linux and FreeBSD code need this attribute to not be // a hard error in order to work correctly. void test2(int i) { char c = (char __attribute__((may_alias))) i; } // vector size too large int __attribute__ ((vector_size(8192))) x1; // expected-error {{vector size too large}} typedef int __attribute__ ((ext_vector_type(8192))) x2; // expected-error {{vector size too large}} // no support for vector enum type enum { e_2 } x3 __attribute__((vector_size(64))); // expected-error {{invalid vector element type}} int x4 __attribute__((ext_vector_type(64))); // expected-error {{'ext_vector_type' attribute only applies to types}}
// X64: define x86_vectorcallcc <4 x float> @"\01hva4@@112"(%struct.HVA4 inreg %a.coerce, %struct.HVA2* %b, <4 x float> %c) v4f32 __vectorcall hva5(struct HVA3 a, struct HVA3 b, v4f32 c, struct HVA2 d) {return d.y;} // X32: define x86_vectorcallcc <4 x float> @"\01hva5@@144"(%struct.HVA3 inreg %a.coerce, %struct.HVA3* inreg %b, <4 x float> %c, %struct.HVA2 inreg %d.coerce) // X64: define x86_vectorcallcc <4 x float> @"\01hva5@@144"(%struct.HVA3 inreg %a.coerce, %struct.HVA3* %b, <4 x float> %c, %struct.HVA2 inreg %d.coerce) struct HVA4 __vectorcall hva6(struct HVA4 a, struct HVA4 b) { return b;} // X32: define x86_vectorcallcc %struct.HVA4 @"\01hva6@@128"(%struct.HVA4 inreg %a.coerce, %struct.HVA4* inreg %b) // X64: define x86_vectorcallcc %struct.HVA4 @"\01hva6@@128"(%struct.HVA4 inreg %a.coerce, %struct.HVA4* %b) struct HVA5 __vectorcall hva7() {struct HVA5 a = {}; return a;} // X32: define x86_vectorcallcc void @"\01hva7@@0"(%struct.HVA5* inreg noalias sret %agg.result) // X64: define x86_vectorcallcc void @"\01hva7@@0"(%struct.HVA5* noalias sret %agg.result) v4f32 __vectorcall hva8(v4f32 a, v4f32 b, v4f32 c, v4f32 d, int e, v4f32 f) {return f;} // X32: define x86_vectorcallcc <4 x float> @"\01hva8@@84"(<4 x float> %a, <4 x float> %b, <4 x float> %c, <4 x float> %d, i32 inreg %e, <4 x float> %f) // X64: define x86_vectorcallcc <4 x float> @"\01hva8@@88"(<4 x float> %a, <4 x float> %b, <4 x float> %c, <4 x float> %d, i32 %e, <4 x float> %f) typedef float __attribute__((ext_vector_type(3))) v3f32; struct OddSizeHVA { v3f32 x, y; }; void __vectorcall odd_size_hva(struct OddSizeHVA a) {} // X32: define x86_vectorcallcc void @"\01odd_size_hva@@32"(%struct.OddSizeHVA inreg %a.coerce) // X64: define x86_vectorcallcc void @"\01odd_size_hva@@32"(%struct.OddSizeHVA inreg %a.coerce) // The Vectorcall ABI only allows passing the first 6 items in registers, so this shouldn't // consider 'p7' as a register. Instead p5 gets put into the register on the second pass. struct HFA2 __vectorcall AddParticles(struct HFA2 p1, float p2, struct HFA4 p3, int p4, struct HFA2 p5, float p6, float p7){ return p1;} // X32: define x86_vectorcallcc %struct.HFA2 @"\01AddParticles@@80"(%struct.HFA2 inreg %p1.coerce, float %p2, %struct.HFA4* inreg %p3, i32 inreg %p4, %struct.HFA2 inreg %p5.coerce, float %p6, float %p7) // X64: define x86_vectorcallcc %struct.HFA2 @"\01AddParticles@@96"(%struct.HFA2 inreg %p1.coerce, float %p2, %struct.HFA4* %p3, i32 %p4, %struct.HFA2 inreg %p5.coerce, float %p6, float %p7)
// CHECK: [[ERROR:%.*]] = alloca float*, align 4 // CHECK: [[TEMP:%.*]] = alloca swifterror float*, align 4 // CHECK: [[T0:%.*]] = load float*, float** [[ERROR]], align 4 // CHECK: store float* [[T0]], float** [[TEMP]], align 4 // CHECK: call [[SWIFTCC:swiftcc]] void @context_error_1(i32* swiftself [[X]], float** swifterror [[TEMP]]) // CHECK: [[T0:%.*]] = load float*, float** [[TEMP]], align 4 // CHECK: store float* [[T0]], float** [[ERROR]], align 4 SWIFTCALL void context_error_2(short s, CONTEXT int *self, ERROR float **error) {} // CHECK-LABEL: define {{.*}} void @context_error_2(i16{{.*}}, i32* swiftself{{.*}}, float** swifterror) /*****************************************************************************/ /********************************** LOWERING *********************************/ /*****************************************************************************/ typedef float float4 __attribute__((ext_vector_type(4))); typedef float float8 __attribute__((ext_vector_type(8))); typedef double double2 __attribute__((ext_vector_type(2))); typedef double double4 __attribute__((ext_vector_type(4))); typedef int int3 __attribute__((ext_vector_type(3))); typedef int int4 __attribute__((ext_vector_type(4))); typedef int int5 __attribute__((ext_vector_type(5))); typedef int int8 __attribute__((ext_vector_type(8))); typedef char char16 __attribute__((ext_vector_type(16))); typedef short short8 __attribute__((ext_vector_type(8))); typedef long long long2 __attribute__((ext_vector_type(2))); #define TEST(TYPE) \ SWIFTCALL TYPE return_##TYPE(void) { \ TYPE result = {}; \ return result; \
// RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -fsyntax-only -verify -fno-lax-vector-conversions %s typedef __attribute__(( ext_vector_type(2) )) float float2; typedef __attribute__(( ext_vector_type(3) )) float float3; typedef __attribute__(( ext_vector_type(4) )) int int4; typedef __attribute__(( ext_vector_type(8) )) short short8; typedef __attribute__(( ext_vector_type(4) )) float float4; typedef float t3 __attribute__ ((vector_size (16))); typedef __typeof__(sizeof(int)) size_t; typedef unsigned long ulong2 __attribute__ ((ext_vector_type(2))); typedef size_t stride4 __attribute__((ext_vector_type(4))); static void test() { float2 vec2; float3 vec3; float4 vec4, vec4_2; int4 ivec4; short8 ish8; t3 vec4_3; int *ptr; int i; vec3 += vec2; // expected-error {{can't convert between vector values of different size}} vec4 += vec3; // expected-error {{can't convert between vector values of different size}} vec4 = 5.0f; vec4 = (float4)5.0f; vec4 = (float4)5; vec4 = (float4)vec4_3; ivec4 = (int4)5.0f;
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s static_assert(__is_literal(int), "fail"); static_assert(__is_literal_type(int), "fail"); // alternate spelling for GCC static_assert(__is_literal(void*), "fail"); enum E { E1 }; static_assert(__is_literal(E), "fail"); static_assert(__is_literal(decltype(E1)), "fail"); typedef int IAR[10]; static_assert(__is_literal(IAR), "fail"); typedef int Vector __attribute__((vector_size(16))); typedef int VectorExt __attribute__((ext_vector_type(4))); static_assert(__is_literal(Vector), "fail"); static_assert(__is_literal(VectorExt), "fail"); // C++0x [basic.types]p10: // A type is a literal type if it is: // [...] // -- a class type that has all of the following properties: // -- it has a trivial destructor // -- every constructor call and full-expression in the // brace-or-equal-initializers for non-static data members (if an) is // a constant expression, // -- it is an aggregate type or has at least one constexpr constructor // or constructor template that is not a copy or move constructor, and // -- it has all non-static data members and base classes of literal // types struct Empty {}; struct LiteralType { int x; E e;
// RUN: %clang_cc1 -triple arm64-apple-ios7 -target-abi darwinpcs -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple aarch64-linux-android -emit-llvm -o - %s | FileCheck -check-prefix=ANDROID %s #include <stdarg.h> typedef __attribute__(( ext_vector_type(2) )) char __char2; typedef __attribute__(( ext_vector_type(3) )) char __char3; typedef __attribute__(( ext_vector_type(4) )) char __char4; typedef __attribute__(( ext_vector_type(5) )) char __char5; typedef __attribute__(( ext_vector_type(9) )) char __char9; typedef __attribute__(( ext_vector_type(19) )) char __char19; typedef __attribute__(( ext_vector_type(3) )) short __short3; typedef __attribute__(( ext_vector_type(5) )) short __short5; typedef __attribute__(( ext_vector_type(3) )) int __int3; typedef __attribute__(( ext_vector_type(5) )) int __int5; typedef __attribute__(( ext_vector_type(3) )) double __double3; // Passing legal vector types as varargs. Check that we've allocated the appropriate size double varargs_vec_2c(int fixed, ...) { // ANDROID: varargs_vec_2c // ANDROID: [[VAR:%.*]] = alloca <2 x i8>, align 2 // ANDROID: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_CUR:%.*]], i64 8 // ANDROID: bitcast i8* [[AP_CUR]] to <2 x i8>* va_list ap; double sum = fixed; va_start(ap, fixed); __char2 c3 = va_arg(ap, __char2); sum = sum + c3.x + c3.y; va_end(ap); return sum; }
extern void takes_struct_of_four_doubles_variadic(double a, struct_of_four_doubles b, struct_of_four_doubles c, double d, ...); void test_struct_of_four_doubles_variadic(void) { // CHECK: test_struct_of_four_doubles_variadic // CHECK: call arm_aapcs_vfpcc void (double, [4 x i64], [4 x i64], double, ...)* @takes_struct_of_four_doubles_variadic(double {{.*}}, [4 x i64] {{.*}}, [4 x i64] {{.*}}, double {{.*}}) takes_struct_of_four_doubles_variadic(3.0, g_s4d, g_s4d, 4.0); } extern void takes_struct_with_backfill(float f1, double a, float f2, struct_of_four_doubles b, struct_of_four_doubles c, double d); void test_struct_with_backfill(void) { // CHECK: test_struct_with_backfill // CHECK: call arm_aapcs_vfpcc void @takes_struct_with_backfill(float {{.*}}, double {{.*}}, float {{.*}}, double {{.*}}, double {{.*}}, double {{.*}}, double {{.*}}, [4 x float] undef, double {{.*}}, double {{.*}}, double {{.*}}, double {{.*}}, double {{.*}}) takes_struct_with_backfill(3.0, 3.1, 3.2, g_s4d, g_s4d, 4.0); } typedef __attribute__(( ext_vector_type(8) )) char __char8; typedef __attribute__(( ext_vector_type(4) )) short __short4; typedef struct { __char8 a1; __short4 a2; __char8 a3; __short4 a4; } struct_of_vecs; extern void takes_struct_of_vecs(double a, struct_of_vecs b, struct_of_vecs c, double d); struct_of_vecs g_vec; void test_struct_of_vecs(void) { // CHECK: test_struct_of_vecs // CHECK: call arm_aapcs_vfpcc void @takes_struct_of_vecs(double {{.*}}, <8 x i8> {{.*}}, <4 x i16> {{.*}}, <8 x i8> {{.*}}, <4 x i16> {{.*}}, [6 x float] undef, <8 x i8> {{.*}}, <4 x i16> {{.*}}, <8 x i8> {{.*}}, <4 x i16> {{.*}}, double {{.*}}) // CHECK64: test_struct_of_vecs // CHECK64: call void @takes_struct_of_vecs(double {{.*}}, <8 x i8> {{.*}}, <4 x i16> {{.*}}, <8 x i8> {{.*}}, <4 x i16> {{.*}}, [3 x float] undef, <8 x i8> {{.*}}, <4 x i16> {{.*}}, <8 x i8> {{.*}}, <4 x i16> {{.*}}, double {{.*}})
// RUN: %clang_cc1 -fsyntax-only -verify %s // Test template instantiation for Clang-specific features. // --------------------------------------------------------------------- // Vector types // --------------------------------------------------------------------- typedef __attribute__(( ext_vector_type(2) )) double double2; typedef __attribute__(( ext_vector_type(4) )) double double4; template<typename T> struct ExtVectorAccess0 { void f(T v1, double4 v2) { v1.xy = v2.yx; } }; template struct ExtVectorAccess0<double2>; template struct ExtVectorAccess0<double4>; typedef __attribute__(( ext_vector_type(2) )) double double2; template<typename T, typename U, int N, int M> struct ShuffleVector0 { void f(T t, U u, double2 a, double2 b) { (void)__builtin_shufflevector(t, u, N, M); // expected-error{{index}} (void)__builtin_shufflevector(a, b, N, M); (void)__builtin_shufflevector(a, b, 2, 1); } };
* * 3. Neither the name of the copyright holder nor the names of its contributors may be used to * endorse or promote products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. */ typedef double vec __attribute__((ext_vector_type(2))); void scale_vector(double *arr, int len, double scale) { vec *vector = (vec*) arr; vec vscale = scale; int vlen = len / 2; int i; for (i = 0; i < vlen; i++) { vector[i] *= vscale; } i *= 2; if (i < len) { arr[i] *= scale; } }
// RUN: clang-cc -emit-llvm %s -o %t typedef __attribute__(( ext_vector_type(4) )) float float4; typedef __attribute__(( ext_vector_type(2) )) float float2; typedef __attribute__(( ext_vector_type(4) )) int int4; float4 foo = (float4){ 1.0, 2.0, 3.0, 4.0 }; const float4 bar = (float4){ 1.0, 2.0, 3.0, __builtin_inff() }; float4 test1(float4 V) { return V.wzyx+V; } float2 vec2, vec2_2; float4 vec4, vec4_2; float f; void test2() { vec2 = vec4.xy; // shorten f = vec2.x; // extract elt vec4 = vec4.yyyy; // splat vec2.x = f; // insert one. vec2.yx = vec2; // reverse } void test3(float4 *out) { *out = ((float4) {1.0f, 2.0f, 3.0f, 4.0f }); }
* you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "rs_core.rsh" typedef unsigned long long ull; typedef unsigned long long ull2 __attribute__((ext_vector_type(2))); typedef unsigned long long ull3 __attribute__((ext_vector_type(3))); typedef unsigned long long ull4 __attribute__((ext_vector_type(4))); #define S_CLAMP(T) \ extern T __attribute__((overloadable)) clamp(T amount, T low, T high) { \ return amount < low ? low : (amount > high ? high : amount); \ } //_CLAMP(float); implemented in .ll S_CLAMP(double); S_CLAMP(char); S_CLAMP(uchar); S_CLAMP(short); S_CLAMP(ushort); S_CLAMP(int);
// This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. // #include "Barrier.h" #include "Matrix2x2.h" typedef int veci16 __attribute__((ext_vector_type(16))); typedef float vecf16 __attribute__((ext_vector_type(16))); veci16* const kFrameBufferAddress = (veci16*) 0x10000000; const vecf16 kXOffsets = { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f }; extern unsigned int kImage[]; const int kImageWidth = 16; const int kImageHeight = 16; const int kBytesPerPixel = 4; const int kScreenWidth = 640; const int kScreenHeight = 480; void dflush(void *ptr) { __asm("dflush %0" : : "r" (ptr));
// RUN: %clang_cc1 -fsyntax-only -verify %s typedef __attribute__(( ext_vector_type(2) )) float float2; typedef __attribute__(( ext_vector_type(4) )) int int4; typedef __attribute__(( ext_vector_type(8) )) short short8; typedef __attribute__(( ext_vector_type(4) )) float float4; typedef float t3 __attribute__ ((vector_size (16))); static void test() { float2 vec2; float4 vec4, vec4_2; int4 ivec4; short8 ish8; t3 vec4_3; int *ptr; int i; vec4 = 5.0f; vec4 = (float4)5.0f; vec4 = (float4)5; vec4 = (float4)vec4_3; ivec4 = (int4)5.0f; ivec4 = (int4)5; ivec4 = (int4)vec4_3; i = (int)ivec4; // expected-error {{invalid conversion between vector type 'int4' and integer type 'int' of different size}} i = ivec4; // expected-error {{assigning to 'int' from incompatible type 'int4'}} ivec4 = (int4)ptr; // expected-error {{invalid conversion between vector type 'int4' and scalar type 'int *'}}
// CHECK: [[ERROR:%.*]] = alloca float*, align 4 // CHECK: [[TEMP:%.*]] = alloca swifterror float*, align 4 // CHECK: [[T0:%.*]] = load float*, float** [[ERROR]], align 4 // CHECK: store float* [[T0]], float** [[TEMP]], align 4 // CHECK: call [[SWIFTCC:swiftcc]] void @context_error_1(i32* swiftself [[X]], float** swifterror [[TEMP]]) // CHECK: [[T0:%.*]] = load float*, float** [[TEMP]], align 4 // CHECK: store float* [[T0]], float** [[ERROR]], align 4 SWIFTCALL void context_error_2(short s, CONTEXT int *self, ERROR float **error) {} // CHECK-LABEL: define {{.*}} void @context_error_2(i16{{.*}}, i32* swiftself{{.*}}, float** swifterror) /*****************************************************************************/ /********************************** LOWERING *********************************/ /*****************************************************************************/ typedef float float4 __attribute__((ext_vector_type(4))); typedef float float8 __attribute__((ext_vector_type(8))); typedef double double2 __attribute__((ext_vector_type(2))); typedef double double4 __attribute__((ext_vector_type(4))); typedef int int3 __attribute__((ext_vector_type(3))); typedef int int4 __attribute__((ext_vector_type(4))); typedef int int5 __attribute__((ext_vector_type(5))); typedef int int8 __attribute__((ext_vector_type(8))); #define TEST(TYPE) \ SWIFTCALL TYPE return_##TYPE(void) { \ TYPE result = {}; \ return result; \ } \ SWIFTCALL void take_##TYPE(TYPE v) { \ } \
// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s typedef __attribute__(( ext_vector_type(4) )) float float4; // CHECK: @test void test() { float4 va; va.hi[0] = 3.0; // CHECK: [[VA:%.*]] = alloca <4 x float> // CHECK: [[CONV:%.*]] = bitcast <4 x float>* [[VA]] to float* // CHECK: [[ADD:%.*]] = getelementptr inbounds float, float* [[CONV]], i64 2 // CHECK: [[ARRIDX:%.*]] = getelementptr inbounds float, float* [[ADD]], i64 0 // CHECK: store float 3.000000e+00, float* [[ARRIDX]] }
// CHECK-LABEL: nvvm_ldg __device__ void nvvm_ldg(const void *p) { // CHECK: call i8 @llvm.nvvm.ldg.global.i.i8.p0i8(i8* {{%[0-9]+}}, i32 1) // CHECK: call i8 @llvm.nvvm.ldg.global.i.i8.p0i8(i8* {{%[0-9]+}}, i32 1) __nvvm_ldg_c((const char *)p); __nvvm_ldg_uc((const unsigned char *)p); // CHECK: call i16 @llvm.nvvm.ldg.global.i.i16.p0i16(i16* {{%[0-9]+}}, i32 2) // CHECK: call i16 @llvm.nvvm.ldg.global.i.i16.p0i16(i16* {{%[0-9]+}}, i32 2) __nvvm_ldg_s((const short *)p); __nvvm_ldg_us((const unsigned short *)p); // CHECK: call i32 @llvm.nvvm.ldg.global.i.i32.p0i32(i32* {{%[0-9]+}}, i32 4) // CHECK: call i32 @llvm.nvvm.ldg.global.i.i32.p0i32(i32* {{%[0-9]+}}, i32 4) __nvvm_ldg_i((const int *)p); __nvvm_ldg_ui((const unsigned int *)p); // LP32: call i32 @llvm.nvvm.ldg.global.i.i32.p0i32(i32* {{%[0-9]+}}, i32 4) // LP32: call i32 @llvm.nvvm.ldg.global.i.i32.p0i32(i32* {{%[0-9]+}}, i32 4) // LP64: call i64 @llvm.nvvm.ldg.global.i.i64.p0i64(i64* {{%[0-9]+}}, i32 8) // LP64: call i64 @llvm.nvvm.ldg.global.i.i64.p0i64(i64* {{%[0-9]+}}, i32 8) __nvvm_ldg_l((const long *)p); __nvvm_ldg_ul((const unsigned long *)p); // CHECK: call float @llvm.nvvm.ldg.global.f.f32.p0f32(float* {{%[0-9]+}}, i32 4) __nvvm_ldg_f((const float *)p); // CHECK: call double @llvm.nvvm.ldg.global.f.f64.p0f64(double* {{%[0-9]+}}, i32 8) __nvvm_ldg_d((const double *)p); // In practice, the pointers we pass to __ldg will be aligned as appropriate // for the CUDA <type>N vector types (e.g. short4), which are not the same as // the LLVM vector types. However, each LLVM vector type has an alignment // less than or equal to its corresponding CUDA type, so we're OK. // // PTX Interoperability section 2.2: "For a vector with an even number of // elements, its alignment is set to number of elements times the alignment of // its member: n*alignof(t)." // CHECK: call <2 x i8> @llvm.nvvm.ldg.global.i.v2i8.p0v2i8(<2 x i8>* {{%[0-9]+}}, i32 2) // CHECK: call <2 x i8> @llvm.nvvm.ldg.global.i.v2i8.p0v2i8(<2 x i8>* {{%[0-9]+}}, i32 2) typedef char char2 __attribute__((ext_vector_type(2))); typedef unsigned char uchar2 __attribute__((ext_vector_type(2))); __nvvm_ldg_c2((const char2 *)p); __nvvm_ldg_uc2((const uchar2 *)p); // CHECK: call <4 x i8> @llvm.nvvm.ldg.global.i.v4i8.p0v4i8(<4 x i8>* {{%[0-9]+}}, i32 4) // CHECK: call <4 x i8> @llvm.nvvm.ldg.global.i.v4i8.p0v4i8(<4 x i8>* {{%[0-9]+}}, i32 4) typedef char char4 __attribute__((ext_vector_type(4))); typedef unsigned char uchar4 __attribute__((ext_vector_type(4))); __nvvm_ldg_c4((const char4 *)p); __nvvm_ldg_uc4((const uchar4 *)p); // CHECK: call <2 x i16> @llvm.nvvm.ldg.global.i.v2i16.p0v2i16(<2 x i16>* {{%[0-9]+}}, i32 4) // CHECK: call <2 x i16> @llvm.nvvm.ldg.global.i.v2i16.p0v2i16(<2 x i16>* {{%[0-9]+}}, i32 4) typedef short short2 __attribute__((ext_vector_type(2))); typedef unsigned short ushort2 __attribute__((ext_vector_type(2))); __nvvm_ldg_s2((const short2 *)p); __nvvm_ldg_us2((const ushort2 *)p); // CHECK: call <4 x i16> @llvm.nvvm.ldg.global.i.v4i16.p0v4i16(<4 x i16>* {{%[0-9]+}}, i32 8) // CHECK: call <4 x i16> @llvm.nvvm.ldg.global.i.v4i16.p0v4i16(<4 x i16>* {{%[0-9]+}}, i32 8) typedef short short4 __attribute__((ext_vector_type(4))); typedef unsigned short ushort4 __attribute__((ext_vector_type(4))); __nvvm_ldg_s4((const short4 *)p); __nvvm_ldg_us4((const ushort4 *)p); // CHECK: call <2 x i32> @llvm.nvvm.ldg.global.i.v2i32.p0v2i32(<2 x i32>* {{%[0-9]+}}, i32 8) // CHECK: call <2 x i32> @llvm.nvvm.ldg.global.i.v2i32.p0v2i32(<2 x i32>* {{%[0-9]+}}, i32 8) typedef int int2 __attribute__((ext_vector_type(2))); typedef unsigned int uint2 __attribute__((ext_vector_type(2))); __nvvm_ldg_i2((const int2 *)p); __nvvm_ldg_ui2((const uint2 *)p); // CHECK: call <4 x i32> @llvm.nvvm.ldg.global.i.v4i32.p0v4i32(<4 x i32>* {{%[0-9]+}}, i32 16) // CHECK: call <4 x i32> @llvm.nvvm.ldg.global.i.v4i32.p0v4i32(<4 x i32>* {{%[0-9]+}}, i32 16) typedef int int4 __attribute__((ext_vector_type(4))); typedef unsigned int uint4 __attribute__((ext_vector_type(4))); __nvvm_ldg_i4((const int4 *)p); __nvvm_ldg_ui4((const uint4 *)p); // CHECK: call <2 x i64> @llvm.nvvm.ldg.global.i.v2i64.p0v2i64(<2 x i64>* {{%[0-9]+}}, i32 16) // CHECK: call <2 x i64> @llvm.nvvm.ldg.global.i.v2i64.p0v2i64(<2 x i64>* {{%[0-9]+}}, i32 16) typedef long long longlong2 __attribute__((ext_vector_type(2))); typedef unsigned long long ulonglong2 __attribute__((ext_vector_type(2))); __nvvm_ldg_ll2((const longlong2 *)p); __nvvm_ldg_ull2((const ulonglong2 *)p); // CHECK: call <2 x float> @llvm.nvvm.ldg.global.f.v2f32.p0v2f32(<2 x float>* {{%[0-9]+}}, i32 8) typedef float float2 __attribute__((ext_vector_type(2))); __nvvm_ldg_f2((const float2 *)p); // CHECK: call <4 x float> @llvm.nvvm.ldg.global.f.v4f32.p0v4f32(<4 x float>* {{%[0-9]+}}, i32 16) typedef float float4 __attribute__((ext_vector_type(4))); __nvvm_ldg_f4((const float4 *)p); // CHECK: call <2 x double> @llvm.nvvm.ldg.global.f.v2f64.p0v2f64(<2 x double>* {{%[0-9]+}}, i32 16) typedef double double2 __attribute__((ext_vector_type(2))); __nvvm_ldg_d2((const double2 *)p); }