[clang] f098fb6 - [Clang] Convert some tests to opaque pointers (NFC)
Nikita Popov via cfe-commits
cfe-commits at lists.llvm.org
Fri Feb 17 05:26:17 PST 2023
Author: Nikita Popov
Date: 2023-02-17T14:26:07+01:00
New Revision: f098fb69f16420cda0624a3ae5ad625a09ca7fe6
URL: https://github.com/llvm/llvm-project/commit/f098fb69f16420cda0624a3ae5ad625a09ca7fe6
DIFF: https://github.com/llvm/llvm-project/commit/f098fb69f16420cda0624a3ae5ad625a09ca7fe6.diff
LOG: [Clang] Convert some tests to opaque pointers (NFC)
Added:
Modified:
clang/test/CodeGen/bpf-attr-preserve-access-index-3.c
clang/test/CodeGen/bpf-attr-preserve-access-index-4.c
clang/test/CodeGen/bpf-attr-preserve-access-index-5.c
clang/test/CodeGen/bpf-attr-preserve-access-index-6.c
clang/test/CodeGen/bpf-attr-preserve-access-index-7.c
clang/test/CodeGen/bpf-attr-preserve-access-index-8.c
clang/test/CodeGen/builtins-memcpy-inline.c
clang/test/CodeGen/builtins-nvptx.c
clang/test/CodeGen/c11atomics.c
clang/test/CodeGen/captured-statements-nested.c
clang/test/CodeGen/captured-statements.c
clang/test/CodeGen/catch-alignment-assumption-array.c
clang/test/CodeGen/catch-alignment-assumption-attribute-align_value-on-lvalue.cpp
clang/test/CodeGen/catch-alignment-assumption-attribute-align_value-on-paramvar.cpp
clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function-variable.cpp
clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function.cpp
clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function-two-params.cpp
clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function.cpp
clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-polymorphism.cpp
clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-three-params-variable.cpp
clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-three-params.cpp
clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-two-params.cpp
clang/test/CodeGen/catch-alignment-assumption-openmp.cpp
clang/test/OpenMP/nvptx_lambda_pointer_capturing.cpp
Removed:
################################################################################
diff --git a/clang/test/CodeGen/bpf-attr-preserve-access-index-3.c b/clang/test/CodeGen/bpf-attr-preserve-access-index-3.c
index 2dbb9a223da8..42d7b67b160b 100644
--- a/clang/test/CodeGen/bpf-attr-preserve-access-index-3.c
+++ b/clang/test/CodeGen/bpf-attr-preserve-access-index-3.c
@@ -1,5 +1,5 @@
// REQUIRES: bpf-registered-target
-// RUN: %clang_cc1 -no-opaque-pointers -triple bpf -emit-llvm -debug-info-kind=limited -disable-llvm-passes %s -o - | FileCheck %s
+// RUN: %clang_cc1 -triple bpf -emit-llvm -debug-info-kind=limited -disable-llvm-passes %s -o - | FileCheck %s
#define __reloc__ __attribute__((preserve_access_index))
@@ -25,8 +25,8 @@ int test(__s3 *arg) {
return arg->a.b[2].c;
}
-// CHECK: call %struct.s2* @llvm.preserve.struct.access.index.p0s_struct.s2s.p0s_struct.s3s(%struct.s3* elementtype(%struct.s3) %{{[0-9a-z]+}}, i32 0, i32 0)
-// CHECK: call %union.anon* @llvm.preserve.struct.access.index.p0s_union.anons.p0s_struct.s2s(%struct.s2* elementtype(%struct.s2) %{{[0-9a-z]+}}, i32 0, i32 0)
-// CHECK: call %union.anon* @llvm.preserve.union.access.index.p0s_union.anons.p0s_union.anons(%union.anon* %{{[0-9a-z]+}}, i32 0)
-// CHECK: call %struct.s1* @llvm.preserve.array.access.index.p0s_struct.s1s.p0a3s_struct.s1s([3 x %struct.s1]* elementtype([3 x %struct.s1]) %{{[0-9a-z]+}}, i32 1, i32 2)
-// CHECK: call i32* @llvm.preserve.struct.access.index.p0i32.p0s_struct.s1s(%struct.s1* elementtype(%struct.s1) %{{[0-9a-z]+}}, i32 0, i32 0)
+// CHECK: call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.s3) %{{[0-9a-z]+}}, i32 0, i32 0)
+// CHECK: call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.s2) %{{[0-9a-z]+}}, i32 0, i32 0)
+// CHECK: call ptr @llvm.preserve.union.access.index.p0.p0(ptr %{{[0-9a-z]+}}, i32 0)
+// CHECK: call ptr @llvm.preserve.array.access.index.p0.p0(ptr elementtype([3 x %struct.s1]) %{{[0-9a-z]+}}, i32 1, i32 2)
+// CHECK: call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.s1) %{{[0-9a-z]+}}, i32 0, i32 0)
diff --git a/clang/test/CodeGen/bpf-attr-preserve-access-index-4.c b/clang/test/CodeGen/bpf-attr-preserve-access-index-4.c
index 714cdd077d5d..2385c73e0518 100644
--- a/clang/test/CodeGen/bpf-attr-preserve-access-index-4.c
+++ b/clang/test/CodeGen/bpf-attr-preserve-access-index-4.c
@@ -1,5 +1,5 @@
// REQUIRES: bpf-registered-target
-// RUN: %clang_cc1 -no-opaque-pointers -triple bpf -emit-llvm -debug-info-kind=limited -disable-llvm-passes %s -o - | FileCheck %s
+// RUN: %clang_cc1 -triple bpf -emit-llvm -debug-info-kind=limited -disable-llvm-passes %s -o - | FileCheck %s
#define __reloc__ __attribute__((preserve_access_index))
@@ -26,8 +26,8 @@ int test(__s3 *arg) {
}
// CHECK: define dso_local i32 @test
-// CHECK-NOT: call %struct.s2* @llvm.preserve.struct.access.index.p0s_struct.s2s.p0s_struct.s3s
-// CHECK: call %union.anon* @llvm.preserve.struct.access.index.p0s_union.anons.p0s_struct.s2s(%struct.s2* elementtype(%struct.s2) %{{[0-9a-z]+}}, i32 0, i32 0)
-// CHECK: call %union.anon* @llvm.preserve.union.access.index.p0s_union.anons.p0s_union.anons(%union.anon* %{{[0-9a-z]+}}, i32 0)
-// CHECK: call %struct.s1* @llvm.preserve.array.access.index.p0s_struct.s1s.p0a3s_struct.s1s([3 x %struct.s1]* elementtype([3 x %struct.s1]) %{{[0-9a-z]+}}, i32 1, i32 2)
-// CHECK-NOT: call i32* @llvm.preserve.struct.access.index.p0i32.p0s_struct.s1s
+// CHECK-NOT: call ptr @llvm.preserve.struct.access.index.p0.p0
+// CHECK: call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.s2) %{{[0-9a-z]+}}, i32 0, i32 0)
+// CHECK: call ptr @llvm.preserve.union.access.index.p0.p0(ptr %{{[0-9a-z]+}}, i32 0)
+// CHECK: call ptr @llvm.preserve.array.access.index.p0.p0(ptr elementtype([3 x %struct.s1]) %{{[0-9a-z]+}}, i32 1, i32 2)
+// CHECK-NOT: call ptr @llvm.preserve.struct.access.index.p0.p0
diff --git a/clang/test/CodeGen/bpf-attr-preserve-access-index-5.c b/clang/test/CodeGen/bpf-attr-preserve-access-index-5.c
index d987e134cc1c..0317c4499b4d 100644
--- a/clang/test/CodeGen/bpf-attr-preserve-access-index-5.c
+++ b/clang/test/CodeGen/bpf-attr-preserve-access-index-5.c
@@ -1,5 +1,5 @@
// REQUIRES: bpf-registered-target
-// RUN: %clang_cc1 -no-opaque-pointers -triple bpf -emit-llvm -debug-info-kind=limited -disable-llvm-passes %s -o - | FileCheck %s
+// RUN: %clang_cc1 -triple bpf -emit-llvm -debug-info-kind=limited -disable-llvm-passes %s -o - | FileCheck %s
#define __reloc__ __attribute__((preserve_access_index))
@@ -25,8 +25,8 @@ int test(__s3 *arg) {
return arg->a.b[2].c;
}
-// CHECK: call %struct.s2* @llvm.preserve.struct.access.index.p0s_struct.s2s.p0s_struct.s3s(%struct.s3* elementtype(%struct.s3) %{{[0-9a-z]+}}, i32 0, i32 0)
-// CHECK-NOT: call %union.anon* @llvm.preserve.struct.access.index.p0s_union.anons.p0s_struct.s2s
-// CHECK: call %union.anon* @llvm.preserve.union.access.index.p0s_union.anons.p0s_union.anons(%union.anon* %{{[0-9a-z]+}}, i32 0)
-// CHECK: call %struct.s1* @llvm.preserve.array.access.index.p0s_struct.s1s.p0a3s_struct.s1s([3 x %struct.s1]* elementtype([3 x %struct.s1]) %{{[0-9a-z]+}}, i32 1, i32 2)
-// CHECK: call i32* @llvm.preserve.struct.access.index.p0i32.p0s_struct.s1s(%struct.s1* elementtype(%struct.s1) %{{[0-9a-z]+}}, i32 0, i32 0)
+// CHECK: call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.s3) %{{[0-9a-z]+}}, i32 0, i32 0)
+// CHECK-NOT: call ptr @llvm.preserve.struct.access.index.p0.p0
+// CHECK: call ptr @llvm.preserve.union.access.index.p0.p0(ptr %{{[0-9a-z]+}}, i32 0)
+// CHECK: call ptr @llvm.preserve.array.access.index.p0.p0(ptr elementtype([3 x %struct.s1]) %{{[0-9a-z]+}}, i32 1, i32 2)
+// CHECK: call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.s1) %{{[0-9a-z]+}}, i32 0, i32 0)
diff --git a/clang/test/CodeGen/bpf-attr-preserve-access-index-6.c b/clang/test/CodeGen/bpf-attr-preserve-access-index-6.c
index caf57c469b45..e0b08a08acfb 100644
--- a/clang/test/CodeGen/bpf-attr-preserve-access-index-6.c
+++ b/clang/test/CodeGen/bpf-attr-preserve-access-index-6.c
@@ -1,5 +1,5 @@
// REQUIRES: bpf-registered-target
-// RUN: %clang_cc1 -no-opaque-pointers -triple bpf -emit-llvm -debug-info-kind=limited -disable-llvm-passes %s -o - | FileCheck %s
+// RUN: %clang_cc1 -triple bpf -emit-llvm -debug-info-kind=limited -disable-llvm-passes %s -o - | FileCheck %s
#define __reloc__ __attribute__((preserve_access_index))
@@ -25,8 +25,8 @@ int test(__s3 *arg) {
return arg->a.b[2].c;
}
-// CHECK: call %struct.s2* @llvm.preserve.struct.access.index.p0s_struct.s2s.p0s_struct.s3s(%struct.s3* elementtype(%struct.s3) %{{[0-9a-z]+}}, i32 0, i32 0)
-// CHECK: call %union.anon* @llvm.preserve.struct.access.index.p0s_union.anons.p0s_struct.s2s(%struct.s2* elementtype(%struct.s2) %{{[0-9a-z]+}}, i32 0, i32 0)
-// CHECK: call %union.anon* @llvm.preserve.union.access.index.p0s_union.anons.p0s_union.anons(%union.anon* %{{[0-9a-z]+}}, i32 0)
-// CHECK: call %struct.s1* @llvm.preserve.array.access.index.p0s_struct.s1s.p0a3s_struct.s1s([3 x %struct.s1]* elementtype([3 x %struct.s1]) %{{[0-9a-z]+}}, i32 1, i32 2)
-// CHECK: call i32* @llvm.preserve.struct.access.index.p0i32.p0s_struct.s1s(%struct.s1* elementtype(%struct.s1) %{{[0-9a-z]+}}, i32 0, i32 0)
+// CHECK: call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.s3) %{{[0-9a-z]+}}, i32 0, i32 0)
+// CHECK: call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.s2) %{{[0-9a-z]+}}, i32 0, i32 0)
+// CHECK: call ptr @llvm.preserve.union.access.index.p0.p0(ptr %{{[0-9a-z]+}}, i32 0)
+// CHECK: call ptr @llvm.preserve.array.access.index.p0.p0(ptr elementtype([3 x %struct.s1]) %{{[0-9a-z]+}}, i32 1, i32 2)
+// CHECK: call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.s1) %{{[0-9a-z]+}}, i32 0, i32 0)
diff --git a/clang/test/CodeGen/bpf-attr-preserve-access-index-7.c b/clang/test/CodeGen/bpf-attr-preserve-access-index-7.c
index ae79a555a782..b75f6b0ffa02 100644
--- a/clang/test/CodeGen/bpf-attr-preserve-access-index-7.c
+++ b/clang/test/CodeGen/bpf-attr-preserve-access-index-7.c
@@ -1,5 +1,5 @@
// REQUIRES: bpf-registered-target
-// RUN: %clang_cc1 -no-opaque-pointers -triple bpf -emit-llvm -debug-info-kind=limited -disable-llvm-passes %s -o - | FileCheck %s
+// RUN: %clang_cc1 -triple bpf -emit-llvm -debug-info-kind=limited -disable-llvm-passes %s -o - | FileCheck %s
#define __reloc__ __attribute__((preserve_access_index))
@@ -29,8 +29,8 @@ int test(__s3 *arg) {
return arg->a.b[2].c;
}
-// CHECK: call %struct.s2* @llvm.preserve.struct.access.index.p0s_struct.s2s.p0s_struct.s3s(%struct.s3* elementtype(%struct.s3) %{{[0-9a-z]+}}, i32 0, i32 0)
-// CHECK: call %union.anon* @llvm.preserve.struct.access.index.p0s_union.anons.p0s_struct.s2s(%struct.s2* elementtype(%struct.s2) %{{[0-9a-z]+}}, i32 0, i32 0)
-// CHECK: call %union.anon* @llvm.preserve.union.access.index.p0s_union.anons.p0s_union.anons(%union.anon* %{{[0-9a-z]+}}, i32 0)
-// CHECK: call %struct.s1* @llvm.preserve.array.access.index.p0s_struct.s1s.p0a3s_struct.s1s([3 x %struct.s1]* elementtype([3 x %struct.s1]) %{{[0-9a-z]+}}, i32 1, i32 2)
-// CHECK: call i32* @llvm.preserve.struct.access.index.p0i32.p0s_struct.s1s(%struct.s1* elementtype(%struct.s1) %{{[0-9a-z]+}}, i32 0, i32 0)
+// CHECK: call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.s3) %{{[0-9a-z]+}}, i32 0, i32 0)
+// CHECK: call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.s2) %{{[0-9a-z]+}}, i32 0, i32 0)
+// CHECK: call ptr @llvm.preserve.union.access.index.p0.p0(ptr %{{[0-9a-z]+}}, i32 0)
+// CHECK: call ptr @llvm.preserve.array.access.index.p0.p0(ptr elementtype([3 x %struct.s1]) %{{[0-9a-z]+}}, i32 1, i32 2)
+// CHECK: call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.s1) %{{[0-9a-z]+}}, i32 0, i32 0)
diff --git a/clang/test/CodeGen/bpf-attr-preserve-access-index-8.c b/clang/test/CodeGen/bpf-attr-preserve-access-index-8.c
index e5cfb3767c67..6495b6a7c4f4 100644
--- a/clang/test/CodeGen/bpf-attr-preserve-access-index-8.c
+++ b/clang/test/CodeGen/bpf-attr-preserve-access-index-8.c
@@ -1,5 +1,5 @@
// REQUIRES: bpf-registered-target
-// RUN: %clang_cc1 -no-opaque-pointers -triple bpf -emit-llvm -debug-info-kind=limited -disable-llvm-passes %s -o - | FileCheck %s
+// RUN: %clang_cc1 -triple bpf -emit-llvm -debug-info-kind=limited -disable-llvm-passes %s -o - | FileCheck %s
#define __reloc__ __attribute__((preserve_access_index))
@@ -29,8 +29,8 @@ int test(__s3 *arg) {
return arg->a.b[2].c;
}
-// CHECK: call %struct.s2* @llvm.preserve.struct.access.index.p0s_struct.s2s.p0s_struct.s3s(%struct.s3* elementtype(%struct.s3) %{{[0-9a-z]+}}, i32 0, i32 0)
-// CHECK: call %union.anon* @llvm.preserve.struct.access.index.p0s_union.anons.p0s_struct.s2s(%struct.s2* elementtype(%struct.s2) %{{[0-9a-z]+}}, i32 0, i32 0)
-// CHECK: call %union.anon* @llvm.preserve.union.access.index.p0s_union.anons.p0s_union.anons(%union.anon* %{{[0-9a-z]+}}, i32 0)
-// CHECK: call %struct.s1* @llvm.preserve.array.access.index.p0s_struct.s1s.p0a3s_struct.s1s([3 x %struct.s1]* elementtype([3 x %struct.s1]) %{{[0-9a-z]+}}, i32 1, i32 2)
-// CHECK: call i32* @llvm.preserve.struct.access.index.p0i32.p0s_struct.s1s(%struct.s1* elementtype(%struct.s1) %{{[0-9a-z]+}}, i32 0, i32 0)
+// CHECK: call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.s3) %{{[0-9a-z]+}}, i32 0, i32 0)
+// CHECK: call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.s2) %{{[0-9a-z]+}}, i32 0, i32 0)
+// CHECK: call ptr @llvm.preserve.union.access.index.p0.p0(ptr %{{[0-9a-z]+}}, i32 0)
+// CHECK: call ptr @llvm.preserve.array.access.index.p0.p0(ptr elementtype([3 x %struct.s1]) %{{[0-9a-z]+}}, i32 1, i32 2)
+// CHECK: call ptr @llvm.preserve.struct.access.index.p0.p0(ptr elementtype(%struct.s1) %{{[0-9a-z]+}}, i32 0, i32 0)
diff --git a/clang/test/CodeGen/builtins-memcpy-inline.c b/clang/test/CodeGen/builtins-memcpy-inline.c
index c9ea43ed9622..eaa7ddd8530e 100644
--- a/clang/test/CodeGen/builtins-memcpy-inline.c
+++ b/clang/test/CodeGen/builtins-memcpy-inline.c
@@ -1,26 +1,26 @@
// REQUIRES: x86-registered-target
-// RUN: %clang_cc1 -no-opaque-pointers -triple x86_64-unknown-linux -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux -emit-llvm %s -o - | FileCheck %s
-// CHECK-LABEL: define{{.*}} void @test_memcpy_inline_0(i8* noundef %dst, i8* noundef %src)
+// CHECK-LABEL: define{{.*}} void @test_memcpy_inline_0(ptr noundef %dst, ptr noundef %src)
void test_memcpy_inline_0(void *dst, const void *src) {
- // CHECK: call void @llvm.memcpy.inline.p0i8.p0i8.i64(i8* align 1 %0, i8* align 1 %1, i64 0, i1 false)
+ // CHECK: call void @llvm.memcpy.inline.p0.p0.i64(ptr align 1 %0, ptr align 1 %1, i64 0, i1 false)
__builtin_memcpy_inline(dst, src, 0);
}
-// CHECK-LABEL: define{{.*}} void @test_memcpy_inline_1(i8* noundef %dst, i8* noundef %src)
+// CHECK-LABEL: define{{.*}} void @test_memcpy_inline_1(ptr noundef %dst, ptr noundef %src)
void test_memcpy_inline_1(void *dst, const void *src) {
- // CHECK: call void @llvm.memcpy.inline.p0i8.p0i8.i64(i8* align 1 %0, i8* align 1 %1, i64 1, i1 false)
+ // CHECK: call void @llvm.memcpy.inline.p0.p0.i64(ptr align 1 %0, ptr align 1 %1, i64 1, i1 false)
__builtin_memcpy_inline(dst, src, 1);
}
-// CHECK-LABEL: define{{.*}} void @test_memcpy_inline_4(i8* noundef %dst, i8* noundef %src)
+// CHECK-LABEL: define{{.*}} void @test_memcpy_inline_4(ptr noundef %dst, ptr noundef %src)
void test_memcpy_inline_4(void *dst, const void *src) {
- // CHECK: call void @llvm.memcpy.inline.p0i8.p0i8.i64(i8* align 1 %0, i8* align 1 %1, i64 4, i1 false)
+ // CHECK: call void @llvm.memcpy.inline.p0.p0.i64(ptr align 1 %0, ptr align 1 %1, i64 4, i1 false)
__builtin_memcpy_inline(dst, src, 4);
}
-// CHECK-LABEL: define{{.*}} void @test_memcpy_inline_aligned_buffers(i64* noundef %dst, i64* noundef %src)
+// CHECK-LABEL: define{{.*}} void @test_memcpy_inline_aligned_buffers(ptr noundef %dst, ptr noundef %src)
void test_memcpy_inline_aligned_buffers(unsigned long long *dst, const unsigned long long *src) {
- // CHECK: call void @llvm.memcpy.inline.p0i8.p0i8.i64(i8* align 8 %1, i8* align 8 %3, i64 4, i1 false)
+ // CHECK: call void @llvm.memcpy.inline.p0.p0.i64(ptr align 8 %0, ptr align 8 %1, i64 4, i1 false)
__builtin_memcpy_inline(dst, src, 4);
}
diff --git a/clang/test/CodeGen/builtins-nvptx.c b/clang/test/CodeGen/builtins-nvptx.c
index 1dc4dec160c4..0851fc829a46 100644
--- a/clang/test/CodeGen/builtins-nvptx.c
+++ b/clang/test/CodeGen/builtins-nvptx.c
@@ -1,25 +1,25 @@
// REQUIRES: nvptx-registered-target
-// RUN: %clang_cc1 -no-opaque-pointers -ffp-contract=off -triple nvptx-unknown-unknown -target-cpu sm_80 -target-feature +ptx70 \
+// RUN: %clang_cc1 -ffp-contract=off -triple nvptx-unknown-unknown -target-cpu sm_80 -target-feature +ptx70 \
// RUN: -fcuda-is-device -S -emit-llvm -o - -x cuda %s \
// RUN: | FileCheck -check-prefix=CHECK -check-prefix=CHECK_PTX70_SM80 -check-prefix=LP32 %s
-// RUN: %clang_cc1 -no-opaque-pointers -ffp-contract=off -triple nvptx64-unknown-unknown -target-cpu sm_80 -target-feature +ptx70 \
+// RUN: %clang_cc1 -ffp-contract=off -triple nvptx64-unknown-unknown -target-cpu sm_80 -target-feature +ptx70 \
// RUN: -fcuda-is-device -S -emit-llvm -o - -x cuda %s \
// RUN: | FileCheck -check-prefix=CHECK -check-prefix=CHECK_PTX70_SM80 -check-prefix=LP64 %s
-// RUN: %clang_cc1 -no-opaque-pointers -ffp-contract=off -triple nvptx-unknown-unknown -target-cpu sm_60 \
+// RUN: %clang_cc1 -ffp-contract=off -triple nvptx-unknown-unknown -target-cpu sm_60 \
// RUN: -fcuda-is-device -S -emit-llvm -o - -x cuda %s \
// RUN: | FileCheck -check-prefix=CHECK -check-prefix=LP32 %s
-// RUN: %clang_cc1 -no-opaque-pointers -ffp-contract=off -triple nvptx64-unknown-unknown -target-cpu sm_60 \
+// RUN: %clang_cc1 -ffp-contract=off -triple nvptx64-unknown-unknown -target-cpu sm_60 \
// RUN: -fcuda-is-device -S -emit-llvm -o - -x cuda %s \
// RUN: | FileCheck -check-prefix=CHECK -check-prefix=LP64 %s
-// RUN: %clang_cc1 -no-opaque-pointers -ffp-contract=off -triple nvptx64-unknown-unknown -target-cpu sm_61 \
+// RUN: %clang_cc1 -ffp-contract=off -triple nvptx64-unknown-unknown -target-cpu sm_61 \
// RUN: -fcuda-is-device -S -emit-llvm -o - -x cuda %s \
// RUN: | FileCheck -check-prefix=CHECK -check-prefix=LP64 %s
-// RUN: %clang_cc1 -no-opaque-pointers -triple nvptx-unknown-unknown -target-cpu sm_53 \
+// RUN: %clang_cc1 -triple nvptx-unknown-unknown -target-cpu sm_53 \
// RUN: -DERROR_CHECK -fcuda-is-device -S -o /dev/null -x cuda -verify %s
-// RUN: %clang_cc1 -no-opaque-pointers -ffp-contract=off -triple nvptx-unknown-unknown -target-cpu sm_86 -target-feature +ptx72 \
+// RUN: %clang_cc1 -ffp-contract=off -triple nvptx-unknown-unknown -target-cpu sm_86 -target-feature +ptx72 \
// RUN: -fcuda-is-device -S -emit-llvm -o - -x cuda %s \
// RUN: | FileCheck -check-prefix=CHECK -check-prefix=CHECK_PTX72_SM86 -check-prefix=LP32 %s
-// RUN: %clang_cc1 -no-opaque-pointers -ffp-contract=off -triple nvptx64-unknown-unknown -target-cpu sm_86 -target-feature +ptx72 \
+// RUN: %clang_cc1 -ffp-contract=off -triple nvptx64-unknown-unknown -target-cpu sm_86 -target-feature +ptx72 \
// RUN: -fcuda-is-device -S -emit-llvm -o - -x cuda %s \
// RUN: | FileCheck -check-prefix=CHECK -check-prefix=CHECK_PTX72_SM86 -check-prefix=LP64 %s
@@ -213,91 +213,91 @@ __shared__ long long sll;
__device__ void nvvm_atom(float *fp, float f, double *dfp, double df, int *ip,
int i, unsigned int *uip, unsigned ui, long *lp,
long l, long long *llp, long long ll) {
- // CHECK: atomicrmw add i32* {{.*}} seq_cst, align 4
+ // CHECK: atomicrmw add ptr {{.*}} seq_cst, align 4
__nvvm_atom_add_gen_i(ip, i);
- // CHECK: atomicrmw add i{{32|64}}* {{.*}} seq_cst, align {{4|8}}
+ // CHECK: atomicrmw add ptr {{.*}} seq_cst, align {{4|8}}
__nvvm_atom_add_gen_l(&dl, l);
- // CHECK: atomicrmw add i64* {{.*}} seq_cst, align 8
+ // CHECK: atomicrmw add ptr {{.*}} seq_cst, align 8
__nvvm_atom_add_gen_ll(&sll, ll);
- // CHECK: atomicrmw sub i32* {{.*}} seq_cst, align 4
+ // CHECK: atomicrmw sub ptr {{.*}} seq_cst, align 4
__nvvm_atom_sub_gen_i(ip, i);
- // CHECK: atomicrmw sub i{{32|64}}* {{.*}} seq_cst, align {{4|8}}
+ // CHECK: atomicrmw sub ptr {{.*}} seq_cst, align {{4|8}}
__nvvm_atom_sub_gen_l(&dl, l);
- // CHECK: atomicrmw sub i64* {{.*}} seq_cst, align 8
+ // CHECK: atomicrmw sub ptr {{.*}} seq_cst, align 8
__nvvm_atom_sub_gen_ll(&sll, ll);
- // CHECK: atomicrmw and i32* {{.*}} seq_cst, align 4
+ // CHECK: atomicrmw and ptr {{.*}} seq_cst, align 4
__nvvm_atom_and_gen_i(ip, i);
- // CHECK: atomicrmw and i{{32|64}}* {{.*}} seq_cst, align {{4|8}}
+ // CHECK: atomicrmw and ptr {{.*}} seq_cst, align {{4|8}}
__nvvm_atom_and_gen_l(&dl, l);
- // CHECK: atomicrmw and i64* {{.*}} seq_cst, align 8
+ // CHECK: atomicrmw and ptr {{.*}} seq_cst, align 8
__nvvm_atom_and_gen_ll(&sll, ll);
- // CHECK: atomicrmw or i32* {{.*}} seq_cst, align 4
+ // CHECK: atomicrmw or ptr {{.*}} seq_cst, align 4
__nvvm_atom_or_gen_i(ip, i);
- // CHECK: atomicrmw or i{{32|64}}* {{.*}} seq_cst, align {{4|8}}
+ // CHECK: atomicrmw or ptr {{.*}} seq_cst, align {{4|8}}
__nvvm_atom_or_gen_l(&dl, l);
- // CHECK: atomicrmw or i64* {{.*}} seq_cst, align 8
+ // CHECK: atomicrmw or ptr {{.*}} seq_cst, align 8
__nvvm_atom_or_gen_ll(&sll, ll);
- // CHECK: atomicrmw xor i32* {{.*}} seq_cst, align 4
+ // CHECK: atomicrmw xor ptr {{.*}} seq_cst, align 4
__nvvm_atom_xor_gen_i(ip, i);
- // CHECK: atomicrmw xor i{{32|64}}* {{.*}} seq_cst, align {{4|8}}
+ // CHECK: atomicrmw xor ptr {{.*}} seq_cst, align {{4|8}}
__nvvm_atom_xor_gen_l(&dl, l);
- // CHECK: atomicrmw xor i64* {{.*}} seq_cst, align 8
+ // CHECK: atomicrmw xor ptr {{.*}} seq_cst, align 8
__nvvm_atom_xor_gen_ll(&sll, ll);
- // CHECK: atomicrmw xchg i32* {{.*}} seq_cst, align 4
+ // CHECK: atomicrmw xchg ptr {{.*}} seq_cst, align 4
__nvvm_atom_xchg_gen_i(ip, i);
- // CHECK: atomicrmw xchg i{{32|64}}* {{.*}} seq_cst, align {{4|8}}
+ // CHECK: atomicrmw xchg ptr {{.*}} seq_cst, align {{4|8}}
__nvvm_atom_xchg_gen_l(&dl, l);
- // CHECK: atomicrmw xchg i64* {{.*}} seq_cst, align 8
+ // CHECK: atomicrmw xchg ptr {{.*}} seq_cst, align 8
__nvvm_atom_xchg_gen_ll(&sll, ll);
- // CHECK: atomicrmw max i32* {{.*}} seq_cst, align 4
+ // CHECK: atomicrmw max ptr {{.*}} seq_cst, align 4
__nvvm_atom_max_gen_i(ip, i);
- // CHECK: atomicrmw umax i32* {{.*}} seq_cst, align 4
+ // CHECK: atomicrmw umax ptr {{.*}} seq_cst, align 4
__nvvm_atom_max_gen_ui((unsigned int *)ip, i);
- // CHECK: atomicrmw max i{{32|64}}* {{.*}} seq_cst, align {{4|8}}
+ // CHECK: atomicrmw max ptr {{.*}} seq_cst, align {{4|8}}
__nvvm_atom_max_gen_l(&dl, l);
- // CHECK: atomicrmw umax i{{32|64}}* {{.*}} seq_cst, align {{4|8}}
+ // CHECK: atomicrmw umax ptr {{.*}} seq_cst, align {{4|8}}
__nvvm_atom_max_gen_ul((unsigned long *)&dl, l);
- // CHECK: atomicrmw max i64* {{.*}} seq_cst, align 8
+ // CHECK: atomicrmw max ptr {{.*}} seq_cst, align 8
__nvvm_atom_max_gen_ll(&sll, ll);
- // CHECK: atomicrmw umax i64* {{.*}} seq_cst, align 8
+ // CHECK: atomicrmw umax ptr {{.*}} seq_cst, align 8
__nvvm_atom_max_gen_ull((unsigned long long *)&sll, ll);
- // CHECK: atomicrmw min i32* {{.*}} seq_cst, align 4
+ // CHECK: atomicrmw min ptr {{.*}} seq_cst, align 4
__nvvm_atom_min_gen_i(ip, i);
- // CHECK: atomicrmw umin i32* {{.*}} seq_cst, align 4
+ // CHECK: atomicrmw umin ptr {{.*}} seq_cst, align 4
__nvvm_atom_min_gen_ui((unsigned int *)ip, i);
- // CHECK: atomicrmw min i{{32|64}}* {{.*}} seq_cst, align {{4|8}}
+ // CHECK: atomicrmw min ptr {{.*}} seq_cst, align {{4|8}}
__nvvm_atom_min_gen_l(&dl, l);
- // CHECK: atomicrmw umin i{{32|64}}* {{.*}} seq_cst, align {{4|8}}
+ // CHECK: atomicrmw umin ptr {{.*}} seq_cst, align {{4|8}}
__nvvm_atom_min_gen_ul((unsigned long *)&dl, l);
- // CHECK: atomicrmw min i64* {{.*}} seq_cst, align 8
+ // CHECK: atomicrmw min ptr {{.*}} seq_cst, align 8
__nvvm_atom_min_gen_ll(&sll, ll);
- // CHECK: atomicrmw umin i64* {{.*}} seq_cst, align 8
+ // CHECK: atomicrmw umin ptr {{.*}} seq_cst, align 8
__nvvm_atom_min_gen_ull((unsigned long long *)&sll, ll);
- // CHECK: cmpxchg i32* {{.*}} seq_cst seq_cst, align 4
+ // CHECK: cmpxchg ptr {{.*}} seq_cst seq_cst, align 4
// CHECK-NEXT: extractvalue { i32, i1 } {{%[0-9]+}}, 0
__nvvm_atom_cas_gen_i(ip, 0, i);
- // CHECK: cmpxchg i{{32|64}}* {{.*}} seq_cst seq_cst, align {{4|8}}
+ // CHECK: cmpxchg ptr {{.*}} seq_cst seq_cst, align {{4|8}}
// CHECK-NEXT: extractvalue { {{i32|i64}}, i1 } {{%[0-9]+}}, 0
__nvvm_atom_cas_gen_l(&dl, 0, l);
- // CHECK: cmpxchg i64* {{.*}} seq_cst seq_cst, align 8
+ // CHECK: cmpxchg ptr {{.*}} seq_cst seq_cst, align 8
// CHECK-NEXT: extractvalue { i64, i1 } {{%[0-9]+}}, 0
__nvvm_atom_cas_gen_ll(&sll, 0, ll);
- // CHECK: atomicrmw fadd float* {{.*}} seq_cst, align 4
+ // CHECK: atomicrmw fadd ptr {{.*}} seq_cst, align 4
__nvvm_atom_add_gen_f(fp, f);
- // CHECK: call i32 @llvm.nvvm.atomic.load.inc.32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.load.inc.32.p0
__nvvm_atom_inc_gen_ui(uip, ui);
- // CHECK: call i32 @llvm.nvvm.atomic.load.dec.32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.load.dec.32.p0
__nvvm_atom_dec_gen_ui(uip, ui);
@@ -306,245 +306,245 @@ __device__ void nvvm_atom(float *fp, float f, double *dfp, double df, int *ip,
#if ERROR_CHECK || __CUDA_ARCH__ >= 600
- // CHECK: call i32 @llvm.nvvm.atomic.add.gen.i.cta.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.add.gen.i.cta.i32.p0
// expected-error at +1 {{'__nvvm_atom_cta_add_gen_i' needs target feature sm_60}}
__nvvm_atom_cta_add_gen_i(ip, i);
- // LP32: call i32 @llvm.nvvm.atomic.add.gen.i.cta.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.add.gen.i.cta.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.add.gen.i.cta.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.add.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_add_gen_l' needs target feature sm_60}}
__nvvm_atom_cta_add_gen_l(&dl, l);
- // CHECK: call i64 @llvm.nvvm.atomic.add.gen.i.cta.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.add.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_add_gen_ll' needs target feature sm_60}}
__nvvm_atom_cta_add_gen_ll(&sll, ll);
- // CHECK: call i32 @llvm.nvvm.atomic.add.gen.i.sys.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.add.gen.i.sys.i32.p0
// expected-error at +1 {{'__nvvm_atom_sys_add_gen_i' needs target feature sm_60}}
__nvvm_atom_sys_add_gen_i(ip, i);
- // LP32: call i32 @llvm.nvvm.atomic.add.gen.i.sys.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.add.gen.i.sys.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.add.gen.i.sys.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.add.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_add_gen_l' needs target feature sm_60}}
__nvvm_atom_sys_add_gen_l(&dl, l);
- // CHECK: call i64 @llvm.nvvm.atomic.add.gen.i.sys.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.add.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_add_gen_ll' needs target feature sm_60}}
__nvvm_atom_sys_add_gen_ll(&sll, ll);
- // CHECK: call float @llvm.nvvm.atomic.add.gen.f.cta.f32.p0f32
+ // CHECK: call float @llvm.nvvm.atomic.add.gen.f.cta.f32.p0
// expected-error at +1 {{'__nvvm_atom_cta_add_gen_f' needs target feature sm_60}}
__nvvm_atom_cta_add_gen_f(fp, f);
- // CHECK: call double @llvm.nvvm.atomic.add.gen.f.cta.f64.p0f64
+ // CHECK: call double @llvm.nvvm.atomic.add.gen.f.cta.f64.p0
// expected-error at +1 {{'__nvvm_atom_cta_add_gen_d' needs target feature sm_60}}
__nvvm_atom_cta_add_gen_d(dfp, df);
- // CHECK: call float @llvm.nvvm.atomic.add.gen.f.sys.f32.p0f32
+ // CHECK: call float @llvm.nvvm.atomic.add.gen.f.sys.f32.p0
// expected-error at +1 {{'__nvvm_atom_sys_add_gen_f' needs target feature sm_60}}
__nvvm_atom_sys_add_gen_f(fp, f);
- // CHECK: call double @llvm.nvvm.atomic.add.gen.f.sys.f64.p0f64
+ // CHECK: call double @llvm.nvvm.atomic.add.gen.f.sys.f64.p0
// expected-error at +1 {{'__nvvm_atom_sys_add_gen_d' needs target feature sm_60}}
__nvvm_atom_sys_add_gen_d(dfp, df);
- // CHECK: call i32 @llvm.nvvm.atomic.exch.gen.i.cta.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.exch.gen.i.cta.i32.p0
// expected-error at +1 {{'__nvvm_atom_cta_xchg_gen_i' needs target feature sm_60}}
__nvvm_atom_cta_xchg_gen_i(ip, i);
- // LP32: call i32 @llvm.nvvm.atomic.exch.gen.i.cta.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.exch.gen.i.cta.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.exch.gen.i.cta.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.exch.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_xchg_gen_l' needs target feature sm_60}}
__nvvm_atom_cta_xchg_gen_l(&dl, l);
- // CHECK: call i64 @llvm.nvvm.atomic.exch.gen.i.cta.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.exch.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_xchg_gen_ll' needs target feature sm_60}}
__nvvm_atom_cta_xchg_gen_ll(&sll, ll);
- // CHECK: call i32 @llvm.nvvm.atomic.exch.gen.i.sys.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.exch.gen.i.sys.i32.p0
// expected-error at +1 {{'__nvvm_atom_sys_xchg_gen_i' needs target feature sm_60}}
__nvvm_atom_sys_xchg_gen_i(ip, i);
- // LP32: call i32 @llvm.nvvm.atomic.exch.gen.i.sys.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.exch.gen.i.sys.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.exch.gen.i.sys.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.exch.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_xchg_gen_l' needs target feature sm_60}}
__nvvm_atom_sys_xchg_gen_l(&dl, l);
- // CHECK: call i64 @llvm.nvvm.atomic.exch.gen.i.sys.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.exch.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_xchg_gen_ll' needs target feature sm_60}}
__nvvm_atom_sys_xchg_gen_ll(&sll, ll);
- // CHECK: call i32 @llvm.nvvm.atomic.max.gen.i.cta.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.max.gen.i.cta.i32.p0
// expected-error at +1 {{'__nvvm_atom_cta_max_gen_i' needs target feature sm_60}}
__nvvm_atom_cta_max_gen_i(ip, i);
- // CHECK: call i32 @llvm.nvvm.atomic.max.gen.i.cta.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.max.gen.i.cta.i32.p0
// expected-error at +1 {{'__nvvm_atom_cta_max_gen_ui' needs target feature sm_60}}
__nvvm_atom_cta_max_gen_ui((unsigned int *)ip, i);
- // LP32: call i32 @llvm.nvvm.atomic.max.gen.i.cta.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.max.gen.i.cta.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.max.gen.i.cta.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.max.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_max_gen_l' needs target feature sm_60}}
__nvvm_atom_cta_max_gen_l(&dl, l);
- // LP32: call i32 @llvm.nvvm.atomic.max.gen.i.cta.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.max.gen.i.cta.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.max.gen.i.cta.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.max.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_max_gen_ul' needs target feature sm_60}}
__nvvm_atom_cta_max_gen_ul((unsigned long *)lp, l);
- // CHECK: call i64 @llvm.nvvm.atomic.max.gen.i.cta.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.max.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_max_gen_ll' needs target feature sm_60}}
__nvvm_atom_cta_max_gen_ll(&sll, ll);
- // CHECK: call i64 @llvm.nvvm.atomic.max.gen.i.cta.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.max.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_max_gen_ull' needs target feature sm_60}}
__nvvm_atom_cta_max_gen_ull((unsigned long long *)llp, ll);
- // CHECK: call i32 @llvm.nvvm.atomic.max.gen.i.sys.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.max.gen.i.sys.i32.p0
// expected-error at +1 {{'__nvvm_atom_sys_max_gen_i' needs target feature sm_60}}
__nvvm_atom_sys_max_gen_i(ip, i);
- // CHECK: call i32 @llvm.nvvm.atomic.max.gen.i.sys.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.max.gen.i.sys.i32.p0
// expected-error at +1 {{'__nvvm_atom_sys_max_gen_ui' needs target feature sm_60}}
__nvvm_atom_sys_max_gen_ui((unsigned int *)ip, i);
- // LP32: call i32 @llvm.nvvm.atomic.max.gen.i.sys.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.max.gen.i.sys.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.max.gen.i.sys.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.max.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_max_gen_l' needs target feature sm_60}}
__nvvm_atom_sys_max_gen_l(&dl, l);
- // LP32: call i32 @llvm.nvvm.atomic.max.gen.i.sys.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.max.gen.i.sys.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.max.gen.i.sys.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.max.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_max_gen_ul' needs target feature sm_60}}
__nvvm_atom_sys_max_gen_ul((unsigned long *)lp, l);
- // CHECK: call i64 @llvm.nvvm.atomic.max.gen.i.sys.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.max.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_max_gen_ll' needs target feature sm_60}}
__nvvm_atom_sys_max_gen_ll(&sll, ll);
- // CHECK: call i64 @llvm.nvvm.atomic.max.gen.i.sys.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.max.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_max_gen_ull' needs target feature sm_60}}
__nvvm_atom_sys_max_gen_ull((unsigned long long *)llp, ll);
- // CHECK: call i32 @llvm.nvvm.atomic.min.gen.i.cta.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.min.gen.i.cta.i32.p0
// expected-error at +1 {{'__nvvm_atom_cta_min_gen_i' needs target feature sm_60}}
__nvvm_atom_cta_min_gen_i(ip, i);
- // CHECK: call i32 @llvm.nvvm.atomic.min.gen.i.cta.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.min.gen.i.cta.i32.p0
// expected-error at +1 {{'__nvvm_atom_cta_min_gen_ui' needs target feature sm_60}}
__nvvm_atom_cta_min_gen_ui((unsigned int *)ip, i);
- // LP32: call i32 @llvm.nvvm.atomic.min.gen.i.cta.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.min.gen.i.cta.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.min.gen.i.cta.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.min.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_min_gen_l' needs target feature sm_60}}
__nvvm_atom_cta_min_gen_l(&dl, l);
- // LP32: call i32 @llvm.nvvm.atomic.min.gen.i.cta.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.min.gen.i.cta.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.min.gen.i.cta.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.min.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_min_gen_ul' needs target feature sm_60}}
__nvvm_atom_cta_min_gen_ul((unsigned long *)lp, l);
- // CHECK: call i64 @llvm.nvvm.atomic.min.gen.i.cta.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.min.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_min_gen_ll' needs target feature sm_60}}
__nvvm_atom_cta_min_gen_ll(&sll, ll);
- // CHECK: call i64 @llvm.nvvm.atomic.min.gen.i.cta.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.min.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_min_gen_ull' needs target feature sm_60}}
__nvvm_atom_cta_min_gen_ull((unsigned long long *)llp, ll);
- // CHECK: call i32 @llvm.nvvm.atomic.min.gen.i.sys.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.min.gen.i.sys.i32.p0
// expected-error at +1 {{'__nvvm_atom_sys_min_gen_i' needs target feature sm_60}}
__nvvm_atom_sys_min_gen_i(ip, i);
- // CHECK: call i32 @llvm.nvvm.atomic.min.gen.i.sys.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.min.gen.i.sys.i32.p0
// expected-error at +1 {{'__nvvm_atom_sys_min_gen_ui' needs target feature sm_60}}
__nvvm_atom_sys_min_gen_ui((unsigned int *)ip, i);
- // LP32: call i32 @llvm.nvvm.atomic.min.gen.i.sys.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.min.gen.i.sys.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.min.gen.i.sys.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.min.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_min_gen_l' needs target feature sm_60}}
__nvvm_atom_sys_min_gen_l(&dl, l);
- // LP32: call i32 @llvm.nvvm.atomic.min.gen.i.sys.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.min.gen.i.sys.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.min.gen.i.sys.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.min.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_min_gen_ul' needs target feature sm_60}}
__nvvm_atom_sys_min_gen_ul((unsigned long *)lp, l);
- // CHECK: call i64 @llvm.nvvm.atomic.min.gen.i.sys.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.min.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_min_gen_ll' needs target feature sm_60}}
__nvvm_atom_sys_min_gen_ll(&sll, ll);
- // CHECK: call i64 @llvm.nvvm.atomic.min.gen.i.sys.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.min.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_min_gen_ull' needs target feature sm_60}}
__nvvm_atom_sys_min_gen_ull((unsigned long long *)llp, ll);
- // CHECK: call i32 @llvm.nvvm.atomic.inc.gen.i.cta.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.inc.gen.i.cta.i32.p0
// expected-error at +1 {{'__nvvm_atom_cta_inc_gen_ui' needs target feature sm_60}}
__nvvm_atom_cta_inc_gen_ui((unsigned int *)ip, i);
- // CHECK: call i32 @llvm.nvvm.atomic.inc.gen.i.sys.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.inc.gen.i.sys.i32.p0
// expected-error at +1 {{'__nvvm_atom_sys_inc_gen_ui' needs target feature sm_60}}
__nvvm_atom_sys_inc_gen_ui((unsigned int *)ip, i);
- // CHECK: call i32 @llvm.nvvm.atomic.dec.gen.i.cta.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.dec.gen.i.cta.i32.p0
// expected-error at +1 {{'__nvvm_atom_cta_dec_gen_ui' needs target feature sm_60}}
__nvvm_atom_cta_dec_gen_ui((unsigned int *)ip, i);
- // CHECK: call i32 @llvm.nvvm.atomic.dec.gen.i.sys.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.dec.gen.i.sys.i32.p0
// expected-error at +1 {{'__nvvm_atom_sys_dec_gen_ui' needs target feature sm_60}}
__nvvm_atom_sys_dec_gen_ui((unsigned int *)ip, i);
- // CHECK: call i32 @llvm.nvvm.atomic.and.gen.i.cta.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.and.gen.i.cta.i32.p0
// expected-error at +1 {{'__nvvm_atom_cta_and_gen_i' needs target feature sm_60}}
__nvvm_atom_cta_and_gen_i(ip, i);
- // LP32: call i32 @llvm.nvvm.atomic.and.gen.i.cta.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.and.gen.i.cta.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.and.gen.i.cta.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.and.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_and_gen_l' needs target feature sm_60}}
__nvvm_atom_cta_and_gen_l(&dl, l);
- // CHECK: call i64 @llvm.nvvm.atomic.and.gen.i.cta.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.and.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_and_gen_ll' needs target feature sm_60}}
__nvvm_atom_cta_and_gen_ll(&sll, ll);
- // CHECK: call i32 @llvm.nvvm.atomic.and.gen.i.sys.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.and.gen.i.sys.i32.p0
// expected-error at +1 {{'__nvvm_atom_sys_and_gen_i' needs target feature sm_60}}
__nvvm_atom_sys_and_gen_i(ip, i);
- // LP32: call i32 @llvm.nvvm.atomic.and.gen.i.sys.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.and.gen.i.sys.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.and.gen.i.sys.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.and.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_and_gen_l' needs target feature sm_60}}
__nvvm_atom_sys_and_gen_l(&dl, l);
- // CHECK: call i64 @llvm.nvvm.atomic.and.gen.i.sys.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.and.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_and_gen_ll' needs target feature sm_60}}
__nvvm_atom_sys_and_gen_ll(&sll, ll);
- // CHECK: call i32 @llvm.nvvm.atomic.or.gen.i.cta.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.or.gen.i.cta.i32.p0
// expected-error at +1 {{'__nvvm_atom_cta_or_gen_i' needs target feature sm_60}}
__nvvm_atom_cta_or_gen_i(ip, i);
- // LP32: call i32 @llvm.nvvm.atomic.or.gen.i.cta.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.or.gen.i.cta.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.or.gen.i.cta.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.or.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_or_gen_l' needs target feature sm_60}}
__nvvm_atom_cta_or_gen_l(&dl, l);
- // CHECK: call i64 @llvm.nvvm.atomic.or.gen.i.cta.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.or.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_or_gen_ll' needs target feature sm_60}}
__nvvm_atom_cta_or_gen_ll(&sll, ll);
- // CHECK: call i32 @llvm.nvvm.atomic.or.gen.i.sys.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.or.gen.i.sys.i32.p0
// expected-error at +1 {{'__nvvm_atom_sys_or_gen_i' needs target feature sm_60}}
__nvvm_atom_sys_or_gen_i(ip, i);
- // LP32: call i32 @llvm.nvvm.atomic.or.gen.i.sys.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.or.gen.i.sys.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.or.gen.i.sys.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.or.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_or_gen_l' needs target feature sm_60}}
__nvvm_atom_sys_or_gen_l(&dl, l);
- // CHECK: call i64 @llvm.nvvm.atomic.or.gen.i.sys.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.or.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_or_gen_ll' needs target feature sm_60}}
__nvvm_atom_sys_or_gen_ll(&sll, ll);
- // CHECK: call i32 @llvm.nvvm.atomic.xor.gen.i.cta.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.xor.gen.i.cta.i32.p0
// expected-error at +1 {{'__nvvm_atom_cta_xor_gen_i' needs target feature sm_60}}
__nvvm_atom_cta_xor_gen_i(ip, i);
- // LP32: call i32 @llvm.nvvm.atomic.xor.gen.i.cta.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.xor.gen.i.cta.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.xor.gen.i.cta.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.xor.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_xor_gen_l' needs target feature sm_60}}
__nvvm_atom_cta_xor_gen_l(&dl, l);
- // CHECK: call i64 @llvm.nvvm.atomic.xor.gen.i.cta.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.xor.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_xor_gen_ll' needs target feature sm_60}}
__nvvm_atom_cta_xor_gen_ll(&sll, ll);
- // CHECK: call i32 @llvm.nvvm.atomic.xor.gen.i.sys.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.xor.gen.i.sys.i32.p0
// expected-error at +1 {{'__nvvm_atom_sys_xor_gen_i' needs target feature sm_60}}
__nvvm_atom_sys_xor_gen_i(ip, i);
- // LP32: call i32 @llvm.nvvm.atomic.xor.gen.i.sys.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.xor.gen.i.sys.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.xor.gen.i.sys.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.xor.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_xor_gen_l' needs target feature sm_60}}
__nvvm_atom_sys_xor_gen_l(&dl, l);
- // CHECK: call i64 @llvm.nvvm.atomic.xor.gen.i.sys.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.xor.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_xor_gen_ll' needs target feature sm_60}}
__nvvm_atom_sys_xor_gen_ll(&sll, ll);
- // CHECK: call i32 @llvm.nvvm.atomic.cas.gen.i.cta.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.cas.gen.i.cta.i32.p0
// expected-error at +1 {{'__nvvm_atom_cta_cas_gen_i' needs target feature sm_60}}
__nvvm_atom_cta_cas_gen_i(ip, i, 0);
- // LP32: call i32 @llvm.nvvm.atomic.cas.gen.i.cta.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.cas.gen.i.cta.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.cas.gen.i.cta.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.cas.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_cas_gen_l' needs target feature sm_60}}
__nvvm_atom_cta_cas_gen_l(&dl, l, 0);
- // CHECK: call i64 @llvm.nvvm.atomic.cas.gen.i.cta.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.cas.gen.i.cta.i64.p0
// expected-error at +1 {{'__nvvm_atom_cta_cas_gen_ll' needs target feature sm_60}}
__nvvm_atom_cta_cas_gen_ll(&sll, ll, 0);
- // CHECK: call i32 @llvm.nvvm.atomic.cas.gen.i.sys.i32.p0i32
+ // CHECK: call i32 @llvm.nvvm.atomic.cas.gen.i.sys.i32.p0
// expected-error at +1 {{'__nvvm_atom_sys_cas_gen_i' needs target feature sm_60}}
__nvvm_atom_sys_cas_gen_i(ip, i, 0);
- // LP32: call i32 @llvm.nvvm.atomic.cas.gen.i.sys.i32.p0i32
- // LP64: call i64 @llvm.nvvm.atomic.cas.gen.i.sys.i64.p0i64
+ // LP32: call i32 @llvm.nvvm.atomic.cas.gen.i.sys.i32.p0
+ // LP64: call i64 @llvm.nvvm.atomic.cas.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_cas_gen_l' needs target feature sm_60}}
__nvvm_atom_sys_cas_gen_l(&dl, l, 0);
- // CHECK: call i64 @llvm.nvvm.atomic.cas.gen.i.sys.i64.p0i64
+ // CHECK: call i64 @llvm.nvvm.atomic.cas.gen.i.sys.i64.p0
// expected-error at +1 {{'__nvvm_atom_sys_cas_gen_ll' needs target feature sm_60}}
__nvvm_atom_sys_cas_gen_ll(&sll, ll, 0);
#endif
@@ -554,31 +554,31 @@ __device__ void nvvm_atom(float *fp, float f, double *dfp, double df, int *ip,
// 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)
+ // CHECK: call i8 @llvm.nvvm.ldg.global.i.i8.p0(ptr {{%[0-9]+}}, i32 1)
+ // CHECK: call i8 @llvm.nvvm.ldg.global.i.i8.p0(ptr {{%[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)
+ // CHECK: call i16 @llvm.nvvm.ldg.global.i.i16.p0(ptr {{%[0-9]+}}, i32 2)
+ // CHECK: call i16 @llvm.nvvm.ldg.global.i.i16.p0(ptr {{%[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)
+ // CHECK: call i32 @llvm.nvvm.ldg.global.i.i32.p0(ptr {{%[0-9]+}}, i32 4)
+ // CHECK: call i32 @llvm.nvvm.ldg.global.i.i32.p0(ptr {{%[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)
+ // LP32: call i32 @llvm.nvvm.ldg.global.i.i32.p0(ptr {{%[0-9]+}}, i32 4)
+ // LP32: call i32 @llvm.nvvm.ldg.global.i.i32.p0(ptr {{%[0-9]+}}, i32 4)
+ // LP64: call i64 @llvm.nvvm.ldg.global.i.i64.p0(ptr {{%[0-9]+}}, i32 8)
+ // LP64: call i64 @llvm.nvvm.ldg.global.i.i64.p0(ptr {{%[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)
+ // CHECK: call float @llvm.nvvm.ldg.global.f.f32.p0(ptr {{%[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)
+ // CHECK: call double @llvm.nvvm.ldg.global.f.f64.p0(ptr {{%[0-9]+}}, i32 8)
__nvvm_ldg_d((const double *)p);
// In practice, the pointers we pass to __ldg will be aligned as appropriate
@@ -590,64 +590,64 @@ __device__ void nvvm_ldg(const void *p) {
// 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)
+ // CHECK: call <2 x i8> @llvm.nvvm.ldg.global.i.v2i8.p0(ptr {{%[0-9]+}}, i32 2)
+ // CHECK: call <2 x i8> @llvm.nvvm.ldg.global.i.v2i8.p0(ptr {{%[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)
+ // CHECK: call <4 x i8> @llvm.nvvm.ldg.global.i.v4i8.p0(ptr {{%[0-9]+}}, i32 4)
+ // CHECK: call <4 x i8> @llvm.nvvm.ldg.global.i.v4i8.p0(ptr {{%[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)
+ // CHECK: call <2 x i16> @llvm.nvvm.ldg.global.i.v2i16.p0(ptr {{%[0-9]+}}, i32 4)
+ // CHECK: call <2 x i16> @llvm.nvvm.ldg.global.i.v2i16.p0(ptr {{%[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)
+ // CHECK: call <4 x i16> @llvm.nvvm.ldg.global.i.v4i16.p0(ptr {{%[0-9]+}}, i32 8)
+ // CHECK: call <4 x i16> @llvm.nvvm.ldg.global.i.v4i16.p0(ptr {{%[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)
+ // CHECK: call <2 x i32> @llvm.nvvm.ldg.global.i.v2i32.p0(ptr {{%[0-9]+}}, i32 8)
+ // CHECK: call <2 x i32> @llvm.nvvm.ldg.global.i.v2i32.p0(ptr {{%[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)
+ // CHECK: call <4 x i32> @llvm.nvvm.ldg.global.i.v4i32.p0(ptr {{%[0-9]+}}, i32 16)
+ // CHECK: call <4 x i32> @llvm.nvvm.ldg.global.i.v4i32.p0(ptr {{%[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)
+ // CHECK: call <2 x i64> @llvm.nvvm.ldg.global.i.v2i64.p0(ptr {{%[0-9]+}}, i32 16)
+ // CHECK: call <2 x i64> @llvm.nvvm.ldg.global.i.v2i64.p0(ptr {{%[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)
+ // CHECK: call <2 x float> @llvm.nvvm.ldg.global.f.v2f32.p0(ptr {{%[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)
+ // CHECK: call <4 x float> @llvm.nvvm.ldg.global.f.v4f32.p0(ptr {{%[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)
+ // CHECK: call <2 x double> @llvm.nvvm.ldg.global.f.v2f64.p0(ptr {{%[0-9]+}}, i32 16)
typedef double double2 __attribute__((ext_vector_type(2)));
__nvvm_ldg_d2((const double2 *)p);
}
diff --git a/clang/test/CodeGen/c11atomics.c b/clang/test/CodeGen/c11atomics.c
index 110a926e3648..773ed41991f7 100644
--- a/clang/test/CodeGen/c11atomics.c
+++ b/clang/test/CodeGen/c11atomics.c
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -no-opaque-pointers %s -emit-llvm -o - -triple=armv5-unknown-freebsd -std=c11 | FileCheck %s
+// RUN: %clang_cc1 %s -emit-llvm -o - -triple=armv5-unknown-freebsd -std=c11 | FileCheck %s
// Test that we are generating atomicrmw instructions, rather than
// compare-exchange loops for common atomic ops. This makes a big
diff erence
@@ -17,12 +17,11 @@ struct elem;
struct ptr {
struct elem *ptr;
};
-// CHECK-DAG: %struct.ptr = type { %struct.elem* }
+// CHECK-DAG: %struct.ptr = type { ptr }
struct elem {
_Atomic(struct ptr) link;
};
-// CHECK-DAG: %struct.elem = type { %struct.ptr }
struct ptr object;
// CHECK-DAG: @object ={{.*}} global %struct.ptr zeroinitializer
@@ -45,61 +44,61 @@ _Atomic(vector) v;
void testinc(void)
{
// Special case for suffix bool++, sets to true and returns the old value.
- // CHECK: atomicrmw xchg i8* @b, i8 1 seq_cst, align 1
+ // CHECK: atomicrmw xchg ptr @b, i8 1 seq_cst, align 1
b++;
- // CHECK: atomicrmw add i32* @i, i32 1 seq_cst, align 4
+ // CHECK: atomicrmw add ptr @i, i32 1 seq_cst, align 4
i++;
- // CHECK: atomicrmw add i64* @l, i64 1 seq_cst, align 8
+ // CHECK: atomicrmw add ptr @l, i64 1 seq_cst, align 8
l++;
- // CHECK: atomicrmw add i16* @s, i16 1 seq_cst, align 2
+ // CHECK: atomicrmw add ptr @s, i16 1 seq_cst, align 2
s++;
// Prefix increment
// Special case for bool: set to true and return true
- // CHECK: store atomic i8 1, i8* @b seq_cst, align 1
+ // CHECK: store atomic i8 1, ptr @b seq_cst, align 1
++b;
// Currently, we have no variant of atomicrmw that returns the new value, so
// we have to generate an atomic add, which returns the old value, and then a
// non-atomic add.
- // CHECK: atomicrmw add i32* @i, i32 1 seq_cst, align 4
+ // CHECK: atomicrmw add ptr @i, i32 1 seq_cst, align 4
// CHECK: add i32
++i;
- // CHECK: atomicrmw add i64* @l, i64 1 seq_cst, align 8
+ // CHECK: atomicrmw add ptr @l, i64 1 seq_cst, align 8
// CHECK: add i64
++l;
- // CHECK: atomicrmw add i16* @s, i16 1 seq_cst, align 2
+ // CHECK: atomicrmw add ptr @s, i16 1 seq_cst, align 2
// CHECK: add i16
++s;
}
// CHECK: testdec
void testdec(void)
{
- // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 noundef 1, i8* noundef @b
+ // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 noundef 1, ptr noundef @b
b--;
- // CHECK: atomicrmw sub i32* @i, i32 1 seq_cst, align 4
+ // CHECK: atomicrmw sub ptr @i, i32 1 seq_cst, align 4
i--;
- // CHECK: atomicrmw sub i64* @l, i64 1 seq_cst, align 8
+ // CHECK: atomicrmw sub ptr @l, i64 1 seq_cst, align 8
l--;
- // CHECK: atomicrmw sub i16* @s, i16 1 seq_cst, align 2
+ // CHECK: atomicrmw sub ptr @s, i16 1 seq_cst, align 2
s--;
- // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 noundef 1, i8* noundef @b
+ // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 noundef 1, ptr noundef @b
--b;
- // CHECK: atomicrmw sub i32* @i, i32 1 seq_cst, align 4
+ // CHECK: atomicrmw sub ptr @i, i32 1 seq_cst, align 4
// CHECK: sub i32
--i;
- // CHECK: atomicrmw sub i64* @l, i64 1 seq_cst, align 8
+ // CHECK: atomicrmw sub ptr @l, i64 1 seq_cst, align 8
// CHECK: sub i64
--l;
- // CHECK: atomicrmw sub i16* @s, i16 1 seq_cst, align 2
+ // CHECK: atomicrmw sub ptr @s, i16 1 seq_cst, align 2
// CHECK: sub i16
--s;
}
// CHECK: testaddeq
void testaddeq(void)
{
- // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 noundef 1, i8* noundef @b
- // CHECK: atomicrmw add i32* @i, i32 42 seq_cst, align 4
- // CHECK: atomicrmw add i64* @l, i64 42 seq_cst, align 8
- // CHECK: atomicrmw add i16* @s, i16 42 seq_cst, align 2
+ // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 noundef 1, ptr noundef @b
+ // CHECK: atomicrmw add ptr @i, i32 42 seq_cst, align 4
+ // CHECK: atomicrmw add ptr @l, i64 42 seq_cst, align 8
+ // CHECK: atomicrmw add ptr @s, i16 42 seq_cst, align 2
b += 42;
i += 42;
l += 42;
@@ -108,10 +107,10 @@ void testaddeq(void)
// CHECK: testsubeq
void testsubeq(void)
{
- // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 noundef 1, i8* noundef @b
- // CHECK: atomicrmw sub i32* @i, i32 42 seq_cst, align 4
- // CHECK: atomicrmw sub i64* @l, i64 42 seq_cst, align 8
- // CHECK: atomicrmw sub i16* @s, i16 42 seq_cst, align 2
+ // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 noundef 1, ptr noundef @b
+ // CHECK: atomicrmw sub ptr @i, i32 42 seq_cst, align 4
+ // CHECK: atomicrmw sub ptr @l, i64 42 seq_cst, align 8
+ // CHECK: atomicrmw sub ptr @s, i16 42 seq_cst, align 2
b -= 42;
i -= 42;
l -= 42;
@@ -120,10 +119,10 @@ void testsubeq(void)
// CHECK: testxoreq
void testxoreq(void)
{
- // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 noundef 1, i8* noundef @b
- // CHECK: atomicrmw xor i32* @i, i32 42 seq_cst, align 4
- // CHECK: atomicrmw xor i64* @l, i64 42 seq_cst, align 8
- // CHECK: atomicrmw xor i16* @s, i16 42 seq_cst, align 2
+ // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 noundef 1, ptr noundef @b
+ // CHECK: atomicrmw xor ptr @i, i32 42 seq_cst, align 4
+ // CHECK: atomicrmw xor ptr @l, i64 42 seq_cst, align 8
+ // CHECK: atomicrmw xor ptr @s, i16 42 seq_cst, align 2
b ^= 42;
i ^= 42;
l ^= 42;
@@ -132,10 +131,10 @@ void testxoreq(void)
// CHECK: testoreq
void testoreq(void)
{
- // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 noundef 1, i8* noundef @b
- // CHECK: atomicrmw or i32* @i, i32 42 seq_cst, align 4
- // CHECK: atomicrmw or i64* @l, i64 42 seq_cst, align 8
- // CHECK: atomicrmw or i16* @s, i16 42 seq_cst, align 2
+ // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 noundef 1, ptr noundef @b
+ // CHECK: atomicrmw or ptr @i, i32 42 seq_cst, align 4
+ // CHECK: atomicrmw or ptr @l, i64 42 seq_cst, align 8
+ // CHECK: atomicrmw or ptr @s, i16 42 seq_cst, align 2
b |= 42;
i |= 42;
l |= 42;
@@ -144,99 +143,91 @@ void testoreq(void)
// CHECK: testandeq
void testandeq(void)
{
- // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 noundef 1, i8* noundef @b
- // CHECK: atomicrmw and i32* @i, i32 42 seq_cst, align 4
- // CHECK: atomicrmw and i64* @l, i64 42 seq_cst, align 8
- // CHECK: atomicrmw and i16* @s, i16 42 seq_cst, align 2
+ // CHECK: call arm_aapcscc zeroext i1 @__atomic_compare_exchange(i32 noundef 1, ptr noundef @b
+ // CHECK: atomicrmw and ptr @i, i32 42 seq_cst, align 4
+ // CHECK: atomicrmw and ptr @l, i64 42 seq_cst, align 8
+ // CHECK: atomicrmw and ptr @s, i16 42 seq_cst, align 2
b &= 42;
i &= 42;
l &= 42;
s &= 42;
}
-// CHECK-LABEL: define{{.*}} arm_aapcscc void @testFloat(float*
+// CHECK-LABEL: define{{.*}} arm_aapcscc void @testFloat(ptr
void testFloat(_Atomic(float) *fp) {
-// CHECK: [[FP:%.*]] = alloca float*
+// CHECK: [[FP:%.*]] = alloca ptr
// CHECK-NEXT: [[X:%.*]] = alloca float
// CHECK-NEXT: [[F:%.*]] = alloca float
// CHECK-NEXT: [[TMP0:%.*]] = alloca float
// CHECK-NEXT: [[TMP1:%.*]] = alloca float
-// CHECK-NEXT: store float* {{%.*}}, float** [[FP]]
+// CHECK-NEXT: store ptr {{%.*}}, ptr [[FP]]
-// CHECK-NEXT: [[T0:%.*]] = load float*, float** [[FP]]
-// CHECK-NEXT: store float 1.000000e+00, float* [[T0]], align 4
+// CHECK-NEXT: [[T0:%.*]] = load ptr, ptr [[FP]]
+// CHECK-NEXT: store float 1.000000e+00, ptr [[T0]], align 4
__c11_atomic_init(fp, 1.0f);
-// CHECK-NEXT: store float 2.000000e+00, float* [[X]], align 4
+// CHECK-NEXT: store float 2.000000e+00, ptr [[X]], align 4
_Atomic(float) x = 2.0f;
-// CHECK-NEXT: [[T0:%.*]] = load float*, float** [[FP]]
-// CHECK-NEXT: [[T1:%.*]] = bitcast float* [[T0]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = bitcast float* [[TMP0]] to i8*
-// CHECK-NEXT: call arm_aapcscc void @__atomic_load(i32 noundef 4, i8* noundef [[T1]], i8* noundef [[T2]], i32 noundef 5)
-// CHECK-NEXT: [[T3:%.*]] = load float, float* [[TMP0]], align 4
-// CHECK-NEXT: store float [[T3]], float* [[F]]
+// CHECK-NEXT: [[T0:%.*]] = load ptr, ptr [[FP]]
+// CHECK-NEXT: call arm_aapcscc void @__atomic_load(i32 noundef 4, ptr noundef [[T0]], ptr noundef [[TMP0]], i32 noundef 5)
+// CHECK-NEXT: [[T3:%.*]] = load float, ptr [[TMP0]], align 4
+// CHECK-NEXT: store float [[T3]], ptr [[F]]
float f = *fp;
-// CHECK-NEXT: [[T0:%.*]] = load float, float* [[F]], align 4
-// CHECK-NEXT: [[T1:%.*]] = load float*, float** [[FP]], align 4
-// CHECK-NEXT: store float [[T0]], float* [[TMP1]], align 4
-// CHECK-NEXT: [[T2:%.*]] = bitcast float* [[T1]] to i8*
-// CHECK-NEXT: [[T3:%.*]] = bitcast float* [[TMP1]] to i8*
-// CHECK-NEXT: call arm_aapcscc void @__atomic_store(i32 noundef 4, i8* noundef [[T2]], i8* noundef [[T3]], i32 noundef 5)
+// CHECK-NEXT: [[T0:%.*]] = load float, ptr [[F]], align 4
+// CHECK-NEXT: [[T1:%.*]] = load ptr, ptr [[FP]], align 4
+// CHECK-NEXT: store float [[T0]], ptr [[TMP1]], align 4
+// CHECK-NEXT: call arm_aapcscc void @__atomic_store(i32 noundef 4, ptr noundef [[T1]], ptr noundef [[TMP1]], i32 noundef 5)
*fp = f;
// CHECK-NEXT: ret void
}
-// CHECK: define{{.*}} arm_aapcscc void @testComplexFloat([[CF:{ float, float }]]*
+// CHECK: define{{.*}} arm_aapcscc void @testComplexFloat(ptr
void testComplexFloat(_Atomic(_Complex float) *fp) {
-// CHECK: [[FP:%.*]] = alloca [[CF]]*, align 4
-// CHECK-NEXT: [[X:%.*]] = alloca [[CF]], align 8
+// CHECK: [[FP:%.*]] = alloca ptr, align 4
+// CHECK-NEXT: [[X:%.*]] = alloca [[CF:{ float, float }]], align 8
// CHECK-NEXT: [[F:%.*]] = alloca [[CF]], align 4
// CHECK-NEXT: [[TMP0:%.*]] = alloca [[CF]], align 8
// CHECK-NEXT: [[TMP1:%.*]] = alloca [[CF]], align 8
-// CHECK-NEXT: store [[CF]]*
+// CHECK-NEXT: store ptr
-// CHECK-NEXT: [[P:%.*]] = load [[CF]]*, [[CF]]** [[FP]]
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[CF]], [[CF]]* [[P]], i32 0, i32 0
-// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[CF]], [[CF]]* [[P]], i32 0, i32 1
-// CHECK-NEXT: store float 1.000000e+00, float* [[T0]]
-// CHECK-NEXT: store float 0.000000e+00, float* [[T1]]
+// CHECK-NEXT: [[P:%.*]] = load ptr, ptr [[FP]]
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[CF]], ptr [[P]], i32 0, i32 0
+// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[CF]], ptr [[P]], i32 0, i32 1
+// CHECK-NEXT: store float 1.000000e+00, ptr [[T0]]
+// CHECK-NEXT: store float 0.000000e+00, ptr [[T1]]
__c11_atomic_init(fp, 1.0f);
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[CF]], [[CF]]* [[X]], i32 0, i32 0
-// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[CF]], [[CF]]* [[X]], i32 0, i32 1
-// CHECK-NEXT: store float 2.000000e+00, float* [[T0]]
-// CHECK-NEXT: store float 0.000000e+00, float* [[T1]]
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[CF]], ptr [[X]], i32 0, i32 0
+// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[CF]], ptr [[X]], i32 0, i32 1
+// CHECK-NEXT: store float 2.000000e+00, ptr [[T0]]
+// CHECK-NEXT: store float 0.000000e+00, ptr [[T1]]
_Atomic(_Complex float) x = 2.0f;
-// CHECK-NEXT: [[T0:%.*]] = load [[CF]]*, [[CF]]** [[FP]]
-// CHECK-NEXT: [[T1:%.*]] = bitcast [[CF]]* [[T0]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = bitcast [[CF]]* [[TMP0]] to i8*
-// CHECK-NEXT: call arm_aapcscc void @__atomic_load(i32 noundef 8, i8* noundef [[T1]], i8* noundef [[T2]], i32 noundef 5)
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[CF]], [[CF]]* [[TMP0]], i32 0, i32 0
-// CHECK-NEXT: [[R:%.*]] = load float, float* [[T0]]
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[CF]], [[CF]]* [[TMP0]], i32 0, i32 1
-// CHECK-NEXT: [[I:%.*]] = load float, float* [[T0]]
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[CF]], [[CF]]* [[F]], i32 0, i32 0
-// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[CF]], [[CF]]* [[F]], i32 0, i32 1
-// CHECK-NEXT: store float [[R]], float* [[T0]]
-// CHECK-NEXT: store float [[I]], float* [[T1]]
+// CHECK-NEXT: [[T0:%.*]] = load ptr, ptr [[FP]]
+// CHECK-NEXT: call arm_aapcscc void @__atomic_load(i32 noundef 8, ptr noundef [[T0]], ptr noundef [[TMP0]], i32 noundef 5)
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[CF]], ptr [[TMP0]], i32 0, i32 0
+// CHECK-NEXT: [[R:%.*]] = load float, ptr [[T0]]
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[CF]], ptr [[TMP0]], i32 0, i32 1
+// CHECK-NEXT: [[I:%.*]] = load float, ptr [[T0]]
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[CF]], ptr [[F]], i32 0, i32 0
+// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[CF]], ptr [[F]], i32 0, i32 1
+// CHECK-NEXT: store float [[R]], ptr [[T0]]
+// CHECK-NEXT: store float [[I]], ptr [[T1]]
_Complex float f = *fp;
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[CF]], [[CF]]* [[F]], i32 0, i32 0
-// CHECK-NEXT: [[R:%.*]] = load float, float* [[T0]]
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[CF]], [[CF]]* [[F]], i32 0, i32 1
-// CHECK-NEXT: [[I:%.*]] = load float, float* [[T0]]
-// CHECK-NEXT: [[DEST:%.*]] = load [[CF]]*, [[CF]]** [[FP]], align 4
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[CF]], [[CF]]* [[TMP1]], i32 0, i32 0
-// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[CF]], [[CF]]* [[TMP1]], i32 0, i32 1
-// CHECK-NEXT: store float [[R]], float* [[T0]]
-// CHECK-NEXT: store float [[I]], float* [[T1]]
-// CHECK-NEXT: [[T0:%.*]] = bitcast [[CF]]* [[DEST]] to i8*
-// CHECK-NEXT: [[T1:%.*]] = bitcast [[CF]]* [[TMP1]] to i8*
-// CHECK-NEXT: call arm_aapcscc void @__atomic_store(i32 noundef 8, i8* noundef [[T0]], i8* noundef [[T1]], i32 noundef 5)
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[CF]], ptr [[F]], i32 0, i32 0
+// CHECK-NEXT: [[R:%.*]] = load float, ptr [[T0]]
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[CF]], ptr [[F]], i32 0, i32 1
+// CHECK-NEXT: [[I:%.*]] = load float, ptr [[T0]]
+// CHECK-NEXT: [[DEST:%.*]] = load ptr, ptr [[FP]], align 4
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[CF]], ptr [[TMP1]], i32 0, i32 0
+// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[CF]], ptr [[TMP1]], i32 0, i32 1
+// CHECK-NEXT: store float [[R]], ptr [[T0]]
+// CHECK-NEXT: store float [[I]], ptr [[T1]]
+// CHECK-NEXT: call arm_aapcscc void @__atomic_store(i32 noundef 8, ptr noundef [[DEST]], ptr noundef [[TMP1]], i32 noundef 5)
*fp = f;
// CHECK-NEXT: ret void
@@ -244,48 +235,42 @@ void testComplexFloat(_Atomic(_Complex float) *fp) {
typedef struct { short x, y, z, w; } S;
_Atomic S testStructGlobal = (S){1, 2, 3, 4};
-// CHECK: define{{.*}} arm_aapcscc void @testStruct([[S:.*]]*
+// CHECK: define{{.*}} arm_aapcscc void @testStruct(ptr
void testStruct(_Atomic(S) *fp) {
-// CHECK: [[FP:%.*]] = alloca [[S]]*, align 4
-// CHECK-NEXT: [[X:%.*]] = alloca [[S]], align 8
+// CHECK: [[FP:%.*]] = alloca ptr, align 4
+// CHECK-NEXT: [[X:%.*]] = alloca [[S:.*]], align 8
// CHECK-NEXT: [[F:%.*]] = alloca [[S:%.*]], align 2
// CHECK-NEXT: [[TMP0:%.*]] = alloca [[S]], align 8
-// CHECK-NEXT: store [[S]]*
-
-// CHECK-NEXT: [[P:%.*]] = load [[S]]*, [[S]]** [[FP]]
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[S]], [[S]]* [[P]], i32 0, i32 0
-// CHECK-NEXT: store i16 1, i16* [[T0]], align 8
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[S]], [[S]]* [[P]], i32 0, i32 1
-// CHECK-NEXT: store i16 2, i16* [[T0]], align 2
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[S]], [[S]]* [[P]], i32 0, i32 2
-// CHECK-NEXT: store i16 3, i16* [[T0]], align 4
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[S]], [[S]]* [[P]], i32 0, i32 3
-// CHECK-NEXT: store i16 4, i16* [[T0]], align 2
+// CHECK-NEXT: store ptr
+
+// CHECK-NEXT: [[P:%.*]] = load ptr, ptr [[FP]]
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[S]], ptr [[P]], i32 0, i32 0
+// CHECK-NEXT: store i16 1, ptr [[T0]], align 8
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[S]], ptr [[P]], i32 0, i32 1
+// CHECK-NEXT: store i16 2, ptr [[T0]], align 2
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[S]], ptr [[P]], i32 0, i32 2
+// CHECK-NEXT: store i16 3, ptr [[T0]], align 4
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[S]], ptr [[P]], i32 0, i32 3
+// CHECK-NEXT: store i16 4, ptr [[T0]], align 2
__c11_atomic_init(fp, (S){1,2,3,4});
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[S]], [[S]]* [[X]], i32 0, i32 0
-// CHECK-NEXT: store i16 1, i16* [[T0]], align 8
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[S]], [[S]]* [[X]], i32 0, i32 1
-// CHECK-NEXT: store i16 2, i16* [[T0]], align 2
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[S]], [[S]]* [[X]], i32 0, i32 2
-// CHECK-NEXT: store i16 3, i16* [[T0]], align 4
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[S]], [[S]]* [[X]], i32 0, i32 3
-// CHECK-NEXT: store i16 4, i16* [[T0]], align 2
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[S]], ptr [[X]], i32 0, i32 0
+// CHECK-NEXT: store i16 1, ptr [[T0]], align 8
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[S]], ptr [[X]], i32 0, i32 1
+// CHECK-NEXT: store i16 2, ptr [[T0]], align 2
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[S]], ptr [[X]], i32 0, i32 2
+// CHECK-NEXT: store i16 3, ptr [[T0]], align 4
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[S]], ptr [[X]], i32 0, i32 3
+// CHECK-NEXT: store i16 4, ptr [[T0]], align 2
_Atomic(S) x = (S){1,2,3,4};
-// CHECK-NEXT: [[T0:%.*]] = load [[S]]*, [[S]]** [[FP]]
-// CHECK-NEXT: [[T1:%.*]] = bitcast [[S]]* [[T0]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = bitcast [[S]]* [[F]] to i8*
-// CHECK-NEXT: call arm_aapcscc void @__atomic_load(i32 noundef 8, i8* noundef [[T1]], i8* noundef [[T2]], i32 noundef 5)
+// CHECK-NEXT: [[T0:%.*]] = load ptr, ptr [[FP]]
+// CHECK-NEXT: call arm_aapcscc void @__atomic_load(i32 noundef 8, ptr noundef [[T0]], ptr noundef [[F]], i32 noundef 5)
S f = *fp;
-// CHECK-NEXT: [[T0:%.*]] = load [[S]]*, [[S]]** [[FP]]
-// CHECK-NEXT: [[T1:%.*]] = bitcast [[S]]* [[TMP0]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = bitcast [[S]]* [[F]] to i8*
-// CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 [[T1]], i8* align 2 [[T2]], i32 8, i1 false)
-// CHECK-NEXT: [[T3:%.*]] = bitcast [[S]]* [[T0]] to i8*
-// CHECK-NEXT: [[T4:%.*]] = bitcast [[S]]* [[TMP0]] to i8*
-// CHECK-NEXT: call arm_aapcscc void @__atomic_store(i32 noundef 8, i8* noundef [[T3]], i8* noundef [[T4]], i32 noundef 5)
+// CHECK-NEXT: [[T0:%.*]] = load ptr, ptr [[FP]]
+// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 8 [[TMP0]], ptr align 2 [[F]], i32 8, i1 false)
+// CHECK-NEXT: call arm_aapcscc void @__atomic_store(i32 noundef 8, ptr noundef [[T0]], ptr noundef [[TMP0]], i32 noundef 5)
*fp = f;
// CHECK-NEXT: ret void
@@ -293,184 +278,134 @@ void testStruct(_Atomic(S) *fp) {
typedef struct { short x, y, z; } PS;
_Atomic PS testPromotedStructGlobal = (PS){1, 2, 3};
-// CHECK: define{{.*}} arm_aapcscc void @testPromotedStruct([[APS:.*]]*
+// CHECK: define{{.*}} arm_aapcscc void @testPromotedStruct(ptr
void testPromotedStruct(_Atomic(PS) *fp) {
-// CHECK: [[FP:%.*]] = alloca [[APS]]*, align 4
-// CHECK-NEXT: [[X:%.*]] = alloca [[APS]], align 8
+// CHECK: [[FP:%.*]] = alloca ptr, align 4
+// CHECK-NEXT: [[X:%.*]] = alloca [[APS:.*]], align 8
// CHECK-NEXT: [[F:%.*]] = alloca [[PS:%.*]], align 2
// CHECK-NEXT: [[TMP0:%.*]] = alloca [[APS]], align 8
// CHECK-NEXT: [[TMP1:%.*]] = alloca [[APS]], align 8
// CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
// CHECK-NEXT: [[TMP2:%.*]] = alloca %struct.PS, align 2
// CHECK-NEXT: [[TMP3:%.*]] = alloca [[APS]], align 8
-// CHECK-NEXT: store [[APS]]*
-
-// CHECK-NEXT: [[P:%.*]] = load [[APS]]*, [[APS]]** [[FP]]
-// CHECK-NEXT: [[T0:%.*]] = bitcast [[APS]]* [[P]] to i8*
-// CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 8 [[T0]], i8 0, i64 8, i1 false)
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[APS]], [[APS]]* [[P]], i32 0, i32 0
-// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[PS]], [[PS]]* [[T0]], i32 0, i32 0
-// CHECK-NEXT: store i16 1, i16* [[T1]], align 8
-// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[PS]], [[PS]]* [[T0]], i32 0, i32 1
-// CHECK-NEXT: store i16 2, i16* [[T1]], align 2
-// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[PS]], [[PS]]* [[T0]], i32 0, i32 2
-// CHECK-NEXT: store i16 3, i16* [[T1]], align 4
+// CHECK-NEXT: store ptr
+
+// CHECK-NEXT: [[P:%.*]] = load ptr, ptr [[FP]]
+// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 8 [[P]], i8 0, i64 8, i1 false)
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[APS]], ptr [[P]], i32 0, i32 0
+// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[PS]], ptr [[T0]], i32 0, i32 0
+// CHECK-NEXT: store i16 1, ptr [[T1]], align 8
+// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[PS]], ptr [[T0]], i32 0, i32 1
+// CHECK-NEXT: store i16 2, ptr [[T1]], align 2
+// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[PS]], ptr [[T0]], i32 0, i32 2
+// CHECK-NEXT: store i16 3, ptr [[T1]], align 4
__c11_atomic_init(fp, (PS){1,2,3});
-// CHECK-NEXT: [[T0:%.*]] = bitcast [[APS]]* [[X]] to i8*
-// CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* align 8 [[T0]], i8 0, i32 8, i1 false)
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[APS]], [[APS]]* [[X]], i32 0, i32 0
-// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[PS]], [[PS]]* [[T0]], i32 0, i32 0
-// CHECK-NEXT: store i16 1, i16* [[T1]], align 8
-// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[PS]], [[PS]]* [[T0]], i32 0, i32 1
-// CHECK-NEXT: store i16 2, i16* [[T1]], align 2
-// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[PS]], [[PS]]* [[T0]], i32 0, i32 2
-// CHECK-NEXT: store i16 3, i16* [[T1]], align 4
+// CHECK-NEXT: call void @llvm.memset.p0.i32(ptr align 8 [[X]], i8 0, i32 8, i1 false)
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[APS]], ptr [[X]], i32 0, i32 0
+// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[PS]], ptr [[T0]], i32 0, i32 0
+// CHECK-NEXT: store i16 1, ptr [[T1]], align 8
+// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[PS]], ptr [[T0]], i32 0, i32 1
+// CHECK-NEXT: store i16 2, ptr [[T1]], align 2
+// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[PS]], ptr [[T0]], i32 0, i32 2
+// CHECK-NEXT: store i16 3, ptr [[T1]], align 4
_Atomic(PS) x = (PS){1,2,3};
-// CHECK-NEXT: [[T0:%.*]] = load [[APS]]*, [[APS]]** [[FP]]
-// CHECK-NEXT: [[T1:%.*]] = bitcast [[APS]]* [[T0]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = bitcast [[APS]]* [[TMP0]] to i8*
-// CHECK-NEXT: call arm_aapcscc void @__atomic_load(i32 noundef 8, i8* noundef [[T1]], i8* noundef [[T2]], i32 noundef 5)
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[APS]], [[APS]]* [[TMP0]], i32 0, i32 0
-// CHECK-NEXT: [[T1:%.*]] = bitcast [[PS]]* [[F]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = bitcast [[PS]]* [[T0]] to i8*
-// CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 2 [[T1]], i8* align 8 [[T2]], i32 6, i1 false)
+// CHECK-NEXT: [[T0:%.*]] = load ptr, ptr [[FP]]
+// CHECK-NEXT: call arm_aapcscc void @__atomic_load(i32 noundef 8, ptr noundef [[T0]], ptr noundef [[TMP0]], i32 noundef 5)
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[APS]], ptr [[TMP0]], i32 0, i32 0
+// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 2 [[F]], ptr align 8 [[T0]], i32 6, i1 false)
PS f = *fp;
-// CHECK-NEXT: [[T0:%.*]] = load [[APS]]*, [[APS]]** [[FP]]
-// CHECK-NEXT: [[T1:%.*]] = bitcast { %struct.PS, [2 x i8] }* [[TMP1]] to i8*
-// CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* align 8 [[T1]], i8 0, i32 8, i1 false)
-// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[APS]], [[APS]]* [[TMP1]], i32 0, i32 0
-// CHECK-NEXT: [[T2:%.*]] = bitcast [[PS]]* [[T1]] to i8*
-// CHECK-NEXT: [[T3:%.*]] = bitcast [[PS]]* [[F]] to i8*
-// CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 [[T2]], i8* align 2 [[T3]], i32 6, i1 false)
-// CHECK-NEXT: [[T4:%.*]] = bitcast [[APS]]* [[T0]] to i8*
-// CHECK-NEXT: [[T5:%.*]] = bitcast [[APS]]* [[TMP1]] to i8*
-// CHECK-NEXT: call arm_aapcscc void @__atomic_store(i32 noundef 8, i8* noundef [[T4]], i8* noundef [[T5]], i32 noundef 5)
+// CHECK-NEXT: [[T0:%.*]] = load ptr, ptr [[FP]]
+// CHECK-NEXT: call void @llvm.memset.p0.i32(ptr align 8 [[TMP1]], i8 0, i32 8, i1 false)
+// CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[APS]], ptr [[TMP1]], i32 0, i32 0
+// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 8 [[T1]], ptr align 2 [[F]], i32 6, i1 false)
+// CHECK-NEXT: call arm_aapcscc void @__atomic_store(i32 noundef 8, ptr noundef [[T0]], ptr noundef [[TMP1]], i32 noundef 5)
*fp = f;
-// CHECK-NEXT: [[T0:%.*]] = load [[APS]]*, [[APS]]** [[FP]], align 4
-// CHECK-NEXT: [[T1:%.*]] = bitcast [[APS]]* [[T0]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = bitcast [[APS]]* [[TMP3]] to i8*
-// CHECK-NEXT: call arm_aapcscc void @__atomic_load(i32 noundef 8, i8* noundef [[T1]], i8* noundef [[T2]], i32 noundef 5)
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[APS]], [[APS]]* [[TMP3]], i32 0, i32 0
-// CHECK-NEXT: [[T1:%.*]] = bitcast %struct.PS* [[TMP2]] to i8*
-// CHECK-NEXT: [[T2:%.*]] = bitcast %struct.PS* [[T0]] to i8*
-// CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 2 [[T1]], i8* align 8 [[T2]], i32 6, i1 false)
-// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds %struct.PS, %struct.PS* [[TMP2]], i32 0, i32 0
-// CHECK-NEXT: [[T1:%.*]] = load i16, i16* [[T0]], align 2
+// CHECK-NEXT: [[T0:%.*]] = load ptr, ptr [[FP]], align 4
+// CHECK-NEXT: call arm_aapcscc void @__atomic_load(i32 noundef 8, ptr noundef [[T0]], ptr noundef [[TMP3]], i32 noundef 5)
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[APS]], ptr [[TMP3]], i32 0, i32 0
+// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 2 [[TMP2]], ptr align 8 [[T0]], i32 6, i1 false)
+// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds %struct.PS, ptr [[TMP2]], i32 0, i32 0
+// CHECK-NEXT: [[T1:%.*]] = load i16, ptr [[T0]], align 2
// CHECK-NEXT: [[T2:%.*]] = sext i16 [[T1]] to i32
-// CHECK-NEXT: store i32 [[T2]], i32* [[A]], align 4
+// CHECK-NEXT: store i32 [[T2]], ptr [[A]], align 4
int a = ((PS)*fp).x;
// CHECK-NEXT: ret void
}
PS test_promoted_load(_Atomic(PS) *addr) {
- // CHECK-LABEL: @test_promoted_load(%struct.PS* noalias sret(%struct.PS) align 2 %agg.result, { %struct.PS, [2 x i8] }* noundef %addr)
- // CHECK: [[ADDR_ARG:%.*]] = alloca { %struct.PS, [2 x i8] }*, align 4
+ // CHECK-LABEL: @test_promoted_load(ptr noalias sret(%struct.PS) align 2 %agg.result, ptr noundef %addr)
+ // CHECK: [[ADDR_ARG:%.*]] = alloca ptr, align 4
// CHECK: [[ATOMIC_RES:%.*]] = alloca { %struct.PS, [2 x i8] }, align 8
- // CHECK: store { %struct.PS, [2 x i8] }* %addr, { %struct.PS, [2 x i8] }** [[ADDR_ARG]], align 4
- // CHECK: [[ADDR:%.*]] = load { %struct.PS, [2 x i8] }*, { %struct.PS, [2 x i8] }** [[ADDR_ARG]], align 4
- // CHECK: [[ADDR64:%.*]] = bitcast { %struct.PS, [2 x i8] }* [[ADDR]] to i64*
- // CHECK: [[ATOMIC_RES64:%.*]] = bitcast { %struct.PS, [2 x i8] }* [[ATOMIC_RES]] to i64*
- // CHECK: [[ADDR8:%.*]] = bitcast i64* [[ADDR64]] to i8*
- // CHECK: [[RES:%.*]] = call arm_aapcscc i64 @__atomic_load_8(i8* noundef [[ADDR8]], i32 noundef 5)
- // CHECK: store i64 [[RES]], i64* [[ATOMIC_RES64]], align 8
- // CHECK: [[ATOMIC_RES_STRUCT:%.*]] = bitcast i64* [[ATOMIC_RES64]] to %struct.PS*
- // CHECK: [[AGG_RESULT8:%.*]] = bitcast %struct.PS* %agg.result to i8*
- // CHECK: [[ATOMIC_RES8:%.*]] = bitcast %struct.PS* [[ATOMIC_RES_STRUCT]] to i8*
- // CHECK: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 2 [[AGG_RESULT8]], i8* align 8 [[ATOMIC_RES8]], i32 6, i1 false)
+ // CHECK: store ptr %addr, ptr [[ADDR_ARG]], align 4
+ // CHECK: [[ADDR:%.*]] = load ptr, ptr [[ADDR_ARG]], align 4
+ // CHECK: [[RES:%.*]] = call arm_aapcscc i64 @__atomic_load_8(ptr noundef [[ADDR]], i32 noundef 5)
+ // CHECK: store i64 [[RES]], ptr [[ATOMIC_RES]], align 8
+ // CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 2 %agg.result, ptr align 8 [[ATOMIC_RES]], i32 6, i1 false)
return __c11_atomic_load(addr, 5);
}
void test_promoted_store(_Atomic(PS) *addr, PS *val) {
- // CHECK-LABEL: @test_promoted_store({ %struct.PS, [2 x i8] }* noundef %addr, %struct.PS* noundef %val)
- // CHECK: [[ADDR_ARG:%.*]] = alloca { %struct.PS, [2 x i8] }*, align 4
- // CHECK: [[VAL_ARG:%.*]] = alloca %struct.PS*, align 4
+ // CHECK-LABEL: @test_promoted_store(ptr noundef %addr, ptr noundef %val)
+ // CHECK: [[ADDR_ARG:%.*]] = alloca ptr, align 4
+ // CHECK: [[VAL_ARG:%.*]] = alloca ptr, align 4
// CHECK: [[NONATOMIC_TMP:%.*]] = alloca %struct.PS, align 2
// CHECK: [[ATOMIC_VAL:%.*]] = alloca { %struct.PS, [2 x i8] }, align 8
- // CHECK: store { %struct.PS, [2 x i8] }* %addr, { %struct.PS, [2 x i8] }** [[ADDR_ARG]], align 4
- // CHECK: store %struct.PS* %val, %struct.PS** [[VAL_ARG]], align 4
- // CHECK: [[ADDR:%.*]] = load { %struct.PS, [2 x i8] }*, { %struct.PS, [2 x i8] }** [[ADDR_ARG]], align 4
- // CHECK: [[VAL:%.*]] = load %struct.PS*, %struct.PS** [[VAL_ARG]], align 4
- // CHECK: [[NONATOMIC_TMP8:%.*]] = bitcast %struct.PS* [[NONATOMIC_TMP]] to i8*
- // CHECK: [[VAL8:%.*]] = bitcast %struct.PS* [[VAL]] to i8*
- // CHECK: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 2 [[NONATOMIC_TMP8]], i8* align 2 [[VAL8]], i32 6, i1 false)
- // CHECK: [[ADDR64:%.*]] = bitcast { %struct.PS, [2 x i8] }* [[ADDR]] to i64*
- // CHECK: [[ATOMIC_VAL8:%.*]] = bitcast { %struct.PS, [2 x i8] }* [[ATOMIC_VAL]] to i8*
- // CHECK: [[NONATOMIC_TMP8:%.*]] = bitcast %struct.PS* [[NONATOMIC_TMP]] to i8*
- // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 [[ATOMIC_VAL8]], i8* align 2 [[NONATOMIC_TMP8]], i64 6, i1 false)
- // CHECK: [[ATOMIC_VAL64:%.*]] = bitcast { %struct.PS, [2 x i8] }* [[ATOMIC_VAL]] to i64*
- // CHECK: [[ADDR8:%.*]] = bitcast i64* [[ADDR64]] to i8*
- // CHECK: [[VAL64:%.*]] = load i64, i64* [[ATOMIC_VAL64]], align 2
- // CHECK: call arm_aapcscc void @__atomic_store_8(i8* noundef [[ADDR8]], i64 noundef [[VAL64]], i32 noundef 5)
+ // CHECK: store ptr %addr, ptr [[ADDR_ARG]], align 4
+ // CHECK: store ptr %val, ptr [[VAL_ARG]], align 4
+ // CHECK: [[ADDR:%.*]] = load ptr, ptr [[ADDR_ARG]], align 4
+ // CHECK: [[VAL:%.*]] = load ptr, ptr [[VAL_ARG]], align 4
+ // CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 2 [[NONATOMIC_TMP]], ptr align 2 [[VAL]], i32 6, i1 false)
+ // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[ATOMIC_VAL]], ptr align 2 [[NONATOMIC_TMP]], i64 6, i1 false)
+ // CHECK: [[VAL64:%.*]] = load i64, ptr [[ATOMIC_VAL]], align 2
+ // CHECK: call arm_aapcscc void @__atomic_store_8(ptr noundef [[ADDR]], i64 noundef [[VAL64]], i32 noundef 5)
__c11_atomic_store(addr, *val, 5);
}
PS test_promoted_exchange(_Atomic(PS) *addr, PS *val) {
- // CHECK-LABEL: @test_promoted_exchange(%struct.PS* noalias sret(%struct.PS) align 2 %agg.result, { %struct.PS, [2 x i8] }* noundef %addr, %struct.PS* noundef %val)
- // CHECK: [[ADDR_ARG:%.*]] = alloca { %struct.PS, [2 x i8] }*, align 4
- // CHECK: [[VAL_ARG:%.*]] = alloca %struct.PS*, align 4
+ // CHECK-LABEL: @test_promoted_exchange(ptr noalias sret(%struct.PS) align 2 %agg.result, ptr noundef %addr, ptr noundef %val)
+ // CHECK: [[ADDR_ARG:%.*]] = alloca ptr, align 4
+ // CHECK: [[VAL_ARG:%.*]] = alloca ptr, align 4
// CHECK: [[NONATOMIC_TMP:%.*]] = alloca %struct.PS, align 2
// CHECK: [[ATOMIC_VAL:%.*]] = alloca { %struct.PS, [2 x i8] }, align 8
// CHECK: [[ATOMIC_RES:%.*]] = alloca { %struct.PS, [2 x i8] }, align 8
- // CHECK: store { %struct.PS, [2 x i8] }* %addr, { %struct.PS, [2 x i8] }** [[ADDR_ARG]], align 4
- // CHECK: store %struct.PS* %val, %struct.PS** [[VAL_ARG]], align 4
- // CHECK: [[ADDR:%.*]] = load { %struct.PS, [2 x i8] }*, { %struct.PS, [2 x i8] }** [[ADDR_ARG]], align 4
- // CHECK: [[VAL:%.*]] = load %struct.PS*, %struct.PS** [[VAL_ARG]], align 4
- // CHECK: [[NONATOMIC_TMP8:%.*]] = bitcast %struct.PS* [[NONATOMIC_TMP]] to i8*
- // CHECK: [[VAL8:%.*]] = bitcast %struct.PS* [[VAL]] to i8*
- // CHECK: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 2 [[NONATOMIC_TMP8]], i8* align 2 [[VAL8]], i32 6, i1 false)
- // CHECK: [[ADDR64:%.*]] = bitcast { %struct.PS, [2 x i8] }* [[ADDR]] to i64*
- // CHECK: [[ATOMIC_VAL8:%.*]] = bitcast { %struct.PS, [2 x i8] }* [[ATOMIC_VAL]] to i8*
- // CHECK: [[NONATOMIC_TMP8:%.*]] = bitcast %struct.PS* [[NONATOMIC_TMP]] to i8*
- // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 [[ATOMIC_VAL8]], i8* align 2 [[NONATOMIC_TMP8]], i64 6, i1 false)
- // CHECK: [[ATOMIC_VAL64:%.*]] = bitcast { %struct.PS, [2 x i8] }* [[ATOMIC_VAL]] to i64*
- // CHECK: [[ATOMIC_RES64:%.*]] = bitcast { %struct.PS, [2 x i8] }* [[ATOMIC_RES]] to i64*
- // CHECK: [[ADDR8:%.*]] = bitcast i64* [[ADDR64]] to i8*
- // CHECK: [[VAL64:%.*]] = load i64, i64* [[ATOMIC_VAL64]], align 2
- // CHECK: [[RES:%.*]] = call arm_aapcscc i64 @__atomic_exchange_8(i8* noundef [[ADDR8]], i64 noundef [[VAL64]], i32 noundef 5)
- // CHECK: store i64 [[RES]], i64* [[ATOMIC_RES64]], align 8
- // CHECK: [[ATOMIC_RES_STRUCT:%.*]] = bitcast i64* [[ATOMIC_RES64]] to %struct.PS*
- // CHECK: [[AGG_RESULT8:%.*]] = bitcast %struct.PS* %agg.result to i8*
- // CHECK: [[ATOMIC_RES8:%.*]] = bitcast %struct.PS* [[ATOMIC_RES_STRUCT]] to i8*
- // CHECK: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 2 [[AGG_RESULT8]], i8* align 8 [[ATOMIC_RES8]], i32 6, i1 false)
+ // CHECK: store ptr %addr, ptr [[ADDR_ARG]], align 4
+ // CHECK: store ptr %val, ptr [[VAL_ARG]], align 4
+ // CHECK: [[ADDR:%.*]] = load ptr, ptr [[ADDR_ARG]], align 4
+ // CHECK: [[VAL:%.*]] = load ptr, ptr [[VAL_ARG]], align 4
+ // CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 2 [[NONATOMIC_TMP]], ptr align 2 [[VAL]], i32 6, i1 false)
+ // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[ATOMIC_VAL]], ptr align 2 [[NONATOMIC_TMP]], i64 6, i1 false)
+ // CHECK: [[VAL64:%.*]] = load i64, ptr [[ATOMIC_VAL]], align 2
+ // CHECK: [[RES:%.*]] = call arm_aapcscc i64 @__atomic_exchange_8(ptr noundef [[ADDR]], i64 noundef [[VAL64]], i32 noundef 5)
+ // CHECK: store i64 [[RES]], ptr [[ATOMIC_RES]], align 8
+ // CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 2 %agg.result, ptr align 8 [[ATOMIC_RES]], i32 6, i1 false)
return __c11_atomic_exchange(addr, *val, 5);
}
_Bool test_promoted_cmpxchg(_Atomic(PS) *addr, PS *desired, PS *new) {
- // CHECK-LABEL: i1 @test_promoted_cmpxchg({ %struct.PS, [2 x i8] }* noundef %addr, %struct.PS* noundef %desired, %struct.PS* noundef %new) #0 {
- // CHECK: [[ADDR_ARG:%.*]] = alloca { %struct.PS, [2 x i8] }*, align 4
- // CHECK: [[DESIRED_ARG:%.*]] = alloca %struct.PS*, align 4
- // CHECK: [[NEW_ARG:%.*]] = alloca %struct.PS*, align 4
+ // CHECK-LABEL: i1 @test_promoted_cmpxchg(ptr noundef %addr, ptr noundef %desired, ptr noundef %new) #0 {
+ // CHECK: [[ADDR_ARG:%.*]] = alloca ptr, align 4
+ // CHECK: [[DESIRED_ARG:%.*]] = alloca ptr, align 4
+ // CHECK: [[NEW_ARG:%.*]] = alloca ptr, align 4
// CHECK: [[NONATOMIC_TMP:%.*]] = alloca %struct.PS, align 2
// CHECK: [[ATOMIC_DESIRED:%.*]] = alloca { %struct.PS, [2 x i8] }, align 8
// CHECK: [[ATOMIC_NEW:%.*]] = alloca { %struct.PS, [2 x i8] }, align 8
- // CHECK: store { %struct.PS, [2 x i8] }* %addr, { %struct.PS, [2 x i8] }** [[ADDR_ARG]], align 4
- // CHECK: store %struct.PS* %desired, %struct.PS** [[DESIRED_ARG]], align 4
- // CHECK: store %struct.PS* %new, %struct.PS** [[NEW_ARG]], align 4
- // CHECK: [[ADDR:%.*]] = load { %struct.PS, [2 x i8] }*, { %struct.PS, [2 x i8] }** [[ADDR_ARG]], align 4
- // CHECK: [[DESIRED:%.*]]= load %struct.PS*, %struct.PS** [[DESIRED_ARG]], align 4
- // CHECK: [[NEW:%.*]] = load %struct.PS*, %struct.PS** [[NEW_ARG]], align 4
- // CHECK: [[NONATOMIC_TMP8:%.*]] = bitcast %struct.PS* [[NONATOMIC_TMP]] to i8*
- // CHECK: [[NEW8:%.*]] = bitcast %struct.PS* [[NEW]] to i8*
- // CHECK: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 2 [[NONATOMIC_TMP8]], i8* align 2 [[NEW8]], i32 6, i1 false)
- // CHECK: [[ADDR64:%.*]] = bitcast { %struct.PS, [2 x i8] }* [[ADDR]] to i64*
- // CHECK: [[ATOMIC_DESIRED8:%.*]] = bitcast { %struct.PS, [2 x i8] }* [[ATOMIC_DESIRED]] to i8*
- // CHECK: [[DESIRED8:%.*]] = bitcast %struct.PS* [[DESIRED]]to i8*
- // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 [[ATOMIC_DESIRED8]], i8* align 2 [[DESIRED8]], i64 6, i1 false)
- // CHECK: [[ATOMIC_DESIRED64:%.*]] = bitcast { %struct.PS, [2 x i8] }* [[ATOMIC_DESIRED]] to i64*
- // CHECK: [[ATOMIC_NEW8:%.*]] = bitcast { %struct.PS, [2 x i8] }* [[ATOMIC_NEW]] to i8*
- // CHECK: [[NONATOMIC_TMP8:%.*]] = bitcast %struct.PS* [[NONATOMIC_TMP]] to i8*
- // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 [[ATOMIC_NEW8]], i8* align 2 [[NONATOMIC_TMP8]], i64 6, i1 false)
- // CHECK: [[ATOMIC_NEW64:%.*]] = bitcast { %struct.PS, [2 x i8] }* [[ATOMIC_NEW]] to i64*
- // CHECK: [[ADDR8:%.*]] = bitcast i64* [[ADDR64]] to i8*
- // CHECK: [[ATOMIC_DESIRED8:%.*]] = bitcast i64* [[ATOMIC_DESIRED64]] to i8*
- // CHECK: [[NEW64:%.*]] = load i64, i64* [[ATOMIC_NEW64]], align 2
- // CHECK: [[RES:%.*]] = call arm_aapcscc zeroext i1 @__atomic_compare_exchange_8(i8* noundef [[ADDR8]], i8* noundef [[ATOMIC_DESIRED8]], i64 noundef [[NEW64]], i32 noundef 5, i32 noundef 5)
+ // CHECK: store ptr %addr, ptr [[ADDR_ARG]], align 4
+ // CHECK: store ptr %desired, ptr [[DESIRED_ARG]], align 4
+ // CHECK: store ptr %new, ptr [[NEW_ARG]], align 4
+ // CHECK: [[ADDR:%.*]] = load ptr, ptr [[ADDR_ARG]], align 4
+ // CHECK: [[DESIRED:%.*]] = load ptr, ptr [[DESIRED_ARG]], align 4
+ // CHECK: [[NEW:%.*]] = load ptr, ptr [[NEW_ARG]], align 4
+ // CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 2 [[NONATOMIC_TMP]], ptr align 2 [[NEW]], i32 6, i1 false)
+ // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[ATOMIC_DESIRED]], ptr align 2 [[DESIRED]], i64 6, i1 false)
+ // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[ATOMIC_NEW]], ptr align 2 [[NONATOMIC_TMP]], i64 6, i1 false)
+ // CHECK: [[NEW64:%.*]] = load i64, ptr [[ATOMIC_NEW]], align 2
+ // CHECK: [[RES:%.*]] = call arm_aapcscc zeroext i1 @__atomic_compare_exchange_8(ptr noundef [[ADDR]], ptr noundef [[ATOMIC_DESIRED]], i64 noundef [[NEW64]], i32 noundef 5, i32 noundef 5)
// CHECK: ret i1 [[RES]]
return __c11_atomic_compare_exchange_strong(addr, desired, *new, 5, 5);
}
@@ -479,12 +414,12 @@ struct Empty {};
struct Empty test_empty_struct_load(_Atomic(struct Empty)* empty) {
// CHECK-LABEL: @test_empty_struct_load(
- // CHECK: call arm_aapcscc zeroext i8 @__atomic_load_1(i8* noundef %{{.*}}, i32 noundef 5)
+ // CHECK: call arm_aapcscc zeroext i8 @__atomic_load_1(ptr noundef %{{.*}}, i32 noundef 5)
return __c11_atomic_load(empty, 5);
}
void test_empty_struct_store(_Atomic(struct Empty)* empty, struct Empty value) {
// CHECK-LABEL: @test_empty_struct_store(
- // CHECK: call arm_aapcscc void @__atomic_store_1(i8* noundef %{{.*}}, i8 noundef zeroext %{{.*}}, i32 noundef 5)
+ // CHECK: call arm_aapcscc void @__atomic_store_1(ptr noundef %{{.*}}, i8 noundef zeroext %{{.*}}, i32 noundef 5)
__c11_atomic_store(empty, value, 5);
}
diff --git a/clang/test/CodeGen/captured-statements-nested.c b/clang/test/CodeGen/captured-statements-nested.c
index 01d6c29e7225..a748c45f5bbc 100644
--- a/clang/test/CodeGen/captured-statements-nested.c
+++ b/clang/test/CodeGen/captured-statements-nested.c
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -no-opaque-pointers -fblocks -emit-llvm %s -o %t
+// RUN: %clang_cc1 -fblocks -emit-llvm %s -o %t
// RUN: FileCheck %s -input-file=%t -check-prefix=CHECK1
// RUN: FileCheck %s -input-file=%t -check-prefix=CHECK2
@@ -11,9 +11,9 @@ struct A {
void test_nest_captured_stmt(int param, int size, int param_arr[size]) {
int w;
int arr[param][size];
- // CHECK1: %struct.anon{{.*}} = type { [[INT:i.+]]*, [[INT]]*, [[SIZE_TYPE:i.+]], [[INT]]**, [[INT]]*, [[SIZE_TYPE]], [[SIZE_TYPE]], [[INT]]* }
- // CHECK1: %struct.anon{{.*}} = type { [[INT]]*, [[INT]]*, [[INT]]**, [[INT]]*, [[SIZE_TYPE]], [[INT]]**, [[INT]]*, [[SIZE_TYPE]], [[SIZE_TYPE]], [[INT]]* }
- // CHECK1: [[T:%struct.anon.*]] = type { [[INT]]*, [[INT]]*, %struct.A*, [[INT]]**, [[INT]]*, [[SIZE_TYPE]], [[INT]]**, [[INT]]*, [[SIZE_TYPE]], [[SIZE_TYPE]], [[INT]]* }
+ // CHECK1: %struct.anon{{.*}} = type { ptr, ptr, [[SIZE_TYPE:i.+]], ptr, ptr, [[SIZE_TYPE]], [[SIZE_TYPE]], ptr }
+ // CHECK1: %struct.anon{{.*}} = type { ptr, ptr, ptr, ptr, [[SIZE_TYPE]], ptr, ptr, [[SIZE_TYPE]], [[SIZE_TYPE]], ptr }
+ // CHECK1: [[T:%struct.anon.*]] = type { ptr, ptr, ptr, ptr, ptr, [[SIZE_TYPE]], ptr, ptr, [[SIZE_TYPE]], [[SIZE_TYPE]], ptr }
#pragma clang __debug captured
{
int x;
@@ -30,65 +30,65 @@ void test_nest_captured_stmt(int param, int size, int param_arr[size]) {
param_arr[size - 1] = 2;
arr[10][z.a] = 12;
- // CHECK1: define internal {{.*}}void @__captured_stmt{{.*}}([[T]]
- // CHECK1: [[PARAM_ARR_SIZE_REF:%.+]] = getelementptr inbounds [[T]], [[T]]* {{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 5
- // CHECK1: [[PARAM_ARR_SIZE:%.+]] = load [[SIZE_TYPE]], [[SIZE_TYPE]]* [[PARAM_ARR_SIZE_REF]]
- // CHECK1: [[ARR_SIZE1_REF:%.+]] = getelementptr inbounds [[T]], [[T]]* {{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 8
- // CHECK1: [[ARR_SIZE1:%.+]] = load [[SIZE_TYPE]], [[SIZE_TYPE]]* [[ARR_SIZE1_REF]]
- // CHECK1: [[ARR_SIZE2_REF:%.+]] = getelementptr inbounds [[T]], [[T]]* {{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 9
- // CHECK1: [[ARR_SIZE2:%.+]] = load [[SIZE_TYPE]], [[SIZE_TYPE]]* [[ARR_SIZE2_REF]]
+ // CHECK1: define internal {{.*}}void @__captured_stmt.2(ptr
+ // CHECK1: [[PARAM_ARR_SIZE_REF:%.+]] = getelementptr inbounds [[T]], ptr {{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 5
+ // CHECK1: [[PARAM_ARR_SIZE:%.+]] = load [[SIZE_TYPE]], ptr [[PARAM_ARR_SIZE_REF]]
+ // CHECK1: [[ARR_SIZE1_REF:%.+]] = getelementptr inbounds [[T]], ptr {{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 8
+ // CHECK1: [[ARR_SIZE1:%.+]] = load [[SIZE_TYPE]], ptr [[ARR_SIZE1_REF]]
+ // CHECK1: [[ARR_SIZE2_REF:%.+]] = getelementptr inbounds [[T]], ptr {{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 9
+ // CHECK1: [[ARR_SIZE2:%.+]] = load [[SIZE_TYPE]], ptr [[ARR_SIZE2_REF]]
//
- // CHECK1: getelementptr inbounds [[T]], [[T]]* {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 2
- // CHECK1-NEXT: load %struct.A*, %struct.A**
- // CHECK1-NEXT: getelementptr inbounds %struct.A, %struct.A*
+ // CHECK1: getelementptr inbounds [[T]], ptr {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 2
+ // CHECK1-NEXT: load ptr, ptr
+ // CHECK1-NEXT: getelementptr inbounds %struct.A, ptr
// CHECK1-NEXT: store i{{.+}} 1
//
- // CHECK1: getelementptr inbounds [[T]], [[T]]* {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 1
- // CHECK1-NEXT: load i{{[0-9]+}}*, i{{[0-9]+}}**
+ // CHECK1: getelementptr inbounds [[T]], ptr {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 1
+ // CHECK1-NEXT: load ptr, ptr
// CHECK1-NEXT: store i{{[0-9]+}} 1
//
- // CHECK1: getelementptr inbounds [[T]], [[T]]* {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0
- // CHECK1-NEXT: load i{{[0-9]+}}*, i{{[0-9]+}}**
+ // CHECK1: getelementptr inbounds [[T]], ptr {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0
+ // CHECK1-NEXT: load ptr, ptr
// CHECK1-NEXT: store i{{[0-9]+}} 1
//
- // CHECK1: getelementptr inbounds [[T]], [[T]]* {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 4
- // CHECK1-NEXT: load i{{[0-9]+}}*, i{{[0-9]+}}**
- // CHECK1-NEXT: load i{{[0-9]+}}, i{{[0-9]+}}*
- // CHECK1-NEXT: getelementptr inbounds [[T]], [[T]]* {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 3
- // CHECK1-NEXT: load i{{[0-9]+}}**, i{{[0-9]+}}***
- // CHECK1-NEXT: load i{{[0-9]+}}*, i{{[0-9]+}}**
+ // CHECK1: getelementptr inbounds [[T]], ptr {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 4
+ // CHECK1-NEXT: load ptr, ptr
+ // CHECK1-NEXT: load i{{[0-9]+}}, ptr
+ // CHECK1-NEXT: getelementptr inbounds [[T]], ptr {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 3
+ // CHECK1-NEXT: load ptr, ptr
+ // CHECK1-NEXT: load ptr, ptr
// CHECK1-NEXT: store i{{[0-9]+}}
//
- // CHECK1: getelementptr inbounds [[T]], [[T]]* {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 2
- // CHECK1-NEXT: load %struct.A*, %struct.A**
- // CHECK1-NEXT: getelementptr inbounds %struct.A, %struct.A*
+ // CHECK1: getelementptr inbounds [[T]], ptr {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 2
+ // CHECK1-NEXT: load ptr, ptr
+ // CHECK1-NEXT: getelementptr inbounds %struct.A, ptr
// CHECK1-NEXT: store float
//
- // CHECK1: getelementptr inbounds [[T]], [[T]]* {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 2
- // CHECK1-NEXT: load %struct.A*, %struct.A**
- // CHECK1-NEXT: getelementptr inbounds %struct.A, %struct.A*
+ // CHECK1: getelementptr inbounds [[T]], ptr {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 2
+ // CHECK1-NEXT: load ptr, ptr
+ // CHECK1-NEXT: getelementptr inbounds %struct.A, ptr
// CHECK1-NEXT: store i8 99
//
- // CHECK1-DAG: [[SIZE_ADDR_REF:%.*]] = getelementptr inbounds [[T]], [[T]]* {{.*}}, i{{.+}} 0, i{{.+}} 7
- // CHECK1-DAG: [[SIZE_ADDR:%.*]] = load i{{.+}}*, i{{.+}}** [[SIZE_ADDR_REF]]
- // CHECK1-DAG: [[SIZE:%.*]] = load i{{.+}}, i{{.+}}* [[SIZE_ADDR]]
+ // CHECK1-DAG: [[SIZE_ADDR_REF:%.*]] = getelementptr inbounds [[T]], ptr {{.*}}, i{{.+}} 0, i{{.+}} 7
+ // CHECK1-DAG: [[SIZE_ADDR:%.*]] = load ptr, ptr [[SIZE_ADDR_REF]]
+ // CHECK1-DAG: [[SIZE:%.*]] = load i{{.+}}, ptr [[SIZE_ADDR]]
// CHECK1-DAG: [[PARAM_ARR_IDX:%.*]] = sub nsw i{{.+}} [[SIZE]], 1
- // CHECK1-DAG: [[PARAM_ARR_ADDR_REF:%.*]] = getelementptr inbounds [[T]], [[T]]* {{.*}}, i{{.+}} 0, i{{.+}} 6
- // CHECK1-DAG: [[PARAM_ARR_ADDR:%.*]] = load i{{.+}}**, i{{.+}}*** [[PARAM_ARR_ADDR_REF]]
- // CHECK1-DAG: [[PARAM_ARR:%.*]] = load i{{.+}}*, i{{.+}}** [[PARAM_ARR_ADDR]]
- // CHECK1-DAG: [[PARAM_ARR_SIZE_MINUS_1_ADDR:%.*]] = getelementptr inbounds i{{.+}}, i{{.+}}* [[PARAM_ARR]], i{{.*}}
- // CHECK1: store i{{.+}} 2, i{{.+}}* [[PARAM_ARR_SIZE_MINUS_1_ADDR]]
+ // CHECK1-DAG: [[PARAM_ARR_ADDR_REF:%.*]] = getelementptr inbounds [[T]], ptr {{.*}}, i{{.+}} 0, i{{.+}} 6
+ // CHECK1-DAG: [[PARAM_ARR_ADDR:%.*]] = load ptr, ptr [[PARAM_ARR_ADDR_REF]]
+ // CHECK1-DAG: [[PARAM_ARR:%.*]] = load ptr, ptr [[PARAM_ARR_ADDR]]
+ // CHECK1-DAG: [[PARAM_ARR_SIZE_MINUS_1_ADDR:%.*]] = getelementptr inbounds i{{.+}}, ptr [[PARAM_ARR]], i{{.*}}
+ // CHECK1: store i{{.+}} 2, ptr [[PARAM_ARR_SIZE_MINUS_1_ADDR]]
//
- // CHECK1-DAG: [[Z_ADDR_REF:%.*]] = getelementptr inbounds [[T]], [[T]]* {{.*}}, i{{.+}} 0, i{{.+}} 2
- // CHECK1-DAG: [[Z_ADDR:%.*]] = load %struct.A*, %struct.A** [[Z_ADDR_REF]]
- // CHECK1-DAG: [[Z_A_ADDR:%.*]] = getelementptr inbounds %struct.A, %struct.A* [[Z_ADDR]], i{{.+}} 0, i{{.+}} 0
- // CHECK1-DAG: [[ARR_IDX_2:%.*]] = load i{{.+}}, i{{.+}}* [[Z_A_ADDR]]
- // CHECK1-DAG: [[ARR_ADDR_REF:%.*]] = getelementptr inbounds [[T]], [[T]]* {{.*}}, i{{.+}} 0, i{{.+}} 10
- // CHECK1-DAG: [[ARR_ADDR:%.*]] = load i{{.+}}*, i{{.+}}** [[ARR_ADDR_REF]]
+ // CHECK1-DAG: [[Z_ADDR_REF:%.*]] = getelementptr inbounds [[T]], ptr {{.*}}, i{{.+}} 0, i{{.+}} 2
+ // CHECK1-DAG: [[Z_ADDR:%.*]] = load ptr, ptr [[Z_ADDR_REF]]
+ // CHECK1-DAG: [[Z_A_ADDR:%.*]] = getelementptr inbounds %struct.A, ptr [[Z_ADDR]], i{{.+}} 0, i{{.+}} 0
+ // CHECK1-DAG: [[ARR_IDX_2:%.*]] = load i{{.+}}, ptr [[Z_A_ADDR]]
+ // CHECK1-DAG: [[ARR_ADDR_REF:%.*]] = getelementptr inbounds [[T]], ptr {{.*}}, i{{.+}} 0, i{{.+}} 10
+ // CHECK1-DAG: [[ARR_ADDR:%.*]] = load ptr, ptr [[ARR_ADDR_REF]]
// CHECK1-DAG: [[ARR_IDX_1:%.*]] = mul {{.*}} 10
- // CHECK1-DAG: [[ARR_10_ADDR:%.*]] = getelementptr inbounds i{{.+}}, i{{.+}}* [[ARR_ADDR]], i{{.*}} [[ARR_IDX_1]]
- // CHECK1-DAG: [[ARR_10_Z_A_ADDR:%.*]] = getelementptr inbounds i{{.+}}, i{{.+}}* [[ARR_10_ADDR]], i{{.*}}
- // CHECK1: store i{{.+}} 12, i{{.+}}* [[ARR_10_Z_A_ADDR]]
+ // CHECK1-DAG: [[ARR_10_ADDR:%.*]] = getelementptr inbounds i{{.+}}, ptr [[ARR_ADDR]], i{{.*}} [[ARR_IDX_1]]
+ // CHECK1-DAG: [[ARR_10_Z_A_ADDR:%.*]] = getelementptr inbounds i{{.+}}, ptr [[ARR_10_ADDR]], i{{.*}}
+ // CHECK1: store i{{.+}} 12, ptr [[ARR_10_Z_A_ADDR]]
}
}
}
@@ -112,11 +112,11 @@ void test_nest_block(void) {
// CHECK2: alloca %struct.anon{{.*}}
//
// CHECK2: store i{{[0-9]+}}
- // CHECK2: store i{{[0-9]+}}* [[Z]]
+ // CHECK2: store ptr [[Z]]
//
// CHECK2: getelementptr inbounds %struct.anon
// CHECK2-NEXT: getelementptr inbounds
- // CHECK2-NEXT: store i{{[0-9]+}}*
+ // CHECK2-NEXT: store ptr
//
// CHECK2: call void @__captured_stmt
@@ -137,20 +137,18 @@ void test_nest_block(void) {
// CHECK2-NEXT: [[C:%[0-9a-z_]*]] = alloca i{{[0-9]+}}
// CHECK2-NEXT: alloca %struct.__block_byref_d
//
- // CHECK2: bitcast %struct.__block_byref_b*
- // CHECK2-NEXT: store i8*
+ // CHECK2: store ptr
//
// CHECK2: [[CapA:%[0-9a-z_.]*]] = getelementptr inbounds {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 7
//
// CHECK2: getelementptr inbounds %struct.anon{{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0
- // CHECK2: load i{{[0-9]+}}*, i{{[0-9]+}}**
- // CHECK2: load i{{[0-9]+}}, i{{[0-9]+}}*
- // CHECK2: store i{{[0-9]+}} {{.*}}, i{{[0-9]+}}* [[CapA]]
+ // CHECK2: load ptr, ptr
+ // CHECK2: load i{{[0-9]+}}, ptr
+ // CHECK2: store i{{[0-9]+}} {{.*}}, ptr [[CapA]]
//
// CHECK2: [[CapC:%[0-9a-z_.]*]] = getelementptr inbounds {{.*}}, i{{[0-9]+}} 0, i{{[0-9]+}} 8
- // CHECK2-NEXT: [[Val:%[0-9a-z_]*]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[C]]
- // CHECK2-NEXT: store i{{[0-9]+}} [[Val]], i{{[0-9]+}}* [[CapC]]
+ // CHECK2-NEXT: [[Val:%[0-9a-z_]*]] = load i{{[0-9]+}}, ptr [[C]]
+ // CHECK2-NEXT: store i{{[0-9]+}} [[Val]], ptr [[CapC]]
//
- // CHECK2: bitcast %struct.__block_byref_d*
- // CHECK2-NEXT: store i8*
+ // CHECK2: store ptr
}
diff --git a/clang/test/CodeGen/captured-statements.c b/clang/test/CodeGen/captured-statements.c
index 5bd94ff0c758..4dd49a468de5 100644
--- a/clang/test/CodeGen/captured-statements.c
+++ b/clang/test/CodeGen/captured-statements.c
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -no-opaque-pointers -triple %itanium_abi_triple -emit-llvm %s -o %t -debug-info-kind=limited
+// RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o %t -debug-info-kind=limited
// RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-GLOBALS
// RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-1
// RUN: FileCheck %s -input-file=%t -check-prefix=CHECK-2
@@ -18,20 +18,20 @@ void test1(void) {
(void)inner;
i++;
}
- // CHECK-1: %struct.anon = type { i32* }
+ // CHECK-1: %struct.anon = type { ptr }
// CHECK-1: {{.+}} global float 3.0
//
// CHECK-1: @test1(
// CHECK-1: alloca %struct.anon
- // CHECK-1: getelementptr inbounds %struct.anon, %struct.anon*
- // CHECK-1: store i32* %i
+ // CHECK-1: getelementptr inbounds %struct.anon, ptr
+ // CHECK-1: store ptr %i
// CHECK-1: call void @[[HelperName:__captured_stmt[\.0-9]+]]
}
-// CHECK-1: define internal {{.*}}void @[[HelperName]](%struct.anon
+// CHECK-1: define internal {{.*}}void @[[HelperName]](ptr
// CHECK-1: getelementptr inbounds %struct.anon{{.*}}, i32 0, i32 0
-// CHECK-1: load i32*, i32**
-// CHECK-1: load i32, i32*
+// CHECK-1: load ptr, ptr
+// CHECK-1: load i32, ptr
// CHECK-1: add nsw i32
// CHECK-1: store i32
@@ -71,11 +71,11 @@ void test4(intptr_t size, intptr_t vla_arr[size]) {
{
vla_arr[0] = 1;
}
- // CHECK-3: test4([[INTPTR_T:i.+]] {{.*}}[[SIZE_ARG:%.+]], [[INTPTR_T]]*
- // CHECK-3: store [[INTPTR_T]] {{.*}}[[SIZE_ARG]], [[INTPTR_T]]* [[SIZE_ADDR:%.+]],
- // CHECK-3: [[SIZE:%.+]] = load [[INTPTR_T]], [[INTPTR_T]]* [[SIZE_ADDR]],
+ // CHECK-3: test4([[INTPTR_T:i.+]] noundef {{.*}}[[SIZE_ARG:%.+]], ptr
+ // CHECK-3: store [[INTPTR_T]] {{.*}}[[SIZE_ARG]], ptr [[SIZE_ADDR:%.+]],
+ // CHECK-3: [[SIZE:%.+]] = load [[INTPTR_T]], ptr [[SIZE_ADDR]],
// CHECK-3: [[REF:%.+]] = getelementptr inbounds
- // CHECK-3: store [[INTPTR_T]] [[SIZE]], [[INTPTR_T]]* [[REF]]
+ // CHECK-3: store [[INTPTR_T]] [[SIZE]], ptr [[REF]]
// CHECK-3: call void @__captured_stmt
}
@@ -90,14 +90,14 @@ void dont_capture_global(void) {
}
// CHECK-GLOBALS: %[[Capture:struct\.anon[\.0-9]*]] = type {}
- // CHECK-GLOBALS: call void @__captured_stmt[[HelperName:[\.0-9]+]](%[[Capture]]
+ // CHECK-GLOBALS: call void @__captured_stmt[[HelperName:\.4]](
}
// CHECK-GLOBALS: define internal {{.*}}void @__captured_stmt[[HelperName]]
// CHECK-GLOBALS-NOT: ret
-// CHECK-GLOBALS: load i32, i32* @global
-// CHECK-GLOBALS: load i32, i32* @
-// CHECK-GLOBALS: load i32, i32* @e
+// CHECK-GLOBALS: load i32, ptr @global
+// CHECK-GLOBALS: load i32, ptr @
+// CHECK-GLOBALS: load i32, ptr @e
// CHECK-GLOBALS-NOT: DIFlagObjectPointer
// CHECK-1-NOT: DIFlagObjectPointer
diff --git a/clang/test/CodeGen/catch-alignment-assumption-array.c b/clang/test/CodeGen/catch-alignment-assumption-array.c
index fbc978410ded..8a39355c0ba0 100644
--- a/clang/test/CodeGen/catch-alignment-assumption-array.c
+++ b/clang/test/CodeGen/catch-alignment-assumption-array.c
@@ -1,32 +1,31 @@
-// RUN: %clang_cc1 -no-opaque-pointers -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
+// RUN: %clang_cc1 -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
// CHECK-SANITIZE-ANYRECOVER: @[[CHAR:.*]] = {{.*}} c"'char *'\00" }
-// CHECK-SANITIZE-ANYRECOVER: @[[ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 31, i32 35 }, {{.*}}* @[[CHAR]] }
+// CHECK-SANITIZE-ANYRECOVER: @[[ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 30, i32 35 }, {{.*}} @[[CHAR]] }
void *caller(void) {
char str[] = "";
// CHECK: define{{.*}}
// CHECK-NEXT: entry:
// CHECK-NEXT: %[[STR:.*]] = alloca [1 x i8], align 1
- // CHECK-NEXT: %[[BITCAST:.*]] = bitcast [1 x i8]* %[[STR]] to i8*
- // CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* align 1 %[[BITCAST]], i8 0, i64 1, i1 false)
- // CHECK-NEXT: %[[ARRAYDECAY:.*]] = getelementptr inbounds [1 x i8], [1 x i8]* %[[STR]], i64 0, i64 0
- // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint i8* %[[ARRAYDECAY]] to i64
+ // CHECK-NEXT: call void @llvm.memset.p0.i64(ptr align 1 %[[STR]], i8 0, i64 1, i1 false)
+ // CHECK-NEXT: %[[ARRAYDECAY:.*]] = getelementptr inbounds [1 x i8], ptr %[[STR]], i64 0, i64 0
+ // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint ptr %[[ARRAYDECAY]] to i64
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[PTRINT]], 0
// CHECK-SANITIZE-NEXT: %[[MASKCOND:.*]] = icmp eq i64 %[[MASKEDPTR]], 0
- // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint i8* %[[ARRAYDECAY]] to i64, !nosanitize
+ // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint ptr %[[ARRAYDECAY]] to i64, !nosanitize
// CHECK-SANITIZE-NEXT: br i1 %[[MASKCOND]], label %[[CONT:.*]], label %[[HANDLER_ALIGNMENT_ASSUMPTION:[^,]+]],{{.*}} !nosanitize
// CHECK-SANITIZE: [[HANDLER_ALIGNMENT_ASSUMPTION]]:
- // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 1, i64 0){{.*}}, !nosanitize
- // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 1, i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 1, i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 1, i64 0){{.*}}, !nosanitize
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23){{.*}}, !nosanitize
// CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
// CHECK-SANITIZE: [[CONT]]:
- // CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* %[[ARRAYDECAY]], i64 1) ]
- // CHECK-NEXT: ret i8* %[[ARRAYDECAY]]
+ // CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr %[[ARRAYDECAY]], i64 1) ]
+ // CHECK-NEXT: ret ptr %[[ARRAYDECAY]]
// CHECK-NEXT: }
return __builtin_assume_aligned(str, 1);
}
diff --git a/clang/test/CodeGen/catch-alignment-assumption-attribute-align_value-on-lvalue.cpp b/clang/test/CodeGen/catch-alignment-assumption-attribute-align_value-on-lvalue.cpp
index 99560beeccc6..f038f472f00f 100644
--- a/clang/test/CodeGen/catch-alignment-assumption-attribute-align_value-on-lvalue.cpp
+++ b/clang/test/CodeGen/catch-alignment-assumption-attribute-align_value-on-lvalue.cpp
@@ -1,39 +1,39 @@
-// RUN: %clang_cc1 -no-opaque-pointers -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
+// RUN: %clang_cc1 -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
typedef char **__attribute__((align_value(0x100000000))) aligned_char;
struct ac_struct {
- // CHECK: %[[STRUCT_AC_STRUCT:.*]] = type { i8** }
+ // CHECK: %[[STRUCT_AC_STRUCT:.*]] = type { ptr }
aligned_char a;
};
// CHECK-SANITIZE-ANYRECOVER: @[[ALIGNED_CHAR:.*]] = {{.*}} c"'aligned_char' (aka 'char **')\00" }
-// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 13 }, {{.*}}* @[[ALIGNED_CHAR]] }
+// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 13 }, {{.*}} @[[ALIGNED_CHAR]] }
char **load_from_ac_struct(struct ac_struct *x) {
- // CHECK: define{{.*}} i8** @{{.*}}(%[[STRUCT_AC_STRUCT]]* noundef %[[X:.*]])
+ // CHECK: define{{.*}} ptr @{{.*}}(ptr noundef %[[X:.*]])
// CHECK-NEXT: [[ENTRY:.*]]:
- // CHECK-NEXT: %[[STRUCT_AC_STRUCT_ADDR:.*]] = alloca %[[STRUCT_AC_STRUCT]]*, align 8
- // CHECK-NEXT: store %[[STRUCT_AC_STRUCT]]* %[[X]], %[[STRUCT_AC_STRUCT]]** %[[STRUCT_AC_STRUCT_ADDR]], align 8
- // CHECK-NEXT: %[[X_RELOADED:.*]] = load %[[STRUCT_AC_STRUCT]]*, %[[STRUCT_AC_STRUCT]]** %[[STRUCT_AC_STRUCT_ADDR]], align 8
- // CHECK: %[[A_ADDR:.*]] = getelementptr inbounds %[[STRUCT_AC_STRUCT]], %[[STRUCT_AC_STRUCT]]* %[[X_RELOADED]], i32 0, i32 0
- // CHECK: %[[A:.*]] = load i8**, i8*** %[[A_ADDR]], align 8
- // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint i8** %[[A]] to i64
+ // CHECK-NEXT: %[[STRUCT_AC_STRUCT_ADDR:.*]] = alloca ptr, align 8
+ // CHECK-NEXT: store ptr %[[X]], ptr %[[STRUCT_AC_STRUCT_ADDR]], align 8
+ // CHECK-NEXT: %[[X_RELOADED:.*]] = load ptr, ptr %[[STRUCT_AC_STRUCT_ADDR]], align 8
+ // CHECK: %[[A_ADDR:.*]] = getelementptr inbounds %[[STRUCT_AC_STRUCT]], ptr %[[X_RELOADED]], i32 0, i32 0
+ // CHECK: %[[A:.*]] = load ptr, ptr %[[A_ADDR]], align 8
+ // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint ptr %[[A]] to i64
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[PTRINT]], 4294967295
// CHECK-SANITIZE-NEXT: %[[MASKCOND:.*]] = icmp eq i64 %[[MASKEDPTR]], 0
- // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint i8** %[[A]] to i64, !nosanitize
+ // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint ptr %[[A]] to i64, !nosanitize
// CHECK-SANITIZE-NEXT: br i1 %[[MASKCOND]], label %[[CONT:.*]], label %[[HANDLER_ALIGNMENT_ASSUMPTION:[^,]+]],{{.*}} !nosanitize
// CHECK-SANITIZE: [[HANDLER_ALIGNMENT_ASSUMPTION]]:
- // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 4294967296, i64 0){{.*}}, !nosanitize
- // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 4294967296, i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 4294967296, i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 4294967296, i64 0){{.*}}, !nosanitize
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23){{.*}}, !nosanitize
// CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
// CHECK-SANITIZE: [[CONT]]:
- // CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8** %[[A]], i64 4294967296) ]
- // CHECK-NEXT: ret i8** %[[A]]
+ // CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr %[[A]], i64 4294967296) ]
+ // CHECK-NEXT: ret ptr %[[A]]
// CHECK-NEXT: }
#line 100
return x->a;
diff --git a/clang/test/CodeGen/catch-alignment-assumption-attribute-align_value-on-paramvar.cpp b/clang/test/CodeGen/catch-alignment-assumption-attribute-align_value-on-paramvar.cpp
index 815c473d3779..bd3c7555ca14 100644
--- a/clang/test/CodeGen/catch-alignment-assumption-attribute-align_value-on-paramvar.cpp
+++ b/clang/test/CodeGen/catch-alignment-assumption-attribute-align_value-on-paramvar.cpp
@@ -1,31 +1,31 @@
-// RUN: %clang_cc1 -no-opaque-pointers -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefixes=CHECK,CHECK-NOSANITIZE
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefixes=CHECK,CHECK-NOSANITIZE
+// RUN: %clang_cc1 -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
// CHECK-SANITIZE-ANYRECOVER: @[[CHAR:.*]] = {{.*}} c"'char **'\00" }
-// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 10 }, {{.*}}* @[[CHAR]] }
+// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 10 }, {{.*}} @[[CHAR]] }
char **passthrough(__attribute__((align_value(0x100000000))) char **x) {
- // CHECK-NOSANITIZE: define{{.*}} i8** @{{.*}}(i8** noundef align 4294967296 %[[X:.*]])
- // CHECK-SANITIZE: define{{.*}} i8** @{{.*}}(i8** noundef %[[X:.*]])
+ // CHECK-NOSANITIZE: define{{.*}} ptr @{{.*}}(ptr noundef align 4294967296 %[[X:.*]])
+ // CHECK-SANITIZE: define{{.*}} ptr @{{.*}}(ptr noundef %[[X:.*]])
// CHECK-NEXT: [[entry:.*]]:
- // CHECK-NEXT: %[[X_ADDR:.*]] = alloca i8**, align 8
- // CHECK-NEXT: store i8** %[[X]], i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: %[[X_RELOADED:.*]] = load i8**, i8*** %[[X_ADDR]], align 8
- // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint i8** %[[X_RELOADED]] to i64
+ // CHECK-NEXT: %[[X_ADDR:.*]] = alloca ptr, align 8
+ // CHECK-NEXT: store ptr %[[X]], ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: %[[X_RELOADED:.*]] = load ptr, ptr %[[X_ADDR]], align 8
+ // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint ptr %[[X_RELOADED]] to i64
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[PTRINT]], 4294967295
// CHECK-SANITIZE-NEXT: %[[MASKCOND:.*]] = icmp eq i64 %[[MASKEDPTR]], 0
- // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint i8** %[[X_RELOADED]] to i64, !nosanitize
+ // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint ptr %[[X_RELOADED]] to i64, !nosanitize
// CHECK-SANITIZE-NEXT: br i1 %[[MASKCOND]], label %[[CONT:.*]], label %[[HANDLER_ALIGNMENT_ASSUMPTION:[^,]+]],{{.*}} !nosanitize
// CHECK-SANITIZE: [[HANDLER_ALIGNMENT_ASSUMPTION]]:
- // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 4294967296, i64 0){{.*}}, !nosanitize
- // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 4294967296, i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 4294967296, i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 4294967296, i64 0){{.*}}, !nosanitize
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23){{.*}}, !nosanitize
// CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
// CHECK-SANITIZE: [[CONT]]:
- // CHECK-SANITIZE-NEXT: call void @llvm.assume(i1 true) [ "align"(i8** %[[X_RELOADED]], i64 4294967296) ]
- // CHECK-NEXT: ret i8** %[[X_RELOADED]]
+ // CHECK-SANITIZE-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr %[[X_RELOADED]], i64 4294967296) ]
+ // CHECK-NEXT: ret ptr %[[X_RELOADED]]
// CHECK-NEXT: }
#line 100
return x;
diff --git a/clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function-variable.cpp b/clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function-variable.cpp
index c252d6b18c0a..a70f3bb090f3 100644
--- a/clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function-variable.cpp
+++ b/clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function-variable.cpp
@@ -1,49 +1,49 @@
-// RUN: %clang_cc1 -no-opaque-pointers -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
+// RUN: %clang_cc1 -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
// CHECK-SANITIZE-ANYRECOVER: @[[CHAR:.*]] = {{.*}} c"'char **'\00" }
-// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 10 }, {{.*}}* @[[CHAR]] }
+// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 10 }, {{.*}} @[[CHAR]] }
char **__attribute__((alloc_align(2)))
passthrough(char **x, unsigned long alignment) {
- // CHECK: define{{.*}} i8** @[[PASSTHROUGH:.*]](i8** noundef %[[X:.*]], i64 noundef %[[ALIGNMENT:.*]])
+ // CHECK: define{{.*}} ptr @[[PASSTHROUGH:.*]](ptr noundef %[[X:.*]], i64 noundef %[[ALIGNMENT:.*]])
// CHECK-NEXT: entry:
- // CHECK-NEXT: %[[X_ADDR:.*]] = alloca i8**, align 8
+ // CHECK-NEXT: %[[X_ADDR:.*]] = alloca ptr, align 8
// CHECK-NEXT: %[[ALIGNMENT_ADDR:.*]] = alloca i64, align 8
- // CHECK-NEXT: store i8** %[[X]], i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: store i64 %[[ALIGNMENT]], i64* %[[ALIGNMENT_ADDR]], align 8
- // CHECK-NEXT: %[[X_RELOADED:.*]] = load i8**, i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: ret i8** %[[X_RELOADED]]
+ // CHECK-NEXT: store ptr %[[X]], ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: store i64 %[[ALIGNMENT]], ptr %[[ALIGNMENT_ADDR]], align 8
+ // CHECK-NEXT: %[[X_RELOADED:.*]] = load ptr, ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: ret ptr %[[X_RELOADED]]
// CHECK-NEXT: }
return x;
}
char **caller(char **x, unsigned long alignment) {
- // CHECK: define{{.*}} i8** @{{.*}}(i8** noundef %[[X:.*]], i64 noundef %[[ALIGNMENT:.*]])
+ // CHECK: define{{.*}} ptr @{{.*}}(ptr noundef %[[X:.*]], i64 noundef %[[ALIGNMENT:.*]])
// CHECK-NEXT: entry:
- // CHECK-NEXT: %[[X_ADDR:.*]] = alloca i8**, align 8
+ // CHECK-NEXT: %[[X_ADDR:.*]] = alloca ptr, align 8
// CHECK-NEXT: %[[ALIGNMENT_ADDR:.*]] = alloca i64, align 8
- // CHECK-NEXT: store i8** %[[X]], i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: store i64 %[[ALIGNMENT]], i64* %[[ALIGNMENT_ADDR]], align 8
- // CHECK-NEXT: %[[X_RELOADED:.*]] = load i8**, i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: %[[ALIGNMENT_RELOADED:.*]] = load i64, i64* %[[ALIGNMENT_ADDR]], align 8
- // CHECK-NEXT: %[[X_RETURNED:.*]] = call noundef i8** @[[PASSTHROUGH]](i8** noundef %[[X_RELOADED]], i64 noundef %[[ALIGNMENT_RELOADED]])
- // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint i8** %[[X_RETURNED]] to i64
+ // CHECK-NEXT: store ptr %[[X]], ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: store i64 %[[ALIGNMENT]], ptr %[[ALIGNMENT_ADDR]], align 8
+ // CHECK-NEXT: %[[X_RELOADED:.*]] = load ptr, ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: %[[ALIGNMENT_RELOADED:.*]] = load i64, ptr %[[ALIGNMENT_ADDR]], align 8
+ // CHECK-NEXT: %[[X_RETURNED:.*]] = call noundef ptr @[[PASSTHROUGH]](ptr noundef %[[X_RELOADED]], i64 noundef %[[ALIGNMENT_RELOADED]])
+ // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint ptr %[[X_RETURNED]] to i64
// CHECK-SANITIZE-NEXT: %[[MASK:.*]] = sub i64 %[[ALIGNMENT_RELOADED]], 1
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[PTRINT]], %[[MASK]]
// CHECK-SANITIZE-NEXT: %[[MASKCOND:.*]] = icmp eq i64 %[[MASKEDPTR]], 0
- // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint i8** %[[X_RETURNED]] to i64, !nosanitize
+ // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint ptr %[[X_RETURNED]] to i64, !nosanitize
// CHECK-SANITIZE-NEXT: br i1 %[[MASKCOND]], label %[[CONT:.*]], label %[[HANDLER_ALIGNMENT_ASSUMPTION:[^,]+]],{{.*}} !nosanitize
// CHECK-SANITIZE: [[HANDLER_ALIGNMENT_ASSUMPTION]]:
- // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 %[[ALIGNMENT_RELOADED]], i64 0){{.*}}, !nosanitize
- // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 %[[ALIGNMENT_RELOADED]], i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 %[[ALIGNMENT_RELOADED]], i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 %[[ALIGNMENT_RELOADED]], i64 0){{.*}}, !nosanitize
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23){{.*}}, !nosanitize
// CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
// CHECK-SANITIZE: [[CONT]]:
- // CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8** %[[X_RETURNED]], i64 %1) ]
- // CHECK-NEXT: ret i8** %[[X_RETURNED]]
+ // CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr %[[X_RETURNED]], i64 %1) ]
+ // CHECK-NEXT: ret ptr %[[X_RETURNED]]
// CHECK-NEXT: }
#line 100
return passthrough(x, alignment);
diff --git a/clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function.cpp b/clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function.cpp
index f7f31f07c835..6c6540e9311c 100644
--- a/clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function.cpp
+++ b/clang/test/CodeGen/catch-alignment-assumption-attribute-alloc_align-on-function.cpp
@@ -1,46 +1,46 @@
-// RUN: %clang_cc1 -no-opaque-pointers -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefixes=CHECK,CHECK-NOSANITIZE
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefixes=CHECK,CHECK-NOSANITIZE
+// RUN: %clang_cc1 -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
// CHECK-SANITIZE-ANYRECOVER: @[[CHAR:.*]] = {{.*}} c"'char **'\00" }
-// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 10 }, {{.*}}* @[[CHAR]] }
+// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 10 }, {{.*}} @[[CHAR]] }
char **__attribute__((alloc_align(2)))
passthrough(char **x, unsigned long alignment) {
- // CHECK: define{{.*}} i8** @[[PASSTHROUGH:.*]](i8** noundef %[[X:.*]], i64 noundef %[[ALIGNMENT:.*]])
+ // CHECK: define{{.*}} ptr @[[PASSTHROUGH:.*]](ptr noundef %[[X:.*]], i64 noundef %[[ALIGNMENT:.*]])
// CHECK-NEXT: entry:
- // CHECK-NEXT: %[[X_ADDR:.*]] = alloca i8**, align 8
+ // CHECK-NEXT: %[[X_ADDR:.*]] = alloca ptr, align 8
// CHECK-NEXT: %[[ALIGNMENT_ADDR:.*]] = alloca i64, align 8
- // CHECK-NEXT: store i8** %[[X]], i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: store i64 %[[ALIGNMENT]], i64* %[[ALIGNMENT_ADDR]], align 8
- // CHECK-NEXT: %[[X_RELOADED:.*]] = load i8**, i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: ret i8** %[[X_RELOADED]]
+ // CHECK-NEXT: store ptr %[[X]], ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: store i64 %[[ALIGNMENT]], ptr %[[ALIGNMENT_ADDR]], align 8
+ // CHECK-NEXT: %[[X_RELOADED:.*]] = load ptr, ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: ret ptr %[[X_RELOADED]]
// CHECK-NEXT: }
return x;
}
char **caller(char **x) {
- // CHECK: define{{.*}} i8** @{{.*}}(i8** noundef %[[X:.*]])
+ // CHECK: define{{.*}} ptr @{{.*}}(ptr noundef %[[X:.*]])
// CHECK-NEXT: entry:
- // CHECK-NEXT: %[[X_ADDR:.*]] = alloca i8**, align 8
- // CHECK-NEXT: store i8** %[[X]], i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: %[[X_RELOADED:.*]] = load i8**, i8*** %[[X_ADDR]], align 8
- // CHECK-NOSANITIZE-NEXT: %[[X_RETURNED:.*]] = call noundef align 128 i8** @[[PASSTHROUGH]](i8** noundef %[[X_RELOADED]], i64 noundef 128)
- // CHECK-SANITIZE-NEXT: %[[X_RETURNED:.*]] = call noundef i8** @[[PASSTHROUGH]](i8** noundef %[[X_RELOADED]], i64 noundef 128)
- // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint i8** %[[X_RETURNED]] to i64
+ // CHECK-NEXT: %[[X_ADDR:.*]] = alloca ptr, align 8
+ // CHECK-NEXT: store ptr %[[X]], ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: %[[X_RELOADED:.*]] = load ptr, ptr %[[X_ADDR]], align 8
+ // CHECK-NOSANITIZE-NEXT: %[[X_RETURNED:.*]] = call noundef align 128 ptr @[[PASSTHROUGH]](ptr noundef %[[X_RELOADED]], i64 noundef 128)
+ // CHECK-SANITIZE-NEXT: %[[X_RETURNED:.*]] = call noundef ptr @[[PASSTHROUGH]](ptr noundef %[[X_RELOADED]], i64 noundef 128)
+ // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint ptr %[[X_RETURNED]] to i64
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[PTRINT]], 127
// CHECK-SANITIZE-NEXT: %[[MASKCOND:.*]] = icmp eq i64 %[[MASKEDPTR]], 0
- // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint i8** %[[X_RETURNED]] to i64, !nosanitize
+ // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint ptr %[[X_RETURNED]] to i64, !nosanitize
// CHECK-SANITIZE-NEXT: br i1 %[[MASKCOND]], label %[[CONT:.*]], label %[[HANDLER_ALIGNMENT_ASSUMPTION:[^,]+]],{{.*}} !nosanitize
// CHECK-SANITIZE: [[HANDLER_ALIGNMENT_ASSUMPTION]]:
- // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 128, i64 0){{.*}}, !nosanitize
- // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 128, i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 128, i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 128, i64 0){{.*}}, !nosanitize
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23){{.*}}, !nosanitize
// CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
// CHECK-SANITIZE: [[CONT]]:
- // CHECK-SANITIZE-NEXT: call void @llvm.assume(i1 true) [ "align"(i8** %[[X_RETURNED]], i64 128) ]
- // CHECK-NEXT: ret i8** %[[X_RETURNED]]
+ // CHECK-SANITIZE-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr %[[X_RETURNED]], i64 128) ]
+ // CHECK-NEXT: ret ptr %[[X_RETURNED]]
// CHECK-NEXT: }
#line 100
return passthrough(x, 128);
diff --git a/clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function-two-params.cpp b/clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function-two-params.cpp
index dcda1cb3952e..3114bfa8e870 100644
--- a/clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function-two-params.cpp
+++ b/clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function-two-params.cpp
@@ -1,43 +1,43 @@
-// RUN: %clang_cc1 -no-opaque-pointers -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
+// RUN: %clang_cc1 -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
// CHECK-SANITIZE-ANYRECOVER: @[[CHAR:.*]] = {{.*}} c"'char **'\00" }
-// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 10 }, {{.*}}* @[[CHAR]] }
+// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 10 }, {{.*}} @[[CHAR]] }
char **__attribute__((assume_aligned(0x100000000, 42))) passthrough(char **x) {
- // CHECK: define{{.*}} i8** @[[PASSTHROUGH:.*]](i8** noundef %[[X:.*]])
+ // CHECK: define{{.*}} ptr @[[PASSTHROUGH:.*]](ptr noundef %[[X:.*]])
// CHECK-NEXT: entry:
- // CHECK-NEXT: %[[X_ADDR:.*]] = alloca i8**, align 8
- // CHECK-NEXT: store i8** %[[X]], i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: %[[X_RELOADED:.*]] = load i8**, i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: ret i8** %[[X_RELOADED]]
+ // CHECK-NEXT: %[[X_ADDR:.*]] = alloca ptr, align 8
+ // CHECK-NEXT: store ptr %[[X]], ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: %[[X_RELOADED:.*]] = load ptr, ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: ret ptr %[[X_RELOADED]]
// CHECK-NEXT: }
return x;
}
char **caller(char **x) {
- // CHECK: define{{.*}} i8** @{{.*}}(i8** noundef %[[X:.*]])
+ // CHECK: define{{.*}} ptr @{{.*}}(ptr noundef %[[X:.*]])
// CHECK-NEXT: entry:
- // CHECK-NEXT: %[[X_ADDR:.*]] = alloca i8**, align 8
- // CHECK-NEXT: store i8** %[[X]], i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: %[[X_RELOADED:.*]] = load i8**, i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: %[[X_RETURNED:.*]] = call noundef i8** @[[PASSTHROUGH]](i8** noundef %[[X_RELOADED]])
- // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint i8** %[[X_RETURNED]] to i64
+ // CHECK-NEXT: %[[X_ADDR:.*]] = alloca ptr, align 8
+ // CHECK-NEXT: store ptr %[[X]], ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: %[[X_RELOADED:.*]] = load ptr, ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: %[[X_RETURNED:.*]] = call noundef ptr @[[PASSTHROUGH]](ptr noundef %[[X_RELOADED]])
+ // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint ptr %[[X_RETURNED]] to i64
// CHECK-SANITIZE-NEXT: %[[OFFSETPTR:.*]] = sub i64 %[[PTRINT]], 42
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[OFFSETPTR]], 4294967295
// CHECK-SANITIZE-NEXT: %[[MASKCOND:.*]] = icmp eq i64 %[[MASKEDPTR]], 0
- // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint i8** %[[X_RETURNED]] to i64, !nosanitize
+ // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint ptr %[[X_RETURNED]] to i64, !nosanitize
// CHECK-SANITIZE-NEXT: br i1 %[[MASKCOND]], label %[[CONT:.*]], label %[[HANDLER_ALIGNMENT_ASSUMPTION:[^,]+]],{{.*}} !nosanitize
// CHECK-SANITIZE: [[HANDLER_ALIGNMENT_ASSUMPTION]]:
- // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 4294967296, i64 42){{.*}}, !nosanitize
- // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 4294967296, i64 42){{.*}}, !nosanitize
+ // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 4294967296, i64 42){{.*}}, !nosanitize
+ // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 4294967296, i64 42){{.*}}, !nosanitize
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23){{.*}}, !nosanitize
// CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
// CHECK-SANITIZE: [[CONT]]:
- // CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8** %[[X_RETURNED]], i64 4294967296, i64 42) ]
- // CHECK-NEXT: ret i8** %[[X_RETURNED]]
+ // CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr %[[X_RETURNED]], i64 4294967296, i64 42) ]
+ // CHECK-NEXT: ret ptr %[[X_RETURNED]]
// CHECK-NEXT: }
#line 100
return passthrough(x);
diff --git a/clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function.cpp b/clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function.cpp
index cf39e9530e98..6c31fb26532b 100644
--- a/clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function.cpp
+++ b/clang/test/CodeGen/catch-alignment-assumption-attribute-assume_aligned-on-function.cpp
@@ -1,43 +1,43 @@
-// RUN: %clang_cc1 -no-opaque-pointers -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefixes=CHECK,CHECK-NOSANITIZE
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s --check-prefixes=CHECK,CHECK-NOSANITIZE
+// RUN: %clang_cc1 -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
// CHECK-SANITIZE-ANYRECOVER: @[[CHAR:.*]] = {{.*}} c"'char **'\00" }
-// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 10 }, {{.*}}* @[[CHAR]] }
+// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 10 }, {{.*}} @[[CHAR]] }
char **__attribute__((assume_aligned(128))) passthrough(char **x) {
- // CHECK: define{{.*}} i8** @[[PASSTHROUGH:.*]](i8** noundef %[[X:.*]])
+ // CHECK: define{{.*}} ptr @[[PASSTHROUGH:.*]](ptr noundef %[[X:.*]])
// CHECK-NEXT: entry:
- // CHECK-NEXT: %[[X_ADDR:.*]] = alloca i8**, align 8
- // CHECK-NEXT: store i8** %[[X]], i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: %[[X_RELOADED:.*]] = load i8**, i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: ret i8** %[[X_RELOADED]]
+ // CHECK-NEXT: %[[X_ADDR:.*]] = alloca ptr, align 8
+ // CHECK-NEXT: store ptr %[[X]], ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: %[[X_RELOADED:.*]] = load ptr, ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: ret ptr %[[X_RELOADED]]
// CHECK-NEXT: }
return x;
}
char **caller(char **x) {
- // CHECK: define{{.*}} i8** @{{.*}}(i8** noundef %[[X]])
+ // CHECK: define{{.*}} ptr @{{.*}}(ptr noundef %[[X]])
// CHECK-NEXT: entry:
- // CHECK-NEXT: %[[X_ADDR]] = alloca i8**, align 8
- // CHECK-NEXT: store i8** %[[X]], i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: %[[X_RELOADED:.*]] = load i8**, i8*** %[[X_ADDR]], align 8
- // CHECK-NOSANITIZE-NEXT: %[[X_RETURNED:.*]] = call noundef align 128 i8** @[[PASSTHROUGH]](i8** noundef %[[X_RELOADED]])
- // CHECK-SANITIZE-NEXT: %[[X_RETURNED:.*]] = call noundef i8** @[[PASSTHROUGH]](i8** noundef %[[X_RELOADED]])
- // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint i8** %[[X_RETURNED]] to i64
+ // CHECK-NEXT: %[[X_ADDR]] = alloca ptr, align 8
+ // CHECK-NEXT: store ptr %[[X]], ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: %[[X_RELOADED:.*]] = load ptr, ptr %[[X_ADDR]], align 8
+ // CHECK-NOSANITIZE-NEXT: %[[X_RETURNED:.*]] = call noundef align 128 ptr @[[PASSTHROUGH]](ptr noundef %[[X_RELOADED]])
+ // CHECK-SANITIZE-NEXT: %[[X_RETURNED:.*]] = call noundef ptr @[[PASSTHROUGH]](ptr noundef %[[X_RELOADED]])
+ // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint ptr %[[X_RETURNED]] to i64
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[PTRINT]], 127
// CHECK-SANITIZE-NEXT: %[[MASKCOND:.*]] = icmp eq i64 %[[MASKEDPTR]], 0
- // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint i8** %[[X_RETURNED]] to i64, !nosanitize
+ // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint ptr %[[X_RETURNED]] to i64, !nosanitize
// CHECK-SANITIZE-NEXT: br i1 %[[MASKCOND]], label %[[CONT:.*]], label %[[HANDLER_ALIGNMENT_ASSUMPTION:[^,]+]],{{.*}} !nosanitize
// CHECK-SANITIZE: [[HANDLER_ALIGNMENT_ASSUMPTION]]:
- // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 128, i64 0){{.*}}, !nosanitize
- // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 128, i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 128, i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 128, i64 0){{.*}}, !nosanitize
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23){{.*}}, !nosanitize
// CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
// CHECK-SANITIZE: [[CONT]]:
- // CHECK-SANITIZE-NEXT: call void @llvm.assume(i1 true) [ "align"(i8** %[[X_RETURNED]], i64 128) ]
- // CHECK-NEXT: ret i8** %[[X_RETURNED]]
+ // CHECK-SANITIZE-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr %[[X_RETURNED]], i64 128) ]
+ // CHECK-NEXT: ret ptr %[[X_RETURNED]]
// CHECK-NEXT: }
#line 100
return passthrough(x);
diff --git a/clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-polymorphism.cpp b/clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-polymorphism.cpp
index 2206a73472f1..a5b969d3cbc0 100644
--- a/clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-polymorphism.cpp
+++ b/clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-polymorphism.cpp
@@ -1,29 +1,27 @@
-// RUN: %clang_cc1 -no-opaque-pointers -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
+// RUN: %clang_cc1 -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
// CHECK-SANITIZE-ANYRECOVER: @[[CHAR:.*]] = {{.*}} c"'B *'\00" }
-// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 35 }, {{.*}}* @[[CHAR]] }
+// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 35 }, {{.*}} @[[CHAR]] }
struct A { int n; };
struct B { int n; };
struct C : A, B {};
void *f(C *c) {
- // CHECK: define {{.*}} i8* @{{.*}}(%struct.C* noundef %[[C:.*]]) {{.*}} {
+ // CHECK: define {{.*}} ptr @{{.*}}(ptr noundef %[[C:.*]]) {{.*}} {
// CHECK-NEXT: [[ENTRY:.*]]:
- // CHECK-NEXT: %[[C_ADDR:.*]] = alloca %struct.C*
- // CHECK-NEXT: store %struct.C* %[[C]], %struct.C** %[[C_ADDR]]
- // CHECK-NEXT: %[[C_RELOAD:.*]] = load %struct.C*, %struct.C** %[[C_ADDR]]
- // CHECK-NEXT: %[[IS_NULL:.*]] = icmp eq %struct.C* %[[C_RELOAD]], null
+ // CHECK-NEXT: %[[C_ADDR:.*]] = alloca ptr
+ // CHECK-NEXT: store ptr %[[C]], ptr %[[C_ADDR]]
+ // CHECK-NEXT: %[[C_RELOAD:.*]] = load ptr, ptr %[[C_ADDR]]
+ // CHECK-NEXT: %[[IS_NULL:.*]] = icmp eq ptr %[[C_RELOAD]], null
// CHECK-NEXT: br i1 %[[IS_NULL]], label %[[CAST_END:[^,]+]], label %[[CAST_NOT_NULL:[^,]+]]
// CHECK: [[CAST_NOT_NULL]]:
- // CHECK-NOSANITIZE-NEXT: %[[BITCAST:.*]] = bitcast %struct.C* %[[C_RELOAD]] to i8*
- // CHECK-NOSANITIZE-NEXT: %[[ADD_PTR:.*]] = getelementptr inbounds i8, i8* %[[BITCAST]], i64 4
- // CHECK-NOSANITIZE-NEXT: %[[BITCAST2:.*]] = bitcast i8* %[[ADD_PTR]] to %struct.B*
+ // CHECK-NOSANITIZE-NEXT: %[[ADD_PTR:.*]] = getelementptr inbounds i8, ptr %[[C_RELOAD]], i64 4
// CHECK-NOSANITIZE-NEXT: br label %[[CAST_END]]
- // CHECK-SANITIZE-NEXT: %[[PTRTOINT:.*]] = ptrtoint %struct.C* %[[C_RELOAD]] to i64, !nosanitize
+ // CHECK-SANITIZE-NEXT: %[[PTRTOINT:.*]] = ptrtoint ptr %[[C_RELOAD]] to i64, !nosanitize
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[PTRTOINT]], 3, !nosanitize
// CHECK-SANITIZE-NEXT: %[[MASKCOND:.*]] = icmp eq i64 %[[MASKEDPTR]], 0, !nosanitize
// CHECK-SANITIZE-NEXT: br i1 %[[MASKCOND]], label %[[CONT:[^,]+]], label %[[HANDLER_TYPE_MISMATCH:[^,]+]]
@@ -33,31 +31,27 @@ void *f(C *c) {
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(
// CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
// CHECK-SANITIZE: [[CONT]]:
- // CHECK-SANITIZE-NEXT: %[[BITCAST:.*]] = bitcast %struct.C* %[[C_RELOAD]] to i8*
- // CHECK-SANITIZE-NEXT: %[[ADD_PTR:.*]] = getelementptr inbounds i8, i8* %[[BITCAST]], i64 4
- // CHECK-SANITIZE-NEXT: %[[BITCAST2:.*]] = bitcast i8* %[[ADD_PTR]] to %struct.B*
+ // CHECK-SANITIZE-NEXT: %[[ADD_PTR:.*]] = getelementptr inbounds i8, ptr %[[C_RELOAD]], i64 4
// CHECK-SANITIZE-NEXT: br label %[[CAST_END]]
// CHECK: [[CAST_END]]:
- // CHECK-NOSANITIZE-NEXT: %[[CAST_RESULT:.*]] = phi %struct.B* [ %[[BITCAST2]], %[[CAST_NOT_NULL]] ], [ null, %[[ENTRY]] ]
- // CHECK-NOSANITIZE-NEXT: %[[CAST_END_BITCAST:.*]] = bitcast %struct.B* %[[CAST_RESULT]] to i8*
- // CHECK-NOSANITIZE-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* %[[CAST_END_BITCAST]], i64 8) ]
- // CHECK-NOSANITIZE-NEXT: ret i8* %[[CAST_END_BITCAST]]
+ // CHECK-NOSANITIZE-NEXT: %[[CAST_RESULT:.*]] = phi ptr [ %[[ADD_PTR]], %[[CAST_NOT_NULL]] ], [ null, %[[ENTRY]] ]
+ // CHECK-NOSANITIZE-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr %[[CAST_RESULT]], i64 8) ]
+ // CHECK-NOSANITIZE-NEXT: ret ptr %[[CAST_RESULT]]
// CHECK-NOSANITIZE-NEXT: }
- // CHECK-SANITIZE-NEXT: %[[CAST_RESULT:.*]] = phi %struct.B* [ %[[BITCAST2]], %[[CONT]] ], [ null, %[[ENTRY]] ]
- // CHECK-SANITIZE-NEXT: %[[CAST_END_BITCAST:.*]] = bitcast %struct.B* %[[CAST_RESULT]] to i8*
- // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint i8* %[[CAST_END_BITCAST]] to i64
+ // CHECK-SANITIZE-NEXT: %[[CAST_RESULT:.*]] = phi ptr [ %[[ADD_PTR]], %[[CONT]] ], [ null, %[[ENTRY]] ]
+ // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint ptr %[[CAST_RESULT]] to i64
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[PTRINT]], 7
// CHECK-SANITIZE-NEXT: %[[MASKCOND:.*]] = icmp eq i64 %[[MASKEDPTR]], 0
- // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint i8* %[[CAST_END_BITCAST]] to i64, !nosanitize
+ // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint ptr %[[CAST_RESULT]] to i64, !nosanitize
// CHECK-SANITIZE-NEXT: br i1 %[[MASKCOND]], label %[[CONT1:.*]], label %[[HANDLER_ALIGNMENT_ASSUMPTION:[^,]+]],{{.*}} !nosanitize
// CHECK-SANITIZE: [[HANDLER_ALIGNMENT_ASSUMPTION]]:
- // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 8, i64 0){{.*}}, !nosanitize
- // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 8, i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 8, i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 8, i64 0){{.*}}, !nosanitize
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23){{.*}}, !nosanitize
// CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
// CHECK-SANITIZE: [[CONT1]]:
- // CHECK-SANITIZE-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* %[[CAST_END_BITCAST]], i64 8) ]
- // CHECK-SANITIZE-NEXT: ret i8* %[[CAST_END_BITCAST]]
+ // CHECK-SANITIZE-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr %[[CAST_RESULT]], i64 8) ]
+ // CHECK-SANITIZE-NEXT: ret ptr %[[CAST_RESULT]]
// CHECK-SANITIZE-NEXT: }
#line 100
return __builtin_assume_aligned((B*)c, 8);
diff --git a/clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-three-params-variable.cpp b/clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-three-params-variable.cpp
index 7e48262621d2..7ee9906e7c56 100644
--- a/clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-three-params-variable.cpp
+++ b/clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-three-params-variable.cpp
@@ -1,35 +1,34 @@
-// RUN: %clang_cc1 -no-opaque-pointers -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
+// RUN: %clang_cc1 -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
// CHECK-SANITIZE-ANYRECOVER: @[[CHAR:.*]] = {{.*}} c"'char **'\00" }
-// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 35 }, {{.*}}* @[[CHAR]] }
+// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 35 }, {{.*}} @[[CHAR]] }
void *caller(char **x, unsigned long offset) {
- // CHECK: define{{.*}} i8* @{{.*}}(i8** noundef %[[X:.*]], i64 noundef %[[OFFSET:.*]])
+ // CHECK: define{{.*}} ptr @{{.*}}(ptr noundef %[[X:.*]], i64 noundef %[[OFFSET:.*]])
// CHECK-NEXT: entry:
- // CHECK-NEXT: %[[X_ADDR:.*]] = alloca i8**, align 8
+ // CHECK-NEXT: %[[X_ADDR:.*]] = alloca ptr, align 8
// CHECK-NEXT: %[[OFFSET_ADDR:.*]] = alloca i64, align 8
- // CHECK-NEXT: store i8** %[[X]], i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: store i64 %[[OFFSET]], i64* %[[OFFSET_ADDR]], align 8
- // CHECK-NEXT: %[[X_RELOADED:.*]] = load i8**, i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: %[[BITCAST:.*]] = bitcast i8** %[[X_RELOADED]] to i8*
- // CHECK-NEXT: %[[OFFSET_RELOADED:.*]] = load i64, i64* %[[OFFSET_ADDR]], align 8
- // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint i8* %[[BITCAST]] to i64
+ // CHECK-NEXT: store ptr %[[X]], ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: store i64 %[[OFFSET]], ptr %[[OFFSET_ADDR]], align 8
+ // CHECK-NEXT: %[[X_RELOADED:.*]] = load ptr, ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: %[[OFFSET_RELOADED:.*]] = load i64, ptr %[[OFFSET_ADDR]], align 8
+ // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint ptr %[[X_RELOADED]] to i64
// CHECK-SANITIZE-NEXT: %[[OFFSETPTR:.*]] = sub i64 %[[PTRINT]], %[[OFFSET_RELOADED]]
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[OFFSETPTR]], 4294967295
// CHECK-SANITIZE-NEXT: %[[MASKCOND:.*]] = icmp eq i64 %[[MASKEDPTR]], 0
- // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint i8* %[[BITCAST]] to i64, !nosanitize
+ // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint ptr %[[X_RELOADED]] to i64, !nosanitize
// CHECK-SANITIZE-NEXT: br i1 %[[MASKCOND]], label %[[CONT:.*]], label %[[HANDLER_ALIGNMENT_ASSUMPTION:[^,]+]],{{.*}} !nosanitize
// CHECK-SANITIZE: [[HANDLER_ALIGNMENT_ASSUMPTION]]:
- // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 4294967296, i64 %[[OFFSET_RELOADED]]){{.*}}, !nosanitize
- // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 4294967296, i64 %[[OFFSET_RELOADED]]){{.*}}, !nosanitize
+ // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 4294967296, i64 %[[OFFSET_RELOADED]]){{.*}}, !nosanitize
+ // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 4294967296, i64 %[[OFFSET_RELOADED]]){{.*}}, !nosanitize
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23){{.*}}, !nosanitize
// CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
// CHECK-SANITIZE: [[CONT]]:
- // CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* %[[BITCAST]], i64 4294967296, i64 %[[OFFSET_RELOADED]]) ]
- // CHECK-NEXT: ret i8* %[[BITCAST]]
+ // CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr %[[X_RELOADED]], i64 4294967296, i64 %[[OFFSET_RELOADED]]) ]
+ // CHECK-NEXT: ret ptr %[[X_RELOADED]]
// CHECK-NEXT: }
#line 100
return __builtin_assume_aligned(x, 0x100000000, offset);
diff --git a/clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-three-params.cpp b/clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-three-params.cpp
index 94cefef5a2e5..f5294f99dde4 100644
--- a/clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-three-params.cpp
+++ b/clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-three-params.cpp
@@ -1,32 +1,31 @@
-// RUN: %clang_cc1 -no-opaque-pointers -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
+// RUN: %clang_cc1 -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
// CHECK-SANITIZE-ANYRECOVER: @[[CHAR:.*]] = {{.*}} c"'char **'\00" }
-// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 35 }, {{.*}}* @[[CHAR]] }
+// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 35 }, {{.*}} @[[CHAR]] }
void *caller(char **x) {
- // CHECK: define{{.*}} i8* @{{.*}}(i8** noundef %[[X:.*]])
+ // CHECK: define{{.*}} ptr @{{.*}}(ptr noundef %[[X:.*]])
// CHECK-NEXT: entry:
- // CHECK-NEXT: %[[X_ADDR:.*]] = alloca i8**, align 8
- // CHECK-NEXT: store i8** %[[X]], i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: %[[X_RELOADED:.*]] = load i8**, i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: %[[BITCAST:.*]] = bitcast i8** %[[X_RELOADED]] to i8*
- // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint i8* %[[BITCAST]] to i64
+ // CHECK-NEXT: %[[X_ADDR:.*]] = alloca ptr, align 8
+ // CHECK-NEXT: store ptr %[[X]], ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: %[[X_RELOADED:.*]] = load ptr, ptr %[[X_ADDR]], align 8
+ // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint ptr %[[X_RELOADED]] to i64
// CHECK-SANITIZE-NEXT: %[[OFFSETPTR:.*]] = sub i64 %[[PTRINT]], 42
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[OFFSETPTR]], 4294967295
// CHECK-SANITIZE-NEXT: %[[MASKCOND:.*]] = icmp eq i64 %[[MASKEDPTR]], 0
- // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint i8* %[[BITCAST]] to i64, !nosanitize
+ // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint ptr %[[X_RELOADED]] to i64, !nosanitize
// CHECK-SANITIZE-NEXT: br i1 %[[MASKCOND]], label %[[CONT:.*]], label %[[HANDLER_ALIGNMENT_ASSUMPTION:[^,]+]],{{.*}} !nosanitize
// CHECK-SANITIZE: [[HANDLER_ALIGNMENT_ASSUMPTION]]:
- // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 4294967296, i64 42){{.*}}, !nosanitize
- // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 4294967296, i64 42){{.*}}, !nosanitize
+ // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 4294967296, i64 42){{.*}}, !nosanitize
+ // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 4294967296, i64 42){{.*}}, !nosanitize
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23){{.*}}, !nosanitize
// CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
// CHECK-SANITIZE: [[CONT]]:
- // CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* %[[BITCAST]], i64 4294967296, i64 42) ]
- // CHECK-NEXT: ret i8* %[[BITCAST]]
+ // CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr %[[X_RELOADED]], i64 4294967296, i64 42) ]
+ // CHECK-NEXT: ret ptr %[[X_RELOADED]]
// CHECK-NEXT: }
#line 100
return __builtin_assume_aligned(x, 0x100000000, 42);
diff --git a/clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-two-params.cpp b/clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-two-params.cpp
index 22c7e9aab867..7022653d06cb 100644
--- a/clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-two-params.cpp
+++ b/clang/test/CodeGen/catch-alignment-assumption-builtin_assume_aligned-two-params.cpp
@@ -1,31 +1,30 @@
-// RUN: %clang_cc1 -no-opaque-pointers -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
-// RUN: %clang_cc1 -no-opaque-pointers -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
+// RUN: %clang_cc1 -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
+// RUN: %clang_cc1 -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
// CHECK-SANITIZE-ANYRECOVER: @[[CHAR:.*]] = {{.*}} c"'char **'\00" }
-// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 35 }, {{.*}}* @[[CHAR]] }
+// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 35 }, {{.*}} @[[CHAR]] }
void *caller(char **x) {
- // CHECK: define{{.*}} i8* @{{.*}}(i8** noundef %[[X:.*]])
+ // CHECK: define{{.*}} ptr @{{.*}}(ptr noundef %[[X:.*]])
// CHECK-NEXT: entry:
- // CHECK-NEXT: %[[X_ADDR:.*]] = alloca i8**, align 8
- // CHECK-NEXT: store i8** %[[X]], i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: %[[X_RELOADED:.*]] = load i8**, i8*** %[[X_ADDR]], align 8
- // CHECK-NEXT: %[[BITCAST:.*]] = bitcast i8** %[[X_RELOADED]] to i8*
- // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint i8* %[[BITCAST]] to i64
+ // CHECK-NEXT: %[[X_ADDR:.*]] = alloca ptr, align 8
+ // CHECK-NEXT: store ptr %[[X]], ptr %[[X_ADDR]], align 8
+ // CHECK-NEXT: %[[X_RELOADED:.*]] = load ptr, ptr %[[X_ADDR]], align 8
+ // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint ptr %[[X_RELOADED]] to i64
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[PTRINT]], 4294967295
// CHECK-SANITIZE-NEXT: %[[MASKCOND:.*]] = icmp eq i64 %[[MASKEDPTR]], 0
- // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint i8* %[[BITCAST]] to i64, !nosanitize
+ // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint ptr %[[X_RELOADED]] to i64, !nosanitize
// CHECK-SANITIZE-NEXT: br i1 %[[MASKCOND]], label %[[CONT:.*]], label %[[HANDLER_ALIGNMENT_ASSUMPTION:[^,]+]],{{.*}} !nosanitize
// CHECK-SANITIZE: [[HANDLER_ALIGNMENT_ASSUMPTION]]:
- // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 4294967296, i64 0){{.*}}, !nosanitize
- // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 4294967296, i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 4294967296, i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 4294967296, i64 0){{.*}}, !nosanitize
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23){{.*}}, !nosanitize
// CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
// CHECK-SANITIZE: [[CONT]]:
- // CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* %[[BITCAST]], i64 4294967296) ]
- // CHECK-NEXT: ret i8* %[[BITCAST]]
+ // CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr %[[X_RELOADED]], i64 4294967296) ]
+ // CHECK-NEXT: ret ptr %[[X_RELOADED]]
// CHECK-NEXT: }
#line 100
return __builtin_assume_aligned(x, 0x100000000);
diff --git a/clang/test/CodeGen/catch-alignment-assumption-openmp.cpp b/clang/test/CodeGen/catch-alignment-assumption-openmp.cpp
index 47e2f33c1100..30ebeee2c18d 100644
--- a/clang/test/CodeGen/catch-alignment-assumption-openmp.cpp
+++ b/clang/test/CodeGen/catch-alignment-assumption-openmp.cpp
@@ -1,29 +1,29 @@
-// RUN: %clang_cc1 -no-opaque-pointers -fopenmp-simd -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
-// RUN: %clang_cc1 -no-opaque-pointers -fopenmp-simd -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
-// RUN: %clang_cc1 -no-opaque-pointers -fopenmp-simd -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
-// RUN: %clang_cc1 -no-opaque-pointers -fopenmp-simd -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -fopenmp-simd -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
+// RUN: %clang_cc1 -fopenmp-simd -fsanitize=alignment -fno-sanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-NORECOVER,CHECK-SANITIZE-UNREACHABLE
+// RUN: %clang_cc1 -fopenmp-simd -fsanitize=alignment -fsanitize-recover=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-ANYRECOVER,CHECK-SANITIZE-RECOVER
+// RUN: %clang_cc1 -fopenmp-simd -fsanitize=alignment -fsanitize-trap=alignment -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s -implicit-check-not="call void @__ubsan_handle_alignment_assumption" --check-prefixes=CHECK,CHECK-SANITIZE,CHECK-SANITIZE-TRAP,CHECK-SANITIZE-UNREACHABLE
// CHECK-SANITIZE-ANYRECOVER: @[[CHAR:.*]] = {{.*}} c"'char *'\00" }
-// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 30 }, {{.*}}* @[[CHAR]] }
+// CHECK-SANITIZE-ANYRECOVER: @[[LINE_100_ALIGNMENT_ASSUMPTION:.*]] = {{.*}}, i32 100, i32 30 }, {{.*}} @[[CHAR]] }
void func(char *data) {
- // CHECK: define{{.*}} void @{{.*}}(i8* noundef %[[DATA:.*]])
+ // CHECK: define{{.*}} void @{{.*}}(ptr noundef %[[DATA:.*]])
// CHECK-NEXT: [[ENTRY:.*]]:
- // CHECK-NEXT: %[[DATA_ADDR:.*]] = alloca i8*, align 8
- // CHECK: store i8* %[[DATA]], i8** %[[DATA_ADDR]], align 8
- // CHECK: %[[DATA_RELOADED:.*]] = load i8*, i8** %[[DATA_ADDR]], align 8
- // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint i8* %[[DATA_RELOADED]] to i64
+ // CHECK-NEXT: %[[DATA_ADDR:.*]] = alloca ptr, align 8
+ // CHECK: store ptr %[[DATA]], ptr %[[DATA_ADDR]], align 8
+ // CHECK: %[[DATA_RELOADED:.*]] = load ptr, ptr %[[DATA_ADDR]], align 8
+ // CHECK-SANITIZE-NEXT: %[[PTRINT:.*]] = ptrtoint ptr %[[DATA_RELOADED]] to i64
// CHECK-SANITIZE-NEXT: %[[MASKEDPTR:.*]] = and i64 %[[PTRINT]], 4294967295
// CHECK-SANITIZE-NEXT: %[[MASKCOND:.*]] = icmp eq i64 %[[MASKEDPTR]], 0
- // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint i8* %[[DATA_RELOADED]] to i64, !nosanitize
+ // CHECK-SANITIZE-NEXT: %[[PTRINT_DUP:.*]] = ptrtoint ptr %[[DATA_RELOADED]] to i64, !nosanitize
// CHECK-SANITIZE-NEXT: br i1 %[[MASKCOND]], label %[[CONT:.*]], label %[[HANDLER_ALIGNMENT_ASSUMPTION:[^,]+]],{{.*}} !nosanitize
// CHECK-SANITIZE: [[HANDLER_ALIGNMENT_ASSUMPTION]]:
- // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 4294967296, i64 0){{.*}}, !nosanitize
- // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(i8* bitcast ({ {{{.*}}}, {{{.*}}}, {{{.*}}}* }* @[[LINE_100_ALIGNMENT_ASSUMPTION]] to i8*), i64 %[[PTRINT_DUP]], i64 4294967296, i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-NORECOVER-NEXT: call void @__ubsan_handle_alignment_assumption_abort(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 4294967296, i64 0){{.*}}, !nosanitize
+ // CHECK-SANITIZE-RECOVER-NEXT: call void @__ubsan_handle_alignment_assumption(ptr @[[LINE_100_ALIGNMENT_ASSUMPTION]], i64 %[[PTRINT_DUP]], i64 4294967296, i64 0){{.*}}, !nosanitize
// CHECK-SANITIZE-TRAP-NEXT: call void @llvm.ubsantrap(i8 23){{.*}}, !nosanitize
// CHECK-SANITIZE-UNREACHABLE-NEXT: unreachable, !nosanitize
// CHECK-SANITIZE: [[CONT]]:
- // CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* %[[DATA_RELOADED]], i64 4294967296) ]
+ // CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr %[[DATA_RELOADED]], i64 4294967296) ]
#line 100
#pragma omp for simd aligned(data : 0x100000000)
diff --git a/clang/test/OpenMP/nvptx_lambda_pointer_capturing.cpp b/clang/test/OpenMP/nvptx_lambda_pointer_capturing.cpp
index 0d8a614d2d4a..ce9a311be58e 100644
--- a/clang/test/OpenMP/nvptx_lambda_pointer_capturing.cpp
+++ b/clang/test/OpenMP/nvptx_lambda_pointer_capturing.cpp
@@ -1,16 +1,16 @@
// Test host codegen only.
-// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-64
-// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -o %t %s
-// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-64
-// RUN: %clang_cc1 -no-opaque-pointers -verify -fopenmp -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-32
-// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -o %t %s
-// RUN: %clang_cc1 -no-opaque-pointers -fopenmp -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-32
+// RUN: %clang_cc1 -verify -fopenmp -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-64
+// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -o %t %s
+// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-64
+// RUN: %clang_cc1 -verify -fopenmp -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-32
+// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -o %t %s
+// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-32
// expected-no-diagnostics
#ifndef HEADER
#define HEADER
-// CHECK: [[ANON_T:%.+]] = type { i32*, i32* }
+// CHECK: [[ANON_T:%.+]] = type { ptr, ptr }
// CHECK-DAG: [[SIZES_TEMPLATE:@.+]] = private {{.+}} constant [5 x i[[PTRSZ:32|64]]] [i{{32|64}} 4, i{{32|64}} 4, i{{32|64}} {{8|16}}, i{{32|64}} 0, i{{32|64}} 0]
// CHECK-DAG: [[TYPES_TEMPLATE:@.+]] = private {{.+}} constant [5 x i64] [i64 800, i64 800, i64 673, i64 844424930132752, i64 844424930132752]
// CHECK-DAG: [[SIZES:@.+]] = private {{.+}} constant [3 x i[[PTRSZ:32|64]]] [i{{32|64}} {{8|16}}, i{{32|64}} 0, i{{32|64}} 0]
@@ -71,115 +71,103 @@ int main()
body(i);
}
-// CHECK: [[BASE_PTRS:%.+]] = alloca [3 x i8*]{{.+}}
-// CHECK: [[PTRS:%.+]] = alloca [3 x i8*]{{.+}}
+// CHECK: [[BASE_PTRS:%.+]] = alloca [3 x ptr]{{.+}}
+// CHECK: [[PTRS:%.+]] = alloca [3 x ptr]{{.+}}
// First gep of pointers inside lambdas to store the values across function call need to be ignored
-// CHECK: {{%.+}} = getelementptr inbounds [[ANON_T]], [[ANON_T]]* %{{.+}}, i{{.+}} 0, i{{.+}} 0
-// CHECK: {{%.+}} = getelementptr inbounds [[ANON_T]], [[ANON_T]]* %{{.+}}, i{{.+}} 0, i{{.+}} 1
+// CHECK: {{%.+}} = getelementptr inbounds [[ANON_T]], ptr %{{.+}}, i{{.+}} 0, i{{.+}} 0
+// CHECK: {{%.+}} = getelementptr inbounds [[ANON_T]], ptr %{{.+}}, i{{.+}} 0, i{{.+}} 1
// access of pointers inside lambdas
-// CHECK: [[BASE_PTR1:%.+]] = getelementptr inbounds [[ANON_T]], [[ANON_T]]* %{{.+}}, i{{.+}} 0, i{{.+}} 0
-// CHECK: [[PTR1:%.+]] = load i32*, i32** [[BASE_PTR1]]
-// CHECK: [[BASE_PTR2:%.+]] = getelementptr inbounds [[ANON_T]], [[ANON_T]]* %{{.+}}, i{{.+}} 0, i{{.+}} 1
-// CHECK: [[PTR2:%.+]] = load i32*, i32** [[BASE_PTR2]]
+// CHECK: [[BASE_PTR1:%.+]] = getelementptr inbounds [[ANON_T]], ptr %{{.+}}, i{{.+}} 0, i{{.+}} 0
+// CHECK: [[PTR1:%.+]] = load ptr, ptr [[BASE_PTR1]]
+// CHECK: [[BASE_PTR2:%.+]] = getelementptr inbounds [[ANON_T]], ptr %{{.+}}, i{{.+}} 0, i{{.+}} 1
+// CHECK: [[PTR2:%.+]] = load ptr, ptr [[BASE_PTR2]]
// storage of pointers in baseptrs and ptrs arrays
-// CHECK: [[LOC_LAMBDA:%.+]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[BASE_PTRS]], i{{.+}} 0, i{{.+}} 0
-// CHECK: [[CAST_LAMBDA:%.+]] = bitcast i8** [[LOC_LAMBDA]] to [[ANON_T]]**
-// CHECK: store [[ANON_T]]* %{{.+}}, [[ANON_T]]** [[CAST_LAMBDA]]{{.+}}
-// CHECK: [[LOC_LAMBDA:%.+]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[PTRS]], i{{.+}} 0, i{{.+}} 0
-// CHECK: [[CAST_LAMBDA:%.+]] = bitcast i8** [[LOC_LAMBDA]] to [[ANON_T]]**
-// CHECK: store [[ANON_T]]* %{{.+}}, [[ANON_T]]** [[CAST_LAMBDA]]{{.+}}
-
-// CHECK: [[LOC_PTR1:%.+]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[BASE_PTRS]], i{{.+}} 0, i{{.+}} 1
-// CHECK: [[CAST_PTR1:%.+]] = bitcast i8** [[LOC_PTR1]] to i32***
-// CHECK: store i32** [[BASE_PTR1]], i32*** [[CAST_PTR1]]{{.+}}
-// CHECK: [[LOC_PTR1:%.+]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[PTRS]], i{{.+}} 0, i{{.+}} 1
-// CHECK: [[CAST_PTR1:%.+]] = bitcast i8** [[LOC_PTR1]] to i32**
-// CHECK: store i32* [[PTR1]], i32** [[CAST_PTR1]]{{.+}}
-
-
-// CHECK: [[LOC_PTR2:%.+]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[BASE_PTRS]], i{{.+}} 0, i{{.+}} 2
-// CHECK: [[CAST_PTR2:%.+]] = bitcast i8** [[LOC_PTR2]] to i32***
-// CHECK: store i32** [[BASE_PTR2]], i32*** [[CAST_PTR2]]{{.+}}
-// CHECK: [[LOC_PTR2:%.+]] = getelementptr inbounds [3 x i8*], [3 x i8*]* [[PTRS]], i{{.+}} 0, i{{.+}} 2
-// CHECK: [[CAST_PTR2:%.+]] = bitcast i8** [[LOC_PTR2]] to i32**
-// CHECK: store i32* [[PTR2]], i32** [[CAST_PTR2]]{{.+}}
+// CHECK: [[LOC_LAMBDA:%.+]] = getelementptr inbounds [3 x ptr], ptr [[BASE_PTRS]], i{{.+}} 0, i{{.+}} 0
+// CHECK: store ptr %{{.+}}, ptr [[LOC_LAMBDA]]{{.+}}
+// CHECK: [[LOC_LAMBDA:%.+]] = getelementptr inbounds [3 x ptr], ptr [[PTRS]], i{{.+}} 0, i{{.+}} 0
+// CHECK: store ptr %{{.+}}, ptr [[LOC_LAMBDA]]{{.+}}
+
+// CHECK: [[LOC_PTR1:%.+]] = getelementptr inbounds [3 x ptr], ptr [[BASE_PTRS]], i{{.+}} 0, i{{.+}} 1
+// CHECK: store ptr [[BASE_PTR1]], ptr [[LOC_PTR1]]{{.+}}
+// CHECK: [[LOC_PTR1:%.+]] = getelementptr inbounds [3 x ptr], ptr [[PTRS]], i{{.+}} 0, i{{.+}} 1
+// CHECK: store ptr [[PTR1]], ptr [[LOC_PTR1]]{{.+}}
+
+
+// CHECK: [[LOC_PTR2:%.+]] = getelementptr inbounds [3 x ptr], ptr [[BASE_PTRS]], i{{.+}} 0, i{{.+}} 2
+// CHECK: store ptr [[BASE_PTR2]], ptr [[LOC_PTR2]]{{.+}}
+// CHECK: [[LOC_PTR2:%.+]] = getelementptr inbounds [3 x ptr], ptr [[PTRS]], i{{.+}} 0, i{{.+}} 2
+// CHECK: store ptr [[PTR2]], ptr [[LOC_PTR2]]{{.+}}
// actual target invocation
- // CHECK: [[BASES_GEP:%.+]] = getelementptr {{.+}} [3 x {{.+}}*], [3 x {{.+}}*]* [[BASE_PTRS]], {{.+}} 0, {{.+}} 0
- // CHECK: [[PTRS_GEP:%.+]] = getelementptr {{.+}} [3 x {{.+}}*], [3 x {{.+}}*]* [[PTRS]], {{.+}} 0, {{.+}} 0
- // CHECK: {{%.+}} = call i32 @__tgt_target_kernel(%struct.ident_t* @{{.+}}, i64 -1, i32 0, i32 0, i8* @.{{.+}}.region_id, %struct.__tgt_kernel_arguments* %{{.+}})
+ // CHECK: [[BASES_GEP:%.+]] = getelementptr {{.+}} [3 x ptr], ptr [[BASE_PTRS]], {{.+}} 0, {{.+}} 0
+ // CHECK: [[PTRS_GEP:%.+]] = getelementptr {{.+}} [3 x ptr], ptr [[PTRS]], {{.+}} 0, {{.+}} 0
+ // CHECK: {{%.+}} = call i32 @__tgt_target_kernel(ptr @{{.+}}, i64 -1, i32 0, i32 0, ptr @.{{.+}}.region_id, ptr %{{.+}})
omp_loop(0,100,body);
omp_loop_ref(0,100,body);
}
-// CHECK: [[BASE_PTRS:%.+]] = alloca [5 x i8*]{{.+}}
-// CHECK: [[PTRS:%.+]] = alloca [5 x i8*]{{.+}}
+// CHECK: [[BASE_PTRS:%.+]] = alloca [5 x ptr]{{.+}}
+// CHECK: [[PTRS:%.+]] = alloca [5 x ptr]{{.+}}
// access of pointers inside lambdas
-// CHECK: [[BASE_PTR1:%.+]] = getelementptr inbounds [[ANON_T]], [[ANON_T]]* %{{.+}}, i{{.+}} 0, i{{.+}} 0
-// CHECK: [[PTR1:%.+]] = load i32*, i32** [[BASE_PTR1]]
-// CHECK: [[BASE_PTR2:%.+]] = getelementptr inbounds [[ANON_T]], [[ANON_T]]* %{{.+}}, i{{.+}} 0, i{{.+}} 1
-// CHECK: [[PTR2:%.+]] = load i32*, i32** [[BASE_PTR2]]
+// CHECK: [[BASE_PTR1:%.+]] = getelementptr inbounds [[ANON_T]], ptr %{{.+}}, i{{.+}} 0, i{{.+}} 0
+// CHECK: [[PTR1:%.+]] = load ptr, ptr [[BASE_PTR1]]
+// CHECK: [[BASE_PTR2:%.+]] = getelementptr inbounds [[ANON_T]], ptr %{{.+}}, i{{.+}} 0, i{{.+}} 1
+// CHECK: [[PTR2:%.+]] = load ptr, ptr [[BASE_PTR2]]
// storage of pointers in baseptrs and ptrs arrays
-// CHECK: [[LOC_LAMBDA:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[BASE_PTRS]], i{{.+}} 0, i{{.+}} 2
-// CHECK: [[CAST_LAMBDA:%.+]] = bitcast i8** [[LOC_LAMBDA]] to [[ANON_T]]**
-// CHECK: store [[ANON_T]]* %{{.+}}, [[ANON_T]]** [[CAST_LAMBDA]]{{.+}}
-// CHECK: [[LOC_LAMBDA:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[PTRS]], i{{.+}} 0, i{{.+}} 2
-// CHECK: [[CAST_LAMBDA:%.+]] = bitcast i8** [[LOC_LAMBDA]] to [[ANON_T]]**
-// CHECK: store [[ANON_T]]* %{{.+}}, [[ANON_T]]** [[CAST_LAMBDA]]{{.+}}
-
-// CHECK: [[LOC_PTR1:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[BASE_PTRS]], i{{.+}} 0, i{{.+}} 3
-// CHECK: [[CAST_PTR1:%.+]] = bitcast i8** [[LOC_PTR1]] to i32***
-// CHECK: store i32** [[BASE_PTR1]], i32*** [[CAST_PTR1]]{{.+}}
-// CHECK: [[LOC_PTR1:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[PTRS]], i{{.+}} 0, i{{.+}} 3
-// CHECK: [[CAST_PTR1:%.+]] = bitcast i8** [[LOC_PTR1]] to i32**
-// CHECK: store i32* [[PTR1]], i32** [[CAST_PTR1]]{{.+}}
-
-
-// CHECK: [[LOC_PTR2:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[BASE_PTRS]], i{{.+}} 0, i{{.+}} 4
-// CHECK: [[CAST_PTR2:%.+]] = bitcast i8** [[LOC_PTR2]] to i32***
-// CHECK: store i32** [[BASE_PTR2]], i32*** [[CAST_PTR2]]{{.+}}
-// CHECK: [[LOC_PTR2:%.+]] = getelementptr inbounds [5 x i8*], [5 x i8*]* [[PTRS]], i{{.+}} 0, i{{.+}} 4
-// CHECK: [[CAST_PTR2:%.+]] = bitcast i8** [[LOC_PTR2]] to i32**
-// CHECK: store i32* [[PTR2]], i32** [[CAST_PTR2]]{{.+}}
+// CHECK: [[LOC_LAMBDA:%.+]] = getelementptr inbounds [5 x ptr], ptr [[BASE_PTRS]], i{{.+}} 0, i{{.+}} 2
+// CHECK: store ptr %{{.+}}, ptr [[LOC_LAMBDA]]{{.+}}
+// CHECK: [[LOC_LAMBDA:%.+]] = getelementptr inbounds [5 x ptr], ptr [[PTRS]], i{{.+}} 0, i{{.+}} 2
+// CHECK: store ptr %{{.+}}, ptr [[LOC_LAMBDA]]{{.+}}
+
+// CHECK: [[LOC_PTR1:%.+]] = getelementptr inbounds [5 x ptr], ptr [[BASE_PTRS]], i{{.+}} 0, i{{.+}} 3
+// CHECK: store ptr [[BASE_PTR1]], ptr [[LOC_PTR1]]{{.+}}
+// CHECK: [[LOC_PTR1:%.+]] = getelementptr inbounds [5 x ptr], ptr [[PTRS]], i{{.+}} 0, i{{.+}} 3
+// CHECK: store ptr [[PTR1]], ptr [[LOC_PTR1]]{{.+}}
+
+
+// CHECK: [[LOC_PTR2:%.+]] = getelementptr inbounds [5 x ptr], ptr [[BASE_PTRS]], i{{.+}} 0, i{{.+}} 4
+// CHECK: store ptr [[BASE_PTR2]], ptr [[LOC_PTR2]]{{.+}}
+// CHECK: [[LOC_PTR2:%.+]] = getelementptr inbounds [5 x ptr], ptr [[PTRS]], i{{.+}} 0, i{{.+}} 4
+// CHECK: store ptr [[PTR2]], ptr [[LOC_PTR2]]{{.+}}
// actual target invocation
-// CHECK: [[BASES_GEP:%.+]] = getelementptr {{.+}} [5 x {{.+}}*], [5 x {{.+}}*]* [[BASE_PTRS]], {{.+}} 0, {{.+}} 0
-// CHECK: [[PTRS_GEP:%.+]] = getelementptr {{.+}} [5 x {{.+}}*], [5 x {{.+}}*]* [[PTRS]], {{.+}} 0, {{.+}} 0
+// CHECK: [[BASES_GEP:%.+]] = getelementptr {{.+}} [5 x ptr], ptr [[BASE_PTRS]], {{.+}} 0, {{.+}} 0
+// CHECK: [[PTRS_GEP:%.+]] = getelementptr {{.+}} [5 x ptr], ptr [[PTRS]], {{.+}} 0, {{.+}} 0
// CHECK: define internal void @{{.+}}omp_loop_ref{{.+}}(
-// CHECK: [[BODY:%body.addr]] = alloca %class.anon*
-// CHECK: [[TMP:%tmp]] = alloca %class.anon*
-// CHECK: [[BODY_REF:%body_ref]] = alloca %class.anon.1*
+// CHECK: [[BODY:%body.addr]] = alloca ptr
+// CHECK: [[TMP:%tmp]] = alloca ptr
+// CHECK: [[BODY_REF:%body_ref]] = alloca ptr
// CHECK: [[REF_TMP:%ref.tmp]] = alloca %class.anon.1
-// CHECK: [[TMP8:%tmp.+]] = alloca %class.anon.1*
-// CHECK: [[L0:%.+]] = load %class.anon*, %class.anon** [[BODY]]
-// CHECK: store %class.anon* [[L0]], %class.anon** [[TMP]]
-// CHECK: [[L5:%.+]] = load %class.anon*, %class.anon** [[TMP]]
-// CHECK-NOT [[L6:%.+]] = load %class.anon*, %class.anon** [[TMP]]
-// CHECK-NOT [[L7:%.+]] = load %class.anon*, %class.anon** [[TMP]]
-// CHECK: store %class.anon.1* [[REF_TMP]], %class.anon.1** [[BODY_REF]]
-// CHECK:[[L47:%.+]] = load %class.anon.1*, %class.anon.1** [[BODY_REF]]
-// CHECK: store %class.anon.1* [[L47]], %class.anon.1** [[TMP8]]
-// CHECK: [[L48:%.+]] = load %class.anon.1*, %class.anon.1** [[TMP8]]
-// CHECK-NOT: [[L49:%.+]] = load %class.anon.1*, %class.anon.1** [[TMP8]]
-// CHECK-NOT: [[L50:%.+]] = load %class.anon.1*, %class.anon.1** [[TMP8]]
+// CHECK: [[TMP8:%tmp.+]] = alloca ptr
+// CHECK: [[L0:%.+]] = load ptr, ptr [[BODY]]
+// CHECK: store ptr [[L0]], ptr [[TMP]]
+// CHECK: [[L5:%.+]] = load ptr, ptr [[TMP]]
+// CHECK-NOT [[L6:%.+]] = load ptr, ptr [[TMP]]
+// CHECK-NOT [[L7:%.+]] = load ptr, ptr [[TMP]]
+// CHECK: store ptr [[REF_TMP]], ptr [[BODY_REF]]
+// CHECK:[[L47:%.+]] = load ptr, ptr [[BODY_REF]]
+// CHECK: store ptr [[L47]], ptr [[TMP8]]
+// CHECK: [[L48:%.+]] = load ptr, ptr [[TMP8]]
+// CHECK-NOT: [[L49:%.+]] = load ptr, ptr [[TMP8]]
+// CHECK-NOT: [[L50:%.+]] = load ptr, ptr [[TMP8]]
// CHECK: ret void
// CHECK: define internal void @{{.+}}xoo{{.+}}(
-// CHECK: [[FADDR:%f.addr]] = alloca %class.anon.0*
-// CHECK: [[L0:%.+]] = load %class.anon.0*, %class.anon.0** [[FADDR]]
-// CHECK: store %class.anon.0* [[L0]], %class.anon.0** [[TMP:%tmp]]
-// CHECK: [[L1:%.+]] = load %class.anon.0*, %class.anon.0** [[TMP]]
-// CHECK-NOT: %4 = load %class.anon.0*, %class.anon.0** [[TMP]]
-// CHECK-NOT: %5 = load %class.anon.0*, %class.anon.0** [[TMP]]
-// CHECK: [[L4:%.+]] = getelementptr inbounds %class.anon.0, %class.anon.0* [[L1]], i32 0, i32 0
-// CHECK: [[L5:%.+]] = load i{{.*}}*, i{{.*}}** [[L4]]
+// CHECK: [[FADDR:%f.addr]] = alloca ptr
+// CHECK: [[L0:%.+]] = load ptr, ptr [[FADDR]]
+// CHECK: store ptr [[L0]], ptr [[TMP:%tmp]]
+// CHECK: [[L1:%.+]] = load ptr, ptr [[TMP]]
+// CHECK-NOT: %4 = load ptr, ptr [[TMP]]
+// CHECK-NOT: %5 = load ptr, ptr [[TMP]]
+// CHECK: [[L4:%.+]] = getelementptr inbounds %class.anon.0, ptr [[L1]], i32 0, i32 0
+// CHECK: [[L5:%.+]] = load ptr, ptr [[L4]]
// CHECK: ret void
#endif
More information about the cfe-commits
mailing list