mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-27 08:56:07 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/clang/test/CodeGen/tbaa-pointers.c

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

260 lines
14 KiB
C
Raw Normal View History

[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// RUN: %clang_cc1 -triple x86_64-apple-darwin -O1 -disable-llvm-passes -no-pointer-tbaa %s -emit-llvm -o - | FileCheck --check-prefixes=COMMON,DISABLE %s
Recommit "[TBAA] Emit distinct TBAA tags for pointers with different depths,types. (#76612)" This reverts the revert commit bee240367cc48bbc93fe5eb57d537968dfe4419f. This version includes updates to the tests to use patterns when matching the pointer argument. Original commit message: This patch extends Clang's TBAA generation code to emit distinct tags for incompatible pointer types. Pointers with different element types are incompatible if the pointee types are also incompatible (modulo sugar/modifiers). Express this in TBAA by generating different tags for pointers based on the pointer depth and pointee type. To get the TBAA tag for the pointee type it uses getTypeInfoHelper on the pointee type. (Moved from https://reviews.llvm.org/D122573) PR: https://github.com/llvm/llvm-project/pull/76612
2024-07-19 13:03:21 +01:00
// RUN: %clang_cc1 -triple x86_64-apple-darwin -O1 -disable-llvm-passes %s -emit-llvm -o - | FileCheck --check-prefixes=COMMON,DEFAULT %s
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// RUN: %clang --target=x86_64-apple-darwin -O1 -fno-pointer-tbaa %s -emit-llvm -S -mllvm -disable-llvm-optzns -o - | FileCheck --check-prefixes=COMMON,DISABLE %s
Recommit "[TBAA] Emit distinct TBAA tags for pointers with different depths,types. (#76612)" This reverts the revert commit bee240367cc48bbc93fe5eb57d537968dfe4419f. This version includes updates to the tests to use patterns when matching the pointer argument. Original commit message: This patch extends Clang's TBAA generation code to emit distinct tags for incompatible pointer types. Pointers with different element types are incompatible if the pointee types are also incompatible (modulo sugar/modifiers). Express this in TBAA by generating different tags for pointers based on the pointer depth and pointee type. To get the TBAA tag for the pointee type it uses getTypeInfoHelper on the pointee type. (Moved from https://reviews.llvm.org/D122573) PR: https://github.com/llvm/llvm-project/pull/76612
2024-07-19 13:03:21 +01:00
// RUN: %clang --target=x86_64-apple-darwin -O1 %s -emit-llvm -S -mllvm -disable-llvm-optzns -o - | FileCheck --check-prefixes=COMMON,DEFAULT %s
[Clang,TBAA] Add test cases for nested pointers and TBAA data.
2022-03-27 19:59:37 +01:00
void p2unsigned(unsigned **ptr) {
Recommit "[TBAA] Emit distinct TBAA tags for pointers with different depths,types. (#76612)" This reverts the revert commit bee240367cc48bbc93fe5eb57d537968dfe4419f. This version includes updates to the tests to use patterns when matching the pointer argument. Original commit message: This patch extends Clang's TBAA generation code to emit distinct tags for incompatible pointer types. Pointers with different element types are incompatible if the pointee types are also incompatible (modulo sugar/modifiers). Express this in TBAA by generating different tags for pointers based on the pointer depth and pointee type. To get the TBAA tag for the pointee type it uses getTypeInfoHelper on the pointee type. (Moved from https://reviews.llvm.org/D122573) PR: https://github.com/llvm/llvm-project/pull/76612
2024-07-19 13:03:21 +01:00
// COMMON-LABEL: define void @p2unsigned(
// COMMON-SAME: ptr noundef [[PTR:%.+]])
[TBAA] Remove references to entry BB in check lines for tbaa-pointers.c Follow-up to 123c036bd361d to remove references to entry BB name from checks, to fix tests for builds that do not generate block names.
2024-07-19 14:51:27 +01:00
// COMMON: [[PTR_ADDR:%.+]] = alloca ptr, align 8
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[P2INT_0:!.+]]
// DEFAULT-NEXT: [[BASE:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[P2INT_0]]
// DEFAULT-NEXT: store ptr null, ptr [[BASE]], align 8, !tbaa [[P1INT_0:!.+]]
// DISABLE-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR:!.+]]
// DISABLE-NEXT: [[BASE:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: store ptr null, ptr [[BASE]], align 8, !tbaa [[ANYPTR]]
[TBAA] Remove references to entry BB in check lines for tbaa-pointers.c Follow-up to 123c036bd361d to remove references to entry BB name from checks, to fix tests for builds that do not generate block names.
2024-07-19 14:51:27 +01:00
// COMMON-NEXT: ret void
[Clang,TBAA] Add test cases for nested pointers and TBAA data.
2022-03-27 19:59:37 +01:00
//
*ptr = 0;
}
void p2unsigned_volatile(unsigned *volatile *ptr) {
Recommit "[TBAA] Emit distinct TBAA tags for pointers with different depths,types. (#76612)" This reverts the revert commit bee240367cc48bbc93fe5eb57d537968dfe4419f. This version includes updates to the tests to use patterns when matching the pointer argument. Original commit message: This patch extends Clang's TBAA generation code to emit distinct tags for incompatible pointer types. Pointers with different element types are incompatible if the pointee types are also incompatible (modulo sugar/modifiers). Express this in TBAA by generating different tags for pointers based on the pointer depth and pointee type. To get the TBAA tag for the pointee type it uses getTypeInfoHelper on the pointee type. (Moved from https://reviews.llvm.org/D122573) PR: https://github.com/llvm/llvm-project/pull/76612
2024-07-19 13:03:21 +01:00
// COMMON-LABEL: define void @p2unsigned_volatile(
// COMMON-SAME: ptr noundef [[PTR:%.+]])
[TBAA] Remove references to entry BB in check lines for tbaa-pointers.c Follow-up to 123c036bd361d to remove references to entry BB name from checks, to fix tests for builds that do not generate block names.
2024-07-19 14:51:27 +01:00
// COMMON: [[PTR_ADDR:%.+]] = alloca ptr, align 8
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[P2INT_0]]
// DEFAULT-NEXT: [[BASE:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[P2INT_0]]
// DEFAULT-NEXT: store volatile ptr null, ptr [[BASE]], align 8, !tbaa [[P1INT_0]]
// DISABLE-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: [[BASE:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: store volatile ptr null, ptr [[BASE]], align 8, !tbaa [[ANYPTR]]
[TBAA] Remove references to entry BB in check lines for tbaa-pointers.c Follow-up to 123c036bd361d to remove references to entry BB name from checks, to fix tests for builds that do not generate block names.
2024-07-19 14:51:27 +01:00
// COMMON-NEXT: ret void
[Clang,TBAA] Add test cases for nested pointers and TBAA data.
2022-03-27 19:59:37 +01:00
//
*ptr = 0;
}
void p3int(int ***ptr) {
Recommit "[TBAA] Emit distinct TBAA tags for pointers with different depths,types. (#76612)" This reverts the revert commit bee240367cc48bbc93fe5eb57d537968dfe4419f. This version includes updates to the tests to use patterns when matching the pointer argument. Original commit message: This patch extends Clang's TBAA generation code to emit distinct tags for incompatible pointer types. Pointers with different element types are incompatible if the pointee types are also incompatible (modulo sugar/modifiers). Express this in TBAA by generating different tags for pointers based on the pointer depth and pointee type. To get the TBAA tag for the pointee type it uses getTypeInfoHelper on the pointee type. (Moved from https://reviews.llvm.org/D122573) PR: https://github.com/llvm/llvm-project/pull/76612
2024-07-19 13:03:21 +01:00
// COMMON-LABEL: define void @p3int(
// COMMON-SAME: ptr noundef [[PTR:%.+]])
[TBAA] Remove references to entry BB in check lines for tbaa-pointers.c Follow-up to 123c036bd361d to remove references to entry BB name from checks, to fix tests for builds that do not generate block names.
2024-07-19 14:51:27 +01:00
// COMMON: [[PTR_ADDR:%.+]] = alloca ptr, align 8
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[P3INT_0:!.+]]
// DEFAULT-NEXT: [[BASE_0:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[P3INT_0]]
// DEFAULT-NEXT: [[BASE_1:%.+]] = load ptr, ptr [[BASE_0]], align 8, !tbaa [[P2INT_0]]
// DEFAULT-NEXT: store ptr null, ptr [[BASE_1]], align 8, !tbaa [[P1INT_0]]
// DISABLE-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: [[BASE_0:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: [[BASE_1:%.+]] = load ptr, ptr [[BASE_0]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: store ptr null, ptr [[BASE_1]], align 8, !tbaa [[ANYPTR]]
[TBAA] Remove references to entry BB in check lines for tbaa-pointers.c Follow-up to 123c036bd361d to remove references to entry BB name from checks, to fix tests for builds that do not generate block names.
2024-07-19 14:51:27 +01:00
// COMMON-NEXT: ret void
[Clang,TBAA] Add test cases for nested pointers and TBAA data.
2022-03-27 19:59:37 +01:00
//
**ptr = 0;
}
void p4char(char ****ptr) {
Recommit "[TBAA] Emit distinct TBAA tags for pointers with different depths,types. (#76612)" This reverts the revert commit bee240367cc48bbc93fe5eb57d537968dfe4419f. This version includes updates to the tests to use patterns when matching the pointer argument. Original commit message: This patch extends Clang's TBAA generation code to emit distinct tags for incompatible pointer types. Pointers with different element types are incompatible if the pointee types are also incompatible (modulo sugar/modifiers). Express this in TBAA by generating different tags for pointers based on the pointer depth and pointee type. To get the TBAA tag for the pointee type it uses getTypeInfoHelper on the pointee type. (Moved from https://reviews.llvm.org/D122573) PR: https://github.com/llvm/llvm-project/pull/76612
2024-07-19 13:03:21 +01:00
// COMMON-LABEL: define void @p4char(
// COMMON-SAME: ptr noundef [[PTR:%.+]])
[TBAA] Remove references to entry BB in check lines for tbaa-pointers.c Follow-up to 123c036bd361d to remove references to entry BB name from checks, to fix tests for builds that do not generate block names.
2024-07-19 14:51:27 +01:00
// COMMON: [[PTR_ADDR:%.+]] = alloca ptr, align 8
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[P4CHAR_0:!.+]]
// DEFAULT-NEXT: [[BASE_0:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[P4CHAR_0]]
// DEFAULT-NEXT: [[BASE_1:%.+]] = load ptr, ptr [[BASE_0]], align 8, !tbaa [[P3CHAR_0:!.+]]
// DEFAULT-NEXT: [[BASE_2:%.+]] = load ptr, ptr [[BASE_1]], align 8, !tbaa [[P2CHAR_0:!.+]]
// DEFAULT-NEXT: store ptr null, ptr [[BASE_2]], align 8, !tbaa [[P1CHAR_0:!.+]]
// DISABLE-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: [[BASE_0:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: [[BASE_1:%.+]] = load ptr, ptr [[BASE_0]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: [[BASE_2:%.+]] = load ptr, ptr [[BASE_1]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: store ptr null, ptr [[BASE_2]], align 8, !tbaa [[ANYPTR]]
[TBAA] Remove references to entry BB in check lines for tbaa-pointers.c Follow-up to 123c036bd361d to remove references to entry BB name from checks, to fix tests for builds that do not generate block names.
2024-07-19 14:51:27 +01:00
// COMMON-NEXT: ret void
[Clang,TBAA] Add test cases for nested pointers and TBAA data.
2022-03-27 19:59:37 +01:00
//
***ptr = 0;
}
void p4char_const1(const char ****ptr) {
Recommit "[TBAA] Emit distinct TBAA tags for pointers with different depths,types. (#76612)" This reverts the revert commit bee240367cc48bbc93fe5eb57d537968dfe4419f. This version includes updates to the tests to use patterns when matching the pointer argument. Original commit message: This patch extends Clang's TBAA generation code to emit distinct tags for incompatible pointer types. Pointers with different element types are incompatible if the pointee types are also incompatible (modulo sugar/modifiers). Express this in TBAA by generating different tags for pointers based on the pointer depth and pointee type. To get the TBAA tag for the pointee type it uses getTypeInfoHelper on the pointee type. (Moved from https://reviews.llvm.org/D122573) PR: https://github.com/llvm/llvm-project/pull/76612
2024-07-19 13:03:21 +01:00
// COMMON-LABEL: define void @p4char_const1(
// COMMON-SAME: ptr noundef [[PTR:%.+]])
[TBAA] Remove references to entry BB in check lines for tbaa-pointers.c Follow-up to 123c036bd361d to remove references to entry BB name from checks, to fix tests for builds that do not generate block names.
2024-07-19 14:51:27 +01:00
// COMMON: [[PTR_ADDR:%.+]] = alloca ptr, align 8
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[P4CHAR_0]]
// DEFAULT-NEXT: [[BASE_0:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[P4CHAR_0]]
// DEFAULT-NEXT: [[BASE_1:%.+]] = load ptr, ptr [[BASE_0]], align 8, !tbaa [[P3CHAR_0]]
// DEFAULT-NEXT: [[BASE_2:%.+]] = load ptr, ptr [[BASE_1]], align 8, !tbaa [[P2CHAR_0]]
// DEFAULT-NEXT: store ptr null, ptr [[BASE_2]], align 8, !tbaa [[P1CHAR_0]]
// DISABLE-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: [[BASE_0:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: [[BASE_1:%.+]] = load ptr, ptr [[BASE_0]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: [[BASE_2:%.+]] = load ptr, ptr [[BASE_1]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: store ptr null, ptr [[BASE_2]], align 8, !tbaa [[ANYPTR]]
Recommit "[TBAA] Emit distinct TBAA tags for pointers with different depths,types. (#76612)" This reverts the revert commit bee240367cc48bbc93fe5eb57d537968dfe4419f. This version includes updates to the tests to use patterns when matching the pointer argument. Original commit message: This patch extends Clang's TBAA generation code to emit distinct tags for incompatible pointer types. Pointers with different element types are incompatible if the pointee types are also incompatible (modulo sugar/modifiers). Express this in TBAA by generating different tags for pointers based on the pointer depth and pointee type. To get the TBAA tag for the pointee type it uses getTypeInfoHelper on the pointee type. (Moved from https://reviews.llvm.org/D122573) PR: https://github.com/llvm/llvm-project/pull/76612
2024-07-19 13:03:21 +01:00
// COMMON-NEXT: ret void
[Clang,TBAA] Add test cases for nested pointers and TBAA data.
2022-03-27 19:59:37 +01:00
//
***ptr = 0;
}
void p4char_const2(const char **const **ptr) {
Recommit "[TBAA] Emit distinct TBAA tags for pointers with different depths,types. (#76612)" This reverts the revert commit bee240367cc48bbc93fe5eb57d537968dfe4419f. This version includes updates to the tests to use patterns when matching the pointer argument. Original commit message: This patch extends Clang's TBAA generation code to emit distinct tags for incompatible pointer types. Pointers with different element types are incompatible if the pointee types are also incompatible (modulo sugar/modifiers). Express this in TBAA by generating different tags for pointers based on the pointer depth and pointee type. To get the TBAA tag for the pointee type it uses getTypeInfoHelper on the pointee type. (Moved from https://reviews.llvm.org/D122573) PR: https://github.com/llvm/llvm-project/pull/76612
2024-07-19 13:03:21 +01:00
// COMMON-LABEL: define void @p4char_const2(
// COMMON-SAME: ptr noundef [[PTR:%.+]])
[TBAA] Remove remaining entry BB in check lines for tbaa-pointers.c (2) Missed out of 47c08fb8d79ec.
2024-07-19 15:48:50 +01:00
// COMMON: [[PTR_ADDR:%.+]] = alloca ptr, align 8
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[P4CHAR_0]]
// DEFAULT-NEXT: [[BASE_0:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[P4CHAR_0]]
// DEFAULT-NEXT: [[BASE_1:%.+]] = load ptr, ptr [[BASE_0]], align 8, !tbaa [[P3CHAR_0]]
// DEFAULT-NEXT: [[BASE_2:%.+]] = load ptr, ptr [[BASE_1]], align 8, !tbaa [[P2CHAR_0]]
// DEFAULT-NEXT: store ptr null, ptr [[BASE_2]], align 8, !tbaa [[P1CHAR_0]]
// DISABLE-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: [[BASE_0:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: [[BASE_1:%.+]] = load ptr, ptr [[BASE_0]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: [[BASE_2:%.+]] = load ptr, ptr [[BASE_1]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: store ptr null, ptr [[BASE_2]], align 8, !tbaa [[ANYPTR]]
[TBAA] Remove references to entry BB in check lines for tbaa-pointers.c Follow-up to 123c036bd361d to remove references to entry BB name from checks, to fix tests for builds that do not generate block names.
2024-07-19 14:51:27 +01:00
// COMMON-NEXT: ret void
[Clang,TBAA] Add test cases for nested pointers and TBAA data.
2022-03-27 19:59:37 +01:00
//
***ptr = 0;
}
struct S1 {
int x;
int y;
};
void p2struct(struct S1 **ptr) {
Recommit "[TBAA] Emit distinct TBAA tags for pointers with different depths,types. (#76612)" This reverts the revert commit bee240367cc48bbc93fe5eb57d537968dfe4419f. This version includes updates to the tests to use patterns when matching the pointer argument. Original commit message: This patch extends Clang's TBAA generation code to emit distinct tags for incompatible pointer types. Pointers with different element types are incompatible if the pointee types are also incompatible (modulo sugar/modifiers). Express this in TBAA by generating different tags for pointers based on the pointer depth and pointee type. To get the TBAA tag for the pointee type it uses getTypeInfoHelper on the pointee type. (Moved from https://reviews.llvm.org/D122573) PR: https://github.com/llvm/llvm-project/pull/76612
2024-07-19 13:03:21 +01:00
// COMMON-LABEL: define void @p2struct(
// COMMON-SAME: ptr noundef [[PTR:%.+]])
[TBAA] Remove references to entry BB in check lines for tbaa-pointers.c Follow-up to 123c036bd361d to remove references to entry BB name from checks, to fix tests for builds that do not generate block names.
2024-07-19 14:51:27 +01:00
// COMMON: [[PTR_ADDR:%.+]] = alloca ptr, align 8
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[P2S1_TAG:!.+]]
// DISABLE-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DEFAULT-NEXT: [[BASE:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[P2S1_TAG]]
// DISABLE-NEXT: [[BASE:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DEFAULT-NEXT: store ptr null, ptr [[BASE]], align 8, !tbaa [[P1S1_TAG:!.+]]
// DISABLE-NEXT: store ptr null, ptr [[BASE]], align 8, !tbaa [[ANYPTR]]
[TBAA] Add tests with pointers to structs to tbaa-pointers.c. Precommit tests for follow-up improvements to Clang's TBAA emission. Also add variants with -pointer-tbaa to tbaa-reference.cpp.
2024-09-30 19:54:03 +01:00
// COMMON-NEXT: ret void
//
*ptr = 0;
}
void p2struct_const(struct S1 const **ptr) {
// COMMON-LABEL: define void @p2struct_const(
// COMMON-SAME: ptr noundef [[PTR:%.+]])
// COMMON: [[PTR_ADDR:%.+]] = alloca ptr, align 8
[TBAA] Extend pointer TBAA to pointers of non-builtin types. (#110569) Extend the logic added in 123c036bd361d (https://github.com/llvm/llvm-project/pull/76612) to support pointers to non-builtin types by using the mangled name of the canonical type. PR: https://github.com/llvm/llvm-project/pull/110569
2024-10-22 16:23:34 -07:00
// COMMON-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR:!.+]]
[TBAA] Add tests with pointers to structs to tbaa-pointers.c. Precommit tests for follow-up improvements to Clang's TBAA emission. Also add variants with -pointer-tbaa to tbaa-reference.cpp.
2024-09-30 19:54:03 +01:00
// COMMON-NEXT: [[BASE:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT-NEXT: store ptr null, ptr [[BASE]], align 8, !tbaa [[P1S1_TAG]]
// DISABLE-NEXT: store ptr null, ptr [[BASE]], align 8, !tbaa [[ANYPTR]]
[TBAA] Remove references to entry BB in check lines for tbaa-pointers.c Follow-up to 123c036bd361d to remove references to entry BB name from checks, to fix tests for builds that do not generate block names.
2024-07-19 14:51:27 +01:00
// COMMON-NEXT: ret void
[Clang,TBAA] Add test cases for nested pointers and TBAA data.
2022-03-27 19:59:37 +01:00
//
*ptr = 0;
}
[TBAA] Add tests with pointers to structs to tbaa-pointers.c. Precommit tests for follow-up improvements to Clang's TBAA emission. Also add variants with -pointer-tbaa to tbaa-reference.cpp.
2024-09-30 19:54:03 +01:00
struct S2 {
struct S1 *s;
};
void p2struct2(struct S2 *ptr) {
// COMMON-LABEL: define void @p2struct2(
// COMMON-SAME: ptr noundef [[PTR:%.+]])
// COMMON: [[PTR_ADDR:%.+]] = alloca ptr, align 8
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[P1S2_TAG:!.+]]
// DEFAULT-NEXT: [[BASE:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[P1S2_TAG]]
[TBAA] Extend pointer TBAA to pointers of non-builtin types. (#110569) Extend the logic added in 123c036bd361d (https://github.com/llvm/llvm-project/pull/76612) to support pointers to non-builtin types by using the mangled name of the canonical type. PR: https://github.com/llvm/llvm-project/pull/110569
2024-10-22 16:23:34 -07:00
// DEFAULT-NEXT: [[S:%.+]] = getelementptr inbounds nuw %struct.S2, ptr [[BASE]], i32 0, i32 0
// DEFAULT-NEXT: store ptr null, ptr [[S]], align 8, !tbaa [[S2_S_TAG:!.+]]
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DISABLE-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: [[BASE:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DISABLE-NEXT: [[S:%.+]] = getelementptr inbounds nuw %struct.S2, ptr [[BASE]], i32 0, i32 0
// DISABLE-NEXT: store ptr null, ptr [[S]], align 8, !tbaa [[S2_S_TAG:!.+]]
[TBAA] Add tests with pointers to structs to tbaa-pointers.c. Precommit tests for follow-up improvements to Clang's TBAA emission. Also add variants with -pointer-tbaa to tbaa-reference.cpp.
2024-09-30 19:54:03 +01:00
// COMMON-NEXT: ret void
ptr->s = 0;
}
[TBAA] Extend pointer TBAA to pointers of non-builtin types. (#110569) Extend the logic added in 123c036bd361d (https://github.com/llvm/llvm-project/pull/76612) to support pointers to non-builtin types by using the mangled name of the canonical type. PR: https://github.com/llvm/llvm-project/pull/110569
2024-10-22 16:23:34 -07:00
void vla1(int n, int ptr[][n], int idx) {
// COMMON-LABEL: define void @vla1(
// COMMON-SAME: i32 noundef [[N:%.+]], ptr noundef [[PTR:%.+]], i32 noundef [[IDX:%.+]])
// COMMON: [[N_ADDR:%.+]] = alloca i32, align 4
// COMMON-NEXT: [[PTR_ADDR:%.+]] = alloca ptr, align 8
// COMMON-NEXT: [[IDX_ADDR:%.+]] = alloca i32, align 4
// COMMON-NEXT: store i32 [[N]], ptr [[N_ADDR]], align 4, !tbaa [[INT_TY:!.+]]
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[P1INT0:!.+]]
// DISABLE-NEXT: store ptr [[PTR]], ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
[TBAA] Extend pointer TBAA to pointers of non-builtin types. (#110569) Extend the logic added in 123c036bd361d (https://github.com/llvm/llvm-project/pull/76612) to support pointers to non-builtin types by using the mangled name of the canonical type. PR: https://github.com/llvm/llvm-project/pull/110569
2024-10-22 16:23:34 -07:00
// COMMON-NEXT: store i32 [[IDX]], ptr [[IDX_ADDR]], align 4, !tbaa [[INT_TY]]
// COMMON-NEXT: [[L:%.+]] = load i32, ptr [[N_ADDR]], align 4, !tbaa [[INT_TY]]
// COMMON-NEXT: [[L_EXT:%.+]] = zext i32 [[L]] to i64
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT-NEXT: [[L_PTR:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[P1INT0]]
// DISABLE-NEXT: [[L_PTR:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
[TBAA] Extend pointer TBAA to pointers of non-builtin types. (#110569) Extend the logic added in 123c036bd361d (https://github.com/llvm/llvm-project/pull/76612) to support pointers to non-builtin types by using the mangled name of the canonical type. PR: https://github.com/llvm/llvm-project/pull/110569
2024-10-22 16:23:34 -07:00
// COMMON-NEXT: [[L_IDX:%.+]] = load i32, ptr [[IDX_ADDR]], align 4, !tbaa [[INT_TY]]
// COMMON-NEXT: [[IDX_EXT:%.+]] = sext i32 [[L_IDX]] to i64
// COMMON-NEXT: [[MUL:%.+]] = mul nsw i64 [[IDX_EXT]], [[L_EXT]]
// COMMON-NEXT: [[GEP1:%.+]] = getelementptr inbounds i32, ptr [[L_PTR]], i64 [[MUL]]
// COMMON-NEXT: [[GEP2:%.+]] = getelementptr inbounds i32, ptr [[GEP1]], i64 0
// COMMON-NEXT: store i32 0, ptr [[GEP2]], align 4, !tbaa [[INT_TAG:!.+]]
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT-NEXT: ret void
[TBAA] Extend pointer TBAA to pointers of non-builtin types. (#110569) Extend the logic added in 123c036bd361d (https://github.com/llvm/llvm-project/pull/76612) to support pointers to non-builtin types by using the mangled name of the canonical type. PR: https://github.com/llvm/llvm-project/pull/110569
2024-10-22 16:23:34 -07:00
ptr[idx][0] = 0;
}
[TBAA] Add test for generating pointer-tbaa for unnamed structs. Currently we generate incorrect metadata not considering compatible types in C.
2024-11-17 19:58:07 +00:00
typedef struct {
int i1;
} TypedefS;
void unamed_struct_typedef(TypedefS *ptr) {
// COMMON-LABEL: define void @unamed_struct_typedef(
Relax clang/test/CodeGen/tbaa-pointers.c for -Asserts. Fixes c4eeef32d5dc (llvmorg-20-init-12475-gc4eeef32d5dc)
2024-11-18 15:25:18 +09:00
// COMMON-SAME: ptr noundef [[PTRA:%.+]])
[TBAA] Simplify checks for unnamed struct case, where anyptr is used.
2025-01-08 14:08:28 +00:00
// COMMON: [[PTR_ADDR:%.+]] = alloca ptr, align 8
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DISABLE-NEXT: store ptr [[PTRA]], ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
[TBAA] Simplify checks for unnamed struct case, where anyptr is used.
2025-01-08 14:08:28 +00:00
// DEFAULT-NEXT: store ptr [[PTRA]], ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR:!.+]]
// COMMON-NEXT: [[L0:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
[TBAA] Add test for generating pointer-tbaa for unnamed structs. Currently we generate incorrect metadata not considering compatible types in C.
2024-11-17 19:58:07 +00:00
// COMMON-NEXT: [[GEP:%.+]] = getelementptr inbounds nuw %struct.TypedefS, ptr [[L0]], i32 0, i32 0
// COMMON-NEXT: store i32 0, ptr [[GEP]], align 4
// COMMON-NEXT: ret void
ptr->i1 = 0;
}
[TBAA] Add Clang pointer TBAA test with void *.
2025-01-08 11:54:01 +00:00
int void_ptrs(void **ptr) {
// COMMON-LABEL: define i32 @void_ptrs(
// COMMON-SAME: ptr noundef [[PTRA:%.+]])
// COMMON: [[PTR_ADDR:%.+]] = alloca ptr, align 8
[TBAA] Refine pointer-tbaa for void pointers by pointer depth (#126047) Commit 77d3f8a avoids distinct tags for any pointers where the ultimate pointee type is `void`, to solve breakage in real-world code that uses (indirections to) `void*` for polymorphism over different pointer types. While this matches the TBAA implementation in GCC, this patch implements a refinement that distinguishes void pointers by pointer depth, as described in the "strict aliasing" documentation included in the aforementioned commit: > `void*` is permitted to alias any pointer type, `void**` is permitted > to alias any pointer to pointer type, and so on. For example, `void**` is no longer considered to alias `int*` in this refinement, but it remains possible to use `void**` for polymorphism over pointers to pointers.
2025-02-20 13:06:56 +01:00
// DISABLE-NEXT: store ptr [[PTRA]], ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DEFAULT-NEXT: store ptr [[PTRA]], ptr [[PTR_ADDR]], align 8, !tbaa [[ANYP2:!.+]]
// DISABLE-NEXT: [[L0:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[ANYPTR]]
// DEFAULT-NEXT: [[L0:%.+]] = load ptr, ptr [[PTR_ADDR]], align 8, !tbaa [[ANYP2]]
[TBAA] Don't emit pointer-tbaa for void pointers. (#122116) While there are no special rules in the standards regarding void pointers and strict aliasing, emitting distinct tags for void pointers break some common idioms and there is no good alternative to re-write the code without strict-aliasing violations. An example is to count the entries in an array of pointers: int count_elements(void * values) { void **seq = values; int count; for (count = 0; seq && seq[count]; count++); return count; } https://clang.godbolt.org/z/8dTv51v8W An example in the wild is from https://github.com/llvm/llvm-project/issues/119099 This patch avoids emitting distinct tags for void pointers, to avoid those idioms causing mis-compiles for now. Fixes https://github.com/llvm/llvm-project/issues/119099. Fixes https://github.com/llvm/llvm-project/issues/122537. PR: https://github.com/llvm/llvm-project/pull/122116
2025-01-31 11:38:14 +00:00
// COMMON-NEXT: [[L1:%.+]] = load ptr, ptr [[L0]], align 8, !tbaa [[ANYPTR]]
[TBAA] Add Clang pointer TBAA test with void *.
2025-01-08 11:54:01 +00:00
// COMMON-NEXT: [[BOOL:%.+]] = icmp ne ptr [[L1]], null
// COMMON-NEXT: [[BOOL_EXT:%.+]] = zext i1 [[BOOL]] to i64
// COMMON-NEXT: [[COND:%.+]] = select i1 [[BOOL]], i32 0, i32 1
// COMMON-NEXT: ret i32 [[COND]]
return *ptr ? 0 : 1;
}
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT: [[P2INT_0]] = !{[[P2INT:!.+]], [[P2INT]], i64 0}
[TBAA] Refine pointer-tbaa for void pointers by pointer depth (#126047) Commit 77d3f8a avoids distinct tags for any pointers where the ultimate pointee type is `void`, to solve breakage in real-world code that uses (indirections to) `void*` for polymorphism over different pointer types. While this matches the TBAA implementation in GCC, this patch implements a refinement that distinguishes void pointers by pointer depth, as described in the "strict aliasing" documentation included in the aforementioned commit: > `void*` is permitted to alias any pointer type, `void**` is permitted > to alias any pointer to pointer type, and so on. For example, `void**` is no longer considered to alias `int*` in this refinement, but it remains possible to use `void**` for polymorphism over pointers to pointers.
2025-02-20 13:06:56 +01:00
// DEFAULT: [[P2INT]] = !{!"p2 int", [[ANY_P2_POINTER:!.+]], i64 0}
// DEFAULT: [[ANY_P2_POINTER]] = !{!"any p2 pointer", [[ANY_POINTER:!.+]], i64 0}
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DISABLE: [[ANYPTR]] = !{[[ANY_POINTER:!.+]], [[ANY_POINTER]], i64 0}
Recommit "[TBAA] Emit distinct TBAA tags for pointers with different depths,types. (#76612)" This reverts the revert commit bee240367cc48bbc93fe5eb57d537968dfe4419f. This version includes updates to the tests to use patterns when matching the pointer argument. Original commit message: This patch extends Clang's TBAA generation code to emit distinct tags for incompatible pointer types. Pointers with different element types are incompatible if the pointee types are also incompatible (modulo sugar/modifiers). Express this in TBAA by generating different tags for pointers based on the pointer depth and pointee type. To get the TBAA tag for the pointee type it uses getTypeInfoHelper on the pointee type. (Moved from https://reviews.llvm.org/D122573) PR: https://github.com/llvm/llvm-project/pull/76612
2024-07-19 13:03:21 +01:00
// COMMON: [[ANY_POINTER]] = !{!"any pointer", [[CHAR:!.+]], i64 0}
// COMMON: [[CHAR]] = !{!"omnipotent char", [[TBAA_ROOT:!.+]], i64 0}
// COMMON: [[TBAA_ROOT]] = !{!"Simple C/C++ TBAA"}
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT: [[P1INT_0]] = !{[[P1INT:!.+]], [[P1INT]], i64 0}
// DEFAULT: [[P1INT]] = !{!"p1 int", [[ANY_POINTER]], i64 0}
// DEFAULT: [[P3INT_0]] = !{[[P3INT:!.+]], [[P3INT]], i64 0}
[TBAA] Refine pointer-tbaa for void pointers by pointer depth (#126047) Commit 77d3f8a avoids distinct tags for any pointers where the ultimate pointee type is `void`, to solve breakage in real-world code that uses (indirections to) `void*` for polymorphism over different pointer types. While this matches the TBAA implementation in GCC, this patch implements a refinement that distinguishes void pointers by pointer depth, as described in the "strict aliasing" documentation included in the aforementioned commit: > `void*` is permitted to alias any pointer type, `void**` is permitted > to alias any pointer to pointer type, and so on. For example, `void**` is no longer considered to alias `int*` in this refinement, but it remains possible to use `void**` for polymorphism over pointers to pointers.
2025-02-20 13:06:56 +01:00
// DEFAULT: [[P3INT]] = !{!"p3 int", [[ANY_P3_POINTER:!.+]], i64 0}
// DEFAULT: [[ANY_P3_POINTER]] = !{!"any p3 pointer", [[ANY_P2_POINTER]], i64 0}
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT: [[P4CHAR_0]] = !{[[P4CHAR:!.+]], [[P4CHAR]], i64 0}
[TBAA] Refine pointer-tbaa for void pointers by pointer depth (#126047) Commit 77d3f8a avoids distinct tags for any pointers where the ultimate pointee type is `void`, to solve breakage in real-world code that uses (indirections to) `void*` for polymorphism over different pointer types. While this matches the TBAA implementation in GCC, this patch implements a refinement that distinguishes void pointers by pointer depth, as described in the "strict aliasing" documentation included in the aforementioned commit: > `void*` is permitted to alias any pointer type, `void**` is permitted > to alias any pointer to pointer type, and so on. For example, `void**` is no longer considered to alias `int*` in this refinement, but it remains possible to use `void**` for polymorphism over pointers to pointers.
2025-02-20 13:06:56 +01:00
// DEFAULT: [[P4CHAR]] = !{!"p4 omnipotent char", [[ANY_P4_POINTER:!.*]], i64 0}
// DEFAULT: [[ANY_P4_POINTER]] = !{!"any p4 pointer", [[ANY_P3_POINTER]], i64 0}
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT: [[P3CHAR_0]] = !{[[P3CHAR:!.+]], [[P3CHAR]], i64 0}
[TBAA] Refine pointer-tbaa for void pointers by pointer depth (#126047) Commit 77d3f8a avoids distinct tags for any pointers where the ultimate pointee type is `void`, to solve breakage in real-world code that uses (indirections to) `void*` for polymorphism over different pointer types. While this matches the TBAA implementation in GCC, this patch implements a refinement that distinguishes void pointers by pointer depth, as described in the "strict aliasing" documentation included in the aforementioned commit: > `void*` is permitted to alias any pointer type, `void**` is permitted > to alias any pointer to pointer type, and so on. For example, `void**` is no longer considered to alias `int*` in this refinement, but it remains possible to use `void**` for polymorphism over pointers to pointers.
2025-02-20 13:06:56 +01:00
// DEFAULT: [[P3CHAR]] = !{!"p3 omnipotent char", [[ANY_P3_POINTER]], i64 0}
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT: [[P2CHAR_0]] = !{[[P2CHAR:!.+]], [[P2CHAR]], i64 0}
[TBAA] Refine pointer-tbaa for void pointers by pointer depth (#126047) Commit 77d3f8a avoids distinct tags for any pointers where the ultimate pointee type is `void`, to solve breakage in real-world code that uses (indirections to) `void*` for polymorphism over different pointer types. While this matches the TBAA implementation in GCC, this patch implements a refinement that distinguishes void pointers by pointer depth, as described in the "strict aliasing" documentation included in the aforementioned commit: > `void*` is permitted to alias any pointer type, `void**` is permitted > to alias any pointer to pointer type, and so on. For example, `void**` is no longer considered to alias `int*` in this refinement, but it remains possible to use `void**` for polymorphism over pointers to pointers.
2025-02-20 13:06:56 +01:00
// DEFAULT: [[P2CHAR]] = !{!"p2 omnipotent char", [[ANY_P2_POINTER]], i64 0}
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT: [[P1CHAR_0]] = !{[[P1CHAR:!.+]], [[P1CHAR]], i64 0}
// DEFAULT: [[P1CHAR]] = !{!"p1 omnipotent char", [[ANY_POINTER]], i64 0}
// DEFAULT: [[P2S1_TAG]] = !{[[P2S1:!.+]], [[P2S1]], i64 0}
[TBAA] Refine pointer-tbaa for void pointers by pointer depth (#126047) Commit 77d3f8a avoids distinct tags for any pointers where the ultimate pointee type is `void`, to solve breakage in real-world code that uses (indirections to) `void*` for polymorphism over different pointer types. While this matches the TBAA implementation in GCC, this patch implements a refinement that distinguishes void pointers by pointer depth, as described in the "strict aliasing" documentation included in the aforementioned commit: > `void*` is permitted to alias any pointer type, `void**` is permitted > to alias any pointer to pointer type, and so on. For example, `void**` is no longer considered to alias `int*` in this refinement, but it remains possible to use `void**` for polymorphism over pointers to pointers.
2025-02-20 13:06:56 +01:00
// DEFAULT: [[P2S1]] = !{!"p2 _ZTS2S1", [[ANY_P2_POINTER]], i64 0}
[Clang] Enable -fpointer-tbaa by default. (#117244) Support for more precise TBAA metadata has been added a while ago (behind the -fpointer-tbaa flag). The more precise TBAA metadata allows treating accesses of different pointer types as no-alias. This helps to remove more redundant loads and stores in a number of workloads. Some highlights on the impact across llvm-test-suite's MultiSource, SPEC2006 & SPEC2017 include: * +2% more NoAlias results for memory accesses * +3% more stores removed by DSE, * +4% more loops vectorized. This closes a relatively big gap to GCC, which has been supporting disambiguating based on pointer types for a long time. (https://clang.godbolt.org/z/K7Wbhrz4q) Pointer-TBAA support for pointers to builtin types has been added in https://github.com/llvm/llvm-project/pull/76612. Support for user-defined types has been added in https://github.com/llvm/llvm-project/pull/110569. There are 2 recent PRs with bug fixes for special cases uncovered during testing: * https://github.com/llvm/llvm-project/pull/116991 * https://github.com/llvm/llvm-project/pull/116596 PR: https://github.com/llvm/llvm-project/pull/117244
2024-12-04 20:55:18 +00:00
// DEFAULT: [[P1S1_TAG:!.+]] = !{[[P1S1:!.+]], [[P1S1]], i64 0}
// DEFAULT: [[P1S1]] = !{!"p1 _ZTS2S1", [[ANY_POINTER]], i64 0}
// DEFAULT: [[P1S2_TAG]] = !{[[P1S2:!.+]], [[P1S2]], i64 0}
// DEFAULT: [[P1S2]] = !{!"p1 _ZTS2S2", [[ANY_POINTER]], i64 0}
// DEFAULT: [[S2_S_TAG]] = !{[[S2_TY:!.+]], [[P1S1]], i64 0}
// DEFAULT: [[S2_TY]] = !{!"S2", [[P1S1]], i64 0}
// DISABLE: [[S2_S_TAG]] = !{[[S2_TY:!.+]], [[ANY_POINTER]], i64 0}
// DISABLE: [[S2_TY]] = !{!"S2", [[ANY_POINTER]], i64 0}
[TBAA] Extend pointer TBAA to pointers of non-builtin types. (#110569) Extend the logic added in 123c036bd361d (https://github.com/llvm/llvm-project/pull/76612) to support pointers to non-builtin types by using the mangled name of the canonical type. PR: https://github.com/llvm/llvm-project/pull/110569
2024-10-22 16:23:34 -07:00
// COMMON: [[INT_TAG]] = !{[[INT_TY:!.+]], [[INT_TY]], i64 0}
// COMMON: [[INT_TY]] = !{!"int", [[CHAR]], i64 0}
[TBAA] Simplify checks for unnamed struct case, where anyptr is used.
2025-01-08 14:08:28 +00:00
// DEFAULT: [[ANYPTR]] = !{[[ANY_POINTER]], [[ANY_POINTER]], i64 0}
[TBAA] Refine pointer-tbaa for void pointers by pointer depth (#126047) Commit 77d3f8a avoids distinct tags for any pointers where the ultimate pointee type is `void`, to solve breakage in real-world code that uses (indirections to) `void*` for polymorphism over different pointer types. While this matches the TBAA implementation in GCC, this patch implements a refinement that distinguishes void pointers by pointer depth, as described in the "strict aliasing" documentation included in the aforementioned commit: > `void*` is permitted to alias any pointer type, `void**` is permitted > to alias any pointer to pointer type, and so on. For example, `void**` is no longer considered to alias `int*` in this refinement, but it remains possible to use `void**` for polymorphism over pointers to pointers.
2025-02-20 13:06:56 +01:00
// DEFAULT: [[ANYP2]] = !{[[ANY_P2_POINTER]], [[ANY_P2_POINTER]], i64 0}
Reference in New Issue Copy Permalink