This is an archive of the discontinued LLVM Phabricator instance.

Differential D122469

OpenMP 5.1 - Support 'seq_cst' clause on 'flush' directive
Needs ReviewPublic

Authored by soumitra on Mar 25 2022, 3:09 AM.

Details

Reviewers
RitanyaB
dreachem
jdoerfert
Summary

OpenMP 5.1
Add support for the seq_cst clause for the flush directive

Diff Detail

Event Timeline

soumitra created this revision.Mar 25 2022, 3:09 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 25 2022, 3:09 AM
Herald added subscribers: jeroen.dobbelaere, kerbowa, arphaman and 5 others. · View Herald Transcript
soumitra requested review of this revision.Mar 25 2022, 3:09 AM
Herald added a reviewer: jdoerfert. · View Herald TranscriptMar 25 2022, 3:09 AM
Herald added projects: Restricted Project, Restricted Project. · View Herald Transcript
Herald added subscribers: llvm-commits, cfe-commits, sstefan1. · View Herald Transcript
Harbormaster completed remote builds in B156243: Diff 418166.Mar 25 2022, 3:10 AM
jdoerfert added a comment.Mar 27 2022, 10:12 PM

I think this contains two distinct changes. Please split.

soumitra updated this revision to Diff 418530.Mar 28 2022, 3:14 AM

The previous patch had unrelated changes inadvertently. Corrected.

Harbormaster completed remote builds in B156516: Diff 418530.Mar 29 2022, 9:52 AM

Revision Contents

PathSize
clang/
include/
clang/
AST/
4 lines
Basic/
2 lines
lib/
Sema/
3 lines
test/
OpenMP/
18 lines
20 lines
13 lines
llvm/
include/
llvm/
Frontend/
OpenMP/
1 line
lib/
Analysis/
102 lines
test/
Analysis/
BasicAA/
9 lines
1 line
448 lines
30 lines
4 lines
10 lines
2 lines
6 lines
1 line
42 lines
3 lines
5 lines
8 lines
9 lines
6 lines
96 lines
2 lines
1 line
3 lines
12 lines
31 lines
30 lines
7 lines
2 lines
10 lines
4 lines
56 lines
2 lines
8 lines
8 lines
3 lines
8 lines
32 lines
120 lines
152 lines
14 lines
49 lines
61 lines
111 lines
54 lines
CFLAliasAnalysis/
Andersen/
15 lines
11 lines
68 lines
49 lines
2 lines
13 lines
23 lines
24 lines
5 lines
7 lines
6 lines
6 lines
34 lines
9 lines
22 lines
8 lines
8 lines
6 lines
12 lines
Steensgaard/
18 lines
4 lines
2 lines
57 lines
2 lines
1 line
8 lines
21 lines
4 lines
23 lines
24 lines
5 lines
7 lines
6 lines
24 lines
30 lines
9 lines
12 lines
6 lines
8 lines
6 lines
6 lines
4 lines
4 lines
4 lines
3 lines
1 line
22 lines
13 lines
GlobalsModRef/
5 lines
ScalarEvolution/
61 lines
CodeGen/
AMDGPU/
114 lines
2 lines

Diff 418166

clang/include/clang/AST/OpenMPClause.h

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,260 Lines • ▼ Show 20 Lines const_child_range used_children() const {
return const_child_range(const_child_iterator(), const_child_iterator()); return const_child_range(const_child_iterator(), const_child_iterator());
} }
static bool classof(const OMPClause *T) { static bool classof(const OMPClause *T) {
return T->getClauseKind() == llvm::omp::OMPC_compare; return T->getClauseKind() == llvm::omp::OMPC_compare;
} }
}; };
/// This represents 'seq_cst' clause in the '#pragma omp atomic' /// This represents 'seq_cst' clause in the '#pragma omp atomic|flush'
/// directive. /// directives.
/// ///
/// \code /// \code
/// #pragma omp atomic seq_cst /// #pragma omp atomic seq_cst
/// \endcode /// \endcode
/// In this example directive '#pragma omp atomic' has 'seq_cst' clause. /// In this example directive '#pragma omp atomic' has 'seq_cst' clause.
class OMPSeqCstClause : public OMPClause { class OMPSeqCstClause : public OMPClause {
public: public:
/// Build 'seq_cst' clause. /// Build 'seq_cst' clause.
▲ Show 20 Lines • Show All 6,641 Lines • Show Last 20 Lines

clang/include/clang/Basic/DiagnosticSemaKinds.td

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 10,561 Lines • ▼ Show 20 Lines
def note_omp_atomic_compare: Note< def note_omp_atomic_compare: Note<
"%select{expected compound statement|expected exactly one expression statement|expected assignment statement|expected conditional operator|expect result value to be at false expression|" "%select{expected compound statement|expected exactly one expression statement|expected assignment statement|expected conditional operator|expect result value to be at false expression|"
"expect binary operator in conditional expression|expect '<', '>' or '==' as order operator|expect comparison in a form of 'x == e', 'e == x', 'x ordop expr', or 'expr ordop x'|" "expect binary operator in conditional expression|expect '<', '>' or '==' as order operator|expect comparison in a form of 'x == e', 'e == x', 'x ordop expr', or 'expr ordop x'|"
"expect lvalue for result value|expect scalar value|expect integer value|unexpected 'else' statement|expect '==' operator|expect an assignment statement 'v = x'|" "expect lvalue for result value|expect scalar value|expect integer value|unexpected 'else' statement|expect '==' operator|expect an assignment statement 'v = x'|"
"expect a 'if' statement|expect no more than two statements|expect a compound statement|expect 'else' statement|expect a form 'r = x == e; if (r) ...'}0">; "expect a 'if' statement|expect no more than two statements|expect a compound statement|expect 'else' statement|expect a form 'r = x == e; if (r) ...'}0">;
def err_omp_atomic_several_clauses : Error< def err_omp_atomic_several_clauses : Error<
"directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause">; "directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause">;
def err_omp_several_mem_order_clauses : Error< def err_omp_several_mem_order_clauses : Error<
"directive '#pragma omp %0' cannot contain more than one %select{'seq_cst', 'relaxed', |}1'acq_rel', 'acquire' or 'release' clause">; "directive '#pragma omp %0' cannot contain more than one %select{'seq_cst', 'relaxed', |}1'seq_cst', 'acq_rel', 'acquire' or 'release' clause">;
def err_omp_atomic_incompatible_mem_order_clause : Error< def err_omp_atomic_incompatible_mem_order_clause : Error<
"directive '#pragma omp atomic%select{ %0|}1' cannot be used with '%2' clause">; "directive '#pragma omp atomic%select{ %0|}1' cannot be used with '%2' clause">;
def note_omp_previous_mem_order_clause : Note< def note_omp_previous_mem_order_clause : Note<
"'%0' clause used here">; "'%0' clause used here">;
def err_omp_target_contains_not_only_teams : Error< def err_omp_target_contains_not_only_teams : Error<
"target construct with nested teams region contains statements outside of the teams construct">; "target construct with nested teams region contains statements outside of the teams construct">;
def note_omp_nested_teams_construct_here : Note< def note_omp_nested_teams_construct_here : Note<
"nested teams construct here">; "nested teams construct here">;
▲ Show 20 Lines • Show All 959 Lines • Show Last 20 Lines

clang/lib/Sema/SemaOpenMP.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 10,533 Lines • ▼ Show 20 Lines for (OMPClause *C : Clauses) {
else else
OrderClause = C; OrderClause = C;
} }
OpenMPClauseKind MemOrderKind = OMPC_unknown; OpenMPClauseKind MemOrderKind = OMPC_unknown;
SourceLocation MemOrderLoc; SourceLocation MemOrderLoc;
for (const OMPClause *C : Clauses) { for (const OMPClause *C : Clauses) {
if (C->getClauseKind() == OMPC_acq_rel || if (C->getClauseKind() == OMPC_acq_rel ||
C->getClauseKind() == OMPC_acquire || C->getClauseKind() == OMPC_acquire ||
C->getClauseKind() == OMPC_release) { C->getClauseKind() == OMPC_release ||
C->getClauseKind() == OMPC_seq_cst /*OpenMP 5.1*/) {
if (MemOrderKind != OMPC_unknown) { if (MemOrderKind != OMPC_unknown) {
Diag(C->getBeginLoc(), diag::err_omp_several_mem_order_clauses) Diag(C->getBeginLoc(), diag::err_omp_several_mem_order_clauses)
<< getOpenMPDirectiveName(OMPD_flush) << 1 << getOpenMPDirectiveName(OMPD_flush) << 1
<< SourceRange(C->getBeginLoc(), C->getEndLoc()); << SourceRange(C->getBeginLoc(), C->getEndLoc());
Diag(MemOrderLoc, diag::note_omp_previous_mem_order_clause) Diag(MemOrderLoc, diag::note_omp_previous_mem_order_clause)
<< getOpenMPClauseName(MemOrderKind); << getOpenMPClauseName(MemOrderKind);
} else { } else {
MemOrderKind = C->getClauseKind(); MemOrderKind = C->getClauseKind();
▲ Show 20 Lines • Show All 11,961 Lines • Show Last 20 Lines

clang/test/OpenMP/flush_ast_print.cpp

// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=50 -ast-print %s | FileCheck %s // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=51 -ast-print %s | FileCheck %s
// RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -x c++ -std=c++11 -emit-pch -o %t %s // RUN: %clang_cc1 -fopenmp -fopenmp-version=51 -x c++ -std=c++11 -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s // RUN: %clang_cc1 -fopenmp -fopenmp-version=51 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=50 -ast-print %s | FileCheck %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=51 -ast-print %s | FileCheck %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=50 -x c++ -std=c++11 -emit-pch -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=51 -x c++ -std=c++11 -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=50 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=51 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
// expected-no-diagnostics // expected-no-diagnostics
#ifndef HEADER #ifndef HEADER
#define HEADER #define HEADER
void foo() {} void foo() {}
template <class T> template <class T>
T tmain(T argc) { T tmain(T argc) {
static T a; static T a;
#pragma omp flush #pragma omp flush
#pragma omp flush acq_rel #pragma omp flush acq_rel
#pragma omp flush acquire #pragma omp flush acquire
#pragma omp flush release #pragma omp flush release
#pragma omp flush seq_cst
#pragma omp flush(a) #pragma omp flush(a)
return a + argc; return a + argc;
} }
// CHECK: static T a; // CHECK: static T a;
// CHECK-NEXT: #pragma omp flush{{$}} // CHECK-NEXT: #pragma omp flush{{$}}
// CHECK-NEXT: #pragma omp flush acq_rel{{$}} // CHECK-NEXT: #pragma omp flush acq_rel{{$}}
// CHECK-NEXT: #pragma omp flush acquire{{$}} // CHECK-NEXT: #pragma omp flush acquire{{$}}
// CHECK-NEXT: #pragma omp flush release{{$}} // CHECK-NEXT: #pragma omp flush release{{$}}
// CHECK-NEXT: #pragma omp flush seq_cst{{$}}
// CHECK-NEXT: #pragma omp flush (a) // CHECK-NEXT: #pragma omp flush (a)
// CHECK: static int a; // CHECK: static int a;
// CHECK-NEXT: #pragma omp flush // CHECK-NEXT: #pragma omp flush
// CHECK-NEXT: #pragma omp flush acq_rel{{$}} // CHECK-NEXT: #pragma omp flush acq_rel{{$}}
// CHECK-NEXT: #pragma omp flush acquire{{$}} // CHECK-NEXT: #pragma omp flush acquire{{$}}
// CHECK-NEXT: #pragma omp flush release{{$}} // CHECK-NEXT: #pragma omp flush release{{$}}
// CHECK-NEXT: #pragma omp flush seq_cst{{$}}
// CHECK-NEXT: #pragma omp flush (a) // CHECK-NEXT: #pragma omp flush (a)
// CHECK: static char a; // CHECK: static char a;
// CHECK-NEXT: #pragma omp flush // CHECK-NEXT: #pragma omp flush
// CHECK-NEXT: #pragma omp flush acq_rel{{$}} // CHECK-NEXT: #pragma omp flush acq_rel{{$}}
// CHECK-NEXT: #pragma omp flush acquire{{$}} // CHECK-NEXT: #pragma omp flush acquire{{$}}
// CHECK-NEXT: #pragma omp flush release{{$}} // CHECK-NEXT: #pragma omp flush release{{$}}
// CHECK-NEXT: #pragma omp flush seq_cst{{$}}
// CHECK-NEXT: #pragma omp flush (a) // CHECK-NEXT: #pragma omp flush (a)
int main(int argc, char **argv) { int main(int argc, char **argv) {
static int a; static int a;
// CHECK: static int a; // CHECK: static int a;
#pragma omp flush #pragma omp flush
#pragma omp flush acq_rel #pragma omp flush acq_rel
#pragma omp flush acquire #pragma omp flush acquire
#pragma omp flush release #pragma omp flush release
#pragma omp flush seq_cst
#pragma omp flush(a) #pragma omp flush(a)
// CHECK-NEXT: #pragma omp flush // CHECK-NEXT: #pragma omp flush
// CHECK-NEXT: #pragma omp flush acq_rel // CHECK-NEXT: #pragma omp flush acq_rel
// CHECK-NEXT: #pragma omp flush acquire{{$}} // CHECK-NEXT: #pragma omp flush acquire{{$}}
// CHECK-NEXT: #pragma omp flush release // CHECK-NEXT: #pragma omp flush release
// CHECK-NEXT: #pragma omp flush seq_cst
// CHECK-NEXT: #pragma omp flush (a) // CHECK-NEXT: #pragma omp flush (a)
return tmain(argc) + tmain(argv[0][0]) + a; return tmain(argc) + tmain(argv[0][0]) + a;
} }
#endif #endif

clang/test/OpenMP/flush_codegen.cpp

// RUN: %clang_cc1 -verify -fopenmp -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=51 -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s // RUN: %clang_cc1 -fopenmp -fopenmp-version=51 -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -debug-info-kind=limited -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 -fopenmp -fopenmp-version=51 -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -debug-info-kind=limited -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp -fopenmp-enable-irbuilder -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=51 -fopenmp-enable-irbuilder -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s
// RUN: %clang_cc1 -fopenmp -fopenmp-enable-irbuilder -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s // RUN: %clang_cc1 -fopenmp -fopenmp-version=51 -fopenmp-enable-irbuilder -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -fopenmp-enable-irbuilder -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -debug-info-kind=limited -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 -fopenmp -fopenmp-version=51 -fopenmp-enable-irbuilder -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -debug-info-kind=limited -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck %s
// RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck --check-prefix SIMD-ONLY0 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=51 -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck --check-prefix SIMD-ONLY0 %s
// RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=51 -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -debug-info-kind=limited -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY0 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=51 -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -debug-info-kind=limited -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY0 %s
// SIMD-ONLY0-NOT: {{__kmpc|__tgt}} // SIMD-ONLY0-NOT: {{__kmpc|__tgt}}
// expected-no-diagnostics // expected-no-diagnostics
#ifndef HEADER #ifndef HEADER
#define HEADER #define HEADER
template <class T> template <class T>
T tmain(T argc) { T tmain(T argc) {
static T a; static T a;
#pragma omp flush #pragma omp flush
#pragma omp flush acq_rel #pragma omp flush acq_rel
#pragma omp flush acquire #pragma omp flush acquire
#pragma omp flush release #pragma omp flush release
#pragma omp flush seq_cst
#pragma omp flush(a) #pragma omp flush(a)
return a + argc; return a + argc;
} }
// CHECK-LABEL: @main // CHECK-LABEL: @main
int main() { int main() {
static int a; static int a;
#pragma omp flush #pragma omp flush
#pragma omp flush acq_rel #pragma omp flush acq_rel
#pragma omp flush acquire #pragma omp flush acquire
#pragma omp flush release #pragma omp flush release
#pragma omp flush seq_cst
#pragma omp flush(a) #pragma omp flush(a)
// CHECK: call {{.*}}void @__kmpc_flush(%{{.+}}* {{(@|%).+}}) // CHECK: call {{.*}}void @__kmpc_flush(%{{.+}}* {{(@|%).+}})
// CHECK: call {{.*}}void @__kmpc_flush(%{{.+}}* {{(@|%).+}}) // CHECK: call {{.*}}void @__kmpc_flush(%{{.+}}* {{(@|%).+}})
// CHECK: call {{.*}}void @__kmpc_flush(%{{.+}}* {{(@|%).+}}) // CHECK: call {{.*}}void @__kmpc_flush(%{{.+}}* {{(@|%).+}})
// CHECK: call {{.*}}void @__kmpc_flush(%{{.+}}* {{(@|%).+}}) // CHECK: call {{.*}}void @__kmpc_flush(%{{.+}}* {{(@|%).+}})
// CHECK: call {{.*}}void @__kmpc_flush(%{{.+}}* {{(@|%).+}}) // CHECK: call {{.*}}void @__kmpc_flush(%{{.+}}* {{(@|%).+}})
return tmain(a); return tmain(a);
// CHECK: call {{.*}} [[TMAIN:@.+]]( // CHECK: call {{.*}} [[TMAIN:@.+]](
Show All 14 Lines

clang/test/OpenMP/flush_messages.cpp

// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 100 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 100 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -ferror-limit 100 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp51 -fopenmp -ferror-limit 100 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 100 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 100 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -ferror-limit 100 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,omp51 -fopenmp-simd -ferror-limit 100 %s -Wuninitialized
struct S1 { // expected-note 2 {{declared here}} struct S1 { // expected-note 2 {{declared here}}
int a; int a;
}; };
template <class T> template <class T>
T tmain(T argc) { T tmain(T argc) {
#pragma omp flush allocate(argc) // expected-error {{unexpected OpenMP clause 'allocate' in directive '#pragma omp flush'}} #pragma omp flush allocate(argc) // expected-error {{unexpected OpenMP clause 'allocate' in directive '#pragma omp flush'}}
▲ Show 20 Lines • Show All 121 Lines • ▼ Show 20 Lines
#pragma omp parallel flush(argc) // expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}} #pragma omp parallel flush(argc) // expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}}
; ;
#pragma omp flush seq_cst // expected-error {{unexpected OpenMP clause 'seq_cst' in directive '#pragma omp flush'}} #pragma omp flush seq_cst // expected-error {{unexpected OpenMP clause 'seq_cst' in directive '#pragma omp flush'}}
#pragma omp flush acq_rel // omp45-error {{unexpected OpenMP clause 'acq_rel' in directive '#pragma omp flush'}} #pragma omp flush acq_rel // omp45-error {{unexpected OpenMP clause 'acq_rel' in directive '#pragma omp flush'}}
#pragma omp flush acquire // omp45-error {{unexpected OpenMP clause 'acquire' in directive '#pragma omp flush'}} #pragma omp flush acquire // omp45-error {{unexpected OpenMP clause 'acquire' in directive '#pragma omp flush'}}
#pragma omp flush release // omp45-error {{unexpected OpenMP clause 'release' in directive '#pragma omp flush'}} #pragma omp flush release // omp45-error {{unexpected OpenMP clause 'release' in directive '#pragma omp flush'}}
#pragma omp flush relaxed // expected-error {{unexpected OpenMP clause 'relaxed' in directive '#pragma omp flush'}} #pragma omp flush relaxed // expected-error {{unexpected OpenMP clause 'relaxed' in directive '#pragma omp flush'}}
#pragma omp flush seq_cst // expected-error {{unexpected OpenMP clause 'seq_cst' in directive '#pragma omp flush'}} #pragma omp flush seq_cst // expected-error {{unexpected OpenMP clause 'seq_cst' in directive '#pragma omp flush'}}
#pragma omp flush acq_rel acquire // omp45-error {{unexpected OpenMP clause 'acq_rel' in directive '#pragma omp flush'}} omp45-error {{unexpected OpenMP clause 'acquire' in directive '#pragma omp flush'}} omp50-error {{directive '#pragma omp flush' cannot contain more than one 'acq_rel', 'acquire' or 'release' clause}} omp50-note {{'acq_rel' clause used here}} #pragma omp flush acq_rel acquire // omp45-error {{unexpected OpenMP clause 'acq_rel' in directive '#pragma omp flush'}} omp45-error {{unexpected OpenMP clause 'acquire' in directive '#pragma omp flush'}} omp50-error {{directive '#pragma omp flush' cannot contain more than one 'seq_cst', 'acq_rel', 'acquire' or 'release' clause}} omp50-note {{'acq_rel' clause used here}} omp51-error {{directive '#pragma omp flush' cannot contain more than one 'seq_cst', 'acq_rel', 'acquire' or 'release' clause}} omp51-note {{'acq_rel' clause used here}}
#pragma omp flush release acquire // omp45-error {{unexpected OpenMP clause 'release' in directive '#pragma omp flush'}} omp45-error {{unexpected OpenMP clause 'acquire' in directive '#pragma omp flush'}} omp50-error {{directive '#pragma omp flush' cannot contain more than one 'acq_rel', 'acquire' or 'release' clause}} omp50-note {{'release' clause used here}}
#pragma omp flush release acquire // omp45-error {{unexpected OpenMP clause 'release' in directive '#pragma omp flush'}} omp45-error {{unexpected OpenMP clause 'acquire' in directive '#pragma omp flush'}} omp50-error {{directive '#pragma omp flush' cannot contain more than one 'seq_cst', 'acq_rel', 'acquire' or 'release' clause}} omp50-note {{'release' clause used here}} omp51-error {{directive '#pragma omp flush' cannot contain more than one 'seq_cst', 'acq_rel', 'acquire' or 'release' clause}} omp51-note {{'release' clause used here}}
#pragma omp flush acq_rel (argc) // omp45-error {{unexpected OpenMP clause 'acq_rel' in directive '#pragma omp flush'}} expected-warning {{extra tokens at the end of '#pragma omp flush' are ignored}} #pragma omp flush acq_rel (argc) // omp45-error {{unexpected OpenMP clause 'acq_rel' in directive '#pragma omp flush'}} expected-warning {{extra tokens at the end of '#pragma omp flush' are ignored}}
#pragma omp flush(argc) acq_rel // omp45-error {{unexpected OpenMP clause 'acq_rel' in directive '#pragma omp flush'}} omp50-error {{'flush' directive with memory order clause 'acq_rel' cannot have the list}} omp50-note {{memory order clause 'acq_rel' is specified here}} #pragma omp flush(argc) acq_rel // omp45-error {{unexpected OpenMP clause 'acq_rel' in directive '#pragma omp flush'}} omp50-error {{'flush' directive with memory order clause 'acq_rel' cannot have the list}} omp50-note {{memory order clause 'acq_rel' is specified here}} omp51-error {{'flush' directive with memory order clause 'acq_rel' cannot have the list}} omp51-note {{memory order clause 'acq_rel' is specified here}}
return tmain(argc); return tmain(argc);
} }

llvm/include/llvm/Frontend/OpenMP/OMP.td

Show First 20 Lines • Show All 511 Lines • ▼ Show 20 Lines let allowedClauses = [
VersionedClause<OMPC_Allocate, 50> VersionedClause<OMPC_Allocate, 50>
]; ];
} }
def OMP_Flush : Directive<"flush"> { def OMP_Flush : Directive<"flush"> {
let allowedOnceClauses = [ let allowedOnceClauses = [
VersionedClause<OMPC_AcqRel, 50>, VersionedClause<OMPC_AcqRel, 50>,
VersionedClause<OMPC_Acquire, 50>, VersionedClause<OMPC_Acquire, 50>,
VersionedClause<OMPC_Release, 50>, VersionedClause<OMPC_Release, 50>,
VersionedClause<OMPC_SeqCst, 51>,
// TODO This should ne `none` instead. Comment carried over from // TODO This should ne `none` instead. Comment carried over from
// OMPKinds.def. // OMPKinds.def.
VersionedClause<OMPC_Flush> VersionedClause<OMPC_Flush>
]; ];
} }
def OMP_Ordered : Directive<"ordered"> { def OMP_Ordered : Directive<"ordered"> {
let allowedClauses = [ let allowedClauses = [
VersionedClause<OMPC_Depend> VersionedClause<OMPC_Depend>
▲ Show 20 Lines • Show All 1,246 Lines • Show Last 20 Lines

llvm/lib/Analysis/AliasAnalysisEvaluator.cpp

Show All 33 Lines
static cl::opt<bool> PrintModRef("print-modref", cl::ReallyHidden); static cl::opt<bool> PrintModRef("print-modref", cl::ReallyHidden);
static cl::opt<bool> PrintMust("print-must", cl::ReallyHidden); static cl::opt<bool> PrintMust("print-must", cl::ReallyHidden);
static cl::opt<bool> PrintMustRef("print-mustref", cl::ReallyHidden); static cl::opt<bool> PrintMustRef("print-mustref", cl::ReallyHidden);
static cl::opt<bool> PrintMustMod("print-mustmod", cl::ReallyHidden); static cl::opt<bool> PrintMustMod("print-mustmod", cl::ReallyHidden);
static cl::opt<bool> PrintMustModRef("print-mustmodref", cl::ReallyHidden); static cl::opt<bool> PrintMustModRef("print-mustmodref", cl::ReallyHidden);
static cl::opt<bool> EvalAAMD("evaluate-aa-metadata", cl::ReallyHidden); static cl::opt<bool> EvalAAMD("evaluate-aa-metadata", cl::ReallyHidden);
static void PrintResults(AliasResult AR, bool P, const Value *V1, static void PrintResults(AliasResult AR, bool P,
const Value *V2, const Module *M) { std::pair<const Value *, Type *> Loc1,
std::pair<const Value *, Type *> Loc2,
const Module *M) {
if (PrintAll || P) { if (PrintAll || P) {
Type *Ty1 = Loc1.second, *Ty2 = Loc2.second;
unsigned AS1 = Loc1.first->getType()->getPointerAddressSpace();
unsigned AS2 = Loc2.first->getType()->getPointerAddressSpace();
std::string o1, o2; std::string o1, o2;
{ {
raw_string_ostream os1(o1), os2(o2); raw_string_ostream os1(o1), os2(o2);
V1->printAsOperand(os1, true, M); Loc1.first->printAsOperand(os1, false, M);
V2->printAsOperand(os2, true, M); Loc2.first->printAsOperand(os2, false, M);
} }
if (o2 < o1) { if (o2 < o1) {
std::swap(o1, o2); std::swap(o1, o2);
std::swap(Ty1, Ty2);
std::swap(AS1, AS2);
// Change offset sign for the local AR, for printing only. // Change offset sign for the local AR, for printing only.
AR.swap(); AR.swap();
} }
errs() << " " << AR << ":\t" << o1 << ", " << o2 << "\n"; errs() << " " << AR << ":\t";
Ty1->print(errs(), false, /* NoDetails */ true);
if (AS1 != 0)
errs() << " addrspace(" << AS1 << ")";
errs() << "* " << o1 << ", ";
Ty2->print(errs(), false, /* NoDetails */ true);
if (AS2 != 0)
errs() << " addrspace(" << AS2 << ")";
errs() << "* " << o2 << "\n";
} }
} }
static inline void PrintModRefResults(const char *Msg, bool P, Instruction *I, static inline void PrintModRefResults(
Value *Ptr, Module *M) { const char *Msg, bool P, Instruction *I,
std::pair<const Value *, Type *> Loc, Module *M) {
if (PrintAll || P) { if (PrintAll || P) {
errs() << " " << Msg << ": Ptr: "; errs() << " " << Msg << ": Ptr: ";
Ptr->printAsOperand(errs(), true, M); Loc.second->print(errs(), false, /* NoDetails */ true);
errs() << "* ";
Loc.first->printAsOperand(errs(), false, M);
errs() << "\t<->" << *I << '\n'; errs() << "\t<->" << *I << '\n';
} }
} }
static inline void PrintModRefResults(const char *Msg, bool P, CallBase *CallA, static inline void PrintModRefResults(const char *Msg, bool P, CallBase *CallA,
CallBase *CallB, Module *M) { CallBase *CallB, Module *M) {
if (PrintAll || P) { if (PrintAll || P) {
errs() << " " << Msg << ": " << *CallA << " <-> " << *CallB << '\n'; errs() << " " << Msg << ": " << *CallA << " <-> " << *CallB << '\n';
Show All 18 LinesPreservedAnalyses AAEvaluator::run(Function &F, FunctionAnalysisManager &AM) {
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
void AAEvaluator::runInternal(Function &F, AAResults &AA) { void AAEvaluator::runInternal(Function &F, AAResults &AA) {
const DataLayout &DL = F.getParent()->getDataLayout(); const DataLayout &DL = F.getParent()->getDataLayout();
++FunctionCount; ++FunctionCount;
SetVector<Value *> Pointers; SetVector<std::pair<const Value *, Type *>> Pointers;
SmallSetVector<CallBase *, 16> Calls; SmallSetVector<CallBase *, 16> Calls;
SetVector<Value *> Loads; SetVector<Value *> Loads;
SetVector<Value *> Stores; SetVector<Value *> Stores;
for (auto &I : F.args())
if (I.getType()->isPointerTy()) // Add all pointer arguments.
Pointers.insert(&I);
for (Instruction &Inst : instructions(F)) { for (Instruction &Inst : instructions(F)) {
if (Inst.getType()->isPointerTy()) // Add all pointer instructions. if (auto *LI = dyn_cast<LoadInst>(&Inst)) {
Pointers.insert(&Inst); Pointers.insert({LI->getPointerOperand(), LI->getType()});
if (EvalAAMD && isa<LoadInst>(&Inst)) Loads.insert(LI);
Loads.insert(&Inst); } else if (auto *SI = dyn_cast<StoreInst>(&Inst)) {
if (EvalAAMD && isa<StoreInst>(&Inst)) Pointers.insert({SI->getPointerOperand(),
Stores.insert(&Inst); SI->getValueOperand()->getType()});
if (auto *Call = dyn_cast<CallBase>(&Inst)) { Stores.insert(SI);
Value *Callee = Call->getCalledOperand(); } else if (auto *CB = dyn_cast<CallBase>(&Inst))
// Skip actual functions for direct function calls. Calls.insert(CB);
if (!isa<Function>(Callee) && isInterestingPointer(Callee))
Pointers.insert(Callee);
// Consider formals.
for (Use &DataOp : Call->data_ops())
if (isInterestingPointer(DataOp))
Pointers.insert(DataOp);
Calls.insert(Call);
} else {
// Consider all operands.
for (Use &Op : Inst.operands())
if (isInterestingPointer(Op))
Pointers.insert(Op);
}
} }
if (PrintAll || PrintNoAlias || PrintMayAlias || PrintPartialAlias || if (PrintAll || PrintNoAlias || PrintMayAlias || PrintPartialAlias ||
PrintMustAlias || PrintNoModRef || PrintMod || PrintRef || PrintModRef) PrintMustAlias || PrintNoModRef || PrintMod || PrintRef || PrintModRef)
errs() << "Function: " << F.getName() << ": " << Pointers.size() errs() << "Function: " << F.getName() << ": " << Pointers.size()
<< " pointers, " << Calls.size() << " call sites\n"; << " pointers, " << Calls.size() << " call sites\n";
// iterate over the worklist, and run the full (n^2)/2 disambiguations // iterate over the worklist, and run the full (n^2)/2 disambiguations
for (SetVector<Value *>::iterator I1 = Pointers.begin(), E = Pointers.end(); for (auto I1 = Pointers.begin(), E = Pointers.end(); I1 != E; ++I1) {
I1 != E; ++I1) { LocationSize Size1 = LocationSize::precise(DL.getTypeStoreSize(I1->second));
auto I1Size = LocationSize::afterPointer(); for (auto I2 = Pointers.begin(); I2 != I1; ++I2) {
Type *I1ElTy = (*I1)->getType()->getPointerElementType(); LocationSize Size2 =
if (I1ElTy->isSized()) LocationSize::precise(DL.getTypeStoreSize(I2->second));
I1Size = LocationSize::precise(DL.getTypeStoreSize(I1ElTy)); AliasResult AR = AA.alias(I1->first, Size1, I2->first, Size2);
for (SetVector<Value *>::iterator I2 = Pointers.begin(); I2 != I1; ++I2) {
auto I2Size = LocationSize::afterPointer();
Type *I2ElTy = (*I2)->getType()->getPointerElementType();
if (I2ElTy->isSized())
I2Size = LocationSize::precise(DL.getTypeStoreSize(I2ElTy));
AliasResult AR = AA.alias(*I1, I1Size, *I2, I2Size);
switch (AR) { switch (AR) {
case AliasResult::NoAlias: case AliasResult::NoAlias:
PrintResults(AR, PrintNoAlias, *I1, *I2, F.getParent()); PrintResults(AR, PrintNoAlias, *I1, *I2, F.getParent());
++NoAliasCount; ++NoAliasCount;
break; break;
case AliasResult::MayAlias: case AliasResult::MayAlias:
PrintResults(AR, PrintMayAlias, *I1, *I2, F.getParent()); PrintResults(AR, PrintMayAlias, *I1, *I2, F.getParent());
++MayAliasCount; ++MayAliasCount;
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines for (SetVector<Value *>::iterator I1 = Stores.begin(), E = Stores.end();
break; break;
} }
} }
} }
} }
// Mod/ref alias analysis: compare all pairs of calls and values // Mod/ref alias analysis: compare all pairs of calls and values
for (CallBase *Call : Calls) { for (CallBase *Call : Calls) {
for (auto Pointer : Pointers) { for (const auto &Pointer : Pointers) {
auto Size = LocationSize::afterPointer(); LocationSize Size =
Type *ElTy = Pointer->getType()->getPointerElementType(); LocationSize::precise(DL.getTypeStoreSize(Pointer.second));
if (ElTy->isSized()) switch (AA.getModRefInfo(Call, Pointer.first, Size)) {
Size = LocationSize::precise(DL.getTypeStoreSize(ElTy));
switch (AA.getModRefInfo(Call, Pointer, Size)) {
case ModRefInfo::NoModRef: case ModRefInfo::NoModRef:
PrintModRefResults("NoModRef", PrintNoModRef, Call, Pointer, PrintModRefResults("NoModRef", PrintNoModRef, Call, Pointer,
F.getParent()); F.getParent());
++NoModRefCount; ++NoModRefCount;
break; break;
case ModRefInfo::Mod: case ModRefInfo::Mod:
PrintModRefResults("Just Mod", PrintMod, Call, Pointer, F.getParent()); PrintModRefResults("Just Mod", PrintMod, Call, Pointer, F.getParent());
++ModCount; ++ModCount;
▲ Show 20 Lines • Show All 188 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/128-bit-ptr.ll

Show All 12 Lines
; CHECK: Function: test0 ; CHECK: Function: test0
; CHECK-NOT: MayAlias: ; CHECK-NOT: MayAlias:
define void @test0(%T addrspace(100)* %P) { define void @test0(%T addrspace(100)* %P) {
%A = getelementptr %T, %T addrspace(100)* %P, i64 0 %A = getelementptr %T, %T addrspace(100)* %P, i64 0
%B = getelementptr %T, %T addrspace(100)* %P, i64 0, i32 0 %B = getelementptr %T, %T addrspace(100)* %P, i64 0, i32 0
%C = getelementptr %T, %T addrspace(100)* %P, i64 0, i32 1 %C = getelementptr %T, %T addrspace(100)* %P, i64 0, i32 1
%D = getelementptr %T, %T addrspace(100)* %P, i64 0, i32 1, i64 0 %D = getelementptr %T, %T addrspace(100)* %P, i64 0, i32 1, i64 0
%E = getelementptr %T, %T addrspace(100)* %P, i64 0, i32 1, i64 5 %E = getelementptr %T, %T addrspace(100)* %P, i64 0, i32 1, i64 5
load %T, %T addrspace(100)* %A
load i32, i32 addrspace(100)* %B
load [10 x i8], [10 x i8] addrspace(100)* %C
load i8, i8 addrspace(100)* %D
load i8, i8 addrspace(100)* %E
ret void ret void
} }
; test1 checks that >64 bits of index can be considered. ; test1 checks that >64 bits of index can be considered.
; If BasicAA is truncating the arithmetic, it will conclude ; If BasicAA is truncating the arithmetic, it will conclude
; that %A and %B must alias when in fact they must not. ; that %A and %B must alias when in fact they must not.
; CHECK: Function: test1 ; CHECK: Function: test1
; CHECK-NOT: MustAlias: ; CHECK-NOT: MustAlias:
; CHECK: NoAlias: ; CHECK: NoAlias:
; CHECK-SAME: %A ; CHECK-SAME: %A
; CHECK-SAME: %B ; CHECK-SAME: %B
define void @test1(double addrspace(100)* %P, i128 %i) { define void @test1(double addrspace(100)* %P, i128 %i) {
; 1180591620717411303424 is 2**70 ; 1180591620717411303424 is 2**70
; 590295810358705651712 is 2**69 ; 590295810358705651712 is 2**69
%i70 = add i128 %i, 1180591620717411303424 %i70 = add i128 %i, 1180591620717411303424
%i69 = add i128 %i, 590295810358705651712 %i69 = add i128 %i, 590295810358705651712
%A = getelementptr double, double addrspace(100)* %P, i128 %i70 %A = getelementptr double, double addrspace(100)* %P, i128 %i70
%B = getelementptr double, double addrspace(100)* %P, i128 %i69 %B = getelementptr double, double addrspace(100)* %P, i128 %i69
load double, double addrspace(100)* %A
load double, double addrspace(100)* %B
ret void ret void
} }
; test2 checks that >64 bits of index can be considered ; test2 checks that >64 bits of index can be considered
; and computes the same address in two ways to ensure that ; and computes the same address in two ways to ensure that
; they are considered equivalent. ; they are considered equivalent.
; CHECK: Function: test2 ; CHECK: Function: test2
; CHECK: MustAlias: ; CHECK: MustAlias:
; CHECK-SAME: %A ; CHECK-SAME: %A
; CHECK-SAME: %C ; CHECK-SAME: %C
define void @test2(double addrspace(100)* %P, i128 %i) { define void @test2(double addrspace(100)* %P, i128 %i) {
; 1180591620717411303424 is 2**70 ; 1180591620717411303424 is 2**70
; 590295810358705651712 is 2**69 ; 590295810358705651712 is 2**69
%i70 = add i128 %i, 1180591620717411303424 %i70 = add i128 %i, 1180591620717411303424
%i69 = add i128 %i, 590295810358705651712 %i69 = add i128 %i, 590295810358705651712
%j70 = add i128 %i69, 590295810358705651712 %j70 = add i128 %i69, 590295810358705651712
%A = getelementptr double, double addrspace(100)* %P, i128 %i70 %A = getelementptr double, double addrspace(100)* %P, i128 %i70
%C = getelementptr double, double addrspace(100)* %P, i128 %j70 %C = getelementptr double, double addrspace(100)* %P, i128 %j70
load double, double addrspace(100)* %A
load double, double addrspace(100)* %C
ret void ret void
} }

llvm/test/Analysis/BasicAA/2006-03-03-BadArraySubscript.ll

Show All 20 Linesno_exit: ; preds = %no_exit, %entry
%tmp.13 = add i32 %tmp.12, %tmp.9 ; <i32> [#uses=1] %tmp.13 = add i32 %tmp.12, %tmp.9 ; <i32> [#uses=1]
%inc = add i32 %i.0.0, 1 ; <i32> [#uses=2] %inc = add i32 %i.0.0, 1 ; <i32> [#uses=2]
%tmp.2 = icmp slt i32 %inc, %N ; <i1> [#uses=1] %tmp.2 = icmp slt i32 %inc, %N ; <i1> [#uses=1]
br i1 %tmp.2, label %no_exit, label %loopexit br i1 %tmp.2, label %no_exit, label %loopexit
loopexit: ; preds = %no_exit, %entry loopexit: ; preds = %no_exit, %entry
%Y.0.1 = phi i32 [ 0, %entry ], [ %tmp.13, %no_exit ] ; <i32> [#uses=1] %Y.0.1 = phi i32 [ 0, %entry ], [ %tmp.13, %no_exit ] ; <i32> [#uses=1]
%tmp.4 = getelementptr [3 x [3 x i32]], [3 x [3 x i32]]* %X, i32 0, i32 0 ; <[3 x i32]*> [#uses=1] %tmp.4 = getelementptr [3 x [3 x i32]], [3 x [3 x i32]]* %X, i32 0, i32 0 ; <[3 x i32]*> [#uses=1]
load [3 x i32], [3 x i32]* %tmp.4
%tmp.15 = call i32 (...) @foo( [3 x i32]* %tmp.4, i32 %Y.0.1 ) ; <i32> [#uses=0] %tmp.15 = call i32 (...) @foo( [3 x i32]* %tmp.4, i32 %Y.0.1 ) ; <i32> [#uses=0]
ret void ret void
} }
declare i32 @foo(...) declare i32 @foo(...)

llvm/test/Analysis/BasicAA/args-rets-allocas-loads.ll

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linesdefine void @caller_a(double* %arg_a0,
store double 0.0, double* %normal_ret_a0 store double 0.0, double* %normal_ret_a0
store double 0.0, double* %normal_ret_a1 store double 0.0, double* %normal_ret_a1
store double 0.0, double* %noalias_ret_a0 store double 0.0, double* %noalias_ret_a0
store double 0.0, double* %noalias_ret_a1 store double 0.0, double* %noalias_ret_a1
ret void ret void
} }
; CHECK: Function: caller_a: 16 pointers, 8 call sites ; CHECK: Function: caller_a: 16 pointers, 8 call sites
; CHECK-NEXT: MayAlias: double** %indirect_a0, double** %indirect_a1
; CHECK-NEXT: MayAlias: double** %indirect_a0, double* %loaded_a0
; CHECK-NEXT: MayAlias: double** %indirect_a1, double* %loaded_a0
; CHECK-NEXT: MayAlias: double** %indirect_a0, double* %loaded_a1
; CHECK-NEXT: MayAlias: double** %indirect_a1, double* %loaded_a1
; CHECK-NEXT: MayAlias: double* %loaded_a0, double* %loaded_a1
; CHECK-NEXT: MayAlias: double* %arg_a0, double** %indirect_a0
; CHECK-NEXT: MayAlias: double* %arg_a0, double** %indirect_a1
; CHECK-NEXT: MayAlias: double* %arg_a0, double* %loaded_a0
; CHECK-NEXT: MayAlias: double* %arg_a0, double* %loaded_a1
; CHECK-NEXT: MayAlias: double* %arg_a1, double** %indirect_a0
; CHECK-NEXT: MayAlias: double* %arg_a1, double** %indirect_a1
; CHECK-NEXT: MayAlias: double* %arg_a1, double* %loaded_a0
; CHECK-NEXT: MayAlias: double* %arg_a1, double* %loaded_a1
; CHECK-NEXT: MayAlias: double* %arg_a0, double* %arg_a1 ; CHECK-NEXT: MayAlias: double* %arg_a0, double* %arg_a1
; CHECK-NEXT: NoAlias: double** %indirect_a0, double* %noalias_arg_a0
; CHECK-NEXT: NoAlias: double** %indirect_a1, double* %noalias_arg_a0
; CHECK-NEXT: NoAlias: double* %loaded_a0, double* %noalias_arg_a0
; CHECK-NEXT: NoAlias: double* %loaded_a1, double* %noalias_arg_a0
; CHECK-NEXT: NoAlias: double* %arg_a0, double* %noalias_arg_a0 ; CHECK-NEXT: NoAlias: double* %arg_a0, double* %noalias_arg_a0
; CHECK-NEXT: NoAlias: double* %arg_a1, double* %noalias_arg_a0 ; CHECK-NEXT: NoAlias: double* %arg_a1, double* %noalias_arg_a0
; CHECK-NEXT: NoAlias: double** %indirect_a0, double* %noalias_arg_a1
; CHECK-NEXT: NoAlias: double** %indirect_a1, double* %noalias_arg_a1
; CHECK-NEXT: NoAlias: double* %loaded_a0, double* %noalias_arg_a1
; CHECK-NEXT: NoAlias: double* %loaded_a1, double* %noalias_arg_a1
; CHECK-NEXT: NoAlias: double* %arg_a0, double* %noalias_arg_a1 ; CHECK-NEXT: NoAlias: double* %arg_a0, double* %noalias_arg_a1
; CHECK-NEXT: NoAlias: double* %arg_a1, double* %noalias_arg_a1 ; CHECK-NEXT: NoAlias: double* %arg_a1, double* %noalias_arg_a1
; CHECK-NEXT: NoAlias: double* %noalias_arg_a0, double* %noalias_arg_a1 ; CHECK-NEXT: NoAlias: double* %noalias_arg_a0, double* %noalias_arg_a1
; CHECK-NEXT: MayAlias: double* %arg_a0, double** %indirect_a0 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double** %indirect_a0
; CHECK-NEXT: MayAlias: double* %arg_a1, double** %indirect_a0 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double** %indirect_a1
; CHECK-NEXT: NoAlias: double* %noalias_arg_a0, double** %indirect_a0 ; CHECK-NEXT: MayAlias: double* %escape_alloca_a0, double* %loaded_a0
; CHECK-NEXT: NoAlias: double* %noalias_arg_a1, double** %indirect_a0 ; CHECK-NEXT: MayAlias: double* %escape_alloca_a0, double* %loaded_a1
; CHECK-NEXT: MayAlias: double* %arg_a0, double** %indirect_a1
; CHECK-NEXT: MayAlias: double* %arg_a1, double** %indirect_a1
; CHECK-NEXT: NoAlias: double* %noalias_arg_a0, double** %indirect_a1
; CHECK-NEXT: NoAlias: double* %noalias_arg_a1, double** %indirect_a1
; CHECK-NEXT: MayAlias: double** %indirect_a0, double** %indirect_a1
; CHECK-NEXT: NoAlias: double* %arg_a0, double* %escape_alloca_a0 ; CHECK-NEXT: NoAlias: double* %arg_a0, double* %escape_alloca_a0
; CHECK-NEXT: NoAlias: double* %arg_a1, double* %escape_alloca_a0 ; CHECK-NEXT: NoAlias: double* %arg_a1, double* %escape_alloca_a0
; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double* %noalias_arg_a0 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double* %noalias_arg_a0
; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double* %noalias_arg_a1 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double* %noalias_arg_a1
; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double** %indirect_a0 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a1, double** %indirect_a0
; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double** %indirect_a1 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a1, double** %indirect_a1
; CHECK-NEXT: MayAlias: double* %escape_alloca_a1, double* %loaded_a0
; CHECK-NEXT: MayAlias: double* %escape_alloca_a1, double* %loaded_a1
; CHECK-NEXT: NoAlias: double* %arg_a0, double* %escape_alloca_a1 ; CHECK-NEXT: NoAlias: double* %arg_a0, double* %escape_alloca_a1
; CHECK-NEXT: NoAlias: double* %arg_a1, double* %escape_alloca_a1 ; CHECK-NEXT: NoAlias: double* %arg_a1, double* %escape_alloca_a1
; CHECK-NEXT: NoAlias: double* %escape_alloca_a1, double* %noalias_arg_a0 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a1, double* %noalias_arg_a0
; CHECK-NEXT: NoAlias: double* %escape_alloca_a1, double* %noalias_arg_a1 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a1, double* %noalias_arg_a1
; CHECK-NEXT: NoAlias: double* %escape_alloca_a1, double** %indirect_a0
; CHECK-NEXT: NoAlias: double* %escape_alloca_a1, double** %indirect_a1
; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double* %escape_alloca_a1 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double* %escape_alloca_a1
; CHECK-NEXT: NoAlias: double** %indirect_a0, double* %noescape_alloca_a0
; CHECK-NEXT: NoAlias: double** %indirect_a1, double* %noescape_alloca_a0
; CHECK-NEXT: NoAlias: double* %loaded_a0, double* %noescape_alloca_a0
; CHECK-NEXT: NoAlias: double* %loaded_a1, double* %noescape_alloca_a0
; CHECK-NEXT: NoAlias: double* %arg_a0, double* %noescape_alloca_a0 ; CHECK-NEXT: NoAlias: double* %arg_a0, double* %noescape_alloca_a0
; CHECK-NEXT: NoAlias: double* %arg_a1, double* %noescape_alloca_a0 ; CHECK-NEXT: NoAlias: double* %arg_a1, double* %noescape_alloca_a0
; CHECK-NEXT: NoAlias: double* %noalias_arg_a0, double* %noescape_alloca_a0 ; CHECK-NEXT: NoAlias: double* %noalias_arg_a0, double* %noescape_alloca_a0
; CHECK-NEXT: NoAlias: double* %noalias_arg_a1, double* %noescape_alloca_a0 ; CHECK-NEXT: NoAlias: double* %noalias_arg_a1, double* %noescape_alloca_a0
; CHECK-NEXT: NoAlias: double* %noescape_alloca_a0, double** %indirect_a0
; CHECK-NEXT: NoAlias: double* %noescape_alloca_a0, double** %indirect_a1
; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double* %noescape_alloca_a0 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double* %noescape_alloca_a0
; CHECK-NEXT: NoAlias: double* %escape_alloca_a1, double* %noescape_alloca_a0 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a1, double* %noescape_alloca_a0
; CHECK-NEXT: NoAlias: double** %indirect_a0, double* %noescape_alloca_a1
; CHECK-NEXT: NoAlias: double** %indirect_a1, double* %noescape_alloca_a1
; CHECK-NEXT: NoAlias: double* %loaded_a0, double* %noescape_alloca_a1
; CHECK-NEXT: NoAlias: double* %loaded_a1, double* %noescape_alloca_a1
; CHECK-NEXT: NoAlias: double* %arg_a0, double* %noescape_alloca_a1 ; CHECK-NEXT: NoAlias: double* %arg_a0, double* %noescape_alloca_a1
; CHECK-NEXT: NoAlias: double* %arg_a1, double* %noescape_alloca_a1 ; CHECK-NEXT: NoAlias: double* %arg_a1, double* %noescape_alloca_a1
; CHECK-NEXT: NoAlias: double* %noalias_arg_a0, double* %noescape_alloca_a1 ; CHECK-NEXT: NoAlias: double* %noalias_arg_a0, double* %noescape_alloca_a1
; CHECK-NEXT: NoAlias: double* %noalias_arg_a1, double* %noescape_alloca_a1 ; CHECK-NEXT: NoAlias: double* %noalias_arg_a1, double* %noescape_alloca_a1
; CHECK-NEXT: NoAlias: double* %noescape_alloca_a1, double** %indirect_a0
; CHECK-NEXT: NoAlias: double* %noescape_alloca_a1, double** %indirect_a1
; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double* %noescape_alloca_a1 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double* %noescape_alloca_a1
; CHECK-NEXT: NoAlias: double* %escape_alloca_a1, double* %noescape_alloca_a1 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a1, double* %noescape_alloca_a1
; CHECK-NEXT: NoAlias: double* %noescape_alloca_a0, double* %noescape_alloca_a1 ; CHECK-NEXT: NoAlias: double* %noescape_alloca_a0, double* %noescape_alloca_a1
; CHECK-NEXT: MayAlias: double** %indirect_a0, double* %normal_ret_a0
; CHECK-NEXT: MayAlias: double** %indirect_a1, double* %normal_ret_a0
; CHECK-NEXT: MayAlias: double* %loaded_a0, double* %normal_ret_a0
; CHECK-NEXT: MayAlias: double* %loaded_a1, double* %normal_ret_a0
; CHECK-NEXT: MayAlias: double* %arg_a0, double* %normal_ret_a0 ; CHECK-NEXT: MayAlias: double* %arg_a0, double* %normal_ret_a0
; CHECK-NEXT: MayAlias: double* %arg_a1, double* %normal_ret_a0 ; CHECK-NEXT: MayAlias: double* %arg_a1, double* %normal_ret_a0
; CHECK-NEXT: NoAlias: double* %noalias_arg_a0, double* %normal_ret_a0 ; CHECK-NEXT: NoAlias: double* %noalias_arg_a0, double* %normal_ret_a0
; CHECK-NEXT: NoAlias: double* %noalias_arg_a1, double* %normal_ret_a0 ; CHECK-NEXT: NoAlias: double* %noalias_arg_a1, double* %normal_ret_a0
; CHECK-NEXT: MayAlias: double* %normal_ret_a0, double** %indirect_a0
; CHECK-NEXT: MayAlias: double* %normal_ret_a0, double** %indirect_a1
; CHECK-NEXT: MayAlias: double* %escape_alloca_a0, double* %normal_ret_a0 ; CHECK-NEXT: MayAlias: double* %escape_alloca_a0, double* %normal_ret_a0
; CHECK-NEXT: MayAlias: double* %escape_alloca_a1, double* %normal_ret_a0 ; CHECK-NEXT: MayAlias: double* %escape_alloca_a1, double* %normal_ret_a0
; CHECK-NEXT: NoAlias: double* %noescape_alloca_a0, double* %normal_ret_a0 ; CHECK-NEXT: NoAlias: double* %noescape_alloca_a0, double* %normal_ret_a0
; CHECK-NEXT: NoAlias: double* %noescape_alloca_a1, double* %normal_ret_a0 ; CHECK-NEXT: NoAlias: double* %noescape_alloca_a1, double* %normal_ret_a0
; CHECK-NEXT: MayAlias: double** %indirect_a0, double* %normal_ret_a1
; CHECK-NEXT: MayAlias: double** %indirect_a1, double* %normal_ret_a1
; CHECK-NEXT: MayAlias: double* %loaded_a0, double* %normal_ret_a1
; CHECK-NEXT: MayAlias: double* %loaded_a1, double* %normal_ret_a1
; CHECK-NEXT: MayAlias: double* %arg_a0, double* %normal_ret_a1 ; CHECK-NEXT: MayAlias: double* %arg_a0, double* %normal_ret_a1
; CHECK-NEXT: MayAlias: double* %arg_a1, double* %normal_ret_a1 ; CHECK-NEXT: MayAlias: double* %arg_a1, double* %normal_ret_a1
; CHECK-NEXT: NoAlias: double* %noalias_arg_a0, double* %normal_ret_a1 ; CHECK-NEXT: NoAlias: double* %noalias_arg_a0, double* %normal_ret_a1
; CHECK-NEXT: NoAlias: double* %noalias_arg_a1, double* %normal_ret_a1 ; CHECK-NEXT: NoAlias: double* %noalias_arg_a1, double* %normal_ret_a1
; CHECK-NEXT: MayAlias: double* %normal_ret_a1, double** %indirect_a0
; CHECK-NEXT: MayAlias: double* %normal_ret_a1, double** %indirect_a1
; CHECK-NEXT: MayAlias: double* %escape_alloca_a0, double* %normal_ret_a1 ; CHECK-NEXT: MayAlias: double* %escape_alloca_a0, double* %normal_ret_a1
; CHECK-NEXT: MayAlias: double* %escape_alloca_a1, double* %normal_ret_a1 ; CHECK-NEXT: MayAlias: double* %escape_alloca_a1, double* %normal_ret_a1
; CHECK-NEXT: NoAlias: double* %noescape_alloca_a0, double* %normal_ret_a1 ; CHECK-NEXT: NoAlias: double* %noescape_alloca_a0, double* %normal_ret_a1
; CHECK-NEXT: NoAlias: double* %noescape_alloca_a1, double* %normal_ret_a1 ; CHECK-NEXT: NoAlias: double* %noescape_alloca_a1, double* %normal_ret_a1
; CHECK-NEXT: MayAlias: double* %normal_ret_a0, double* %normal_ret_a1 ; CHECK-NEXT: MayAlias: double* %normal_ret_a0, double* %normal_ret_a1
; CHECK-NEXT: NoAlias: double** %indirect_a0, double* %noalias_ret_a0
; CHECK-NEXT: NoAlias: double** %indirect_a1, double* %noalias_ret_a0
; CHECK-NEXT: NoAlias: double* %loaded_a0, double* %noalias_ret_a0
; CHECK-NEXT: NoAlias: double* %loaded_a1, double* %noalias_ret_a0
; CHECK-NEXT: NoAlias: double* %arg_a0, double* %noalias_ret_a0 ; CHECK-NEXT: NoAlias: double* %arg_a0, double* %noalias_ret_a0
; CHECK-NEXT: NoAlias: double* %arg_a1, double* %noalias_ret_a0 ; CHECK-NEXT: NoAlias: double* %arg_a1, double* %noalias_ret_a0
; CHECK-NEXT: NoAlias: double* %noalias_arg_a0, double* %noalias_ret_a0 ; CHECK-NEXT: NoAlias: double* %noalias_arg_a0, double* %noalias_ret_a0
; CHECK-NEXT: NoAlias: double* %noalias_arg_a1, double* %noalias_ret_a0 ; CHECK-NEXT: NoAlias: double* %noalias_arg_a1, double* %noalias_ret_a0
; CHECK-NEXT: NoAlias: double* %noalias_ret_a0, double** %indirect_a0
; CHECK-NEXT: NoAlias: double* %noalias_ret_a0, double** %indirect_a1
; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double* %noalias_ret_a0 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double* %noalias_ret_a0
; CHECK-NEXT: NoAlias: double* %escape_alloca_a1, double* %noalias_ret_a0 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a1, double* %noalias_ret_a0
; CHECK-NEXT: NoAlias: double* %noalias_ret_a0, double* %noescape_alloca_a0 ; CHECK-NEXT: NoAlias: double* %noalias_ret_a0, double* %noescape_alloca_a0
; CHECK-NEXT: NoAlias: double* %noalias_ret_a0, double* %noescape_alloca_a1 ; CHECK-NEXT: NoAlias: double* %noalias_ret_a0, double* %noescape_alloca_a1
; CHECK-NEXT: NoAlias: double* %noalias_ret_a0, double* %normal_ret_a0 ; CHECK-NEXT: NoAlias: double* %noalias_ret_a0, double* %normal_ret_a0
; CHECK-NEXT: NoAlias: double* %noalias_ret_a0, double* %normal_ret_a1 ; CHECK-NEXT: NoAlias: double* %noalias_ret_a0, double* %normal_ret_a1
; CHECK-NEXT: NoAlias: double** %indirect_a0, double* %noalias_ret_a1
; CHECK-NEXT: NoAlias: double** %indirect_a1, double* %noalias_ret_a1
; CHECK-NEXT: NoAlias: double* %loaded_a0, double* %noalias_ret_a1
; CHECK-NEXT: NoAlias: double* %loaded_a1, double* %noalias_ret_a1
; CHECK-NEXT: NoAlias: double* %arg_a0, double* %noalias_ret_a1 ; CHECK-NEXT: NoAlias: double* %arg_a0, double* %noalias_ret_a1
; CHECK-NEXT: NoAlias: double* %arg_a1, double* %noalias_ret_a1 ; CHECK-NEXT: NoAlias: double* %arg_a1, double* %noalias_ret_a1
; CHECK-NEXT: NoAlias: double* %noalias_arg_a0, double* %noalias_ret_a1 ; CHECK-NEXT: NoAlias: double* %noalias_arg_a0, double* %noalias_ret_a1
; CHECK-NEXT: NoAlias: double* %noalias_arg_a1, double* %noalias_ret_a1 ; CHECK-NEXT: NoAlias: double* %noalias_arg_a1, double* %noalias_ret_a1
; CHECK-NEXT: NoAlias: double* %noalias_ret_a1, double** %indirect_a0
; CHECK-NEXT: NoAlias: double* %noalias_ret_a1, double** %indirect_a1
; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double* %noalias_ret_a1 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a0, double* %noalias_ret_a1
; CHECK-NEXT: NoAlias: double* %escape_alloca_a1, double* %noalias_ret_a1 ; CHECK-NEXT: NoAlias: double* %escape_alloca_a1, double* %noalias_ret_a1
; CHECK-NEXT: NoAlias: double* %noalias_ret_a1, double* %noescape_alloca_a0 ; CHECK-NEXT: NoAlias: double* %noalias_ret_a1, double* %noescape_alloca_a0
; CHECK-NEXT: NoAlias: double* %noalias_ret_a1, double* %noescape_alloca_a1 ; CHECK-NEXT: NoAlias: double* %noalias_ret_a1, double* %noescape_alloca_a1
; CHECK-NEXT: NoAlias: double* %noalias_ret_a1, double* %normal_ret_a0 ; CHECK-NEXT: NoAlias: double* %noalias_ret_a1, double* %normal_ret_a0
; CHECK-NEXT: NoAlias: double* %noalias_ret_a1, double* %normal_ret_a1 ; CHECK-NEXT: NoAlias: double* %noalias_ret_a1, double* %normal_ret_a1
; CHECK-NEXT: NoAlias: double* %noalias_ret_a0, double* %noalias_ret_a1 ; CHECK-NEXT: NoAlias: double* %noalias_ret_a0, double* %noalias_ret_a1
; CHECK-NEXT: MayAlias: double* %arg_a0, double* %loaded_a0 ; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a0 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: MayAlias: double* %arg_a1, double* %loaded_a0 ; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a1 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: NoAlias: double* %loaded_a0, double* %noalias_arg_a0 ; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a0 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: NoAlias: double* %loaded_a0, double* %noalias_arg_a1 ; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a1 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: MayAlias: double* %loaded_a0, double** %indirect_a0
; CHECK-NEXT: MayAlias: double* %loaded_a0, double** %indirect_a1
; CHECK-NEXT: MayAlias: double* %escape_alloca_a0, double* %loaded_a0
; CHECK-NEXT: MayAlias: double* %escape_alloca_a1, double* %loaded_a0
; CHECK-NEXT: NoAlias: double* %loaded_a0, double* %noescape_alloca_a0
; CHECK-NEXT: NoAlias: double* %loaded_a0, double* %noescape_alloca_a1
; CHECK-NEXT: MayAlias: double* %loaded_a0, double* %normal_ret_a0
; CHECK-NEXT: MayAlias: double* %loaded_a0, double* %normal_ret_a1
; CHECK-NEXT: NoAlias: double* %loaded_a0, double* %noalias_ret_a0
; CHECK-NEXT: NoAlias: double* %loaded_a0, double* %noalias_ret_a1
; CHECK-NEXT: MayAlias: double* %arg_a0, double* %loaded_a1
; CHECK-NEXT: MayAlias: double* %arg_a1, double* %loaded_a1
; CHECK-NEXT: NoAlias: double* %loaded_a1, double* %noalias_arg_a0
; CHECK-NEXT: NoAlias: double* %loaded_a1, double* %noalias_arg_a1
; CHECK-NEXT: MayAlias: double* %loaded_a1, double** %indirect_a0
; CHECK-NEXT: MayAlias: double* %loaded_a1, double** %indirect_a1
; CHECK-NEXT: MayAlias: double* %escape_alloca_a0, double* %loaded_a1
; CHECK-NEXT: MayAlias: double* %escape_alloca_a1, double* %loaded_a1
; CHECK-NEXT: NoAlias: double* %loaded_a1, double* %noescape_alloca_a0
; CHECK-NEXT: NoAlias: double* %loaded_a1, double* %noescape_alloca_a1
; CHECK-NEXT: MayAlias: double* %loaded_a1, double* %normal_ret_a0
; CHECK-NEXT: MayAlias: double* %loaded_a1, double* %normal_ret_a1
; CHECK-NEXT: NoAlias: double* %loaded_a1, double* %noalias_ret_a0
; CHECK-NEXT: NoAlias: double* %loaded_a1, double* %noalias_ret_a1
; CHECK-NEXT: MayAlias: double* %loaded_a0, double* %loaded_a1
; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a0 <-> %normal_ret_a0 = call double* @normal_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a0 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a1 <-> %normal_ret_a0 = call double* @normal_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a1 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a0 <-> %normal_ret_a0 = call double* @normal_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a0 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a1 <-> %normal_ret_a0 = call double* @normal_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a1 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a0 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a1 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a0 <-> %normal_ret_a0 = call double* @normal_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a0 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a1 <-> %normal_ret_a0 = call double* @normal_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a1 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a0 <-> %normal_ret_a0 = call double* @normal_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a0 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a1 <-> %normal_ret_a0 = call double* @normal_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a1 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a0 <-> %normal_ret_a0 = call double* @normal_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a0 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a1 <-> %normal_ret_a0 = call double* @normal_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a1 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a0 <-> %normal_ret_a0 = call double* @normal_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a0 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a1 <-> %normal_ret_a0 = call double* @normal_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a1 <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a0 <-> %normal_ret_a0 = call double* @normal_returner() ; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a0 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a1 <-> %normal_ret_a0 = call double* @normal_returner() ; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a1 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a0 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a1 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a0 <-> %normal_ret_a1 = call double* @normal_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a0 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a1 <-> %normal_ret_a1 = call double* @normal_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a1 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a0 <-> %normal_ret_a1 = call double* @normal_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a0 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a1 <-> %normal_ret_a1 = call double* @normal_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a1 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a0 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a1 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a0 <-> %normal_ret_a1 = call double* @normal_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a0 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a1 <-> %normal_ret_a1 = call double* @normal_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a1 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a0 <-> %normal_ret_a1 = call double* @normal_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a0 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a1 <-> %normal_ret_a1 = call double* @normal_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a1 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a0 <-> %normal_ret_a1 = call double* @normal_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a0 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a1 <-> %normal_ret_a1 = call double* @normal_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a1 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a0 <-> %normal_ret_a1 = call double* @normal_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a0 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a1 <-> %normal_ret_a1 = call double* @normal_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a1 <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a0 <-> %normal_ret_a1 = call double* @normal_returner() ; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a0 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a1 <-> %normal_ret_a1 = call double* @normal_returner() ; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a1 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a0 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a1 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a0 <-> %noalias_ret_a0 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a0 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a1 <-> %noalias_ret_a0 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a1 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a0 <-> %noalias_ret_a0 = call double* @noalias_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a0 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a1 <-> %noalias_ret_a0 = call double* @noalias_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a1 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a0 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a1 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a0 <-> %noalias_ret_a0 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a0 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a1 <-> %noalias_ret_a0 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a1 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a0 <-> %noalias_ret_a0 = call double* @noalias_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a0 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a1 <-> %noalias_ret_a0 = call double* @noalias_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a1 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a0 <-> %noalias_ret_a0 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a0 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a1 <-> %noalias_ret_a0 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a1 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %noalias_ret_a0 <-> %noalias_ret_a0 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %noalias_ret_a0 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a1 <-> %noalias_ret_a0 = call double* @noalias_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a1 <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a0 <-> %noalias_ret_a0 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a0 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a1 <-> %noalias_ret_a0 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a1 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a0 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a1 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a0 <-> %noalias_ret_a1 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a0 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a1 <-> %noalias_ret_a1 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a1 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a0 <-> %noalias_ret_a1 = call double* @noalias_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a0 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a1 <-> %noalias_ret_a1 = call double* @noalias_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a1 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a0 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a1 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a0 <-> %noalias_ret_a1 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a0 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a1 <-> %noalias_ret_a1 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a1 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a0 <-> %noalias_ret_a1 = call double* @noalias_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a0 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a1 <-> %noalias_ret_a1 = call double* @noalias_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a1 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a0 <-> %noalias_ret_a1 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a0 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a1 <-> %noalias_ret_a1 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a1 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a0 <-> %noalias_ret_a1 = call double* @noalias_returner() ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a0 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %noalias_ret_a1 <-> %noalias_ret_a1 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double* %noalias_ret_a1 <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a0 <-> %noalias_ret_a1 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a0 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a1 <-> %noalias_ret_a1 = call double* @noalias_returner() ; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a1 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a0 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a1 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a0 <-> call void @callee(double* %escape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a0 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a1 <-> call void @callee(double* %escape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a1 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a0 <-> call void @callee(double* %escape_alloca_a0) ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a0 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a1 <-> call void @callee(double* %escape_alloca_a0) ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a1 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a0 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a1 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a0 <-> call void @callee(double* %escape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a0 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a1 <-> call void @callee(double* %escape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a1 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a0 <-> call void @callee(double* %escape_alloca_a0) ; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a0 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a1 <-> call void @callee(double* %escape_alloca_a0) ; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a1 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a0 <-> call void @callee(double* %escape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a0 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a1 <-> call void @callee(double* %escape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a1 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a0 <-> call void @callee(double* %escape_alloca_a0) ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a0 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a1 <-> call void @callee(double* %escape_alloca_a0) ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a1 <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a0 <-> call void @callee(double* %escape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a0 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a1 <-> call void @callee(double* %escape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a1 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a0 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a1 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a0 <-> call void @callee(double* %escape_alloca_a1) ; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a0 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a1 <-> call void @callee(double* %escape_alloca_a1) ; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a1 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a0 <-> call void @callee(double* %escape_alloca_a1) ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a0 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a1 <-> call void @callee(double* %escape_alloca_a1) ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a1 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a0 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a1 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a0 <-> call void @callee(double* %escape_alloca_a1) ; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a0 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a1 <-> call void @callee(double* %escape_alloca_a1) ; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a1 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a0 <-> call void @callee(double* %escape_alloca_a1) ; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a0 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a1 <-> call void @callee(double* %escape_alloca_a1) ; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a1 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a0 <-> call void @callee(double* %escape_alloca_a1) ; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a0 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a1 <-> call void @callee(double* %escape_alloca_a1) ; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a1 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a0 <-> call void @callee(double* %escape_alloca_a1) ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a0 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a1 <-> call void @callee(double* %escape_alloca_a1) ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a1 <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a0 <-> call void @callee(double* %escape_alloca_a1) ; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a0 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a1 <-> call void @callee(double* %escape_alloca_a1) ; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a1 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a0 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a1 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a0 <-> call void @nocap_callee(double* %noescape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a0 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a1 <-> call void @nocap_callee(double* %noescape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a1 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a0 <-> call void @nocap_callee(double* %noescape_alloca_a0) ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a0 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a1 <-> call void @nocap_callee(double* %noescape_alloca_a0) ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a1 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a0 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a1 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a0 <-> call void @nocap_callee(double* %noescape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a0 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a1 <-> call void @nocap_callee(double* %noescape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a1 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %noescape_alloca_a0 <-> call void @nocap_callee(double* %noescape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double* %noescape_alloca_a0 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a1 <-> call void @nocap_callee(double* %noescape_alloca_a0) ; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a1 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a0 <-> call void @nocap_callee(double* %noescape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a0 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a1 <-> call void @nocap_callee(double* %noescape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a1 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a0 <-> call void @nocap_callee(double* %noescape_alloca_a0) ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a0 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a1 <-> call void @nocap_callee(double* %noescape_alloca_a0) ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a1 <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a0 <-> call void @nocap_callee(double* %noescape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a0 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a1 <-> call void @nocap_callee(double* %noescape_alloca_a0) ; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a1 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a0 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a1 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a0 <-> call void @nocap_callee(double* %noescape_alloca_a1) ; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a0 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a1 <-> call void @nocap_callee(double* %noescape_alloca_a1) ; CHECK-NEXT: Both ModRef: Ptr: double* %arg_a1 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a0 <-> call void @nocap_callee(double* %noescape_alloca_a1) ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a0 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a1 <-> call void @nocap_callee(double* %noescape_alloca_a1) ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_arg_a1 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a0 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double** %indirect_a1 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a0 <-> call void @nocap_callee(double* %noescape_alloca_a1) ; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a0 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a1 <-> call void @nocap_callee(double* %noescape_alloca_a1) ; CHECK-NEXT: Both ModRef: Ptr: double* %escape_alloca_a1 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a0 <-> call void @nocap_callee(double* %noescape_alloca_a1) ; CHECK-NEXT: NoModRef: Ptr: double* %noescape_alloca_a0 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %noescape_alloca_a1 <-> call void @nocap_callee(double* %noescape_alloca_a1) ; CHECK-NEXT: Both ModRef: Ptr: double* %noescape_alloca_a1 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a0 <-> call void @nocap_callee(double* %noescape_alloca_a1) ; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a0 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a1 <-> call void @nocap_callee(double* %noescape_alloca_a1) ; CHECK-NEXT: Both ModRef: Ptr: double* %normal_ret_a1 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a0 <-> call void @nocap_callee(double* %noescape_alloca_a1) ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a0 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a1 <-> call void @nocap_callee(double* %noescape_alloca_a1) ; CHECK-NEXT: NoModRef: Ptr: double* %noalias_ret_a1 <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a0 <-> call void @nocap_callee(double* %noescape_alloca_a1) ; CHECK-NEXT: Both ModRef: %normal_ret_a0 = call double* @normal_returner() <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: Ptr: double* %loaded_a1 <-> call void @nocap_callee(double* %noescape_alloca_a1) ; CHECK-NEXT: Both ModRef: %normal_ret_a0 = call double* @normal_returner() <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: %normal_ret_a0 = call double* @normal_returner() <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: %normal_ret_a0 = call double* @normal_returner() <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: %normal_ret_a0 = call double* @normal_returner() <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: %normal_ret_a0 = call double* @normal_returner() <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: %normal_ret_a0 = call double* @normal_returner() <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: %normal_ret_a1 = call double* @normal_returner() <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: %normal_ret_a1 = call double* @normal_returner() <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: %normal_ret_a1 = call double* @normal_returner() <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: %normal_ret_a1 = call double* @normal_returner() <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: %normal_ret_a1 = call double* @normal_returner() <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: %normal_ret_a1 = call double* @normal_returner() <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: %normal_ret_a1 = call double* @normal_returner() <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: %noalias_ret_a0 = call double* @noalias_returner() <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: %noalias_ret_a0 = call double* @noalias_returner() <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: %noalias_ret_a0 = call double* @noalias_returner() <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: %noalias_ret_a0 = call double* @noalias_returner() <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: %noalias_ret_a0 = call double* @noalias_returner() <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: %noalias_ret_a0 = call double* @noalias_returner() <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: %noalias_ret_a0 = call double* @noalias_returner() <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: %noalias_ret_a1 = call double* @noalias_returner() <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: %noalias_ret_a1 = call double* @noalias_returner() <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: %noalias_ret_a1 = call double* @noalias_returner() <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: %noalias_ret_a1 = call double* @noalias_returner() <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: %noalias_ret_a1 = call double* @noalias_returner() <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: %noalias_ret_a1 = call double* @noalias_returner() <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: %noalias_ret_a1 = call double* @noalias_returner() <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: call void @callee(double* %escape_alloca_a0) <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: call void @callee(double* %escape_alloca_a0) <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: call void @callee(double* %escape_alloca_a0) <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: call void @callee(double* %escape_alloca_a0) <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: call void @callee(double* %escape_alloca_a0) <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: call void @callee(double* %escape_alloca_a0) <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: call void @callee(double* %escape_alloca_a0) <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: call void @callee(double* %escape_alloca_a1) <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: call void @callee(double* %escape_alloca_a1) <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: call void @callee(double* %escape_alloca_a1) <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: call void @callee(double* %escape_alloca_a1) <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: call void @callee(double* %escape_alloca_a1) <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: call void @callee(double* %escape_alloca_a1) <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK-NEXT: Both ModRef: call void @callee(double* %escape_alloca_a1) <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: call void @nocap_callee(double* %noescape_alloca_a0) <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: call void @nocap_callee(double* %noescape_alloca_a0) <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: call void @nocap_callee(double* %noescape_alloca_a0) <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: call void @nocap_callee(double* %noescape_alloca_a0) <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: call void @nocap_callee(double* %noescape_alloca_a0) <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: call void @nocap_callee(double* %noescape_alloca_a0) <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: call void @nocap_callee(double* %noescape_alloca_a0) <-> call void @nocap_callee(double* %noescape_alloca_a1)
; CHECK-NEXT: Both ModRef: call void @nocap_callee(double* %noescape_alloca_a1) <-> %normal_ret_a0 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: call void @nocap_callee(double* %noescape_alloca_a1) <-> %normal_ret_a1 = call double* @normal_returner()
; CHECK-NEXT: Both ModRef: call void @nocap_callee(double* %noescape_alloca_a1) <-> %noalias_ret_a0 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: call void @nocap_callee(double* %noescape_alloca_a1) <-> %noalias_ret_a1 = call double* @noalias_returner()
; CHECK-NEXT: Both ModRef: call void @nocap_callee(double* %noescape_alloca_a1) <-> call void @callee(double* %escape_alloca_a0)
; CHECK-NEXT: Both ModRef: call void @nocap_callee(double* %noescape_alloca_a1) <-> call void @callee(double* %escape_alloca_a1)
; CHECK-NEXT: Both ModRef: call void @nocap_callee(double* %noescape_alloca_a1) <-> call void @nocap_callee(double* %noescape_alloca_a0)
; CHECK: ===== Alias Analysis Evaluator Report ===== ; CHECK: ===== Alias Analysis Evaluator Report =====
; CHECK-NEXT: 120 Total Alias Queries Performed ; CHECK-NEXT: 120 Total Alias Queries Performed
; CHECK-NEXT: 84 no alias responses (70.0%) ; CHECK-NEXT: 84 no alias responses (70.0%)
; CHECK-NEXT: 36 may alias responses (30.0%) ; CHECK-NEXT: 36 may alias responses (30.0%)
; CHECK-NEXT: 0 partial alias responses (0.0%) ; CHECK-NEXT: 0 partial alias responses (0.0%)
; CHECK-NEXT: 0 must alias responses (0.0%) ; CHECK-NEXT: 0 must alias responses (0.0%)
; CHECK-NEXT: Alias Analysis Evaluator Pointer Alias Summary: 70%/30%/0% ; CHECK-NEXT: Alias Analysis Evaluator Pointer Alias Summary: 70%/30%/0%
; CHECK-NEXT: 184 Total ModRef Queries Performed ; CHECK-NEXT: 184 Total ModRef Queries Performed
Show All 10 Lines

llvm/test/Analysis/BasicAA/assume-index-positive.ll

; RUN: opt -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info %s 2>&1 | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info %s 2>&1 | FileCheck %s
; %col.ptr.1 and %col.ptr.2 do not alias, if we know that %skip >= 0, because ; %col.ptr.1 and %col.ptr.2 do not alias, if we know that %skip >= 0, because
; the distance between %col.ptr.1 and %col.ptr.2 is %skip + 6 and we load 6 ; the distance between %col.ptr.1 and %col.ptr.2 is %skip + 6 and we load 6
; elements. ; elements.
define void @test1(double* %ptr, i32 %skip) { define void @test1(double* %ptr, i32 %skip) {
; CHECK-LABEL: Function: test1: 4 pointers, 1 call sites ; CHECK-LABEL: Function: test1: 4 pointers, 1 call sites
; CHECK-NEXT: MustAlias: <6 x double>* %col.ptr.1, double* %ptr ; CHECK-NEXT: MustAlias: <6 x double>* %col.ptr.1, double* %ptr
; CHECK-NEXT: NoAlias: double* %col.ptr.2, double* %ptr ; CHECK-NEXT: NoAlias: double* %col.ptr.2, double* %ptr
; CHECK-NEXT: NoAlias: <6 x double>* %col.ptr.1, double* %col.ptr.2 ; CHECK-NEXT: NoAlias: <6 x double>* %col.ptr.1, double* %col.ptr.2
; CHECK-NEXT: NoAlias: <6 x double>* %col.ptr.2.cast, double* %ptr ; CHECK-NEXT: NoAlias: <6 x double>* %col.ptr.2.cast, double* %ptr
; CHECK-NEXT: NoAlias: <6 x double>* %col.ptr.1, <6 x double>* %col.ptr.2.cast ; CHECK-NEXT: NoAlias: <6 x double>* %col.ptr.1, <6 x double>* %col.ptr.2.cast
; CHECK-NEXT: MustAlias: <6 x double>* %col.ptr.2.cast, double* %col.ptr.2 ; CHECK-NEXT: MustAlias: double* %col.ptr.2, <6 x double>* %col.ptr.2.cast
; CHECK-NEXT: NoModRef: Ptr: double* %ptr <-> call void @llvm.assume(i1 %gt) ; CHECK-NEXT: NoModRef: Ptr: double* %ptr <-> call void @llvm.assume(i1 %gt)
; CHECK-NEXT: NoModRef: Ptr: <6 x double>* %col.ptr.1 <-> call void @llvm.assume(i1 %gt) ; CHECK-NEXT: NoModRef: Ptr: <6 x double>* %col.ptr.1 <-> call void @llvm.assume(i1 %gt)
; CHECK-NEXT: NoModRef: Ptr: double* %col.ptr.2 <-> call void @llvm.assume(i1 %gt) ; CHECK-NEXT: NoModRef: Ptr: double* %col.ptr.2 <-> call void @llvm.assume(i1 %gt)
; CHECK-NEXT: NoModRef: Ptr: <6 x double>* %col.ptr.2.cast <-> call void @llvm.assume(i1 %gt) ; CHECK-NEXT: NoModRef: Ptr: <6 x double>* %col.ptr.2.cast <-> call void @llvm.assume(i1 %gt)
; ;
load double, double* %ptr
%gt = icmp sgt i32 %skip, -1 %gt = icmp sgt i32 %skip, -1
call void @llvm.assume(i1 %gt) call void @llvm.assume(i1 %gt)
%stride = add nsw nuw i32 %skip, 6 %stride = add nsw nuw i32 %skip, 6
%col.ptr.1 = bitcast double* %ptr to <6 x double>* %col.ptr.1 = bitcast double* %ptr to <6 x double>*
%lv.1 = load <6 x double>, <6 x double>* %col.ptr.1, align 8 %lv.1 = load <6 x double>, <6 x double>* %col.ptr.1, align 8
%col.ptr.2= getelementptr double, double* %ptr, i32 %stride %col.ptr.2= getelementptr double, double* %ptr, i32 %stride
%col.ptr.2.cast = bitcast double* %col.ptr.2 to <6 x double>* %col.ptr.2.cast = bitcast double* %col.ptr.2 to <6 x double>*
load double, double* %col.ptr.2
%lv.2 = load <6 x double>, <6 x double>* %col.ptr.2.cast, align 8 %lv.2 = load <6 x double>, <6 x double>* %col.ptr.2.cast, align 8
%res.1 = fadd <6 x double> %lv.1, %lv.1 %res.1 = fadd <6 x double> %lv.1, %lv.1
%res.2 = fadd <6 x double> %lv.2, %lv.2 %res.2 = fadd <6 x double> %lv.2, %lv.2
store <6 x double> %res.1, <6 x double>* %col.ptr.1, align 8 store <6 x double> %res.1, <6 x double>* %col.ptr.1, align 8
store <6 x double> %res.2, <6 x double>* %col.ptr.2.cast, align 8 store <6 x double> %res.2, <6 x double>* %col.ptr.2.cast, align 8
ret void ret void
} }
; Same as @test1, but now we do not have an assume guaranteeing %skip >= 0. ; Same as @test1, but now we do not have an assume guaranteeing %skip >= 0.
define void @test2(double* %ptr, i32 %skip) { define void @test2(double* %ptr, i32 %skip) {
; CHECK-LABEL: Function: test2: 4 pointers, 0 call sites ; CHECK-LABEL: Function: test2: 4 pointers, 0 call sites
; CHECK-NEXT: MustAlias: <6 x double>* %col.ptr.1, double* %ptr ; CHECK-NEXT: MustAlias: <6 x double>* %col.ptr.1, double* %ptr
; CHECK-NEXT: MayAlias: double* %col.ptr.2, double* %ptr ; CHECK-NEXT: MayAlias: double* %col.ptr.2, double* %ptr
; CHECK-NEXT: MayAlias: <6 x double>* %col.ptr.1, double* %col.ptr.2 ; CHECK-NEXT: MayAlias: <6 x double>* %col.ptr.1, double* %col.ptr.2
; CHECK-NEXT: MayAlias: <6 x double>* %col.ptr.2.cast, double* %ptr ; CHECK-NEXT: MayAlias: <6 x double>* %col.ptr.2.cast, double* %ptr
; CHECK-NEXT: MayAlias: <6 x double>* %col.ptr.1, <6 x double>* %col.ptr.2.cast ; CHECK-NEXT: MayAlias: <6 x double>* %col.ptr.1, <6 x double>* %col.ptr.2.cast
; CHECK-NEXT: MustAlias: <6 x double>* %col.ptr.2.cast, double* %col.ptr.2 ; CHECK-NEXT: MustAlias: double* %col.ptr.2, <6 x double>* %col.ptr.2.cast
; ;
load double, double* %ptr
%stride = add nsw nuw i32 %skip, 6 %stride = add nsw nuw i32 %skip, 6
%col.ptr.1 = bitcast double* %ptr to <6 x double>* %col.ptr.1 = bitcast double* %ptr to <6 x double>*
%lv.1 = load <6 x double>, <6 x double>* %col.ptr.1, align 8 %lv.1 = load <6 x double>, <6 x double>* %col.ptr.1, align 8
%col.ptr.2= getelementptr double, double* %ptr, i32 %stride %col.ptr.2 = getelementptr double, double* %ptr, i32 %stride
load double, double* %col.ptr.2
%col.ptr.2.cast = bitcast double* %col.ptr.2 to <6 x double>* %col.ptr.2.cast = bitcast double* %col.ptr.2 to <6 x double>*
%lv.2 = load <6 x double>, <6 x double>* %col.ptr.2.cast, align 8 %lv.2 = load <6 x double>, <6 x double>* %col.ptr.2.cast, align 8
%res.1 = fadd <6 x double> %lv.1, %lv.1 %res.1 = fadd <6 x double> %lv.1, %lv.1
%res.2 = fadd <6 x double> %lv.2, %lv.2 %res.2 = fadd <6 x double> %lv.2, %lv.2
store <6 x double> %res.1, <6 x double>* %col.ptr.1, align 8 store <6 x double> %res.1, <6 x double>* %col.ptr.1, align 8
store <6 x double> %res.2, <6 x double>* %col.ptr.2.cast, align 8 store <6 x double> %res.2, <6 x double>* %col.ptr.2.cast, align 8
ret void ret void
} }
; Same as @test1, this time the assume just guarantees %skip > -3, which is ; Same as @test1, this time the assume just guarantees %skip > -3, which is
; enough to derive NoAlias for %ptr and %col.ptr.2 (distance is more than 3 ; enough to derive NoAlias for %ptr and %col.ptr.2 (distance is more than 3
; doubles, and we load 1 double), but not %col.ptr.1 and %col.ptr.2 (distance ; doubles, and we load 1 double), but not %col.ptr.1 and %col.ptr.2 (distance
; is more than 3 doubles, and we load 6 doubles). ; is more than 3 doubles, and we load 6 doubles).
define void @test3(double* %ptr, i32 %skip) { define void @test3(double* %ptr, i32 %skip) {
; CHECK-LABEL: Function: test3: 4 pointers, 1 call sites ; CHECK-LABEL: Function: test3: 4 pointers, 1 call sites
; CHECK-NEXT: MustAlias: <6 x double>* %col.ptr.1, double* %ptr ; CHECK-NEXT: MustAlias: <6 x double>* %col.ptr.1, double* %ptr
; CHECK-NEXT: NoAlias: double* %col.ptr.2, double* %ptr ; CHECK-NEXT: NoAlias: double* %col.ptr.2, double* %ptr
; CHECK-NEXT: MayAlias: <6 x double>* %col.ptr.1, double* %col.ptr.2 ; CHECK-NEXT: MayAlias: <6 x double>* %col.ptr.1, double* %col.ptr.2
; CHECK-NEXT: NoAlias: <6 x double>* %col.ptr.2.cast, double* %ptr ; CHECK-NEXT: NoAlias: <6 x double>* %col.ptr.2.cast, double* %ptr
; CHECK-NEXT: MayAlias: <6 x double>* %col.ptr.1, <6 x double>* %col.ptr.2.cast ; CHECK-NEXT: MayAlias: <6 x double>* %col.ptr.1, <6 x double>* %col.ptr.2.cast
; CHECK-NEXT: MustAlias: <6 x double>* %col.ptr.2.cast, double* %col.ptr.2 ; CHECK-NEXT: MustAlias: double* %col.ptr.2, <6 x double>* %col.ptr.2.cast
; CHECK-NEXT: NoModRef: Ptr: double* %ptr <-> call void @llvm.assume(i1 %gt) ; CHECK-NEXT: NoModRef: Ptr: double* %ptr <-> call void @llvm.assume(i1 %gt)
; CHECK-NEXT: NoModRef: Ptr: <6 x double>* %col.ptr.1 <-> call void @llvm.assume(i1 %gt) ; CHECK-NEXT: NoModRef: Ptr: <6 x double>* %col.ptr.1 <-> call void @llvm.assume(i1 %gt)
; CHECK-NEXT: NoModRef: Ptr: double* %col.ptr.2 <-> call void @llvm.assume(i1 %gt) ; CHECK-NEXT: NoModRef: Ptr: double* %col.ptr.2 <-> call void @llvm.assume(i1 %gt)
; CHECK-NEXT: NoModRef: Ptr: <6 x double>* %col.ptr.2.cast <-> call void @llvm.assume(i1 %gt) ; CHECK-NEXT: NoModRef: Ptr: <6 x double>* %col.ptr.2.cast <-> call void @llvm.assume(i1 %gt)
; ;
load double, double* %ptr
%gt = icmp sgt i32 %skip, -3 %gt = icmp sgt i32 %skip, -3
call void @llvm.assume(i1 %gt) call void @llvm.assume(i1 %gt)
%stride = add nsw nuw i32 %skip, 6 %stride = add nsw nuw i32 %skip, 6
%col.ptr.1 = bitcast double* %ptr to <6 x double>* %col.ptr.1 = bitcast double* %ptr to <6 x double>*
%lv.1 = load <6 x double>, <6 x double>* %col.ptr.1, align 8 %lv.1 = load <6 x double>, <6 x double>* %col.ptr.1, align 8
%col.ptr.2= getelementptr double, double* %ptr, i32 %stride %col.ptr.2 = getelementptr double, double* %ptr, i32 %stride
load double, double* %col.ptr.2
%col.ptr.2.cast = bitcast double* %col.ptr.2 to <6 x double>* %col.ptr.2.cast = bitcast double* %col.ptr.2 to <6 x double>*
%lv.2 = load <6 x double>, <6 x double>* %col.ptr.2.cast, align 8 %lv.2 = load <6 x double>, <6 x double>* %col.ptr.2.cast, align 8
%res.1 = fadd <6 x double> %lv.1, %lv.1 %res.1 = fadd <6 x double> %lv.1, %lv.1
%res.2 = fadd <6 x double> %lv.2, %lv.2 %res.2 = fadd <6 x double> %lv.2, %lv.2
store <6 x double> %res.1, <6 x double>* %col.ptr.1, align 8 store <6 x double> %res.1, <6 x double>* %col.ptr.1, align 8
store <6 x double> %res.2, <6 x double>* %col.ptr.2.cast, align 8 store <6 x double> %res.2, <6 x double>* %col.ptr.2.cast, align 8
ret void ret void
} }
; Same as @test1, but the assume uses the sge predicate for %skip >= 0. ; Same as @test1, but the assume uses the sge predicate for %skip >= 0.
define void @test4(double* %ptr, i32 %skip) { define void @test4(double* %ptr, i32 %skip) {
; CHECK-LABEL: Function: test4: 4 pointers, 1 call sites ; CHECK-LABEL: Function: test4: 4 pointers, 1 call sites
; CHECK-NEXT: MustAlias: <6 x double>* %col.ptr.1, double* %ptr ; CHECK-NEXT: MustAlias: <6 x double>* %col.ptr.1, double* %ptr
; CHECK-NEXT: NoAlias: double* %col.ptr.2, double* %ptr ; CHECK-NEXT: NoAlias: double* %col.ptr.2, double* %ptr
; CHECK-NEXT: NoAlias: <6 x double>* %col.ptr.1, double* %col.ptr.2 ; CHECK-NEXT: NoAlias: <6 x double>* %col.ptr.1, double* %col.ptr.2
; CHECK-NEXT: NoAlias: <6 x double>* %col.ptr.2.cast, double* %ptr ; CHECK-NEXT: NoAlias: <6 x double>* %col.ptr.2.cast, double* %ptr
; CHECK-NEXT: NoAlias: <6 x double>* %col.ptr.1, <6 x double>* %col.ptr.2.cast ; CHECK-NEXT: NoAlias: <6 x double>* %col.ptr.1, <6 x double>* %col.ptr.2.cast
; CHECK-NEXT: MustAlias: <6 x double>* %col.ptr.2.cast, double* %col.ptr.2 ; CHECK-NEXT: MustAlias: double* %col.ptr.2, <6 x double>* %col.ptr.2.cast
; CHECK-NEXT: NoModRef: Ptr: double* %ptr <-> call void @llvm.assume(i1 %gt) ; CHECK-NEXT: NoModRef: Ptr: double* %ptr <-> call void @llvm.assume(i1 %gt)
; CHECK-NEXT: NoModRef: Ptr: <6 x double>* %col.ptr.1 <-> call void @llvm.assume(i1 %gt) ; CHECK-NEXT: NoModRef: Ptr: <6 x double>* %col.ptr.1 <-> call void @llvm.assume(i1 %gt)
; CHECK-NEXT: NoModRef: Ptr: double* %col.ptr.2 <-> call void @llvm.assume(i1 %gt) ; CHECK-NEXT: NoModRef: Ptr: double* %col.ptr.2 <-> call void @llvm.assume(i1 %gt)
; CHECK-NEXT: NoModRef: Ptr: <6 x double>* %col.ptr.2.cast <-> call void @llvm.assume(i1 %gt) ; CHECK-NEXT: NoModRef: Ptr: <6 x double>* %col.ptr.2.cast <-> call void @llvm.assume(i1 %gt)
; ;
load double, double* %ptr
%gt = icmp sge i32 %skip, 0 %gt = icmp sge i32 %skip, 0
call void @llvm.assume(i1 %gt) call void @llvm.assume(i1 %gt)
%stride = add nsw nuw i32 %skip, 6 %stride = add nsw nuw i32 %skip, 6
%col.ptr.1 = bitcast double* %ptr to <6 x double>* %col.ptr.1 = bitcast double* %ptr to <6 x double>*
%lv.1 = load <6 x double>, <6 x double>* %col.ptr.1, align 8 %lv.1 = load <6 x double>, <6 x double>* %col.ptr.1, align 8
%col.ptr.2= getelementptr double, double* %ptr, i32 %stride %col.ptr.2 = getelementptr double, double* %ptr, i32 %stride
load double, double* %col.ptr.2
%col.ptr.2.cast = bitcast double* %col.ptr.2 to <6 x double>* %col.ptr.2.cast = bitcast double* %col.ptr.2 to <6 x double>*
%lv.2 = load <6 x double>, <6 x double>* %col.ptr.2.cast, align 8 %lv.2 = load <6 x double>, <6 x double>* %col.ptr.2.cast, align 8
%res.1 = fadd <6 x double> %lv.1, %lv.1 %res.1 = fadd <6 x double> %lv.1, %lv.1
%res.2 = fadd <6 x double> %lv.2, %lv.2 %res.2 = fadd <6 x double> %lv.2, %lv.2
store <6 x double> %res.1, <6 x double>* %col.ptr.1, align 8 store <6 x double> %res.1, <6 x double>* %col.ptr.1, align 8
store <6 x double> %res.2, <6 x double>* %col.ptr.2.cast, align 8 store <6 x double> %res.2, <6 x double>* %col.ptr.2.cast, align 8
ret void ret void
} }
define void @symmetry([0 x i8]* %ptr, i32 %a, i32 %b, i32 %c) { define void @symmetry([0 x i8]* %ptr, i32 %a, i32 %b, i32 %c) {
; CHECK-LABEL: Function: symmetry ; CHECK-LABEL: Function: symmetry
; CHECK: NoAlias: i8* %gep1, i8* %gep2 ; CHECK: NoAlias: i8* %gep1, i8* %gep2
; ;
%b.cmp = icmp slt i32 %b, 0 %b.cmp = icmp slt i32 %b, 0
call void @llvm.assume(i1 %b.cmp) call void @llvm.assume(i1 %b.cmp)
%gep1 = getelementptr [0 x i8], [0 x i8]* %ptr, i32 %a, i32 %b %gep1 = getelementptr [0 x i8], [0 x i8]* %ptr, i32 %a, i32 %b
load i8, i8* %gep1
call void @barrier() call void @barrier()
%c.cmp = icmp sgt i32 %c, -1 %c.cmp = icmp sgt i32 %c, -1
call void @llvm.assume(i1 %c.cmp) call void @llvm.assume(i1 %c.cmp)
%c.off = add nuw nsw i32 %c, 1 %c.off = add nuw nsw i32 %c, 1
%gep2 = getelementptr [0 x i8], [0 x i8]* %ptr, i32 %a, i32 %c.off %gep2 = getelementptr [0 x i8], [0 x i8]* %ptr, i32 %a, i32 %c.off
load i8, i8* %gep2
ret void ret void
} }
; %ptr.neg and %ptr.shl may alias, as the shl renders the previously ; %ptr.neg and %ptr.shl may alias, as the shl renders the previously
; non-negative value potentially negative. ; non-negative value potentially negative.
define void @shl_of_non_negative(i8* %ptr, i64 %a) { define void @shl_of_non_negative(i8* %ptr, i64 %a) {
; CHECK-LABEL: Function: shl_of_non_negative ; CHECK-LABEL: Function: shl_of_non_negative
; CHECK: NoAlias: i8* %ptr.a, i8* %ptr.neg ; CHECK: NoAlias: i8* %ptr.a, i8* %ptr.neg
; CHECK: MayAlias: i8* %ptr.neg, i8* %ptr.shl ; CHECK: MayAlias: i8* %ptr.neg, i8* %ptr.shl
%a.cmp = icmp sge i64 %a, 0 %a.cmp = icmp sge i64 %a, 0
call void @llvm.assume(i1 %a.cmp) call void @llvm.assume(i1 %a.cmp)
%ptr.neg = getelementptr i8, i8* %ptr, i64 -2 %ptr.neg = getelementptr i8, i8* %ptr, i64 -2
%ptr.a = getelementptr i8, i8* %ptr, i64 %a %ptr.a = getelementptr i8, i8* %ptr, i64 %a
%shl = shl i64 %a, 1 %shl = shl i64 %a, 1
%ptr.shl = getelementptr i8, i8* %ptr, i64 %shl %ptr.shl = getelementptr i8, i8* %ptr, i64 %shl
load i8, i8* %ptr.a
load i8, i8* %ptr.neg
load i8, i8* %ptr.shl
ret void ret void
} }
; Unlike the previous case, %ptr.neg and %ptr.shl can't alias, because ; Unlike the previous case, %ptr.neg and %ptr.shl can't alias, because
; shl nsw of non-negative is non-negative. ; shl nsw of non-negative is non-negative.
define void @shl_nsw_of_non_negative(i8* %ptr, i64 %a) { define void @shl_nsw_of_non_negative(i8* %ptr, i64 %a) {
; CHECK-LABEL: Function: shl_nsw_of_non_negative ; CHECK-LABEL: Function: shl_nsw_of_non_negative
; CHECK: NoAlias: i8* %ptr.a, i8* %ptr.neg ; CHECK: NoAlias: i8* %ptr.a, i8* %ptr.neg
; CHECK: NoAlias: i8* %ptr.neg, i8* %ptr.shl ; CHECK: NoAlias: i8* %ptr.neg, i8* %ptr.shl
%a.cmp = icmp sge i64 %a, 0 %a.cmp = icmp sge i64 %a, 0
call void @llvm.assume(i1 %a.cmp) call void @llvm.assume(i1 %a.cmp)
%ptr.neg = getelementptr i8, i8* %ptr, i64 -2 %ptr.neg = getelementptr i8, i8* %ptr, i64 -2
%ptr.a = getelementptr i8, i8* %ptr, i64 %a %ptr.a = getelementptr i8, i8* %ptr, i64 %a
%shl = shl nsw i64 %a, 1 %shl = shl nsw i64 %a, 1
%ptr.shl = getelementptr i8, i8* %ptr, i64 %shl %ptr.shl = getelementptr i8, i8* %ptr, i64 %shl
load i8, i8* %ptr.a
load i8, i8* %ptr.neg
load i8, i8* %ptr.shl
ret void ret void
} }
declare void @llvm.assume(i1 %cond) declare void @llvm.assume(i1 %cond)
declare void @barrier() declare void @barrier()

llvm/test/Analysis/BasicAA/assume.ll

; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32"
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) #0 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) #0
declare void @llvm.assume(i1) #0 declare void @llvm.assume(i1) #0
define void @test1(i8* %P, i8* %Q) nounwind ssp { define void @test1(i8* %P, i8* %Q) nounwind ssp {
tail call void @llvm.assume(i1 true) tail call void @llvm.assume(i1 true)
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
load i8, i8* %P
load i8, i8* %Q
ret void ret void
; CHECK-LABEL: Function: test1: ; CHECK-LABEL: Function: test1:
; CHECK: MayAlias: i8* %P, i8* %Q ; CHECK: MayAlias: i8* %P, i8* %Q
; CHECK: NoModRef: Ptr: i8* %P <-> tail call void @llvm.assume(i1 true) ; CHECK: NoModRef: Ptr: i8* %P <-> tail call void @llvm.assume(i1 true)
; CHECK: NoModRef: Ptr: i8* %Q <-> tail call void @llvm.assume(i1 true) ; CHECK: NoModRef: Ptr: i8* %Q <-> tail call void @llvm.assume(i1 true)
; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: NoModRef: tail call void @llvm.assume(i1 true) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: NoModRef: tail call void @llvm.assume(i1 true) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: NoModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.assume(i1 true) ; CHECK: NoModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.assume(i1 true)
} }
; Same but with operand bundles ; Same but with operand bundles
define void @test2(i8* %P, i8* %Q) nounwind ssp { define void @test2(i8* %P, i8* %Q) nounwind ssp {
tail call void @llvm.assume(i1 true) [ "nonnull"(i8* %P) ] tail call void @llvm.assume(i1 true) [ "nonnull"(i8* %P) ]
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
load i8, i8* %P
load i8, i8* %Q
ret void ret void
; CHECK-LABEL: Function: test2: ; CHECK-LABEL: Function: test2:
; CHECK: MayAlias: i8* %P, i8* %Q ; CHECK: MayAlias: i8* %P, i8* %Q
; CHECK: NoModRef: Ptr: i8* %P <-> tail call void @llvm.assume(i1 true) [ "nonnull"(i8* %P) ] ; CHECK: NoModRef: Ptr: i8* %P <-> tail call void @llvm.assume(i1 true) [ "nonnull"(i8* %P) ]
; CHECK: NoModRef: Ptr: i8* %Q <-> tail call void @llvm.assume(i1 true) [ "nonnull"(i8* %P) ] ; CHECK: NoModRef: Ptr: i8* %Q <-> tail call void @llvm.assume(i1 true) [ "nonnull"(i8* %P) ]
; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: NoModRef: tail call void @llvm.assume(i1 true) [ "nonnull"(i8* %P) ] <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: NoModRef: tail call void @llvm.assume(i1 true) [ "nonnull"(i8* %P) ] <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: NoModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.assume(i1 true) [ "nonnull"(i8* %P) ] ; CHECK: NoModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.assume(i1 true) [ "nonnull"(i8* %P) ]
} }
attributes #0 = { nounwind } attributes #0 = { nounwind }

llvm/test/Analysis/BasicAA/atomic-memory-intrinsics.ll

; RUN: opt -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 %s | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 %s | FileCheck %s
declare void @llvm.memset.element.unordered.atomic.p0i8.i32(i8*, i8, i64, i32) declare void @llvm.memset.element.unordered.atomic.p0i8.i32(i8*, i8, i64, i32)
define void @test_memset_element_unordered_atomic_const_size(i8* noalias %a) { define void @test_memset_element_unordered_atomic_const_size(i8* noalias %a) {
; CHECK-LABEL: Function: test_memset_element_unordered_atomic_const_size ; CHECK-LABEL: Function: test_memset_element_unordered_atomic_const_size
; CHECK: Just Mod (MustAlias): Ptr: i8* %a <-> call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 4, i32 1) ; CHECK: Just Mod (MustAlias): Ptr: i8* %a <-> call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 4, i32 1)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 4, i32 1) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 4, i32 1)
; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 4, i32 1) ; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 4, i32 1)
; ;
entry: entry:
load i8, i8* %a
call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 1 %a, i8 0, i64 4, i32 1) call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 1 %a, i8 0, i64 4, i32 1)
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
ret void ret void
} }
define void @test_memset_element_unordered_atomic_variable_size(i8* noalias %a, i64 %n) { define void @test_memset_element_unordered_atomic_variable_size(i8* noalias %a, i64 %n) {
; CHECK-LABEL: Function: test_memset_element_unordered_atomic_variable_size ; CHECK-LABEL: Function: test_memset_element_unordered_atomic_variable_size
; CHECK: Just Mod (MustAlias): Ptr: i8* %a <-> call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 %n, i32 1) ; CHECK: Just Mod (MustAlias): Ptr: i8* %a <-> call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 %n, i32 1)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 %n, i32 1) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 %n, i32 1)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.5 <-> call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 %n, i32 1) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.5 <-> call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %a, i8 0, i64 %n, i32 1)
; ;
entry: entry:
load i8, i8* %a
call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 1 %a, i8 0, i64 %n, i32 1) call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 1 %a, i8 0, i64 %n, i32 1)
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
ret void ret void
} }
declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32) declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32)
define void @test_memcpy_element_unordered_atomic_const_size(i8* noalias %a, i8* noalias %b) { define void @test_memcpy_element_unordered_atomic_const_size(i8* noalias %a, i8* noalias %b) {
; CHECK-LABEL: Function: test_memcpy_element_unordered_atomic_const_size ; CHECK-LABEL: Function: test_memcpy_element_unordered_atomic_const_size
; CHECK: Just Ref: Ptr: i8* %a <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1) ; CHECK: Just Ref: Ptr: i8* %a <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1)
; CHECK-NEXT: Just Mod: Ptr: i8* %b <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1) ; CHECK-NEXT: Just Mod: Ptr: i8* %b <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1) ; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1)
; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1) ; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1)
; CHECK-NEXT: Just Mod: Ptr: i8* %b.gep.1 <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1) ; CHECK-NEXT: Just Mod: Ptr: i8* %b.gep.1 <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1)
; CHECK-NEXT: NoModRef: Ptr: i8* %b.gep.5 <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1) ; CHECK-NEXT: NoModRef: Ptr: i8* %b.gep.5 <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1)
; ;
entry: entry:
load i8, i8* %a
load i8, i8* %b
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1) call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1)
%b.gep.1 = getelementptr i8, i8* %b, i32 1 %b.gep.1 = getelementptr i8, i8* %b, i32 1
store i8 0, i8* %b.gep.1 store i8 0, i8* %b.gep.1
%b.gep.5 = getelementptr i8, i8* %b, i32 5 %b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 1, i8* %b.gep.5 store i8 1, i8* %b.gep.5
ret void ret void
} }
define void @test_memcpy_element_unordered_atomic_variable_size(i8* noalias %a, i8* noalias %b, i64 %n) { define void @test_memcpy_element_unordered_atomic_variable_size(i8* noalias %a, i8* noalias %b, i64 %n) {
; CHECK-LABEL: Function: test_memcpy_element_unordered_atomic_variable_size ; CHECK-LABEL: Function: test_memcpy_element_unordered_atomic_variable_size
; CHECK: Just Ref: Ptr: i8* %a <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1) ; CHECK: Just Ref: Ptr: i8* %a <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1)
; CHECK-NEXT: Just Mod: Ptr: i8* %b <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1) ; CHECK-NEXT: Just Mod: Ptr: i8* %b <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1) ; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.5 <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1) ; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.5 <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1)
; CHECK-NEXT: Just Mod: Ptr: i8* %b.gep.1 <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1) ; CHECK-NEXT: Just Mod: Ptr: i8* %b.gep.1 <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1)
; CHECK-NEXT: Just Mod: Ptr: i8* %b.gep.5 <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1) ; CHECK-NEXT: Just Mod: Ptr: i8* %b.gep.5 <-> call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1)
; ;
entry: entry:
load i8, i8* %a
load i8, i8* %b
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1) call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1)
%b.gep.1 = getelementptr i8, i8* %b, i32 1 %b.gep.1 = getelementptr i8, i8* %b, i32 1
store i8 0, i8* %b.gep.1 store i8 0, i8* %b.gep.1
%b.gep.5 = getelementptr i8, i8* %b, i32 5 %b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 1, i8* %b.gep.5 store i8 1, i8* %b.gep.5
ret void ret void
} }
declare void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32) declare void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32)
define void @test_memmove_element_unordered_atomic_const_size(i8* noalias %a, i8* noalias %b) { define void @test_memmove_element_unordered_atomic_const_size(i8* noalias %a, i8* noalias %b) {
; CHECK-LABEL: Function: test_memmove_element_unordered_atomic_const_size ; CHECK-LABEL: Function: test_memmove_element_unordered_atomic_const_size
; CHECK: Just Ref: Ptr: i8* %a <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1) ; CHECK: Just Ref: Ptr: i8* %a <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1)
; CHECK-NEXT: Just Mod: Ptr: i8* %b <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1) ; CHECK-NEXT: Just Mod: Ptr: i8* %b <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1) ; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1)
; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1) ; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1)
; CHECK-NEXT: Just Mod: Ptr: i8* %b.gep.1 <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1) ; CHECK-NEXT: Just Mod: Ptr: i8* %b.gep.1 <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1)
; CHECK-NEXT: NoModRef: Ptr: i8* %b.gep.5 <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1) ; CHECK-NEXT: NoModRef: Ptr: i8* %b.gep.5 <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1)
; ;
entry: entry:
load i8, i8* %a
load i8, i8* %b
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1) call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 4, i32 1)
%b.gep.1 = getelementptr i8, i8* %b, i32 1 %b.gep.1 = getelementptr i8, i8* %b, i32 1
store i8 0, i8* %b.gep.1 store i8 0, i8* %b.gep.1
%b.gep.5 = getelementptr i8, i8* %b, i32 5 %b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 1, i8* %b.gep.5 store i8 1, i8* %b.gep.5
ret void ret void
} }
define void @test_memmove_element_unordered_atomic_variable_size(i8* noalias %a, i8* noalias %b, i64 %n) { define void @test_memmove_element_unordered_atomic_variable_size(i8* noalias %a, i8* noalias %b, i64 %n) {
; CHECK-LABEL: Function: test_memmove_element_unordered_atomic_variable_size ; CHECK-LABEL: Function: test_memmove_element_unordered_atomic_variable_size
; CHECK: Just Ref: Ptr: i8* %a <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1) ; CHECK: Just Ref: Ptr: i8* %a <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1)
; CHECK-NEXT: Just Mod: Ptr: i8* %b <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1) ; CHECK-NEXT: Just Mod: Ptr: i8* %b <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1) ; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.5 <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1) ; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.5 <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1)
; CHECK-NEXT: Just Mod: Ptr: i8* %b.gep.1 <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1) ; CHECK-NEXT: Just Mod: Ptr: i8* %b.gep.1 <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1)
; CHECK-NEXT: Just Mod: Ptr: i8* %b.gep.5 <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1) ; CHECK-NEXT: Just Mod: Ptr: i8* %b.gep.5 <-> call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1)
; ;
entry: entry:
load i8, i8* %a
load i8, i8* %b
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1) call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 %n, i32 1)
%b.gep.1 = getelementptr i8, i8* %b, i32 1 %b.gep.1 = getelementptr i8, i8* %b, i32 1
store i8 0, i8* %b.gep.1 store i8 0, i8* %b.gep.1
%b.gep.5 = getelementptr i8, i8* %b, i32 5 %b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 1, i8* %b.gep.5 store i8 1, i8* %b.gep.5
ret void ret void
} }

llvm/test/Analysis/BasicAA/bug.23540.ll

; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@c = external global i32 @c = external global i32
; CHECK-LABEL: f ; CHECK-LABEL: f
; CHECK: MayAlias: i32* %arrayidx, i32* %arrayidx6 ; CHECK: MayAlias: i32* %arrayidx, i32* %arrayidx6
define void @f() { define void @f() {
%idxprom = zext i32 undef to i64 %idxprom = zext i32 undef to i64
%add4 = add i32 0, 1 %add4 = add i32 0, 1
%idxprom5 = zext i32 %add4 to i64 %idxprom5 = zext i32 %add4 to i64
%arrayidx6 = getelementptr inbounds i32, i32* @c, i64 %idxprom5 %arrayidx6 = getelementptr inbounds i32, i32* @c, i64 %idxprom5
%arrayidx = getelementptr inbounds i32, i32* @c, i64 %idxprom %arrayidx = getelementptr inbounds i32, i32* @c, i64 %idxprom
load i32, i32* %arrayidx
load i32, i32* %arrayidx6
ret void ret void
} }

llvm/test/Analysis/BasicAA/bug.23626.ll

Show All 12 Linesdefine void @compute1(i32 %num.0.lcssa, i32* %out) {
%idxprom = zext i32 %num.0.lcssa to i64 %idxprom = zext i32 %num.0.lcssa to i64
%arrayidx8 = getelementptr inbounds i32, i32* %out, i64 %idxprom %arrayidx8 = getelementptr inbounds i32, i32* %out, i64 %idxprom
%add9 = or i32 %num.0.lcssa, 1 %add9 = or i32 %num.0.lcssa, 1
%idxprom10 = zext i32 %add9 to i64 %idxprom10 = zext i32 %add9 to i64
%arrayidx11 = getelementptr inbounds i32, i32* %out, i64 %idxprom10 %arrayidx11 = getelementptr inbounds i32, i32* %out, i64 %idxprom10
%add12 = or i32 %num.0.lcssa, 2 %add12 = or i32 %num.0.lcssa, 2
%idxprom13 = zext i32 %add12 to i64 %idxprom13 = zext i32 %add12 to i64
%arrayidx14 = getelementptr inbounds i32, i32* %out, i64 %idxprom13 %arrayidx14 = getelementptr inbounds i32, i32* %out, i64 %idxprom13
load i32, i32* %out
load i32, i32* %arrayidx8
load i32, i32* %arrayidx11
load i32, i32* %arrayidx14
ret void ret void
} }
; CHECK-LABEL: compute2 ; CHECK-LABEL: compute2
; CHECK: MayAlias: i32* %arrayidx11, i32* %out.addr ; CHECK: MayAlias: i32* %arrayidx11, i32* %out.addr
define void @compute2(i32 %num, i32* %out.addr) { define void @compute2(i32 %num, i32* %out.addr) {
%add9 = add i32 %num, 1 %add9 = add i32 %num, 1
%idxprom10 = zext i32 %add9 to i64 %idxprom10 = zext i32 %add9 to i64
%arrayidx11 = getelementptr inbounds i32, i32* %out.addr, i64 %idxprom10 %arrayidx11 = getelementptr inbounds i32, i32* %out.addr, i64 %idxprom10
load i32, i32* %out.addr
load i32, i32* %arrayidx11
ret void ret void
} }

llvm/test/Analysis/BasicAA/call-attrs.ll

; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
declare void @readonly_attr(i8* readonly nocapture) declare void @readonly_attr(i8* readonly nocapture)
declare void @writeonly_attr(i8* writeonly nocapture) declare void @writeonly_attr(i8* writeonly nocapture)
declare void @readnone_attr(i8* readnone nocapture) declare void @readnone_attr(i8* readnone nocapture)
declare void @readonly_func(i8* nocapture) readonly declare void @readonly_func(i8* nocapture) readonly
declare void @writeonly_func(i8* nocapture) writeonly declare void @writeonly_func(i8* nocapture) writeonly
declare void @readnone_func(i8* nocapture) readnone declare void @readnone_func(i8* nocapture) readnone
declare void @read_write(i8* writeonly nocapture, i8* readonly nocapture, i8* readnone nocapture) declare void @read_write(i8* writeonly nocapture, i8* readonly nocapture, i8* readnone nocapture)
declare void @func() declare void @func()
define void @test(i8* noalias %p) { define void @test(i8* noalias %p) {
entry: entry:
load i8, i8* %p
call void @readonly_attr(i8* %p) call void @readonly_attr(i8* %p)
call void @readonly_func(i8* %p) call void @readonly_func(i8* %p)
call void @writeonly_attr(i8* %p) call void @writeonly_attr(i8* %p)
call void @writeonly_func(i8* %p) call void @writeonly_func(i8* %p)
call void @readnone_attr(i8* %p) call void @readnone_attr(i8* %p)
call void @readnone_func(i8* %p) call void @readnone_func(i8* %p)
Show All 18 Lines

llvm/test/Analysis/BasicAA/cs-cs.ll

; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -S 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -S 2>&1 | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32"
target triple = "arm-apple-ios" target triple = "arm-apple-ios"
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1) #0 declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1) #0
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1) #0 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1) #0
declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32) #0 declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32) #0
declare void @a_readonly_func(i8*) #1 declare void @a_readonly_func(i8*) #1
declare void @a_writeonly_func(i8*) #2 declare void @a_writeonly_func(i8*) #2
define void @test2(i8* %P, i8* %Q) #3 { define void @test2(i8* %P, i8* %Q) #3 {
load i8, i8* %P
load i8, i8* %Q
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
ret void ret void
; CHECK-LABEL: Function: test2: ; CHECK-LABEL: Function: test2:
; CHECK: MayAlias: i8* %P, i8* %Q ; CHECK: MayAlias: i8* %P, i8* %Q
; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Both ModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Both ModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
} }
define void @test2_atomic(i8* %P, i8* %Q) #3 { define void @test2_atomic(i8* %P, i8* %Q) #3 {
load i8, i8* %P
load i8, i8* %Q
tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1) tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1)
tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1) tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1)
ret void ret void
; CHECK-LABEL: Function: test2_atomic: ; CHECK-LABEL: Function: test2_atomic:
; CHECK: MayAlias: i8* %P, i8* %Q ; CHECK: MayAlias: i8* %P, i8* %Q
; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1) ; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1)
; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1) ; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1)
; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1) ; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1)
; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1) ; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1)
; CHECK: Both ModRef: tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1) <-> tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1) ; CHECK: Both ModRef: tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1) <-> tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1)
; CHECK: Both ModRef: tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1) <-> tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1) ; CHECK: Both ModRef: tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1) <-> tail call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %P, i8* align 1 %Q, i64 12, i32 1)
} }
define void @test2a(i8* noalias %P, i8* noalias %Q) #3 { define void @test2a(i8* noalias %P, i8* noalias %Q) #3 {
load i8, i8* %P
load i8, i8* %Q
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
ret void ret void
; CHECK-LABEL: Function: test2a: ; CHECK-LABEL: Function: test2a:
; CHECK: NoAlias: i8* %P, i8* %Q ; CHECK: NoAlias: i8* %P, i8* %Q
; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
} }
define void @test2b(i8* noalias %P, i8* noalias %Q) #3 { define void @test2b(i8* noalias %P, i8* noalias %Q) #3 {
load i8, i8* %P
load i8, i8* %Q
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
%R = getelementptr i8, i8* %P, i64 12 %R = getelementptr i8, i8* %P, i64 12
load i8, i8* %R
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
ret void ret void
; CHECK-LABEL: Function: test2b: ; CHECK-LABEL: Function: test2b:
; CHECK: NoAlias: i8* %P, i8* %Q ; CHECK: NoAlias: i8* %P, i8* %Q
; CHECK: NoAlias: i8* %P, i8* %R ; CHECK: NoAlias: i8* %P, i8* %R
; CHECK: NoAlias: i8* %Q, i8* %R ; CHECK: NoAlias: i8* %Q, i8* %R
; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: NoModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: NoModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: NoModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) ; CHECK: NoModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) ; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
; CHECK: NoModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) ; CHECK: NoModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
; CHECK: NoModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: NoModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
} }
define void @test2c(i8* noalias %P, i8* noalias %Q) #3 { define void @test2c(i8* noalias %P, i8* noalias %Q) #3 {
load i8, i8* %P
load i8, i8* %Q
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
%R = getelementptr i8, i8* %P, i64 11 %R = getelementptr i8, i8* %P, i64 11
load i8, i8* %R
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
ret void ret void
; CHECK-LABEL: Function: test2c: ; CHECK-LABEL: Function: test2c:
; CHECK: NoAlias: i8* %P, i8* %Q ; CHECK: NoAlias: i8* %P, i8* %Q
; CHECK: NoAlias: i8* %P, i8* %R ; CHECK: NoAlias: i8* %P, i8* %R
; CHECK: NoAlias: i8* %Q, i8* %R ; CHECK: NoAlias: i8* %Q, i8* %R
; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: NoModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) ; CHECK: NoModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) ; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
} }
define void @test2d(i8* noalias %P, i8* noalias %Q) #3 { define void @test2d(i8* noalias %P, i8* noalias %Q) #3 {
load i8, i8* %P
load i8, i8* %Q
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
%R = getelementptr i8, i8* %P, i64 -12 %R = getelementptr i8, i8* %P, i64 -12
load i8, i8* %R
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
ret void ret void
; CHECK-LABEL: Function: test2d: ; CHECK-LABEL: Function: test2d:
; CHECK: NoAlias: i8* %P, i8* %Q ; CHECK: NoAlias: i8* %P, i8* %Q
; CHECK: NoAlias: i8* %P, i8* %R ; CHECK: NoAlias: i8* %P, i8* %R
; CHECK: NoAlias: i8* %Q, i8* %R ; CHECK: NoAlias: i8* %Q, i8* %R
; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: NoModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: NoModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: NoModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) ; CHECK: NoModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) ; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
; CHECK: NoModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) ; CHECK: NoModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
; CHECK: NoModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: NoModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
} }
define void @test2e(i8* noalias %P, i8* noalias %Q) #3 { define void @test2e(i8* noalias %P, i8* noalias %Q) #3 {
load i8, i8* %P
load i8, i8* %Q
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
%R = getelementptr i8, i8* %P, i64 -11 %R = getelementptr i8, i8* %P, i64 -11
load i8, i8* %R
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
ret void ret void
; CHECK-LABEL: Function: test2e: ; CHECK-LABEL: Function: test2e:
; CHECK: NoAlias: i8* %P, i8* %Q ; CHECK: NoAlias: i8* %P, i8* %Q
; CHECK: NoAlias: i8* %P, i8* %R ; CHECK: NoAlias: i8* %P, i8* %R
; CHECK: NoAlias: i8* %Q, i8* %R ; CHECK: NoAlias: i8* %Q, i8* %R
; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: NoModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: NoModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) ; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %R, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
} }
define void @test3(i8* %P, i8* %Q) #3 { define void @test3(i8* %P, i8* %Q) #3 {
load i8, i8* %P
load i8, i8* %Q
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false)
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
ret void ret void
; CHECK-LABEL: Function: test3: ; CHECK-LABEL: Function: test3:
; CHECK: MayAlias: i8* %P, i8* %Q ; CHECK: MayAlias: i8* %P, i8* %Q
; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false) ; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false)
; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false) ; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false)
; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Both ModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Both ModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false) ; CHECK: Both ModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false)
} }
define void @test3a(i8* noalias %P, i8* noalias %Q) #3 { define void @test3a(i8* noalias %P, i8* noalias %Q) #3 {
load i8, i8* %P
load i8, i8* %Q
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false)
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
ret void ret void
; CHECK-LABEL: Function: test3a: ; CHECK-LABEL: Function: test3a:
; CHECK: NoAlias: i8* %P, i8* %Q ; CHECK: NoAlias: i8* %P, i8* %Q
; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false) ; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false)
; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false) ; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false)
; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false) ; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 8, i1 false)
} }
define void @test4(i8* %P, i8* noalias %Q) #3 { define void @test4(i8* %P, i8* noalias %Q) #3 {
load i8, i8* %P
load i8, i8* %Q
tail call void @llvm.memset.p0i8.i64(i8* %P, i8 42, i64 8, i1 false) tail call void @llvm.memset.p0i8.i64(i8* %P, i8 42, i64 8, i1 false)
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
ret void ret void
; CHECK-LABEL: Function: test4: ; CHECK-LABEL: Function: test4:
; CHECK: NoAlias: i8* %P, i8* %Q ; CHECK: NoAlias: i8* %P, i8* %Q
; CHECK: Just Mod (MustAlias): Ptr: i8* %P <-> tail call void @llvm.memset.p0i8.i64(i8* %P, i8 42, i64 8, i1 false) ; CHECK: Just Mod (MustAlias): Ptr: i8* %P <-> tail call void @llvm.memset.p0i8.i64(i8* %P, i8 42, i64 8, i1 false)
; CHECK: NoModRef: Ptr: i8* %Q <-> tail call void @llvm.memset.p0i8.i64(i8* %P, i8 42, i64 8, i1 false) ; CHECK: NoModRef: Ptr: i8* %Q <-> tail call void @llvm.memset.p0i8.i64(i8* %P, i8 42, i64 8, i1 false)
; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: tail call void @llvm.memset.p0i8.i64(i8* %P, i8 42, i64 8, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: tail call void @llvm.memset.p0i8.i64(i8* %P, i8 42, i64 8, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memset.p0i8.i64(i8* %P, i8 42, i64 8, i1 false) ; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memset.p0i8.i64(i8* %P, i8 42, i64 8, i1 false)
} }
define void @test5(i8* %P, i8* %Q, i8* %R) #3 { define void @test5(i8* %P, i8* %Q, i8* %R) #3 {
load i8, i8* %P
load i8, i8* %Q
load i8, i8* %R
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false)
ret void ret void
; CHECK-LABEL: Function: test5: ; CHECK-LABEL: Function: test5:
; CHECK: MayAlias: i8* %P, i8* %Q ; CHECK: MayAlias: i8* %P, i8* %Q
; CHECK: MayAlias: i8* %P, i8* %R ; CHECK: MayAlias: i8* %P, i8* %R
; CHECK: MayAlias: i8* %Q, i8* %R ; CHECK: MayAlias: i8* %Q, i8* %R
; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Both ModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false) ; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false)
; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false) ; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false)
; CHECK: Both ModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false) ; CHECK: Both ModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false)
; CHECK: Both ModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false) ; CHECK: Both ModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false)
; CHECK: Both ModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Both ModRef: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
} }
define void @test5a(i8* noalias %P, i8* noalias %Q, i8* noalias %R) nounwind ssp { define void @test5a(i8* noalias %P, i8* noalias %Q, i8* noalias %R) nounwind ssp {
load i8, i8* %P
load i8, i8* %Q
load i8, i8* %R
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false)
ret void ret void
; CHECK-LABEL: Function: test5a: ; CHECK-LABEL: Function: test5a:
; CHECK: NoAlias: i8* %P, i8* %Q ; CHECK: NoAlias: i8* %P, i8* %Q
; CHECK: NoAlias: i8* %P, i8* %R ; CHECK: NoAlias: i8* %P, i8* %R
; CHECK: NoAlias: i8* %Q, i8* %R ; CHECK: NoAlias: i8* %Q, i8* %R
; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: NoModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: NoModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false) ; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false)
; CHECK: NoModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false) ; CHECK: NoModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false)
; CHECK: Just Ref: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false) ; CHECK: Just Ref: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false)
; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false) ; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false)
; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) ; CHECK: Just Mod: tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %R, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
} }
define void @test6(i8* %P) #3 { define void @test6(i8* %P) #3 {
load i8, i8* %P
call void @llvm.memset.p0i8.i64(i8* align 8 %P, i8 -51, i64 32, i1 false) call void @llvm.memset.p0i8.i64(i8* align 8 %P, i8 -51, i64 32, i1 false)
call void @a_readonly_func(i8* %P) call void @a_readonly_func(i8* %P)
ret void ret void
; CHECK-LABEL: Function: test6: ; CHECK-LABEL: Function: test6:
; CHECK: Just Mod (MustAlias): Ptr: i8* %P <-> call void @llvm.memset.p0i8.i64(i8* align 8 %P, i8 -51, i64 32, i1 false) ; CHECK: Just Mod (MustAlias): Ptr: i8* %P <-> call void @llvm.memset.p0i8.i64(i8* align 8 %P, i8 -51, i64 32, i1 false)
; CHECK: Just Ref: Ptr: i8* %P <-> call void @a_readonly_func(i8* %P) ; CHECK: Just Ref: Ptr: i8* %P <-> call void @a_readonly_func(i8* %P)
; CHECK: Just Mod: call void @llvm.memset.p0i8.i64(i8* align 8 %P, i8 -51, i64 32, i1 false) <-> call void @a_readonly_func(i8* %P) ; CHECK: Just Mod: call void @llvm.memset.p0i8.i64(i8* align 8 %P, i8 -51, i64 32, i1 false) <-> call void @a_readonly_func(i8* %P)
; CHECK: Just Ref: call void @a_readonly_func(i8* %P) <-> call void @llvm.memset.p0i8.i64(i8* align 8 %P, i8 -51, i64 32, i1 false) ; CHECK: Just Ref: call void @a_readonly_func(i8* %P) <-> call void @llvm.memset.p0i8.i64(i8* align 8 %P, i8 -51, i64 32, i1 false)
} }
define void @test7(i8* %P) #3 { define void @test7(i8* %P) #3 {
load i8, i8* %P
call void @a_writeonly_func(i8* %P) call void @a_writeonly_func(i8* %P)
call void @a_readonly_func(i8* %P) call void @a_readonly_func(i8* %P)
ret void ret void
; CHECK-LABEL: Function: test7: ; CHECK-LABEL: Function: test7:
; CHECK: Just Mod: Ptr: i8* %P <-> call void @a_writeonly_func(i8* %P) ; CHECK: Just Mod: Ptr: i8* %P <-> call void @a_writeonly_func(i8* %P)
; CHECK: Just Ref: Ptr: i8* %P <-> call void @a_readonly_func(i8* %P) ; CHECK: Just Ref: Ptr: i8* %P <-> call void @a_readonly_func(i8* %P)
; CHECK: Just Mod: call void @a_writeonly_func(i8* %P) <-> call void @a_readonly_func(i8* %P) ; CHECK: Just Mod: call void @a_writeonly_func(i8* %P) <-> call void @a_readonly_func(i8* %P)
; CHECK: Just Ref: call void @a_readonly_func(i8* %P) <-> call void @a_writeonly_func(i8* %P) ; CHECK: Just Ref: call void @a_readonly_func(i8* %P) <-> call void @a_writeonly_func(i8* %P)
} }
declare void @an_inaccessiblememonly_func() #4 declare void @an_inaccessiblememonly_func() #4
declare void @an_inaccessibleorargmemonly_func(i8*) #5 declare void @an_inaccessibleorargmemonly_func(i8*) #5
declare void @an_argmemonly_func(i8*) #0 declare void @an_argmemonly_func(i8*) #0
define void @test8(i8* %p) { define void @test8(i8* %p) {
entry: entry:
%q = getelementptr i8, i8* %p, i64 16 %q = getelementptr i8, i8* %p, i64 16
load i8, i8* %p
load i8, i8* %q
call void @a_readonly_func(i8* %p) call void @a_readonly_func(i8* %p)
call void @an_inaccessiblememonly_func() call void @an_inaccessiblememonly_func()
call void @a_writeonly_func(i8* %q) call void @a_writeonly_func(i8* %q)
call void @an_inaccessiblememonly_func() call void @an_inaccessiblememonly_func()
call void @an_inaccessibleorargmemonly_func(i8* %q) call void @an_inaccessibleorargmemonly_func(i8* %q)
call void @an_argmemonly_func(i8* %q) call void @an_argmemonly_func(i8* %q)
ret void ret void
Show All 24 Lines
; CHECK: NoModRef: call void @an_argmemonly_func(i8* %q) <-> call void @an_inaccessiblememonly_func() ; CHECK: NoModRef: call void @an_argmemonly_func(i8* %q) <-> call void @an_inaccessiblememonly_func()
; CHECK: Both ModRef (MustAlias): call void @an_argmemonly_func(i8* %q) <-> call void @an_inaccessibleorargmemonly_func(i8* %q) ; CHECK: Both ModRef (MustAlias): call void @an_argmemonly_func(i8* %q) <-> call void @an_inaccessibleorargmemonly_func(i8* %q)
} }
;; test that MustAlias is set for calls when no MayAlias is found. ;; test that MustAlias is set for calls when no MayAlias is found.
declare void @another_argmemonly_func(i8*, i8*) #0 declare void @another_argmemonly_func(i8*, i8*) #0
define void @test8a(i8* noalias %p, i8* noalias %q) { define void @test8a(i8* noalias %p, i8* noalias %q) {
entry: entry:
load i8, i8* %p
load i8, i8* %q
call void @another_argmemonly_func(i8* %p, i8* %q) call void @another_argmemonly_func(i8* %p, i8* %q)
ret void ret void
; CHECK-LABEL: Function: test8a ; CHECK-LABEL: Function: test8a
; CHECK: Both ModRef: Ptr: i8* %p <-> call void @another_argmemonly_func(i8* %p, i8* %q) ; CHECK: Both ModRef: Ptr: i8* %p <-> call void @another_argmemonly_func(i8* %p, i8* %q)
; CHECK: Both ModRef: Ptr: i8* %q <-> call void @another_argmemonly_func(i8* %p, i8* %q) ; CHECK: Both ModRef: Ptr: i8* %q <-> call void @another_argmemonly_func(i8* %p, i8* %q)
} }
define void @test8b(i8* %p, i8* %q) { define void @test8b(i8* %p, i8* %q) {
entry: entry:
load i8, i8* %p
load i8, i8* %q
call void @another_argmemonly_func(i8* %p, i8* %q) call void @another_argmemonly_func(i8* %p, i8* %q)
ret void ret void
; CHECK-LABEL: Function: test8b ; CHECK-LABEL: Function: test8b
; CHECK: Both ModRef: Ptr: i8* %p <-> call void @another_argmemonly_func(i8* %p, i8* %q) ; CHECK: Both ModRef: Ptr: i8* %p <-> call void @another_argmemonly_func(i8* %p, i8* %q)
; CHECK: Both ModRef: Ptr: i8* %q <-> call void @another_argmemonly_func(i8* %p, i8* %q) ; CHECK: Both ModRef: Ptr: i8* %q <-> call void @another_argmemonly_func(i8* %p, i8* %q)
} }
;; test that unknown operand bundle has unknown effect to the heap ;; test that unknown operand bundle has unknown effect to the heap
define void @test9(i8* %p) { define void @test9(i8* %p) {
; CHECK-LABEL: Function: test9 ; CHECK-LABEL: Function: test9
entry: entry:
%q = getelementptr i8, i8* %p, i64 16 %q = getelementptr i8, i8* %p, i64 16
load i8, i8* %p
load i8, i8* %q
call void @a_readonly_func(i8* %p) [ "unknown"() ] call void @a_readonly_func(i8* %p) [ "unknown"() ]
call void @an_inaccessiblememonly_func() [ "unknown"() ] call void @an_inaccessiblememonly_func() [ "unknown"() ]
call void @an_inaccessibleorargmemonly_func(i8* %q) [ "unknown"() ] call void @an_inaccessibleorargmemonly_func(i8* %q) [ "unknown"() ]
call void @an_argmemonly_func(i8* %q) [ "unknown"() ] call void @an_argmemonly_func(i8* %q) [ "unknown"() ]
ret void ret void
; CHECK: Both ModRef: Ptr: i8* %p <-> call void @a_readonly_func(i8* %p) [ "unknown"() ] ; CHECK: Both ModRef: Ptr: i8* %p <-> call void @a_readonly_func(i8* %p) [ "unknown"() ]
; CHECK: Both ModRef: Ptr: i8* %q <-> call void @a_readonly_func(i8* %p) [ "unknown"() ] ; CHECK: Both ModRef: Ptr: i8* %q <-> call void @a_readonly_func(i8* %p) [ "unknown"() ]
Show All 17 Lines
; CHECK: Both ModRef: call void @an_argmemonly_func(i8* %q) [ "unknown"() ] <-> call void @an_inaccessibleorargmemonly_func(i8* %q) [ "unknown"() ] ; CHECK: Both ModRef: call void @an_argmemonly_func(i8* %q) [ "unknown"() ] <-> call void @an_inaccessibleorargmemonly_func(i8* %q) [ "unknown"() ]
} }
;; test callsite overwrite of unknown operand bundle ;; test callsite overwrite of unknown operand bundle
define void @test10(i8* %p) { define void @test10(i8* %p) {
; CHECK-LABEL: Function: test10 ; CHECK-LABEL: Function: test10
entry: entry:
%q = getelementptr i8, i8* %p, i64 16 %q = getelementptr i8, i8* %p, i64 16
load i8, i8* %p
load i8, i8* %q
call void @a_readonly_func(i8* %p) #6 [ "unknown"() ] call void @a_readonly_func(i8* %p) #6 [ "unknown"() ]
call void @an_inaccessiblememonly_func() #7 [ "unknown"() ] call void @an_inaccessiblememonly_func() #7 [ "unknown"() ]
call void @an_inaccessibleorargmemonly_func(i8* %q) #8 [ "unknown"() ] call void @an_inaccessibleorargmemonly_func(i8* %q) #8 [ "unknown"() ]
call void @an_argmemonly_func(i8* %q) #9 [ "unknown"() ] call void @an_argmemonly_func(i8* %q) #9 [ "unknown"() ]
ret void ret void
; CHECK: Just Ref: Ptr: i8* %p <-> call void @a_readonly_func(i8* %p) #9 [ "unknown"() ] ; CHECK: Just Ref: Ptr: i8* %p <-> call void @a_readonly_func(i8* %p) #9 [ "unknown"() ]
; CHECK: Just Ref: Ptr: i8* %q <-> call void @a_readonly_func(i8* %p) #9 [ "unknown"() ] ; CHECK: Just Ref: Ptr: i8* %q <-> call void @a_readonly_func(i8* %p) #9 [ "unknown"() ]
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Analysis/BasicAA/dag.ll

; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
; BasicAA's guard against use-def cycles shouldn't prevent it from ; BasicAA's guard against use-def cycles shouldn't prevent it from
; analyzing use-def dags. ; analyzing use-def dags.
; CHECK: MustAlias: i8* %base, i8* %phi ; CHECK: MustAlias: i8* %base, i8* %phi
; CHECK: MustAlias: i8* %phi, i8* %wwa ; CHECK: MustAlias: i8* %phi, i8* %wwa
; CHECK: MustAlias: i8* %phi, i8* %wwb ; CHECK: MustAlias: i8* %phi, i8* %wwb
; CHECK: MustAlias: i16* %bigbase, i8* %phi ; CHECK: MustAlias: i16* %bigbase, i8* %phi
define i8 @foo(i8* %base, i1 %x, i1 %w) { define i8 @foo(i8* %base, i1 %x, i1 %w) {
entry: entry:
load i8, i8* %base
br i1 %w, label %wa, label %wb br i1 %w, label %wa, label %wb
wa: wa:
%wwa = bitcast i8* %base to i8* %wwa = bitcast i8* %base to i8*
load i8, i8* %wwa
br label %wc br label %wc
wb: wb:
%wwb = bitcast i8* %base to i8* %wwb = bitcast i8* %base to i8*
load i8, i8* %wwb
br label %wc br label %wc
wc: wc:
%first = phi i8* [ %wwa, %wa ], [ %wwb, %wb ] %first = phi i8* [ %wwa, %wa ], [ %wwb, %wb ]
%fc = bitcast i8* %first to i8* %fc = bitcast i8* %first to i8*
br i1 %x, label %xa, label %xb br i1 %x, label %xa, label %xb
xa: xa:
%xxa = bitcast i8* %fc to i8* %xxa = bitcast i8* %fc to i8*
br label %xc br label %xc
Show All 14 Lines

llvm/test/Analysis/BasicAA/deoptimize.ll

; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32"
@G1 = external global i32 @G1 = external global i32
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1)
declare void @llvm.memmove.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) declare void @llvm.memmove.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1)
declare void @llvm.experimental.deoptimize.void(...) declare void @llvm.experimental.deoptimize.void(...)
declare void @unknown_but_readonly() readonly declare void @unknown_but_readonly() readonly
define void @test1(i8* %p) { define void @test1(i8* %p) {
load i8, i8* %p
call void(...) @llvm.experimental.deoptimize.void() [ "deopt"() ] call void(...) @llvm.experimental.deoptimize.void() [ "deopt"() ]
ret void ret void
; CHECK-LABEL: Function: test1: ; CHECK-LABEL: Function: test1:
; CHECK: Just Ref: Ptr: i8* %p <-> call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ] ; CHECK: Just Ref: Ptr: i8* %p <-> call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
} }
; By specification calls with deopt bundles reads through all operands and entire heap. ; By specification calls with deopt bundles reads through all operands and entire heap.
; Check that global G1 is reported as Ref by memcpy/memmove calls. ; Check that global G1 is reported as Ref by memcpy/memmove calls.
define i32 @test_memcpy_with_deopt() { define i32 @test_memcpy_with_deopt() {
; CHECK-LABEL: Function: test_memcpy_with_deopt: ; CHECK-LABEL: Function: test_memcpy_with_deopt:
; CHECK: Just Mod: Ptr: i8* %A <-> call void @llvm.memcpy.p0i8.p0i8.i64(i8* %A, i8* %B, i64 -1, i1 false) [ "deopt"() ] ; CHECK: Just Mod: Ptr: i8* %A <-> call void @llvm.memcpy.p0i8.p0i8.i64(i8* %A, i8* %B, i64 -1, i1 false) [ "deopt"() ]
; CHECK: Just Ref: Ptr: i8* %B <-> call void @llvm.memcpy.p0i8.p0i8.i64(i8* %A, i8* %B, i64 -1, i1 false) [ "deopt"() ] ; CHECK: Just Ref: Ptr: i8* %B <-> call void @llvm.memcpy.p0i8.p0i8.i64(i8* %A, i8* %B, i64 -1, i1 false) [ "deopt"() ]
; CHECK: Just Ref: Ptr: i32* @G1 <-> call void @llvm.memcpy.p0i8.p0i8.i64(i8* %A, i8* %B, i64 -1, i1 false) [ "deopt"() ] ; CHECK: Just Ref: Ptr: i32* @G1 <-> call void @llvm.memcpy.p0i8.p0i8.i64(i8* %A, i8* %B, i64 -1, i1 false) [ "deopt"() ]
%A = alloca i8 %A = alloca i8
%B = alloca i8 %B = alloca i8
load i8, i8* %A
load i8, i8* %B
store i32 2, i32* @G1 ;; Not referenced by semantics of memcpy but still may be read due to "deopt" store i32 2, i32* @G1 ;; Not referenced by semantics of memcpy but still may be read due to "deopt"
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %A, i8* %B, i64 -1, i1 false) [ "deopt"() ] call void @llvm.memcpy.p0i8.p0i8.i64(i8* %A, i8* %B, i64 -1, i1 false) [ "deopt"() ]
%C = load i32, i32* @G1 %C = load i32, i32* @G1
ret i32 %C ret i32 %C
} }
define i32 @test_memmove_with_deopt() { define i32 @test_memmove_with_deopt() {
; CHECK-LABEL: Function: test_memmove_with_deopt: ; CHECK-LABEL: Function: test_memmove_with_deopt:
; CHECK: Just Mod: Ptr: i8* %A <-> call void @llvm.memmove.p0i8.p0i8.i64(i8* %A, i8* %B, i64 -1, i1 false) [ "deopt"() ] ; CHECK: Just Mod: Ptr: i8* %A <-> call void @llvm.memmove.p0i8.p0i8.i64(i8* %A, i8* %B, i64 -1, i1 false) [ "deopt"() ]
; CHECK: Just Ref: Ptr: i8* %B <-> call void @llvm.memmove.p0i8.p0i8.i64(i8* %A, i8* %B, i64 -1, i1 false) [ "deopt"() ] ; CHECK: Just Ref: Ptr: i8* %B <-> call void @llvm.memmove.p0i8.p0i8.i64(i8* %A, i8* %B, i64 -1, i1 false) [ "deopt"() ]
; CHECK: Just Ref: Ptr: i32* @G1 <-> call void @llvm.memmove.p0i8.p0i8.i64(i8* %A, i8* %B, i64 -1, i1 false) [ "deopt"() ] ; CHECK: Just Ref: Ptr: i32* @G1 <-> call void @llvm.memmove.p0i8.p0i8.i64(i8* %A, i8* %B, i64 -1, i1 false) [ "deopt"() ]
%A = alloca i8 %A = alloca i8
%B = alloca i8 %B = alloca i8
load i8, i8* %A
load i8, i8* %B
store i32 2, i32* @G1 ;; Not referenced by semantics of memcpy but still may be read due to "deopt" store i32 2, i32* @G1 ;; Not referenced by semantics of memcpy but still may be read due to "deopt"
call void @llvm.memmove.p0i8.p0i8.i64(i8* %A, i8* %B, i64 -1, i1 false) [ "deopt"() ] call void @llvm.memmove.p0i8.p0i8.i64(i8* %A, i8* %B, i64 -1, i1 false) [ "deopt"() ]
%C = load i32, i32* @G1 %C = load i32, i32* @G1
ret i32 %C ret i32 %C
} }

llvm/test/Analysis/BasicAA/dereferenceable.ll

; RUN: opt -aa-pipeline=basic-aa -print-all-alias-modref-info -passes=aa-eval < %s 2>&1 | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -print-all-alias-modref-info -passes=aa-eval < %s 2>&1 | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -print-all-alias-modref-info -passes=aa-eval -use-dereferenceable-at-point-semantics=1 < %s 2>&1 | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -print-all-alias-modref-info -passes=aa-eval -use-dereferenceable-at-point-semantics=1 < %s 2>&1 | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
@G = global i32 0, align 4 @G = global i32 0, align 4
define i64 @global_and_deref_arg_1(i64* dereferenceable(8) %arg) nofree nosync { define i64 @global_and_deref_arg_1(i64* dereferenceable(8) %arg) nofree nosync {
; CHECK: Function: global_and_deref_arg_1: 2 pointers, 0 call sites ; CHECK: Function: global_and_deref_arg_1: 2 pointers, 0 call sites
; CHECK-NEXT: NoAlias: i32* @G, i64* %arg ; CHECK-NEXT: NoAlias: i64* %arg, i32* @G
bb: bb:
store i64 1, i64* %arg, align 8 store i64 1, i64* %arg, align 8
store i32 0, i32* @G, align 4 store i32 0, i32* @G, align 4
%tmp = load i64, i64* %arg, align 8 %tmp = load i64, i64* %arg, align 8
ret i64 %tmp ret i64 %tmp
} }
define i32 @global_and_deref_arg_2(i32* dereferenceable(8) %arg) nofree nosync { define i32 @global_and_deref_arg_2(i32* dereferenceable(8) %arg) nofree nosync {
; CHECK: Function: global_and_deref_arg_2: 2 pointers, 0 call sites ; CHECK: Function: global_and_deref_arg_2: 2 pointers, 0 call sites
; CHECK-NEXT: NoAlias: i32* %arg, i32* @G ; CHECK-NEXT: NoAlias: i32* %arg, i32* @G
bb: bb:
store i32 1, i32* %arg, align 8 store i32 1, i32* %arg, align 8
store i32 0, i32* @G, align 4 store i32 0, i32* @G, align 4
%tmp = load i32, i32* %arg, align 8 %tmp = load i32, i32* %arg, align 8
ret i32 %tmp ret i32 %tmp
} }
define i32 @byval_and_deref_arg_1(i32* byval(i32) %obj, i64* dereferenceable(8) %arg) nofree nosync { define i32 @byval_and_deref_arg_1(i32* byval(i32) %obj, i64* dereferenceable(8) %arg) nofree nosync {
; CHECK: Function: byval_and_deref_arg_1: 2 pointers, 0 call sites ; CHECK: Function: byval_and_deref_arg_1: 2 pointers, 0 call sites
; CHECK-NEXT: NoAlias: i32* %obj, i64* %arg ; CHECK-NEXT: NoAlias: i64* %arg, i32* %obj
bb: bb:
store i32 1, i32* %obj, align 4 store i32 1, i32* %obj, align 4
store i64 0, i64* %arg, align 8 store i64 0, i64* %arg, align 8
%tmp = load i32, i32* %obj, align 4 %tmp = load i32, i32* %obj, align 4
ret i32 %tmp ret i32 %tmp
} }
define i32 @byval_and_deref_arg_2(i32* byval(i32) %obj, i32* dereferenceable(8) %arg) nofree nosync { define i32 @byval_and_deref_arg_2(i32* byval(i32) %obj, i32* dereferenceable(8) %arg) nofree nosync {
Show All 36 Linesbb:
ret i32 %tmp ret i32 %tmp
} }
; Baseline tests, same as above but with 2 instead of 8 dereferenceable bytes. ; Baseline tests, same as above but with 2 instead of 8 dereferenceable bytes.
define i64 @global_and_deref_arg_non_deref_1(i64* dereferenceable(2) %arg) nofree nosync { define i64 @global_and_deref_arg_non_deref_1(i64* dereferenceable(2) %arg) nofree nosync {
; CHECK: Function: global_and_deref_arg_non_deref_1: 2 pointers, 0 call sites ; CHECK: Function: global_and_deref_arg_non_deref_1: 2 pointers, 0 call sites
; CHECK-NEXT: NoAlias: i32* @G, i64* %arg ; CHECK-NEXT: NoAlias: i64* %arg, i32* @G
bb: bb:
store i64 1, i64* %arg, align 8 store i64 1, i64* %arg, align 8
store i32 0, i32* @G, align 4 store i32 0, i32* @G, align 4
%tmp = load i64, i64* %arg, align 8 %tmp = load i64, i64* %arg, align 8
ret i64 %tmp ret i64 %tmp
} }
define i32 @global_and_deref_arg_non_deref_2(i32* dereferenceable(2) %arg) nofree nosync { define i32 @global_and_deref_arg_non_deref_2(i32* dereferenceable(2) %arg) nofree nosync {
; CHECK: Function: global_and_deref_arg_non_deref_2: 2 pointers, 0 call sites ; CHECK: Function: global_and_deref_arg_non_deref_2: 2 pointers, 0 call sites
; Different result than above (see @global_and_deref_arg_2). ; Different result than above (see @global_and_deref_arg_2).
; CHECK-NEXT: MayAlias: i32* %arg, i32* @G ; CHECK-NEXT: MayAlias: i32* %arg, i32* @G
bb: bb:
store i32 1, i32* %arg, align 8 store i32 1, i32* %arg, align 8
store i32 0, i32* @G, align 4 store i32 0, i32* @G, align 4
%tmp = load i32, i32* %arg, align 8 %tmp = load i32, i32* %arg, align 8
ret i32 %tmp ret i32 %tmp
} }
define i32 @byval_and_deref_arg_non_deref_1(i32* byval(i32) %obj, i64* dereferenceable(2) %arg) nofree nosync { define i32 @byval_and_deref_arg_non_deref_1(i32* byval(i32) %obj, i64* dereferenceable(2) %arg) nofree nosync {
; CHECK: Function: byval_and_deref_arg_non_deref_1: 2 pointers, 0 call sites ; CHECK: Function: byval_and_deref_arg_non_deref_1: 2 pointers, 0 call sites
; CHECK-NEXT: NoAlias: i32* %obj, i64* %arg ; CHECK-NEXT: NoAlias: i64* %arg, i32* %obj
bb: bb:
store i32 1, i32* %obj, align 4 store i32 1, i32* %obj, align 4
store i64 0, i64* %arg, align 8 store i64 0, i64* %arg, align 8
%tmp = load i32, i32* %obj, align 4 %tmp = load i32, i32* %obj, align 4
ret i32 %tmp ret i32 %tmp
} }
define i32 @byval_and_deref_arg_non_deref_2(i32* byval(i32) %obj, i32* dereferenceable(2) %arg) nofree nosync { define i32 @byval_and_deref_arg_non_deref_2(i32* byval(i32) %obj, i32* dereferenceable(2) %arg) nofree nosync {
Show All 38 Lines

llvm/test/Analysis/BasicAA/gep-decomposition-limit.ll

Show All 21 Linesdefine void @test(i8* %base) {
%gep.inc1 = getelementptr i8, i8* %base, i64 1 %gep.inc1 = getelementptr i8, i8* %base, i64 1
%gep.inc2 = getelementptr i8, i8* %gep.inc1, i64 1 %gep.inc2 = getelementptr i8, i8* %gep.inc1, i64 1
%gep.inc3 = getelementptr i8, i8* %gep.inc2, i64 1 %gep.inc3 = getelementptr i8, i8* %gep.inc2, i64 1
%gep.inc4 = getelementptr i8, i8* %gep.inc3, i64 1 %gep.inc4 = getelementptr i8, i8* %gep.inc3, i64 1
%gep.inc5 = getelementptr i8, i8* %gep.inc4, i64 1 %gep.inc5 = getelementptr i8, i8* %gep.inc4, i64 1
%gep.inc6 = getelementptr i8, i8* %gep.inc5, i64 1 %gep.inc6 = getelementptr i8, i8* %gep.inc5, i64 1
%gep.inc7 = getelementptr i8, i8* %gep.inc6, i64 1 %gep.inc7 = getelementptr i8, i8* %gep.inc6, i64 1
load i8, i8* %gep.add5
load i8, i8* %gep.add6
load i8, i8* %gep.add7
load i8, i8* %gep.inc3
load i8, i8* %gep.inc4
load i8, i8* %gep.inc5
load i8, i8* %gep.inc6
load i8, i8* %gep.inc7
ret void ret void
} }

llvm/test/Analysis/BasicAA/gep-implicit-trunc-32-bit-pointers.ll

; RUN: opt -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output %s 2>&1 | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output %s 2>&1 | FileCheck %s
target datalayout = "p:32:32:32" target datalayout = "p:32:32:32"
; Test cases with i64 bit GEP indices that will get truncated implicitly to 32 ; Test cases with i64 bit GEP indices that will get truncated implicitly to 32
; bit due to the datalayout. ; bit due to the datalayout.
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
define void @mustalias_overflow_in_32_bit_constants(i8* %ptr) { define void @mustalias_overflow_in_32_bit_constants(i8* %ptr) {
; CHECK-LABEL: Function: mustalias_overflow_in_32_bit_constants: 3 pointers, 0 call sites ; CHECK-LABEL: Function: mustalias_overflow_in_32_bit_constants: 3 pointers, 0 call sites
; CHECK-NEXT: MustAlias: i8* %gep.1, i8* %ptr ; CHECK-NEXT: MustAlias: i8* %gep.1, i8* %ptr
; CHECK-NEXT: MustAlias: i8* %gep.2, i8* %ptr ; CHECK-NEXT: MustAlias: i8* %gep.2, i8* %ptr
; CHECK-NEXT: MustAlias: i8* %gep.1, i8* %gep.2 ; CHECK-NEXT: MustAlias: i8* %gep.1, i8* %gep.2
; ;
load i8, i8* %ptr
%gep.1 = getelementptr i8, i8* %ptr, i64 4294967296 %gep.1 = getelementptr i8, i8* %ptr, i64 4294967296
store i8 0, i8* %gep.1 store i8 0, i8* %gep.1
%gep.2 = getelementptr i8, i8* %ptr, i64 0 %gep.2 = getelementptr i8, i8* %ptr, i64 0
store i8 1, i8* %gep.2 store i8 1, i8* %gep.2
ret void ret void
} }
define void @mustalias_overflow_in_32_with_var_index([1 x i8]* %ptr, i64 %n) { define void @mustalias_overflow_in_32_with_var_index([1 x i8]* %ptr, i64 %n) {
; CHECK-LABEL: Function: mustalias_overflow_in_32_with_var_index ; CHECK-LABEL: Function: mustalias_overflow_in_32_with_var_index
; CHECK: MustAlias: i8* %gep.1, i8* %gep.2 ; CHECK: MustAlias: i8* %gep.1, i8* %gep.2
; ;
load [1 x i8], [1 x i8]* %ptr
%gep.1 = getelementptr [1 x i8], [1 x i8]* %ptr, i64 %n, i64 4294967296 %gep.1 = getelementptr [1 x i8], [1 x i8]* %ptr, i64 %n, i64 4294967296
store i8 0, i8* %gep.1 store i8 0, i8* %gep.1
%gep.2 = getelementptr [1 x i8], [1 x i8]* %ptr, i64 %n, i64 0 %gep.2 = getelementptr [1 x i8], [1 x i8]* %ptr, i64 %n, i64 0
store i8 1, i8* %gep.2 store i8 1, i8* %gep.2
ret void ret void
} }
define void @noalias_overflow_in_32_bit_constants(i8* %ptr) { define void @noalias_overflow_in_32_bit_constants(i8* %ptr) {
; CHECK-LABEL: Function: noalias_overflow_in_32_bit_constants: 3 pointers, 0 call sites ; CHECK-LABEL: Function: noalias_overflow_in_32_bit_constants: 3 pointers, 0 call sites
; CHECK-NEXT: MustAlias: i8* %gep.1, i8* %ptr ; CHECK-NEXT: MustAlias: i8* %gep.1, i8* %ptr
; CHECK-NEXT: NoAlias: i8* %gep.2, i8* %ptr ; CHECK-NEXT: NoAlias: i8* %gep.2, i8* %ptr
; CHECK-NEXT: NoAlias: i8* %gep.1, i8* %gep.2 ; CHECK-NEXT: NoAlias: i8* %gep.1, i8* %gep.2
; ;
load i8, i8* %ptr
%gep.1 = getelementptr i8, i8* %ptr, i64 4294967296 %gep.1 = getelementptr i8, i8* %ptr, i64 4294967296
store i8 0, i8* %gep.1 store i8 0, i8* %gep.1
%gep.2 = getelementptr i8, i8* %ptr, i64 1 %gep.2 = getelementptr i8, i8* %ptr, i64 1
store i8 1, i8* %gep.2 store i8 1, i8* %gep.2
ret void ret void
} }
; The GEP indices get implicitly truncated to 32 bit, so multiples of 2^32 ; The GEP indices get implicitly truncated to 32 bit, so multiples of 2^32
; (=4294967296) will be 0. ; (=4294967296) will be 0.
; See https://alive2.llvm.org/ce/z/HHjQgb. ; See https://alive2.llvm.org/ce/z/HHjQgb.
define void @mustalias_overflow_in_32_bit_add_mul_gep(i8* %ptr, i64 %i) { define void @mustalias_overflow_in_32_bit_add_mul_gep(i8* %ptr, i64 %i) {
; CHECK-LABEL: Function: mustalias_overflow_in_32_bit_add_mul_gep: 3 pointers, 1 call sites ; CHECK-LABEL: Function: mustalias_overflow_in_32_bit_add_mul_gep: 3 pointers, 1 call sites
; CHECK-NEXT: MayAlias: i8* %gep.1, i8* %ptr ; CHECK-NEXT: MayAlias: i8* %gep.1, i8* %ptr
; CHECK-NEXT: MayAlias: i8* %gep.2, i8* %ptr ; CHECK-NEXT: MayAlias: i8* %gep.2, i8* %ptr
; CHECK-NEXT: MayAlias: i8* %gep.1, i8* %gep.2 ; CHECK-NEXT: MayAlias: i8* %gep.1, i8* %gep.2
; ;
load i8, i8* %ptr
%s.1 = icmp sgt i64 %i, 0 %s.1 = icmp sgt i64 %i, 0
call void @llvm.assume(i1 %s.1) call void @llvm.assume(i1 %s.1)
%mul = mul nuw nsw i64 %i, 4294967296 %mul = mul nuw nsw i64 %i, 4294967296
%add = add nuw nsw i64 %mul, %i %add = add nuw nsw i64 %mul, %i
%gep.1 = getelementptr i8, i8* %ptr, i64 %add %gep.1 = getelementptr i8, i8* %ptr, i64 %add
store i8 0, i8* %gep.1 store i8 0, i8* %gep.1
%gep.2 = getelementptr i8, i8* %ptr, i64 %i %gep.2 = getelementptr i8, i8* %ptr, i64 %i
store i8 1, i8* %gep.2 store i8 1, i8* %gep.2
ret void ret void
} }
define void @mayalias_overflow_in_32_bit_non_zero(i8* %ptr, i64 %n) { define void @mayalias_overflow_in_32_bit_non_zero(i8* %ptr, i64 %n) {
; CHECK-LABEL: Function: mayalias_overflow_in_32_bit_non_zero ; CHECK-LABEL: Function: mayalias_overflow_in_32_bit_non_zero
; CHECK: MayAlias: i8* %gep, i8* %ptr ; CHECK: MayAlias: i8* %gep, i8* %ptr
; ;
load i8, i8* %ptr
%c = icmp ne i64 %n, 0 %c = icmp ne i64 %n, 0
call void @llvm.assume(i1 %c) call void @llvm.assume(i1 %c)
store i8 0, i8* %ptr store i8 0, i8* %ptr
%gep = getelementptr i8, i8* %ptr, i64 %n %gep = getelementptr i8, i8* %ptr, i64 %n
store i8 1, i8* %gep store i8 1, i8* %gep
ret void ret void
} }
define void @mayalias_overflow_in_32_bit_positive(i8* %ptr, i64 %n) { define void @mayalias_overflow_in_32_bit_positive(i8* %ptr, i64 %n) {
; CHECK-LABEL: Function: mayalias_overflow_in_32_bit_positive ; CHECK-LABEL: Function: mayalias_overflow_in_32_bit_positive
; CHECK: NoAlias: i8* %gep.1, i8* %ptr ; CHECK: NoAlias: i8* %gep.1, i8* %ptr
; CHECK: MayAlias: i8* %gep.2, i8* %ptr ; CHECK: MayAlias: i8* %gep.2, i8* %ptr
; CHECK: MayAlias: i8* %gep.1, i8* %gep.2 ; CHECK: MayAlias: i8* %gep.1, i8* %gep.2
; ;
load i8, i8* %ptr
%c = icmp sgt i64 %n, 0 %c = icmp sgt i64 %n, 0
call void @llvm.assume(i1 %c) call void @llvm.assume(i1 %c)
%gep.1 = getelementptr i8, i8* %ptr, i64 -1 %gep.1 = getelementptr i8, i8* %ptr, i64 -1
store i8 0, i8* %gep.1 store i8 0, i8* %gep.1
%gep.2 = getelementptr i8, i8* %ptr, i64 %n %gep.2 = getelementptr i8, i8* %ptr, i64 %n
store i8 1, i8* %gep.2 store i8 1, i8* %gep.2
ret void ret void
} }

llvm/test/Analysis/BasicAA/gep-modulo.ll

; RUN: opt -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output %s 2>&1 | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output %s 2>&1 | FileCheck %s
target datalayout = "p:64:64:64" target datalayout = "p:64:64:64"
; %gep.idx and %gep.6 must-alias if %mul overflows (e.g. %idx == 52). ; %gep.idx and %gep.6 must-alias if %mul overflows (e.g. %idx == 52).
define void @may_overflow_mul_add_i8([16 x i8]* %ptr, i8 %idx) { define void @may_overflow_mul_add_i8([16 x i8]* %ptr, i8 %idx) {
; CHECK-LABEL: Function: may_overflow_mul_add_i8: 3 pointers, 0 call sites ; CHECK-LABEL: Function: may_overflow_mul_add_i8: 3 pointers, 0 call sites
; CHECK-NEXT: MayAlias: [16 x i8]* %ptr, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.idx, [16 x i8]* %ptr
; CHECK-NEXT: PartialAlias (off 6): [16 x i8]* %ptr, i8* %gep.6 ; CHECK-NEXT: PartialAlias (off -6): i8* %gep.6, [16 x i8]* %ptr
; CHECK-NEXT: MayAlias: i8* %gep.6, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.6, i8* %gep.idx
; ;
load [16 x i8], [16 x i8]* %ptr
%mul = mul i8 %idx, 5 %mul = mul i8 %idx, 5
%add = add i8 %mul, 2 %add = add i8 %mul, 2
%gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i8 %add %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i8 %add
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
%gep.6 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 6 %gep.6 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 6
store i8 1, i8* %gep.6, align 1 store i8 1, i8* %gep.6, align 1
ret void ret void
} }
define void @nuw_nsw_mul_add_i8([16 x i8]* %ptr, i8 %idx) { define void @nuw_nsw_mul_add_i8([16 x i8]* %ptr, i8 %idx) {
; CHECK-LABEL: Function: nuw_nsw_mul_add_i8: 3 pointers, 0 call sites ; CHECK-LABEL: Function: nuw_nsw_mul_add_i8: 3 pointers, 0 call sites
; CHECK-NEXT: MayAlias: [16 x i8]* %ptr, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.idx, [16 x i8]* %ptr
; CHECK-NEXT: PartialAlias (off 6): [16 x i8]* %ptr, i8* %gep.6 ; CHECK-NEXT: PartialAlias (off -6): i8* %gep.6, [16 x i8]* %ptr
; CHECK-NEXT: NoAlias: i8* %gep.6, i8* %gep.idx ; CHECK-NEXT: NoAlias: i8* %gep.6, i8* %gep.idx
; ;
load [16 x i8], [16 x i8]* %ptr
%mul = mul nuw nsw i8 %idx, 5 %mul = mul nuw nsw i8 %idx, 5
%add = add nuw nsw i8 %mul, 2 %add = add nuw nsw i8 %mul, 2
%gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i8 %add %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i8 %add
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
%gep.6 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 6 %gep.6 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 6
store i8 1, i8* %gep.6, align 1 store i8 1, i8* %gep.6, align 1
ret void ret void
} }
; %gep.idx and %gep.3 must-alias if %mul overflows (e.g. %idx == 52). ; %gep.idx and %gep.3 must-alias if %mul overflows (e.g. %idx == 52).
define void @may_overflow_mul_sub_i8([16 x i8]* %ptr, i8 %idx) { define void @may_overflow_mul_sub_i8([16 x i8]* %ptr, i8 %idx) {
; CHECK-LABEL: Function: may_overflow_mul_sub_i8: 3 pointers, 0 call sites ; CHECK-LABEL: Function: may_overflow_mul_sub_i8: 3 pointers, 0 call sites
; CHECK-NEXT: MayAlias: [16 x i8]* %ptr, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.idx, [16 x i8]* %ptr
; CHECK-NEXT: PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3 ; CHECK-NEXT: PartialAlias (off -3): i8* %gep.3, [16 x i8]* %ptr
; CHECK-NEXT: MayAlias: i8* %gep.3, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.3, i8* %gep.idx
; ;
load [16 x i8], [16 x i8]* %ptr
%mul = mul i8 %idx, 5 %mul = mul i8 %idx, 5
%sub = sub i8 %mul, 1 %sub = sub i8 %mul, 1
%gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i8 %sub %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i8 %sub
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
%gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3 %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3
store i8 1, i8* %gep.3, align 1 store i8 1, i8* %gep.3, align 1
ret void ret void
} }
define void @nuw_nsw_mul_sub_i8([16 x i8]* %ptr, i8 %idx) { define void @nuw_nsw_mul_sub_i8([16 x i8]* %ptr, i8 %idx) {
; CHECK-LABEL: Function: nuw_nsw_mul_sub_i8: 3 pointers, 0 call sites ; CHECK-LABEL: Function: nuw_nsw_mul_sub_i8: 3 pointers, 0 call sites
; CHECK-NEXT: MayAlias: [16 x i8]* %ptr, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.idx, [16 x i8]* %ptr
; CHECK-NEXT: PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3 ; CHECK-NEXT: PartialAlias (off -3): i8* %gep.3, [16 x i8]* %ptr
; CHECK-NEXT: NoAlias: i8* %gep.3, i8* %gep.idx ; CHECK-NEXT: NoAlias: i8* %gep.3, i8* %gep.idx
; ;
load [16 x i8], [16 x i8]* %ptr
%mul = mul nuw nsw i8 %idx, 5 %mul = mul nuw nsw i8 %idx, 5
%sub = sub nuw nsw i8 %mul, 1 %sub = sub nuw nsw i8 %mul, 1
%gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i8 %sub %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i8 %sub
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
%gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3 %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3
store i8 1, i8* %gep.3, align 1 store i8 1, i8* %gep.3, align 1
ret void ret void
} }
; %gep.idx and %gep.3 must-alias if %mul overflows ; %gep.idx and %gep.3 must-alias if %mul overflows
; (e.g. %idx == 3689348814741910323). ; (e.g. %idx == 3689348814741910323).
define void @may_overflow_mul_sub_i64([16 x i8]* %ptr, i64 %idx) { define void @may_overflow_mul_sub_i64([16 x i8]* %ptr, i64 %idx) {
; CHECK-LABEL: Function: may_overflow_mul_sub_i64: 3 pointers, 0 call sites ; CHECK-LABEL: Function: may_overflow_mul_sub_i64: 3 pointers, 0 call sites
; CHECK-NEXT: MayAlias: [16 x i8]* %ptr, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.idx, [16 x i8]* %ptr
; CHECK-NEXT: PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3 ; CHECK-NEXT: PartialAlias (off -3): i8* %gep.3, [16 x i8]* %ptr
; CHECK-NEXT: MayAlias: i8* %gep.3, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.3, i8* %gep.idx
; ;
load [16 x i8], [16 x i8]* %ptr
%mul = mul i64 %idx, 5 %mul = mul i64 %idx, 5
%sub = sub i64 %mul, 1 %sub = sub i64 %mul, 1
%gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
%gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3 %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3
store i8 1, i8* %gep.3, align 1 store i8 1, i8* %gep.3, align 1
ret void ret void
} }
define void @nuw_nsw_mul_sub_i64([16 x i8]* %ptr, i64 %idx) { define void @nuw_nsw_mul_sub_i64([16 x i8]* %ptr, i64 %idx) {
; CHECK-LABEL: Function: nuw_nsw_mul_sub_i64: 3 pointers, 0 call sites ; CHECK-LABEL: Function: nuw_nsw_mul_sub_i64: 3 pointers, 0 call sites
; CHECK-NEXT: MayAlias: [16 x i8]* %ptr, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.idx, [16 x i8]* %ptr
; CHECK-NEXT: PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3 ; CHECK-NEXT: PartialAlias (off -3): i8* %gep.3, [16 x i8]* %ptr
; CHECK-NEXT: NoAlias: i8* %gep.3, i8* %gep.idx ; CHECK-NEXT: NoAlias: i8* %gep.3, i8* %gep.idx
; ;
load [16 x i8], [16 x i8]* %ptr
%mul = mul nuw nsw i64 %idx, 5 %mul = mul nuw nsw i64 %idx, 5
%sub = sub nuw nsw i64 %mul, 1 %sub = sub nuw nsw i64 %mul, 1
%gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
%gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3 %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3
store i8 1, i8* %gep.3, align 1 store i8 1, i8* %gep.3, align 1
ret void ret void
} }
define void @only_nsw_mul_sub_i64([16 x i8]* %ptr, i64 %idx) { define void @only_nsw_mul_sub_i64([16 x i8]* %ptr, i64 %idx) {
; CHECK-LABEL: Function: only_nsw_mul_sub_i64: 3 pointers, 0 call sites ; CHECK-LABEL: Function: only_nsw_mul_sub_i64: 3 pointers, 0 call sites
; CHECK-NEXT: MayAlias: [16 x i8]* %ptr, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.idx, [16 x i8]* %ptr
; CHECK-NEXT: PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3 ; CHECK-NEXT: PartialAlias (off -3): i8* %gep.3, [16 x i8]* %ptr
; CHECK-NEXT: NoAlias: i8* %gep.3, i8* %gep.idx ; CHECK-NEXT: NoAlias: i8* %gep.3, i8* %gep.idx
; ;
load [16 x i8], [16 x i8]* %ptr
%mul = mul nsw i64 %idx, 5 %mul = mul nsw i64 %idx, 5
%sub = sub nsw i64 %mul, 1 %sub = sub nsw i64 %mul, 1
%gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
%gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3 %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3
store i8 1, i8* %gep.3, align 1 store i8 1, i8* %gep.3, align 1
ret void ret void
} }
define void @only_nuw_mul_sub_i64([16 x i8]* %ptr, i64 %idx) { define void @only_nuw_mul_sub_i64([16 x i8]* %ptr, i64 %idx) {
; CHECK-LABEL: Function: only_nuw_mul_sub_i64: 3 pointers, 0 call sites ; CHECK-LABEL: Function: only_nuw_mul_sub_i64: 3 pointers, 0 call sites
; CHECK-NEXT: MayAlias: [16 x i8]* %ptr, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.idx, [16 x i8]* %ptr
; CHECK-NEXT: PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3 ; CHECK-NEXT: PartialAlias (off -3): i8* %gep.3, [16 x i8]* %ptr
; CHECK-NEXT: MayAlias: i8* %gep.3, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.3, i8* %gep.idx
; ;
load [16 x i8], [16 x i8]* %ptr
%mul = mul nuw i64 %idx, 5 %mul = mul nuw i64 %idx, 5
%sub = sub nuw i64 %mul, 1 %sub = sub nuw i64 %mul, 1
%gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
%gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3 %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3
store i8 1, i8* %gep.3, align 1 store i8 1, i8* %gep.3, align 1
ret void ret void
} }
; Even though the mul and sub may overflow %gep.idx and %gep.3 cannot alias ; Even though the mul and sub may overflow %gep.idx and %gep.3 cannot alias
; because we multiply by a power-of-2. ; because we multiply by a power-of-2.
define void @may_overflow_mul_pow2_sub_i64([16 x i8]* %ptr, i64 %idx) { define void @may_overflow_mul_pow2_sub_i64([16 x i8]* %ptr, i64 %idx) {
; CHECK-LABEL: Function: may_overflow_mul_pow2_sub_i64: 3 pointers, 0 call sites ; CHECK-LABEL: Function: may_overflow_mul_pow2_sub_i64: 3 pointers, 0 call sites
; CHECK-NEXT: MayAlias: [16 x i8]* %ptr, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.idx, [16 x i8]* %ptr
; CHECK-NEXT: PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3 ; CHECK-NEXT: PartialAlias (off -3): i8* %gep.3, [16 x i8]* %ptr
; CHECK-NEXT: NoAlias: i8* %gep.3, i8* %gep.idx ; CHECK-NEXT: NoAlias: i8* %gep.3, i8* %gep.idx
; ;
load [16 x i8], [16 x i8]* %ptr
%mul = mul i64 %idx, 8 %mul = mul i64 %idx, 8
%sub = sub i64 %mul, 1 %sub = sub i64 %mul, 1
%gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
%gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3 %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3
store i8 1, i8* %gep.3, align 1 store i8 1, i8* %gep.3, align 1
ret void ret void
} }
; Multiplies by power-of-2 preserves modulo and the sub does not wrap. ; Multiplies by power-of-2 preserves modulo and the sub does not wrap.
define void @mul_pow2_sub_nsw_nuw_i64([16 x i8]* %ptr, i64 %idx) { define void @mul_pow2_sub_nsw_nuw_i64([16 x i8]* %ptr, i64 %idx) {
; CHECK-LABEL: Function: mul_pow2_sub_nsw_nuw_i64: 3 pointers, 0 call sites ; CHECK-LABEL: Function: mul_pow2_sub_nsw_nuw_i64: 3 pointers, 0 call sites
; CHECK-NEXT: MayAlias: [16 x i8]* %ptr, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.idx, [16 x i8]* %ptr
; CHECK-NEXT: PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3 ; CHECK-NEXT: PartialAlias (off -3): i8* %gep.3, [16 x i8]* %ptr
; CHECK-NEXT: NoAlias: i8* %gep.3, i8* %gep.idx ; CHECK-NEXT: NoAlias: i8* %gep.3, i8* %gep.idx
; ;
load [16 x i8], [16 x i8]* %ptr
%mul = mul i64 %idx, 8 %mul = mul i64 %idx, 8
%sub = sub nuw nsw i64 %mul, 1 %sub = sub nuw nsw i64 %mul, 1
%gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
%gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3 %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3
store i8 1, i8* %gep.3, align 1 store i8 1, i8* %gep.3, align 1
ret void ret void
} }
define void @may_overflow_shl_sub_i64([16 x i8]* %ptr, i64 %idx) { define void @may_overflow_shl_sub_i64([16 x i8]* %ptr, i64 %idx) {
; CHECK-LABEL: Function: may_overflow_shl_sub_i64: 3 pointers, 0 call sites ; CHECK-LABEL: Function: may_overflow_shl_sub_i64: 3 pointers, 0 call sites
; CHECK-NEXT: MayAlias: [16 x i8]* %ptr, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.idx, [16 x i8]* %ptr
; CHECK-NEXT: PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3 ; CHECK-NEXT: PartialAlias (off -3): i8* %gep.3, [16 x i8]* %ptr
; CHECK-NEXT: MayAlias: i8* %gep.3, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.3, i8* %gep.idx
; ;
load [16 x i8], [16 x i8]* %ptr
%mul = shl i64 %idx, 2 %mul = shl i64 %idx, 2
%sub = sub i64 %mul, 1 %sub = sub i64 %mul, 1
%gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
%gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3 %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3
store i8 1, i8* %gep.3, align 1 store i8 1, i8* %gep.3, align 1
ret void ret void
} }
define void @shl_sub_nsw_nuw_i64([16 x i8]* %ptr, i64 %idx) { define void @shl_sub_nsw_nuw_i64([16 x i8]* %ptr, i64 %idx) {
; CHECK-LABEL: Function: shl_sub_nsw_nuw_i64: 3 pointers, 0 call sites ; CHECK-LABEL: Function: shl_sub_nsw_nuw_i64: 3 pointers, 0 call sites
; CHECK-NEXT: MayAlias: [16 x i8]* %ptr, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.idx, [16 x i8]* %ptr
; CHECK-NEXT: PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3 ; CHECK-NEXT: PartialAlias (off -3): i8* %gep.3, [16 x i8]* %ptr
; CHECK-NEXT: NoAlias: i8* %gep.3, i8* %gep.idx ; CHECK-NEXT: NoAlias: i8* %gep.3, i8* %gep.idx
; ;
load [16 x i8], [16 x i8]* %ptr
%mul = shl i64 %idx, 3 %mul = shl i64 %idx, 3
%sub = sub nsw nuw i64 %mul, 1 %sub = sub nsw nuw i64 %mul, 1
%gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
%gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3 %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 3
store i8 1, i8* %gep.3, align 1 store i8 1, i8* %gep.3, align 1
ret void ret void
} }
; %gep.idx and %gep.3 must-alias if %mul overflows (e.g. %idx == 110). ; %gep.idx and %gep.3 must-alias if %mul overflows (e.g. %idx == 110).
define void @may_overflow_i32_sext([16 x i8]* %ptr, i32 %idx) { define void @may_overflow_i32_sext([16 x i8]* %ptr, i32 %idx) {
; CHECK-LABEL: Function: may_overflow_i32_sext: 3 pointers, 0 call sites ; CHECK-LABEL: Function: may_overflow_i32_sext: 3 pointers, 0 call sites
; CHECK-NEXT: MayAlias: [16 x i8]* %ptr, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.idx, [16 x i8]* %ptr
; CHECK-NEXT: PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3 ; CHECK-NEXT: PartialAlias (off -3): i8* %gep.3, [16 x i8]* %ptr
; CHECK-NEXT: MayAlias: i8* %gep.3, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.3, i8* %gep.idx
; ;
load [16 x i8], [16 x i8]* %ptr
%mul = mul i32 %idx, 678152731 %mul = mul i32 %idx, 678152731
%sub = sub i32 %mul, 1582356375 %sub = sub i32 %mul, 1582356375
%sub.ext = sext i32 %sub to i64 %sub.ext = sext i32 %sub to i64
%gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub.ext %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub.ext
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
%gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3 %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3
store i8 1, i8* %gep.3, align 1 store i8 1, i8* %gep.3, align 1
ret void ret void
} }
define void @nuw_nsw_i32_sext([16 x i8]* %ptr, i32 %idx) { define void @nuw_nsw_i32_sext([16 x i8]* %ptr, i32 %idx) {
; CHECK-LABEL: Function: nuw_nsw_i32_sext: 3 pointers, 0 call sites ; CHECK-LABEL: Function: nuw_nsw_i32_sext: 3 pointers, 0 call sites
; CHECK-NEXT: NoAlias: [16 x i8]* %ptr, i8* %gep.idx ; CHECK-NEXT: NoAlias: i8* %gep.idx, [16 x i8]* %ptr
; CHECK-NEXT: PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3 ; CHECK-NEXT: PartialAlias (off -3): i8* %gep.3, [16 x i8]* %ptr
; CHECK-NEXT: NoAlias: i8* %gep.3, i8* %gep.idx ; CHECK-NEXT: NoAlias: i8* %gep.3, i8* %gep.idx
; ;
load [16 x i8], [16 x i8]* %ptr
%mul = mul nuw nsw i32 %idx, 678152731 %mul = mul nuw nsw i32 %idx, 678152731
%sub = sub nuw nsw i32 %mul, 1582356375 %sub = sub nuw nsw i32 %mul, 1582356375
%sub.ext = sext i32 %sub to i64 %sub.ext = sext i32 %sub to i64
%gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub.ext %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub.ext
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
%gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3 %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3
store i8 1, i8* %gep.3, align 1 store i8 1, i8* %gep.3, align 1
ret void ret void
} }
; %gep.idx and %gep.3 must-alias if %mul overflows (e.g. %idx == 110). ; %gep.idx and %gep.3 must-alias if %mul overflows (e.g. %idx == 110).
define void @may_overflow_i32_zext([16 x i8]* %ptr, i32 %idx) { define void @may_overflow_i32_zext([16 x i8]* %ptr, i32 %idx) {
; CHECK-LABEL: Function: may_overflow_i32_zext: 3 pointers, 0 call sites ; CHECK-LABEL: Function: may_overflow_i32_zext: 3 pointers, 0 call sites
; CHECK-NEXT: MayAlias: [16 x i8]* %ptr, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.idx, [16 x i8]* %ptr
; CHECK-NEXT: PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3 ; CHECK-NEXT: PartialAlias (off -3): i8* %gep.3, [16 x i8]* %ptr
; CHECK-NEXT: MayAlias: i8* %gep.3, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.3, i8* %gep.idx
; ;
load [16 x i8], [16 x i8]* %ptr
%mul = mul i32 %idx, 678152731 %mul = mul i32 %idx, 678152731
%sub = sub i32 %mul, 1582356375 %sub = sub i32 %mul, 1582356375
%sub.ext = zext i32 %sub to i64 %sub.ext = zext i32 %sub to i64
%gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub.ext %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub.ext
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
%gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3 %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3
store i8 1, i8* %gep.3, align 1 store i8 1, i8* %gep.3, align 1
ret void ret void
} }
define void @nuw_nsw_i32_zext([16 x i8]* %ptr, i32 %idx) { define void @nuw_nsw_i32_zext([16 x i8]* %ptr, i32 %idx) {
; CHECK-LABEL: Function: nuw_nsw_i32_zext: 3 pointers, 0 call sites ; CHECK-LABEL: Function: nuw_nsw_i32_zext: 3 pointers, 0 call sites
; CHECK-NEXT: NoAlias: [16 x i8]* %ptr, i8* %gep.idx ; CHECK-NEXT: NoAlias: i8* %gep.idx, [16 x i8]* %ptr
; CHECK-NEXT: PartialAlias (off 3): [16 x i8]* %ptr, i8* %gep.3 ; CHECK-NEXT: PartialAlias (off -3): i8* %gep.3, [16 x i8]* %ptr
; CHECK-NEXT: NoAlias: i8* %gep.3, i8* %gep.idx ; CHECK-NEXT: NoAlias: i8* %gep.3, i8* %gep.idx
; ;
load [16 x i8], [16 x i8]* %ptr
%mul = mul nuw nsw i32 %idx, 678152731 %mul = mul nuw nsw i32 %idx, 678152731
%sub = sub nuw nsw i32 %mul, 1582356375 %sub = sub nuw nsw i32 %mul, 1582356375
%sub.ext = zext i32 %sub to i64 %sub.ext = zext i32 %sub to i64
%gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub.ext %gep.idx = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub.ext
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
%gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3 %gep.3 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i32 3
store i8 1, i8* %gep.3, align 1 store i8 1, i8* %gep.3, align 1
ret void ret void
} }
; %mul.1 and %sub.2 are equal, if %idx = 9, because %mul.1 overflows. Hence ; %mul.1 and %sub.2 are equal, if %idx = 9, because %mul.1 overflows. Hence
; %gep.mul.1 and %gep.sub.2 may alias. ; %gep.mul.1 and %gep.sub.2 may alias.
define void @may_overflow_pointer_diff([16 x i8]* %ptr, i64 %idx) { define void @may_overflow_pointer_diff([16 x i8]* %ptr, i64 %idx) {
; CHECK-LABEL: Function: may_overflow_pointer_diff: 3 pointers, 0 call sites ; CHECK-LABEL: Function: may_overflow_pointer_diff: 3 pointers, 0 call sites
; CHECK-NEXT: MayAlias: [16 x i8]* %ptr, i8* %gep.mul.1 ; CHECK-NEXT: MayAlias: i8* %gep.mul.1, [16 x i8]* %ptr
; CHECK-NEXT: MayAlias: [16 x i8]* %ptr, i8* %gep.sub.2 ; CHECK-NEXT: MayAlias: i8* %gep.sub.2, [16 x i8]* %ptr
; CHECK-NEXT: MayAlias: i8* %gep.mul.1, i8* %gep.sub.2 ; CHECK-NEXT: MayAlias: i8* %gep.mul.1, i8* %gep.sub.2
; ;
load [16 x i8], [16 x i8]* %ptr
%mul.1 = mul i64 %idx, 6148914691236517207 %mul.1 = mul i64 %idx, 6148914691236517207
%gep.mul.1 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %mul.1 %gep.mul.1 = getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %mul.1
store i8 1, i8* %gep.mul.1, align 1 store i8 1, i8* %gep.mul.1, align 1
%mul.2 = mul nsw i64 %idx, 3 %mul.2 = mul nsw i64 %idx, 3
%sub.2 = sub nsw i64 %mul.2, 12 %sub.2 = sub nsw i64 %mul.2, 12
%gep.sub.2= getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub.2 %gep.sub.2= getelementptr [16 x i8], [16 x i8]* %ptr, i32 0, i64 %sub.2
store i8 0, i8* %gep.sub.2, align 1 store i8 0, i8* %gep.sub.2, align 1
ret void ret void
} }
; %gep.1 and %gep.idx may alias, e.g. if %idx.1 = 8 and %idx.2 == 2. %gep.idx is then ; %gep.1 and %gep.idx may alias, e.g. if %idx.1 = 8 and %idx.2 == 2. %gep.idx is then
; (((18446744073709551614 * 8) % 2^64 + 6 * 2) % 2^64 + 10) % 2^64 == 6. ; (((18446744073709551614 * 8) % 2^64 + 6 * 2) % 2^64 + 10) % 2^64 == 6.
define void @may_overflow_mul_scale_neg([200 x [ 6 x i8]]* %ptr, i64 %idx.1,i64 %idx.2) { define void @may_overflow_mul_scale_neg([200 x [ 6 x i8]]* %ptr, i64 %idx.1,i64 %idx.2) {
; CHECK-LABEL: Function: may_overflow_mul_scale_neg: 4 pointers, 2 call sites ; CHECK-LABEL: Function: may_overflow_mul_scale_neg: 4 pointers, 2 call sites
; CHECK-NEXT: MustAlias: [200 x [6 x i8]]* %ptr, i8* %bc ; CHECK-NEXT: MustAlias: i8* %bc, [200 x [6 x i8]]* %ptr
; CHECK-NEXT: PartialAlias (off 6): [200 x [6 x i8]]* %ptr, i8* %gep.1 ; CHECK-NEXT: PartialAlias (off -6): i8* %gep.1, [200 x [6 x i8]]* %ptr
; CHECK-NEXT: NoAlias: i8* %bc, i8* %gep.1 ; CHECK-NEXT: NoAlias: i8* %bc, i8* %gep.1
; CHECK-NEXT: MayAlias: [200 x [6 x i8]]* %ptr, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.idx, [200 x [6 x i8]]* %ptr
; CHECK-NEXT: MayAlias: i8* %bc, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %bc, i8* %gep.idx
; CHECK-NEXT: MayAlias: i8* %gep.1, i8* %gep.idx ; CHECK-NEXT: MayAlias: i8* %gep.1, i8* %gep.idx
; ;
load [200 x [6 x i8]], [200 x [6 x i8]]* %ptr
%idx.1.pos = icmp sge i64 %idx.1, 0 %idx.1.pos = icmp sge i64 %idx.1, 0
call void @llvm.assume(i1 %idx.1.pos) call void @llvm.assume(i1 %idx.1.pos)
%idx.2.pos = icmp sge i64 %idx.2, 0 %idx.2.pos = icmp sge i64 %idx.2, 0
call void @llvm.assume(i1 %idx.2.pos) call void @llvm.assume(i1 %idx.2.pos)
%bc = bitcast [ 200 x [ 6 x i8 ] ]* %ptr to i8* %bc = bitcast [ 200 x [ 6 x i8 ] ]* %ptr to i8*
load i8, i8* %bc
%gep.1 = getelementptr i8, i8* %bc, i64 6 %gep.1 = getelementptr i8, i8* %bc, i64 6
store i8 1, i8* %gep.1, align 1 store i8 1, i8* %gep.1, align 1
%mul.0 = mul i64 %idx.1, -2 %mul.0 = mul i64 %idx.1, -2
%add = add i64 %mul.0, 10 %add = add i64 %mul.0, 10
%gep.idx = getelementptr [ 200 x [ 6 x i8 ] ], [ 200 x [ 6 x i8 ] ]* %ptr, i64 0, i64 %idx.2, i64 %add %gep.idx = getelementptr [ 200 x [ 6 x i8 ] ], [ 200 x [ 6 x i8 ] ]* %ptr, i64 0, i64 %idx.2, i64 %add
store i8 0, i8* %gep.idx, align 1 store i8 0, i8* %gep.idx, align 1
ret void ret void
} }
; If %v == 10581764700698480926, %idx == 917, so %gep.917 and %gep.idx may alias. ; If %v == 10581764700698480926, %idx == 917, so %gep.917 and %gep.idx may alias.
define i8 @mul_may_overflow_var_nonzero_minabsvarindex_one_index([2000 x i8]* %arr, i8 %x, i64 %v) { define i8 @mul_may_overflow_var_nonzero_minabsvarindex_one_index([2000 x i8]* %arr, i8 %x, i64 %v) {
; CHECK-LABEL: Function: mul_may_overflow_var_nonzero_minabsvarindex_one_index: 4 pointers, 0 call sites ; CHECK-LABEL: Function: mul_may_overflow_var_nonzero_minabsvarindex_one_index: 4 pointers, 0 call sites
; CHECK-NEXT: NoAlias: [2000 x i8]* %arr, i8* %gep.idx ; CHECK-NEXT: NoAlias: [2000 x i8]* %arr, i8* %gep.idx
; CHECK-NEXT: PartialAlias (off 917): [2000 x i8]* %arr, i8* %gep.917 ; CHECK-NEXT: PartialAlias (off 917): [2000 x i8]* %arr, i8* %gep.917
; CHECK-NEXT: NoAlias: i8* %gep.917, i8* %gep.idx ; CHECK-NEXT: NoAlias: i8* %gep.917, i8* %gep.idx
; CHECK-NEXT: MustAlias: [2000 x i8]* %arr, i8* %gep.0 ; CHECK-NEXT: MustAlias: [2000 x i8]* %arr, i8* %gep.0
; CHECK-NEXT: NoAlias: i8* %gep.0, i8* %gep.idx ; CHECK-NEXT: NoAlias: i8* %gep.0, i8* %gep.idx
; CHECK-NEXT: NoAlias: i8* %gep.0, i8* %gep.917 ; CHECK-NEXT: NoAlias: i8* %gep.0, i8* %gep.917
; ;
load [2000 x i8], [2000 x i8]* %arr
%or = or i64 %v, 1 %or = or i64 %v, 1
%idx = mul i64 %or, 1844674407370955 %idx = mul i64 %or, 1844674407370955
%gep.idx = getelementptr inbounds [2000 x i8], [2000 x i8]* %arr, i32 0, i64 %idx %gep.idx = getelementptr inbounds [2000 x i8], [2000 x i8]* %arr, i32 0, i64 %idx
%l = load i8, i8* %gep.idx %l = load i8, i8* %gep.idx
%gep.917 = getelementptr inbounds [2000 x i8], [2000 x i8]* %arr, i32 0, i32 917 %gep.917 = getelementptr inbounds [2000 x i8], [2000 x i8]* %arr, i32 0, i32 917
store i8 0, i8* %gep.917 store i8 0, i8* %gep.917
%gep.0 = getelementptr inbounds [2000 x i8], [2000 x i8]* %arr, i32 0, i32 0 %gep.0 = getelementptr inbounds [2000 x i8], [2000 x i8]* %arr, i32 0, i32 0
store i8 0, i8* %gep.0 store i8 0, i8* %gep.0
ret i8 %l ret i8 %l
} }
define i8 @mul_nsw_var_nonzero_minabsvarindex_one_index([2000 x i8]* %arr, i8 %x, i64 %v) { define i8 @mul_nsw_var_nonzero_minabsvarindex_one_index([2000 x i8]* %arr, i8 %x, i64 %v) {
; CHECK-LABEL: Function: mul_nsw_var_nonzero_minabsvarindex_one_index: 4 pointers, 0 call sites ; CHECK-LABEL: Function: mul_nsw_var_nonzero_minabsvarindex_one_index: 4 pointers, 0 call sites
; CHECK-NEXT: NoAlias: [2000 x i8]* %arr, i8* %gep.idx ; CHECK-NEXT: NoAlias: [2000 x i8]* %arr, i8* %gep.idx
; CHECK-NEXT: PartialAlias (off 917): [2000 x i8]* %arr, i8* %gep.917 ; CHECK-NEXT: PartialAlias (off 917): [2000 x i8]* %arr, i8* %gep.917
; CHECK-NEXT: NoAlias: i8* %gep.917, i8* %gep.idx ; CHECK-NEXT: NoAlias: i8* %gep.917, i8* %gep.idx
; CHECK-NEXT: MustAlias: [2000 x i8]* %arr, i8* %gep.0 ; CHECK-NEXT: MustAlias: [2000 x i8]* %arr, i8* %gep.0
; CHECK-NEXT: NoAlias: i8* %gep.0, i8* %gep.idx ; CHECK-NEXT: NoAlias: i8* %gep.0, i8* %gep.idx
; CHECK-NEXT: NoAlias: i8* %gep.0, i8* %gep.917 ; CHECK-NEXT: NoAlias: i8* %gep.0, i8* %gep.917
; ;
load [2000 x i8], [2000 x i8]* %arr
%or = or i64 %v, 1 %or = or i64 %v, 1
%idx = mul nsw i64 %or, 1844674407370955 %idx = mul nsw i64 %or, 1844674407370955
%gep.idx = getelementptr inbounds [2000 x i8], [2000 x i8]* %arr, i32 0, i64 %idx %gep.idx = getelementptr inbounds [2000 x i8], [2000 x i8]* %arr, i32 0, i64 %idx
%l = load i8, i8* %gep.idx %l = load i8, i8* %gep.idx
%gep.917 = getelementptr inbounds [2000 x i8], [2000 x i8]* %arr, i32 0, i32 917 %gep.917 = getelementptr inbounds [2000 x i8], [2000 x i8]* %arr, i32 0, i32 917
store i8 0, i8* %gep.917 store i8 0, i8* %gep.917
%gep.0 = getelementptr inbounds [2000 x i8], [2000 x i8]* %arr, i32 0, i32 0 %gep.0 = getelementptr inbounds [2000 x i8], [2000 x i8]* %arr, i32 0, i32 0
store i8 0, i8* %gep.0 store i8 0, i8* %gep.0
ret i8 %l ret i8 %l
} }
declare void @llvm.assume(i1) declare void @llvm.assume(i1)

llvm/test/Analysis/BasicAA/guards.ll

; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32"
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) #0 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) #0
declare void @llvm.experimental.guard(i1, ...) declare void @llvm.experimental.guard(i1, ...)
declare void @unknown_but_readonly() readonly declare void @unknown_but_readonly() readonly
define void @test1(i8* %P, i8* %Q) { define void @test1(i8* %P, i8* %Q) {
load i8, i8* %P
load i8, i8* %Q
tail call void(i1,...) @llvm.experimental.guard(i1 true) [ "deopt"() ] tail call void(i1,...) @llvm.experimental.guard(i1 true) [ "deopt"() ]
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
ret void ret void
; CHECK-LABEL: Function: test1: ; CHECK-LABEL: Function: test1:
; CHECK: Just Ref: Ptr: i8* %P <-> tail call void (i1, ...) @llvm.experimental.guard(i1 true) [ "deopt"() ] ; CHECK: Just Ref: Ptr: i8* %P <-> tail call void (i1, ...) @llvm.experimental.guard(i1 true) [ "deopt"() ]
; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void (i1, ...) @llvm.experimental.guard(i1 true) [ "deopt"() ] ; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void (i1, ...) @llvm.experimental.guard(i1 true) [ "deopt"() ]
Show All 14 Lines

llvm/test/Analysis/BasicAA/index-size.ll

; RUN: opt -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output %s 2>&1 | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output %s 2>&1 | FileCheck %s
target datalayout = "p:64:64:64:32" target datalayout = "p:64:64:64:32"
; gep.1 and gep.2 must alias, because they are truncated to the index size ; gep.1 and gep.2 must alias, because they are truncated to the index size
; (32-bit), not the pointer size (64-bit). ; (32-bit), not the pointer size (64-bit).
define void @mustalias_due_to_index_size(i8* %ptr) { define void @mustalias_due_to_index_size(i8* %ptr) {
; CHECK-LABEL: Function: mustalias_due_to_index_size ; CHECK-LABEL: Function: mustalias_due_to_index_size
; CHECK-NEXT: MustAlias: i8* %gep.1, i8* %ptr ; CHECK-NEXT: MustAlias: i8* %gep.1, i8* %ptr
; CHECK-NEXT: MustAlias: i8* %gep.2, i8* %ptr ; CHECK-NEXT: MustAlias: i8* %gep.2, i8* %ptr
; CHECK-NEXT: MustAlias: i8* %gep.1, i8* %gep.2 ; CHECK-NEXT: MustAlias: i8* %gep.1, i8* %gep.2
; ;
load i8, i8* %ptr
%gep.1 = getelementptr i8, i8* %ptr, i64 4294967296 %gep.1 = getelementptr i8, i8* %ptr, i64 4294967296
store i8 0, i8* %gep.1 store i8 0, i8* %gep.1
%gep.2 = getelementptr i8, i8* %ptr, i64 0 %gep.2 = getelementptr i8, i8* %ptr, i64 0
store i8 1, i8* %gep.2 store i8 1, i8* %gep.2
ret void ret void
} }

llvm/test/Analysis/BasicAA/invariant_group.ll

Show All 29 Lines
; CHECK-DAG: NoModRef: Ptr: i8* %a.bitcast <-> %a.laundered = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %a.bitcast) ; CHECK-DAG: NoModRef: Ptr: i8* %a.bitcast <-> %a.laundered = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %a.bitcast)
; CHECK-DAG: NoModRef: Ptr: i8* %n <-> %a.laundered = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %a.bitcast) ; CHECK-DAG: NoModRef: Ptr: i8* %n <-> %a.laundered = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %a.bitcast)
; CHECK-DAG: NoModRef: Ptr: i8* %a.laundered <-> %a.laundered = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %a.bitcast) ; CHECK-DAG: NoModRef: Ptr: i8* %a.laundered <-> %a.laundered = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %a.bitcast)
; CHECK-DAG: NoModRef: Ptr: i8* %n.laundered <-> %a.laundered = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %a.bitcast) ; CHECK-DAG: NoModRef: Ptr: i8* %n.laundered <-> %a.laundered = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %a.bitcast)
entry: entry:
%a = alloca %struct.A, align 8 %a = alloca %struct.A, align 8
%a.bitcast = bitcast %struct.A* %a to i8* %a.bitcast = bitcast %struct.A* %a to i8*
load %struct.A, %struct.A* %a
load i8, i8* %a.bitcast
%n = getelementptr inbounds %struct.A, %struct.A* %a, i64 0, i32 1 %n = getelementptr inbounds %struct.A, %struct.A* %a, i64 0, i32 1
store i8 42, i8* %n store i8 42, i8* %n
%a.laundered = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %a.bitcast) %a.laundered = call i8* @llvm.launder.invariant.group.p0i8(i8* nonnull %a.bitcast)
load i8, i8* %a.laundered
%n.laundered = getelementptr inbounds i8, i8* %a.laundered, i64 8 %n.laundered = getelementptr inbounds i8, i8* %a.laundered, i64 8
%v = load i8, i8* %n.laundered %v = load i8, i8* %n.laundered
; make sure that the load from %n.laundered to %v aliases the store of 42 to %n ; make sure that the load from %n.laundered to %v aliases the store of 42 to %n
; CHECK-GVN: ret i8 42 ; CHECK-GVN: ret i8 42
ret i8 %v ret i8 %v
} }
declare i8* @llvm.launder.invariant.group.p0i8(i8*) declare i8* @llvm.launder.invariant.group.p0i8(i8*)

llvm/test/Analysis/BasicAA/libfuncs-darwin.ll

; RUN: opt -mtriple=x86_64-apple-macosx10.7 -aa-pipeline=basic-aa -passes=inferattrs,aa-eval -print-all-alias-modref-info -disable-output 2>&1 %s | FileCheck %s ; RUN: opt -mtriple=x86_64-apple-macosx10.7 -aa-pipeline=basic-aa -passes=inferattrs,aa-eval -print-all-alias-modref-info -disable-output 2>&1 %s | FileCheck %s
declare void @memset_pattern4(i8*, i8*, i64) declare void @memset_pattern4(i8*, i8*, i64)
declare void @memset_pattern8(i8*, i8*, i64) declare void @memset_pattern8(i8*, i8*, i64)
declare void @memset_pattern16(i8*, i8*, i64) declare void @memset_pattern16(i8*, i8*, i64)
define void @test_memset_pattern4_const_size(i8* noalias %a, i8* noalias %pattern) { define void @test_memset_pattern4_const_size(i8* noalias %a, i8* noalias %pattern) {
; CHECK-LABEL: Function: test_memset_pattern4_const_size ; CHECK-LABEL: Function: test_memset_pattern4_const_size
; CHECK: Just Mod: Ptr: i8* %a <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 17) ; CHECK: Just Mod: Ptr: i8* %a <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 17)
; CHECK-NEXT: Just Ref: Ptr: i8* %pattern <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 17) ; CHECK-NEXT: Just Ref: Ptr: i8* %pattern <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 17)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 17) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 17)
; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.17 <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 17) ; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.17 <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 17)
; CHECK-NEXT: Just Ref: Ptr: i8* %pattern.gep.3 <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 17) ; CHECK-NEXT: Just Ref: Ptr: i8* %pattern.gep.3 <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 17)
; CHECK-NEXT: NoModRef: Ptr: i8* %pattern.gep.4 <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 17) ; CHECK-NEXT: NoModRef: Ptr: i8* %pattern.gep.4 <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 17)
; ;
entry: entry:
load i8, i8* %a
load i8, i8* %pattern
call void @memset_pattern4(i8* %a, i8* %pattern, i64 17) call void @memset_pattern4(i8* %a, i8* %pattern, i64 17)
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.17 = getelementptr i8, i8* %a, i32 17 %a.gep.17 = getelementptr i8, i8* %a, i32 17
store i8 1, i8* %a.gep.17 store i8 1, i8* %a.gep.17
%pattern.gep.3 = getelementptr i8, i8* %pattern, i32 3 %pattern.gep.3 = getelementptr i8, i8* %pattern, i32 3
store i8 1, i8* %pattern.gep.3 store i8 1, i8* %pattern.gep.3
%pattern.gep.4 = getelementptr i8, i8* %pattern, i32 4 %pattern.gep.4 = getelementptr i8, i8* %pattern, i32 4
store i8 1, i8* %pattern.gep.4 store i8 1, i8* %pattern.gep.4
ret void ret void
} }
define void @test_memset_pattern4_variable_size(i8* noalias %a, i8* noalias %pattern, i64 %n) { define void @test_memset_pattern4_variable_size(i8* noalias %a, i8* noalias %pattern, i64 %n) {
; CHECK-LABEL: Function: test_memset_pattern4_variable_size ; CHECK-LABEL: Function: test_memset_pattern4_variable_size
; CHECK: Just Mod: Ptr: i8* %a <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 %n) ; CHECK: Just Mod: Ptr: i8* %a <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %pattern <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %pattern <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 %n)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 %n) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 %n)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.17 <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 %n) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.17 <-> call void @memset_pattern4(i8* %a, i8* %pattern, i64 %n)
; ;
entry: entry:
load i8, i8* %a
load i8, i8* %pattern
call void @memset_pattern4(i8* %a, i8* %pattern, i64 %n) call void @memset_pattern4(i8* %a, i8* %pattern, i64 %n)
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.17 = getelementptr i8, i8* %a, i32 17 %a.gep.17 = getelementptr i8, i8* %a, i32 17
store i8 1, i8* %a.gep.17 store i8 1, i8* %a.gep.17
ret void ret void
} }
define void @test_memset_pattern8_const_size(i8* noalias %a, i8* noalias %pattern) { define void @test_memset_pattern8_const_size(i8* noalias %a, i8* noalias %pattern) {
; CHECK-LABEL: Function: test_memset_pattern8_const_size ; CHECK-LABEL: Function: test_memset_pattern8_const_size
; CHECK: Just Mod: Ptr: i8* %a <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 17) ; CHECK: Just Mod: Ptr: i8* %a <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 17)
; CHECK-NEXT: Just Ref: Ptr: i8* %pattern <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 17) ; CHECK-NEXT: Just Ref: Ptr: i8* %pattern <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 17)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 17) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 17)
; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.17 <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 17) ; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.17 <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 17)
; CHECK-NEXT: Just Ref: Ptr: i8* %pattern.gep.7 <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 17) ; CHECK-NEXT: Just Ref: Ptr: i8* %pattern.gep.7 <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 17)
; CHECK-NEXT: NoModRef: Ptr: i8* %pattern.gep.8 <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 17) ; CHECK-NEXT: NoModRef: Ptr: i8* %pattern.gep.8 <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 17)
; ;
entry: entry:
load i8, i8* %a
load i8, i8* %pattern
call void @memset_pattern8(i8* %a, i8* %pattern, i64 17) call void @memset_pattern8(i8* %a, i8* %pattern, i64 17)
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.17 = getelementptr i8, i8* %a, i32 17 %a.gep.17 = getelementptr i8, i8* %a, i32 17
store i8 1, i8* %a.gep.17 store i8 1, i8* %a.gep.17
%pattern.gep.7 = getelementptr i8, i8* %pattern, i32 7 %pattern.gep.7 = getelementptr i8, i8* %pattern, i32 7
store i8 1, i8* %pattern.gep.7 store i8 1, i8* %pattern.gep.7
%pattern.gep.8 = getelementptr i8, i8* %pattern, i32 8 %pattern.gep.8 = getelementptr i8, i8* %pattern, i32 8
store i8 1, i8* %pattern.gep.8 store i8 1, i8* %pattern.gep.8
ret void ret void
} }
define void @test_memset_pattern8_variable_size(i8* noalias %a, i8* noalias %pattern, i64 %n) { define void @test_memset_pattern8_variable_size(i8* noalias %a, i8* noalias %pattern, i64 %n) {
; CHECK-LABEL: Function: test_memset_pattern8_variable_size ; CHECK-LABEL: Function: test_memset_pattern8_variable_size
; CHECK: Just Mod: Ptr: i8* %a <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 %n) ; CHECK: Just Mod: Ptr: i8* %a <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %pattern <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %pattern <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 %n)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 %n) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 %n)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.17 <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 %n) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.17 <-> call void @memset_pattern8(i8* %a, i8* %pattern, i64 %n)
; ;
entry: entry:
load i8, i8* %a
load i8, i8* %pattern
call void @memset_pattern8(i8* %a, i8* %pattern, i64 %n) call void @memset_pattern8(i8* %a, i8* %pattern, i64 %n)
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.17 = getelementptr i8, i8* %a, i32 17 %a.gep.17 = getelementptr i8, i8* %a, i32 17
store i8 1, i8* %a.gep.17 store i8 1, i8* %a.gep.17
ret void ret void
} }
define void @test_memset_pattern16_const_size(i8* noalias %a, i8* noalias %pattern) { define void @test_memset_pattern16_const_size(i8* noalias %a, i8* noalias %pattern) {
; CHECK-LABEL: Function: test_memset_pattern16_const_size ; CHECK-LABEL: Function: test_memset_pattern16_const_size
; CHECK: Just Mod: Ptr: i8* %a <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 17) ; CHECK: Just Mod: Ptr: i8* %a <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 17)
; CHECK-NEXT: Just Ref: Ptr: i8* %pattern <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 17) ; CHECK-NEXT: Just Ref: Ptr: i8* %pattern <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 17)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 17) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 17)
; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.17 <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 17) ; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.17 <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 17)
; CHECK-NEXT: Just Ref: Ptr: i8* %pattern.gep.15 <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 17) ; CHECK-NEXT: Just Ref: Ptr: i8* %pattern.gep.15 <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 17)
; CHECK-NEXT: NoModRef: Ptr: i8* %pattern.gep.16 <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 17) ; CHECK-NEXT: NoModRef: Ptr: i8* %pattern.gep.16 <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 17)
; ;
entry: entry:
load i8, i8* %a
load i8, i8* %pattern
call void @memset_pattern16(i8* %a, i8* %pattern, i64 17) call void @memset_pattern16(i8* %a, i8* %pattern, i64 17)
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.17 = getelementptr i8, i8* %a, i32 17 %a.gep.17 = getelementptr i8, i8* %a, i32 17
store i8 1, i8* %a.gep.17 store i8 1, i8* %a.gep.17
%pattern.gep.15 = getelementptr i8, i8* %pattern, i32 15 %pattern.gep.15 = getelementptr i8, i8* %pattern, i32 15
store i8 1, i8* %pattern.gep.15 store i8 1, i8* %pattern.gep.15
%pattern.gep.16 = getelementptr i8, i8* %pattern, i32 16 %pattern.gep.16 = getelementptr i8, i8* %pattern, i32 16
store i8 1, i8* %pattern.gep.16 store i8 1, i8* %pattern.gep.16
ret void ret void
} }
define void @test_memset_pattern16_variable_size(i8* noalias %a, i8* noalias %pattern, i64 %n) { define void @test_memset_pattern16_variable_size(i8* noalias %a, i8* noalias %pattern, i64 %n) {
; CHECK-LABEL: Function: test_memset_pattern16_variable_size ; CHECK-LABEL: Function: test_memset_pattern16_variable_size
; CHECK: Just Mod: Ptr: i8* %a <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 %n) ; CHECK: Just Mod: Ptr: i8* %a <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %pattern <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %pattern <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 %n)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 %n) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 %n)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.17 <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 %n) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.17 <-> call void @memset_pattern16(i8* %a, i8* %pattern, i64 %n)
; ;
entry: entry:
load i8, i8* %a
load i8, i8* %pattern
call void @memset_pattern16(i8* %a, i8* %pattern, i64 %n) call void @memset_pattern16(i8* %a, i8* %pattern, i64 %n)
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.17 = getelementptr i8, i8* %a, i32 17 %a.gep.17 = getelementptr i8, i8* %a, i32 17
store i8 1, i8* %a.gep.17 store i8 1, i8* %a.gep.17
ret void ret void
} }

llvm/test/Analysis/BasicAA/libfuncs.ll

; RUN: opt -mtriple=i386-pc-linux-gnu -aa-pipeline=basic-aa -passes=inferattrs,aa-eval -print-all-alias-modref-info -disable-output 2>&1 %s | FileCheck %s ; RUN: opt -mtriple=i386-pc-linux-gnu -aa-pipeline=basic-aa -passes=inferattrs,aa-eval -print-all-alias-modref-info -disable-output 2>&1 %s | FileCheck %s
; CHECK-LABEL: Function: test_memcmp_const_size ; CHECK-LABEL: Function: test_memcmp_const_size
; CHECK: Just Ref: Ptr: i8* %a <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4) ; CHECK: Just Ref: Ptr: i8* %a <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: NoModRef: Ptr: i8* %b.gep.5 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: NoModRef: Ptr: i8* %b.gep.5 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
define i32 @test_memcmp_const_size(i8* noalias %a, i8* noalias %b) { define i32 @test_memcmp_const_size(i8* noalias %a, i8* noalias %b) {
entry: entry:
load i8, i8* %a
load i8, i8* %b
%res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4) %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
%b.gep.1 = getelementptr i8, i8* %b, i32 1 %b.gep.1 = getelementptr i8, i8* %b, i32 1
store i8 2, i8* %b.gep.1 store i8 2, i8* %b.gep.1
%b.gep.5 = getelementptr i8, i8* %b, i32 5 %b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 3, i8* %b.gep.5 store i8 3, i8* %b.gep.5
ret i32 %res ret i32 %res
} }
; CHECK-LABEL: Function: test_memcmp_variable_size ; CHECK-LABEL: Function: test_memcmp_variable_size
; CHECK: Just Ref: Ptr: i8* %a <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 %n) ; CHECK: Just Ref: Ptr: i8* %a <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.5 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.5 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.5 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.5 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 %n)
define i32 @test_memcmp_variable_size(i8* noalias %a, i8* noalias %b, i64 %n) { define i32 @test_memcmp_variable_size(i8* noalias %a, i8* noalias %b, i64 %n) {
entry: entry:
load i8, i8* %a
load i8, i8* %b
%res = tail call i32 @memcmp(i8* %a, i8* %b, i64 %n) %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 %n)
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
%b.gep.1 = getelementptr i8, i8* %b, i32 1 %b.gep.1 = getelementptr i8, i8* %b, i32 1
store i8 2, i8* %b.gep.1 store i8 2, i8* %b.gep.1
%b.gep.5 = getelementptr i8, i8* %b, i32 5 %b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 3, i8* %b.gep.5 store i8 3, i8* %b.gep.5
ret i32 %res ret i32 %res
} }
declare i32 @memcmp(i8*, i8*, i64) declare i32 @memcmp(i8*, i8*, i64)
declare i32 @bcmp(i8*, i8*, i64) declare i32 @bcmp(i8*, i8*, i64)
; CHECK-LABEL: Function: test_bcmp_const_size ; CHECK-LABEL: Function: test_bcmp_const_size
; CHECK: Just Ref: Ptr: i8* %a <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4) ; CHECK: Just Ref: Ptr: i8* %a <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: NoModRef: Ptr: i8* %b.gep.5 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: NoModRef: Ptr: i8* %b.gep.5 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4)
define i32 @test_bcmp_const_size(i8* noalias %a, i8* noalias %b) { define i32 @test_bcmp_const_size(i8* noalias %a, i8* noalias %b) {
entry: entry:
load i8, i8* %a
load i8, i8* %b
%res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4) %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4)
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
%b.gep.1 = getelementptr i8, i8* %b, i32 1 %b.gep.1 = getelementptr i8, i8* %b, i32 1
store i8 2, i8* %b.gep.1 store i8 2, i8* %b.gep.1
%b.gep.5 = getelementptr i8, i8* %b, i32 5 %b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 3, i8* %b.gep.5 store i8 3, i8* %b.gep.5
ret i32 %res ret i32 %res
} }
; CHECK-LABEL: Function: test_bcmp_variable_size ; CHECK-LABEL: Function: test_bcmp_variable_size
; CHECK: Just Ref: Ptr: i8* %a <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n) ; CHECK: Just Ref: Ptr: i8* %a <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.5 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.5 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.5 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.5 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n)
define i32 @test_bcmp_variable_size(i8* noalias %a, i8* noalias %b, i64 %n) { define i32 @test_bcmp_variable_size(i8* noalias %a, i8* noalias %b, i64 %n) {
entry: entry:
load i8, i8* %a
load i8, i8* %b
%res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n) %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n)
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
%b.gep.1 = getelementptr i8, i8* %b, i32 1 %b.gep.1 = getelementptr i8, i8* %b, i32 1
store i8 2, i8* %b.gep.1 store i8 2, i8* %b.gep.1
%b.gep.5 = getelementptr i8, i8* %b, i32 5 %b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 3, i8* %b.gep.5 store i8 3, i8* %b.gep.5
ret i32 %res ret i32 %res
} }
declare i8* @memchr(i8*, i32, i64) declare i8* @memchr(i8*, i32, i64)
; CHECK-LABEL: Function: test_memchr_const_size ; CHECK-LABEL: Function: test_memchr_const_size
; CHECK: Just Ref: Ptr: i8* %res <-> %res = call i8* @memchr(i8* %a, i32 42, i64 4) ; CHECK: Just Ref: Ptr: i8* %res <-> %res = call i8* @memchr(i8* %a, i32 42, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> %res = call i8* @memchr(i8* %a, i32 42, i64 4) ; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> %res = call i8* @memchr(i8* %a, i32 42, i64 4)
; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> %res = call i8* @memchr(i8* %a, i32 42, i64 4) ; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> %res = call i8* @memchr(i8* %a, i32 42, i64 4)
define i8* @test_memchr_const_size(i8* noalias %a) { define i8* @test_memchr_const_size(i8* noalias %a) {
entry: entry:
%res = call i8* @memchr(i8* %a, i32 42, i64 4) %res = call i8* @memchr(i8* %a, i32 42, i64 4)
load i8, i8* %res
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
ret i8* %res ret i8* %res
} }
declare i8* @memccpy(i8*, i8*, i32, i64) declare i8* @memccpy(i8*, i8*, i32, i64)
; CHECK-LABEL: Function: test_memccpy_const_size ; CHECK-LABEL: Function: test_memccpy_const_size
; CHECK: Just Mod: Ptr: i8* %a <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4) ; CHECK: Just Mod: Ptr: i8* %a <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4) ; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
; CHECK-NEXT: Just Mod: Ptr: i8* %res <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4) ; CHECK-NEXT: Just Mod: Ptr: i8* %res <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4) ; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4) ; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
; CHECK-NEXT: NoModRef: Ptr: i8* %b.gep.5 <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4) ; CHECK-NEXT: NoModRef: Ptr: i8* %b.gep.5 <-> %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
define i8* @test_memccpy_const_size(i8* noalias %a, i8* noalias %b) { define i8* @test_memccpy_const_size(i8* noalias %a, i8* noalias %b) {
entry: entry:
load i8, i8* %a
load i8, i8* %b
%res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4) %res = call i8* @memccpy(i8* %a, i8* %b, i32 42, i64 4)
load i8, i8* %res
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
%b.gep.1 = getelementptr i8, i8* %b, i32 1 %b.gep.1 = getelementptr i8, i8* %b, i32 1
store i8 2, i8* %b.gep.1 store i8 2, i8* %b.gep.1
%b.gep.5 = getelementptr i8, i8* %b, i32 5 %b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 3, i8* %b.gep.5 store i8 3, i8* %b.gep.5
Show All 11 Lines
; CHECK-NEXT: Both ModRef: Ptr: i8* %res <-> %res = tail call i8* @strcat(i8* %a.gep.1, i8* %b.gep.1) ; CHECK-NEXT: Both ModRef: Ptr: i8* %res <-> %res = tail call i8* @strcat(i8* %a.gep.1, i8* %b.gep.1)
; CHECK-NEXT: Both ModRef: Ptr: i8* %a.gep.5 <-> %res = tail call i8* @strcat(i8* %a.gep.1, i8* %b.gep.1) ; CHECK-NEXT: Both ModRef: Ptr: i8* %a.gep.5 <-> %res = tail call i8* @strcat(i8* %a.gep.1, i8* %b.gep.1)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.5 <-> %res = tail call i8* @strcat(i8* %a.gep.1, i8* %b.gep.1) ; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.5 <-> %res = tail call i8* @strcat(i8* %a.gep.1, i8* %b.gep.1)
; ;
entry: entry:
store i8 0, i8* %a store i8 0, i8* %a
store i8 2, i8* %b store i8 2, i8* %b
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
load i8, i8* %a.gep.1
%b.gep.1 = getelementptr i8, i8* %b, i32 1 %b.gep.1 = getelementptr i8, i8* %b, i32 1
load i8, i8* %b.gep.1
%res = tail call i8* @strcat(i8* %a.gep.1, i8* %b.gep.1) %res = tail call i8* @strcat(i8* %a.gep.1, i8* %b.gep.1)
load i8, i8* %res
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
%b.gep.5 = getelementptr i8, i8* %b, i32 5 %b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 3, i8* %b.gep.5 store i8 3, i8* %b.gep.5
ret i8* %res ret i8* %res
} }
declare i8* @strncat(i8*, i8*, i64) declare i8* @strncat(i8*, i8*, i64)
define i8* @test_strncat_read_write_after(i8* noalias %a, i8* noalias %b, i64 %n) { define i8* @test_strncat_read_write_after(i8* noalias %a, i8* noalias %b, i64 %n) {
; CHECK-LABEL: Function: test_strncat_read_write_after ; CHECK-LABEL: Function: test_strncat_read_write_after
; CHECK: NoModRef: Ptr: i8* %a <-> %res = tail call i8* @strncat(i8* %a.gep.1, i8* %b.gep.1, i64 %n) ; CHECK: NoModRef: Ptr: i8* %a <-> %res = tail call i8* @strncat(i8* %a.gep.1, i8* %b.gep.1, i64 %n)
; CHECK-NEXT: NoModRef: Ptr: i8* %b <-> %res = tail call i8* @strncat(i8* %a.gep.1, i8* %b.gep.1, i64 %n) ; CHECK-NEXT: NoModRef: Ptr: i8* %b <-> %res = tail call i8* @strncat(i8* %a.gep.1, i8* %b.gep.1, i64 %n)
; CHECK-NEXT: Both ModRef: Ptr: i8* %a.gep.1 <-> %res = tail call i8* @strncat(i8* %a.gep.1, i8* %b.gep.1, i64 %n) ; CHECK-NEXT: Both ModRef: Ptr: i8* %a.gep.1 <-> %res = tail call i8* @strncat(i8* %a.gep.1, i8* %b.gep.1, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i8* @strncat(i8* %a.gep.1, i8* %b.gep.1, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i8* @strncat(i8* %a.gep.1, i8* %b.gep.1, i64 %n)
; CHECK-NEXT: Both ModRef: Ptr: i8* %res <-> %res = tail call i8* @strncat(i8* %a.gep.1, i8* %b.gep.1, i64 %n) ; CHECK-NEXT: Both ModRef: Ptr: i8* %res <-> %res = tail call i8* @strncat(i8* %a.gep.1, i8* %b.gep.1, i64 %n)
; CHECK-NEXT: Both ModRef: Ptr: i8* %a.gep.5 <-> %res = tail call i8* @strncat(i8* %a.gep.1, i8* %b.gep.1, i64 %n) ; CHECK-NEXT: Both ModRef: Ptr: i8* %a.gep.5 <-> %res = tail call i8* @strncat(i8* %a.gep.1, i8* %b.gep.1, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.5 <-> %res = tail call i8* @strncat(i8* %a.gep.1, i8* %b.gep.1, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.5 <-> %res = tail call i8* @strncat(i8* %a.gep.1, i8* %b.gep.1, i64 %n)
; ;
entry: entry:
store i8 0, i8* %a store i8 0, i8* %a
store i8 2, i8* %b store i8 2, i8* %b
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
load i8, i8* %a.gep.1
%b.gep.1 = getelementptr i8, i8* %b, i32 1 %b.gep.1 = getelementptr i8, i8* %b, i32 1
load i8, i8* %b.gep.1
%res = tail call i8* @strncat(i8* %a.gep.1, i8* %b.gep.1, i64 %n) %res = tail call i8* @strncat(i8* %a.gep.1, i8* %b.gep.1, i64 %n)
load i8, i8* %res
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
%b.gep.5 = getelementptr i8, i8* %b, i32 5 %b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 3, i8* %b.gep.5 store i8 3, i8* %b.gep.5
ret i8* %res ret i8* %res
} }
declare i8* @strcpy(i8*, i8*) declare i8* @strcpy(i8*, i8*)
define i8* @test_strcpy_read_write_after(i8* noalias %a, i8* noalias %b) { define i8* @test_strcpy_read_write_after(i8* noalias %a, i8* noalias %b) {
; CHECK-LABEL: Function: test_strcpy_read_write_after ; CHECK-LABEL: Function: test_strcpy_read_write_after
; CHECK: NoModRef: Ptr: i8* %a <-> %res = tail call i8* @strcpy(i8* %a.gep.1, i8* %b.gep.1) ; CHECK: NoModRef: Ptr: i8* %a <-> %res = tail call i8* @strcpy(i8* %a.gep.1, i8* %b.gep.1)
; CHECK-NEXT: NoModRef: Ptr: i8* %b <-> %res = tail call i8* @strcpy(i8* %a.gep.1, i8* %b.gep.1) ; CHECK-NEXT: NoModRef: Ptr: i8* %b <-> %res = tail call i8* @strcpy(i8* %a.gep.1, i8* %b.gep.1)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> %res = tail call i8* @strcpy(i8* %a.gep.1, i8* %b.gep.1) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> %res = tail call i8* @strcpy(i8* %a.gep.1, i8* %b.gep.1)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i8* @strcpy(i8* %a.gep.1, i8* %b.gep.1) ; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i8* @strcpy(i8* %a.gep.1, i8* %b.gep.1)
; CHECK-NEXT: Just Mod: Ptr: i8* %res <-> %res = tail call i8* @strcpy(i8* %a.gep.1, i8* %b.gep.1) ; CHECK-NEXT: Just Mod: Ptr: i8* %res <-> %res = tail call i8* @strcpy(i8* %a.gep.1, i8* %b.gep.1)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.5 <-> %res = tail call i8* @strcpy(i8* %a.gep.1, i8* %b.gep.1) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.5 <-> %res = tail call i8* @strcpy(i8* %a.gep.1, i8* %b.gep.1)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.5 <-> %res = tail call i8* @strcpy(i8* %a.gep.1, i8* %b.gep.1) ; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.5 <-> %res = tail call i8* @strcpy(i8* %a.gep.1, i8* %b.gep.1)
; ;
entry: entry:
store i8 0, i8* %a store i8 0, i8* %a
store i8 2, i8* %b store i8 2, i8* %b
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
load i8, i8* %a.gep.1
%b.gep.1 = getelementptr i8, i8* %b, i32 1 %b.gep.1 = getelementptr i8, i8* %b, i32 1
load i8, i8* %b.gep.1
%res = tail call i8* @strcpy(i8* %a.gep.1, i8* %b.gep.1) %res = tail call i8* @strcpy(i8* %a.gep.1, i8* %b.gep.1)
load i8, i8* %res
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
%b.gep.5 = getelementptr i8, i8* %b, i32 5 %b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 3, i8* %b.gep.5 store i8 3, i8* %b.gep.5
ret i8* %res ret i8* %res
} }
declare i8* @strncpy(i8*, i8*, i64) declare i8* @strncpy(i8*, i8*, i64)
define i8* @test_strncpy_const_size(i8* noalias %a, i8* noalias %b) { define i8* @test_strncpy_const_size(i8* noalias %a, i8* noalias %b) {
; CHECK-LABEL: Function: test_strncpy_const_size ; CHECK-LABEL: Function: test_strncpy_const_size
; CHECK: Just Mod: Ptr: i8* %a <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 4) ; CHECK: Just Mod: Ptr: i8* %a <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: Just Mod: Ptr: i8* %res <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: Just Mod: Ptr: i8* %res <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: NoModRef: Ptr: i8* %b.gep.5 <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: NoModRef: Ptr: i8* %b.gep.5 <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 4)
; ;
entry: entry:
load i8, i8* %a
load i8, i8* %b
%res = tail call i8* @strncpy(i8* %a, i8* %b, i64 4) %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 4)
load i8, i8* %res
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
%b.gep.1 = getelementptr i8, i8* %b, i32 1 %b.gep.1 = getelementptr i8, i8* %b, i32 1
store i8 2, i8* %b.gep.1 store i8 2, i8* %b.gep.1
%b.gep.5 = getelementptr i8, i8* %b, i32 5 %b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 3, i8* %b.gep.5 store i8 3, i8* %b.gep.5
ret i8* %res ret i8* %res
} }
define i8* @test_strncpy_variable_size(i8* noalias %a, i8* noalias %b, i64 %n) { define i8* @test_strncpy_variable_size(i8* noalias %a, i8* noalias %b, i64 %n) {
; CHECK-LABEL: Function: test_strncpy_variable_size ; CHECK-LABEL: Function: test_strncpy_variable_size
; CHECK: Just Mod: Ptr: i8* %a <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 %n) ; CHECK: Just Mod: Ptr: i8* %a <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Mod: Ptr: i8* %res <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 %n) ; CHECK-NEXT: Just Mod: Ptr: i8* %res <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 %n) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.5 <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 %n) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.5 <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.5 <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 %n) ; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.5 <-> %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 %n)
; ;
entry: entry:
load i8, i8* %a
load i8, i8* %b
%res = tail call i8* @strncpy(i8* %a, i8* %b, i64 %n) %res = tail call i8* @strncpy(i8* %a, i8* %b, i64 %n)
load i8, i8* %res
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
%b.gep.1 = getelementptr i8, i8* %b, i32 1 %b.gep.1 = getelementptr i8, i8* %b, i32 1
store i8 2, i8* %b.gep.1 store i8 2, i8* %b.gep.1
%b.gep.5 = getelementptr i8, i8* %b, i32 5 %b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 3, i8* %b.gep.5 store i8 3, i8* %b.gep.5
ret i8* %res ret i8* %res
} }
declare i8* @__memset_chk(i8* writeonly, i32, i64, i64) declare i8* @__memset_chk(i8* writeonly, i32, i64, i64)
; CHECK-LABEL: Function: test_memset_chk_const_size ; CHECK-LABEL: Function: test_memset_chk_const_size
define i8* @test_memset_chk_const_size(i8* noalias %a, i64 %n) { define i8* @test_memset_chk_const_size(i8* noalias %a, i64 %n) {
; CHECK: Just Mod (MustAlias): Ptr: i8* %a <-> %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 4, i64 %n) ; CHECK: Just Mod (MustAlias): Ptr: i8* %a <-> %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 4, i64 %n)
; CHECK-NEXT: Just Mod: Ptr: i8* %res <-> %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 4, i64 %n) ; CHECK-NEXT: Just Mod: Ptr: i8* %res <-> %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 4, i64 %n)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 4, i64 %n) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 4, i64 %n)
; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 4, i64 %n) ; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 4, i64 %n)
; ;
entry: entry:
load i8, i8* %a
%res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 4, i64 %n) %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 4, i64 %n)
load i8, i8* %res
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
ret i8* %res ret i8* %res
} }
define i8* @test_memset_chk_variable_size(i8* noalias %a, i64 %n.1, i64 %n.2) { define i8* @test_memset_chk_variable_size(i8* noalias %a, i64 %n.1, i64 %n.2) {
; CHECK-LABEL: Function: test_memset_chk_variable_size ; CHECK-LABEL: Function: test_memset_chk_variable_size
; CHECK: Just Mod (MustAlias): Ptr: i8* %a <-> %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 %n.1, i64 %n.2) ; CHECK: Just Mod (MustAlias): Ptr: i8* %a <-> %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 %n.1, i64 %n.2)
; CHECK-NEXT: Just Mod: Ptr: i8* %res <-> %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 %n.1, i64 %n.2) ; CHECK-NEXT: Just Mod: Ptr: i8* %res <-> %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 %n.1, i64 %n.2)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 %n.1, i64 %n.2) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.1 <-> %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 %n.1, i64 %n.2)
; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.5 <-> %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 %n.1, i64 %n.2) ; CHECK-NEXT: Just Mod: Ptr: i8* %a.gep.5 <-> %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 %n.1, i64 %n.2)
; ;
entry: entry:
load i8, i8* %a
%res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 %n.1, i64 %n.2) %res = tail call i8* @__memset_chk(i8* %a, i32 0, i64 %n.1, i64 %n.2)
load i8, i8* %res
%a.gep.1 = getelementptr i8, i8* %a, i32 1 %a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1 store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5 %a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
ret i8* %res ret i8* %res
} }

llvm/test/Analysis/BasicAA/negoffset.ll

; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128" target datalayout = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128"
target triple = "i386-unknown-linux-gnu" target triple = "i386-unknown-linux-gnu"
declare i32* @random.i32(i32* %ptr) declare i32* @random.i32(i32* %ptr)
declare i8* @random.i8(i32* %ptr) declare i8* @random.i8(i32* %ptr)
; CHECK-LABEL: Function: arr: ; CHECK-LABEL: Function: arr:
; CHECK-DAG: MayAlias: i32* %alloca, i32* %p0 ; CHECK-DAG: MayAlias: i32* %alloca, i32* %p0
; CHECK-DAG: NoAlias: i32* %alloca, i32* %p1 ; CHECK-DAG: NoAlias: i32* %alloca, i32* %p1
define void @arr() { define void @arr() {
%alloca = alloca i32, i32 4 %alloca = alloca i32, i32 4
%random = call i32* @random.i32(i32* %alloca) %random = call i32* @random.i32(i32* %alloca)
%p0 = getelementptr inbounds i32, i32* %random, i32 0 %p0 = getelementptr inbounds i32, i32* %random, i32 0
%p1 = getelementptr inbounds i32, i32* %random, i32 1 %p1 = getelementptr inbounds i32, i32* %random, i32 1
load i32, i32* %alloca
load i32, i32* %p0
load i32, i32* %p1
ret void ret void
} }
; CHECK-LABEL: Function: arg: ; CHECK-LABEL: Function: arg:
; CHECK-DAG: MayAlias: i32* %arg, i32* %p0 ; CHECK-DAG: MayAlias: i32* %arg, i32* %p0
; CHECK-DAG: MayAlias: i32* %arg, i32* %p1 ; CHECK-DAG: MayAlias: i32* %arg, i32* %p1
define void @arg(i32* %arg) { define void @arg(i32* %arg) {
%random = call i32* @random.i32(i32* %arg) %random = call i32* @random.i32(i32* %arg)
%p0 = getelementptr inbounds i32, i32* %random, i32 0 %p0 = getelementptr inbounds i32, i32* %random, i32 0
%p1 = getelementptr inbounds i32, i32* %random, i32 1 %p1 = getelementptr inbounds i32, i32* %random, i32 1
load i32, i32* %arg
load i32, i32* %p0
load i32, i32* %p1
ret void ret void
} }
@gv = global i32 1 @gv = global i32 1
; CHECK-LABEL: Function: global: ; CHECK-LABEL: Function: global:
; CHECK-DAG: MayAlias: i32* %p0, i32* @gv ; CHECK-DAG: MayAlias: i32* %p0, i32* @gv
; CHECK-DAG: NoAlias: i32* %p1, i32* @gv ; CHECK-DAG: NoAlias: i32* %p1, i32* @gv
define void @global() { define void @global() {
%random = call i32* @random.i32(i32* @gv) %random = call i32* @random.i32(i32* @gv)
%p0 = getelementptr inbounds i32, i32* %random, i32 0 %p0 = getelementptr inbounds i32, i32* %random, i32 0
%p1 = getelementptr inbounds i32, i32* %random, i32 1 %p1 = getelementptr inbounds i32, i32* %random, i32 1
load i32, i32* @gv
load i32, i32* %p0
load i32, i32* %p1
ret void ret void
} }
; CHECK-LABEL: Function: struct: ; CHECK-LABEL: Function: struct:
; CHECK-DAG: MayAlias: i32* %f0, i32* %p0 ; CHECK-DAG: MayAlias: i32* %f0, i32* %p0
; CHECK-DAG: MayAlias: i32* %f1, i32* %p0 ; CHECK-DAG: MayAlias: i32* %f1, i32* %p0
; CHECK-DAG: NoAlias: i32* %f0, i32* %p1 ; CHECK-DAG: NoAlias: i32* %f0, i32* %p1
; CHECK-DAG: MayAlias: i32* %f1, i32* %p1 ; CHECK-DAG: MayAlias: i32* %f1, i32* %p1
%struct = type { i32, i32, i32 } %struct = type { i32, i32, i32 }
define void @struct() { define void @struct() {
%alloca = alloca %struct %alloca = alloca %struct
%alloca.i32 = bitcast %struct* %alloca to i32* %alloca.i32 = bitcast %struct* %alloca to i32*
%random = call i32* @random.i32(i32* %alloca.i32) %random = call i32* @random.i32(i32* %alloca.i32)
%f0 = getelementptr inbounds %struct, %struct* %alloca, i32 0, i32 0 %f0 = getelementptr inbounds %struct, %struct* %alloca, i32 0, i32 0
%f1 = getelementptr inbounds %struct, %struct* %alloca, i32 0, i32 1 %f1 = getelementptr inbounds %struct, %struct* %alloca, i32 0, i32 1
%p0 = getelementptr inbounds i32, i32* %random, i32 0 %p0 = getelementptr inbounds i32, i32* %random, i32 0
%p1 = getelementptr inbounds i32, i32* %random, i32 1 %p1 = getelementptr inbounds i32, i32* %random, i32 1
load i32, i32* %f0
load i32, i32* %f1
load i32, i32* %p0
load i32, i32* %p1
ret void ret void
} }
; CHECK-LABEL: Function: complex1: ; CHECK-LABEL: Function: complex1:
; CHECK-DAG: MayAlias: i32* %a2.0, i32* %r2.0 ; CHECK-DAG: MayAlias: i32* %a2.0, i32* %r2.0
; CHECK-DAG: NoAlias: i32* %a2.0, i32* %r2.1 ; CHECK-DAG: NoAlias: i32* %a2.0, i32* %r2.1
; CHECK-DAG: MayAlias: i32* %a2.0, i32* %r2.i ; CHECK-DAG: MayAlias: i32* %a2.0, i32* %r2.i
; CHECK-DAG: MayAlias: i32* %a2.0, i32* %r2.1i ; CHECK-DAG: MayAlias: i32* %a2.0, i32* %r2.1i
; CHECK-DAG: NoAlias: i32* %a1, i32* %r2.0 ; CHECK-DAG: NoAlias: i32* %a1, i32* %r2.0
; CHECK-DAG: NoAlias: i32* %a1, i32* %r2.1 ; CHECK-DAG: NoAlias: i32* %a1, i32* %r2.1
; CHECK-DAG: MayAlias: i32* %a1, i32* %r2.i ; CHECK-DAG: MayAlias: i32* %a1, i32* %r2.i
; CHECK-DAG: MayAlias: i32* %a1, i32* %r2.1i ; CHECK-DAG: MayAlias: i32* %a1, i32* %r2.1i
%complex = type { i32, i32, [4 x i32] } %complex = type { i32, i32, [4 x i32] }
define void @complex1(i32 %i) { define void @complex1(i32 %i) {
%alloca = alloca %complex %alloca = alloca %complex
%alloca.i32 = bitcast %complex* %alloca to i32* %alloca.i32 = bitcast %complex* %alloca to i32*
%r.i32 = call i32* @random.i32(i32* %alloca.i32) %r.i32 = call i32* @random.i32(i32* %alloca.i32)
%random = bitcast i32* %r.i32 to %complex* %random = bitcast i32* %r.i32 to %complex*
%a1 = getelementptr inbounds %complex, %complex* %alloca, i32 0, i32 1 %a1 = getelementptr inbounds %complex, %complex* %alloca, i32 0, i32 1
%a2.0 = getelementptr inbounds %complex, %complex* %alloca, i32 0, i32 2, i32 0 %a2.0 = getelementptr inbounds %complex, %complex* %alloca, i32 0, i32 2, i32 0
%r2.0 = getelementptr inbounds %complex, %complex* %random, i32 0, i32 2, i32 0 %r2.0 = getelementptr inbounds %complex, %complex* %random, i32 0, i32 2, i32 0
%r2.1 = getelementptr inbounds %complex, %complex* %random, i32 0, i32 2, i32 1 %r2.1 = getelementptr inbounds %complex, %complex* %random, i32 0, i32 2, i32 1
%r2.i = getelementptr inbounds %complex, %complex* %random, i32 0, i32 2, i32 %i %r2.i = getelementptr inbounds %complex, %complex* %random, i32 0, i32 2, i32 %i
%r2.1i = getelementptr inbounds i32, i32* %r2.1, i32 %i %r2.1i = getelementptr inbounds i32, i32* %r2.1, i32 %i
load i32, i32* %a2.0
load i32, i32* %a1
load i32, i32* %r2.0
load i32, i32* %r2.1
load i32, i32* %r2.i
load i32, i32* %r2.1i
ret void ret void
} }
; CHECK-LABEL: Function: complex2: ; CHECK-LABEL: Function: complex2:
; CHECK-DAG: NoAlias: i32* %alloca, i32* %p120 ; CHECK-DAG: NoAlias: i32* %alloca, i32* %p120
; CHECK-DAG: MayAlias: i32* %alloca, i32* %pi20 ; CHECK-DAG: MayAlias: i32* %alloca, i32* %pi20
; CHECK-DAG: MayAlias: i32* %alloca, i32* %pij1 ; CHECK-DAG: MayAlias: i32* %alloca, i32* %pij1
; CHECK-DAG: MayAlias: i32* %a3, i32* %pij1 ; CHECK-DAG: MayAlias: i32* %a3, i32* %pij1
%inner = type { i32, i32 } %inner = type { i32, i32 }
%outer = type { i32, i32, [10 x %inner] } %outer = type { i32, i32, [10 x %inner] }
declare %outer* @rand_outer(i32* %p) declare %outer* @rand_outer(i32* %p)
define void @complex2(i32 %i, i32 %j) { define void @complex2(i32 %i, i32 %j) {
%alloca = alloca i32, i32 128 %alloca = alloca i32, i32 128
%a3 = getelementptr inbounds i32, i32* %alloca, i32 3 %a3 = getelementptr inbounds i32, i32* %alloca, i32 3
%random = call %outer* @rand_outer(i32* %alloca) %random = call %outer* @rand_outer(i32* %alloca)
%p120 = getelementptr inbounds %outer, %outer* %random, i32 1, i32 2, i32 2, i32 0 %p120 = getelementptr inbounds %outer, %outer* %random, i32 1, i32 2, i32 2, i32 0
%pi20 = getelementptr inbounds %outer, %outer* %random, i32 %i, i32 2, i32 2, i32 0 %pi20 = getelementptr inbounds %outer, %outer* %random, i32 %i, i32 2, i32 2, i32 0
%pij1 = getelementptr inbounds %outer, %outer* %random, i32 %i, i32 2, i32 %j, i32 1 %pij1 = getelementptr inbounds %outer, %outer* %random, i32 %i, i32 2, i32 %j, i32 1
load i32, i32* %alloca
load i32, i32* %a3
load i32, i32* %p120
load i32, i32* %pi20
load i32, i32* %pij1
ret void ret void
} }
; CHECK-LABEL: Function: pointer_offset: ; CHECK-LABEL: Function: pointer_offset:
; CHECK-DAG: MayAlias: i32** %add.ptr, i32** %p1 ; CHECK-DAG: MayAlias: i32** %add.ptr, i32** %p1
; CHECK-DAG: MayAlias: i32** %add.ptr, i32** %q2 ; CHECK-DAG: MayAlias: i32** %add.ptr, i32** %q2
%struct.X = type { i32*, i32* } %struct.X = type { i32*, i32* }
define i32 @pointer_offset(i32 signext %i, i32 signext %j, i32 zeroext %off) { define i32 @pointer_offset(i32 signext %i, i32 signext %j, i32 zeroext %off) {
Show All 14 Linesentry:
ret i32 %2 ret i32 %2
} }
; CHECK-LABEL: Function: one_size_unknown: ; CHECK-LABEL: Function: one_size_unknown:
; CHECK: NoModRef: Ptr: i8* %p.minus1 <-> call void @llvm.memset.p0i8.i32(i8* %p, i8 0, i32 %size, i1 false) ; CHECK: NoModRef: Ptr: i8* %p.minus1 <-> call void @llvm.memset.p0i8.i32(i8* %p, i8 0, i32 %size, i1 false)
define void @one_size_unknown(i8* %p, i32 %size) { define void @one_size_unknown(i8* %p, i32 %size) {
%p.minus1 = getelementptr inbounds i8, i8* %p, i32 -1 %p.minus1 = getelementptr inbounds i8, i8* %p, i32 -1
call void @llvm.memset.p0i8.i32(i8* %p, i8 0, i32 %size, i1 false) call void @llvm.memset.p0i8.i32(i8* %p, i8 0, i32 %size, i1 false)
load i8, i8* %p.minus1
ret void ret void
} }
; If part of the addressing is done with non-inbounds GEPs, we can't use ; If part of the addressing is done with non-inbounds GEPs, we can't use
; properties implied by the last gep w/the whole offset. In this case, ; properties implied by the last gep w/the whole offset. In this case,
; %random = %alloc - 4 bytes is well defined, and results in %step == %alloca, ; %random = %alloc - 4 bytes is well defined, and results in %step == %alloca,
; leaving %p as an entirely inbounds gep pointing inside %alloca ; leaving %p as an entirely inbounds gep pointing inside %alloca
; CHECK-LABEL: Function: all_inbounds: ; CHECK-LABEL: Function: all_inbounds:
; CHECK: MayAlias: i32* %alloca, i8* %p0 ; CHECK: MayAlias: i32* %alloca, i8* %p0
; CHECK: MayAlias: i32* %alloca, i8* %p1 ; CHECK: MayAlias: i32* %alloca, i8* %p1
define void @all_inbounds() { define void @all_inbounds() {
%alloca = alloca i32, i32 4 %alloca = alloca i32, i32 4
%random = call i8* @random.i8(i32* %alloca) %random = call i8* @random.i8(i32* %alloca)
%p0 = getelementptr inbounds i8, i8* %random, i8 0 %p0 = getelementptr inbounds i8, i8* %random, i8 0
%step = getelementptr i8, i8* %random, i8 4 %step = getelementptr i8, i8* %random, i8 4
%p1 = getelementptr inbounds i8, i8* %step, i8 2 %p1 = getelementptr inbounds i8, i8* %step, i8 2
load i32, i32* %alloca
load i8, i8* %p0
load i8, i8* %p1
ret void ret void
} }
; For all values of %x, %p0 and %p1 can't alias because %random would ; For all values of %x, %p0 and %p1 can't alias because %random would
; have to be out of bounds (and thus a contradiction) for them to be equal. ; have to be out of bounds (and thus a contradiction) for them to be equal.
; CHECK-LABEL: Function: common_factor: ; CHECK-LABEL: Function: common_factor:
; CHECK: NoAlias: i32* %p0, i32* %p1 ; CHECK: NoAlias: i32* %p0, i32* %p1
define void @common_factor(i32 %x) { define void @common_factor(i32 %x) {
%alloca = alloca i32, i32 4 %alloca = alloca i32, i32 4
%random = call i8* @random.i8(i32* %alloca) %random = call i8* @random.i8(i32* %alloca)
%p0 = getelementptr inbounds i32, i32* %alloca, i32 %x %p0 = getelementptr inbounds i32, i32* %alloca, i32 %x
%step = getelementptr inbounds i8, i8* %random, i8 4 %step = getelementptr inbounds i8, i8* %random, i8 4
%step.bitcast = bitcast i8* %step to i32* %step.bitcast = bitcast i8* %step to i32*
%p1 = getelementptr inbounds i32, i32* %step.bitcast, i32 %x %p1 = getelementptr inbounds i32, i32* %step.bitcast, i32 %x
load i32, i32* %p0
load i32, i32* %p1
ret void ret void
} }
declare void @llvm.memset.p0i8.i32(i8*, i8, i32, i1) declare void @llvm.memset.p0i8.i32(i8*, i8, i32, i1)

llvm/test/Analysis/BasicAA/noalias-geps.ll

Show All 20 Lines
bb3: bb3:
%ptr_phi = phi i32* [ %f, %bb1 ], [ %f2, %bb2 ] %ptr_phi = phi i32* [ %f, %bb1 ], [ %f2, %bb2 ]
%ptr_phi2 = phi i32* [ %g, %bb1 ], [ %g2, %bb2 ] %ptr_phi2 = phi i32* [ %g, %bb1 ], [ %g2, %bb2 ]
; CHECK: NoAlias: i32* %f1, i32* %g1 ; CHECK: NoAlias: i32* %f1, i32* %g1
%f1 = getelementptr i32, i32* %ptr_phi , i32 1 %f1 = getelementptr i32, i32* %ptr_phi , i32 1
%g1 = getelementptr i32, i32* %ptr_phi2 , i32 1 %g1 = getelementptr i32, i32* %ptr_phi2 , i32 1
; This should also work if the access size is not the same. ; This should also work if the access size is not the same.
; CHECK: NoAlias: i16* %h1, i32* %f1 ; CHECK: NoAlias: i32* %f1, i16* %h1
%h1 = bitcast i32* %g1 to i16* %h1 = bitcast i32* %g1 to i16*
load i32, i32* %f1
load i32, i32* %g1
load i16, i16* %h1
ret i32 0 ret i32 0
} }
; Check that geps with equal indices of noalias base pointers stay noalias. ; Check that geps with equal indices of noalias base pointers stay noalias.
define i32 @test2([2 x i32]* %p, i32 %i) { define i32 @test2([2 x i32]* %p, i32 %i) {
; CHECK-LABEL: Function: test2: ; CHECK-LABEL: Function: test2:
%pi = getelementptr [2 x i32], [2 x i32]* %p, i32 0 %pi = getelementptr [2 x i32], [2 x i32]* %p, i32 0
Show All 10 Linesbb2:
%g2 = getelementptr [2 x i32], [2 x i32]* %pi.next, i32 1 %g2 = getelementptr [2 x i32], [2 x i32]* %pi.next, i32 1
br label %bb3 br label %bb3
bb3: bb3:
%ptr_phi = phi [2 x i32]* [ %f, %bb1 ], [ %f2, %bb2 ] %ptr_phi = phi [2 x i32]* [ %f, %bb1 ], [ %f2, %bb2 ]
%ptr_phi2 = phi [2 x i32]* [ %g, %bb1 ], [ %g2, %bb2 ] %ptr_phi2 = phi [2 x i32]* [ %g, %bb1 ], [ %g2, %bb2 ]
; CHECK: NoAlias: i32* %f1, i32* %g1 ; CHECK: NoAlias: i32* %f1, i32* %g1
%f1 = getelementptr [2 x i32], [2 x i32]* %ptr_phi , i32 1, i32 %i %f1 = getelementptr [2 x i32], [2 x i32]* %ptr_phi , i32 1, i32 %i
%g1 = getelementptr [2 x i32], [2 x i32]* %ptr_phi2 , i32 1, i32 %i %g1 = getelementptr [2 x i32], [2 x i32]* %ptr_phi2 , i32 1, i32 %i
load i32, i32* %f1
load i32, i32* %g1
ret i32 0 ret i32 0
} }

llvm/test/Analysis/BasicAA/noalias-scope-decl.ll

; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32" target datalayout = "e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32-f32:32:32-f64:32:32-v64:32:64-v128:32:128-a0:0:32-n32"
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) #0 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) #0
declare void @llvm.experimental.noalias.scope.decl(metadata) declare void @llvm.experimental.noalias.scope.decl(metadata)
define void @test1(i8* %P, i8* %Q) nounwind ssp { define void @test1(i8* %P, i8* %Q) nounwind ssp {
load i8, i8* %P
load i8, i8* %Q
tail call void @llvm.experimental.noalias.scope.decl(metadata !0) tail call void @llvm.experimental.noalias.scope.decl(metadata !0)
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false) tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %P, i8* %Q, i64 12, i1 false)
ret void ret void
; CHECK-LABEL: Function: test1: ; CHECK-LABEL: Function: test1:
; CHECK: MayAlias: i8* %P, i8* %Q ; CHECK: MayAlias: i8* %P, i8* %Q
; CHECK: NoModRef: Ptr: i8* %P <-> tail call void @llvm.experimental.noalias.scope.decl(metadata !0) ; CHECK: NoModRef: Ptr: i8* %P <-> tail call void @llvm.experimental.noalias.scope.decl(metadata !0)
Show All 13 Lines

llvm/test/Analysis/BasicAA/phi-aa.ll

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Linesfor.body:
%sub6 = sub i32 %2, 6 %sub6 = sub i32 %2, 6
store i32 %sub6, i32* %arrayidx5, align 4 store i32 %sub6, i32* %arrayidx5, align 4
; %0 and %arrayidx5 can alias! It is not safe to DSE the above store. ; %0 and %arrayidx5 can alias! It is not safe to DSE the above store.
%3 = load i32, i32* %0, align 4 %3 = load i32, i32* %0, align 4
store i32 %3, i32* %arrayidx5, align 4 store i32 %3, i32* %arrayidx5, align 4
%sub11 = add i32 %1, -1 %sub11 = add i32 %1, -1
%idxprom12 = zext i32 %sub11 to i64 %idxprom12 = zext i32 %sub11 to i64
%arrayidx13 = getelementptr inbounds [100 x i32], [100 x i32]* %oa5, i64 0, i64 %idxprom12 %arrayidx13 = getelementptr inbounds [100 x i32], [100 x i32]* %oa5, i64 0, i64 %idxprom12
load i32, i32* %arrayidx13
call void @inc(i32* %jj7) call void @inc(i32* %jj7)
br label %codeRepl br label %codeRepl
bye: bye:
%.reload = load i32, i32* %jj7, align 4 %.reload = load i32, i32* %jj7, align 4
ret i32 %.reload ret i32 %.reload
} }
Show All 10 Lines
; CHECK: NoAlias: i32* %val3, i32* @Y ; CHECK: NoAlias: i32* %val3, i32* @Y
define void @loop_phi_chain(i32 %a, i32 %b, i32 %c) { define void @loop_phi_chain(i32 %a, i32 %b, i32 %c) {
entry: entry:
br label %loop1 br label %loop1
loop1: loop1:
%n1 = phi i32 [ 0, %entry ], [ %add1, %loop2 ] %n1 = phi i32 [ 0, %entry ], [ %add1, %loop2 ]
%val1 = phi i32* [ @X, %entry ], [ %val2, %loop2 ] %val1 = phi i32* [ @X, %entry ], [ %val2, %loop2 ]
load i32, i32* %val1
%add1 = add i32 %n1, 1 %add1 = add i32 %n1, 1
%cmp1 = icmp ne i32 %n1, 32 %cmp1 = icmp ne i32 %n1, 32
br i1 %cmp1, label %loop2, label %end br i1 %cmp1, label %loop2, label %end
loop2: loop2:
%n2 = phi i32 [ 0, %loop1 ], [ %add2, %loop3 ] %n2 = phi i32 [ 0, %loop1 ], [ %add2, %loop3 ]
%val2 = phi i32* [ %val1, %loop1 ], [ %val3, %loop3 ] %val2 = phi i32* [ %val1, %loop1 ], [ %val3, %loop3 ]
load i32, i32* %val2
%add2 = add i32 %n2, 1 %add2 = add i32 %n2, 1
%cmp2 = icmp ne i32 %n2, 32 %cmp2 = icmp ne i32 %n2, 32
br i1 %cmp2, label %loop3, label %loop1 br i1 %cmp2, label %loop3, label %loop1
loop3: loop3:
%n3 = phi i32 [ 0, %loop2 ], [ %add3, %loop3 ] %n3 = phi i32 [ 0, %loop2 ], [ %add3, %loop3 ]
%val3 = phi i32* [ %val2, %loop2 ], [ %val3, %loop3 ] %val3 = phi i32* [ %val2, %loop2 ], [ %val3, %loop3 ]
store i32 0, i32* %val3, align 4 store i32 0, i32* %val3, align 4
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Linesexit:
call void @llvm.memset.p0i8.i32(i8* %g, i8 0, i32 %size, i1 false) call void @llvm.memset.p0i8.i32(i8* %g, i8 0, i32 %size, i1 false)
call void @llvm.memset.p0i8.i32(i8* %z, i8 0, i32 %size, i1 false) call void @llvm.memset.p0i8.i32(i8* %z, i8 0, i32 %size, i1 false)
ret void ret void
} }
declare void @llvm.memset.p0i8.i32(i8*, i8, i32, i1) declare void @llvm.memset.p0i8.i32(i8*, i8, i32, i1)
; CHECK-LABEL: unsound_inequality ; CHECK-LABEL: unsound_inequality
; CHECK: MayAlias: i32* %arrayidx13, i32* %phi
; CHECK: MayAlias: i32* %arrayidx5, i32* %phi ; CHECK: MayAlias: i32* %arrayidx5, i32* %phi
; CHECK: MayAlias: i32* %arrayidx13, i32* %phi
; CHECK: NoAlias: i32* %arrayidx13, i32* %arrayidx5 ; CHECK: NoAlias: i32* %arrayidx13, i32* %arrayidx5
; When recursively reasoning about phis, we can't use predicates between ; When recursively reasoning about phis, we can't use predicates between
; two values as we might be comparing the two from different iterations. ; two values as we might be comparing the two from different iterations.
define i32 @unsound_inequality(i32* %jj7, i32* %j) { define i32 @unsound_inequality(i32* %jj7, i32* %j) {
entry: entry:
%oa5 = alloca [100 x i32], align 16 %oa5 = alloca [100 x i32], align 16
br label %for.body br label %for.body
for.body: ; preds = %for.body, %entry for.body: ; preds = %for.body, %entry
%phi = phi i32* [ %arrayidx13, %for.body ], [ %j, %entry ] %phi = phi i32* [ %arrayidx13, %for.body ], [ %j, %entry ]
load i32, i32* %phi
%idx = load i32, i32* %jj7, align 4 %idx = load i32, i32* %jj7, align 4
%arrayidx5 = getelementptr inbounds [100 x i32], [100 x i32]* %oa5, i64 0, i32 %idx %arrayidx5 = getelementptr inbounds [100 x i32], [100 x i32]* %oa5, i64 0, i32 %idx
store i32 0, i32* %arrayidx5, align 4 store i32 0, i32* %arrayidx5, align 4
store i32 0, i32* %phi, align 4 store i32 0, i32* %phi, align 4
%notequal = add i32 %idx, 1 %notequal = add i32 %idx, 1
%arrayidx13 = getelementptr inbounds [100 x i32], [100 x i32]* %oa5, i64 0, i32 %notequal %arrayidx13 = getelementptr inbounds [100 x i32], [100 x i32]* %oa5, i64 0, i32 %notequal
store i32 0, i32* %arrayidx13, align 4 store i32 0, i32* %arrayidx13, align 4
br label %for.body br label %for.body
} }
; CHECK-LABEL: single_arg_phi ; CHECK-LABEL: single_arg_phi
; CHECK: NoAlias: i32* %ptr, i32* %ptr.next ; CHECK: NoAlias: i32* %ptr, i32* %ptr.next
; CHECK: MustAlias: i32* %ptr, i32* %ptr.phi ; CHECK: MustAlias: i32* %ptr, i32* %ptr.phi
; CHECK: MustAlias: i32* %ptr.next, i32* %ptr.next.phi ; CHECK: MustAlias: i32* %ptr.next, i32* %ptr.next.phi
define void @single_arg_phi(i32* %ptr.base) { define void @single_arg_phi(i32* %ptr.base) {
entry: entry:
br label %loop br label %loop
loop: loop:
%ptr = phi i32* [ %ptr.base, %entry ], [ %ptr.next, %split ] %ptr = phi i32* [ %ptr.base, %entry ], [ %ptr.next, %split ]
%ptr.next = getelementptr inbounds i32, i32* %ptr, i64 1 %ptr.next = getelementptr inbounds i32, i32* %ptr, i64 1
load i32, i32* %ptr
load i32, i32* %ptr.next
br label %split br label %split
split: split:
%ptr.phi = phi i32* [ %ptr, %loop ] %ptr.phi = phi i32* [ %ptr, %loop ]
%ptr.next.phi = phi i32* [ %ptr.next, %loop ] %ptr.next.phi = phi i32* [ %ptr.next, %loop ]
load i32, i32* %ptr.phi
load i32, i32* %ptr.next.phi
br label %loop br label %loop
} }

llvm/test/Analysis/BasicAA/phi-spec-order.ll

Show All 21 Linesfor.cond2.preheader: ; preds = %for.end, %entry
br label %for.body4 br label %for.body4
for.body4: ; preds = %for.body4, %for.cond2.preheader for.body4: ; preds = %for.body4, %for.cond2.preheader
%lsr.iv4 = phi [16000 x double]* [ %i11, %for.body4 ], [ bitcast (double* getelementptr inbounds ([16000 x double], [16000 x double]* @Y, i64 0, i64 8) %lsr.iv4 = phi [16000 x double]* [ %i11, %for.body4 ], [ bitcast (double* getelementptr inbounds ([16000 x double], [16000 x double]* @Y, i64 0, i64 8)
to [16000 x double]*), %for.cond2.preheader ] to [16000 x double]*), %for.cond2.preheader ]
%lsr.iv1 = phi [16000 x double]* [ %i10, %for.body4 ], [ @X, %for.cond2.preheader ] %lsr.iv1 = phi [16000 x double]* [ %i10, %for.body4 ], [ @X, %for.cond2.preheader ]
%lsr.iv = phi i32 [ %lsr.iv.next, %for.body4 ], [ 16000, %for.cond2.preheader ] %lsr.iv = phi i32 [ %lsr.iv.next, %for.body4 ], [ 16000, %for.cond2.preheader ]
load [16000 x double], [16000 x double]* %lsr.iv4
load [16000 x double], [16000 x double]* %lsr.iv1
%lsr.iv46 = bitcast [16000 x double]* %lsr.iv4 to <4 x double>* %lsr.iv46 = bitcast [16000 x double]* %lsr.iv4 to <4 x double>*
%lsr.iv12 = bitcast [16000 x double]* %lsr.iv1 to <4 x double>* %lsr.iv12 = bitcast [16000 x double]* %lsr.iv1 to <4 x double>*
%scevgep11 = getelementptr <4 x double>, <4 x double>* %lsr.iv46, i64 -2 %scevgep11 = getelementptr <4 x double>, <4 x double>* %lsr.iv46, i64 -2
%i6 = load <4 x double>, <4 x double>* %scevgep11, align 32 %i6 = load <4 x double>, <4 x double>* %scevgep11, align 32
%add = fadd <4 x double> %i6, <double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00> %add = fadd <4 x double> %i6, <double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00>
store <4 x double> %add, <4 x double>* %lsr.iv12, align 32 store <4 x double> %add, <4 x double>* %lsr.iv12, align 32
%scevgep10 = getelementptr <4 x double>, <4 x double>* %lsr.iv46, i64 -1 %scevgep10 = getelementptr <4 x double>, <4 x double>* %lsr.iv46, i64 -1
%i7 = load <4 x double>, <4 x double>* %scevgep10, align 32 %i7 = load <4 x double>, <4 x double>* %scevgep10, align 32
%add.4 = fadd <4 x double> %i7, <double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00> %add.4 = fadd <4 x double> %i7, <double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00>
%scevgep9 = getelementptr <4 x double>, <4 x double>* %lsr.iv12, i64 1 %scevgep9 = getelementptr <4 x double>, <4 x double>* %lsr.iv12, i64 1
store <4 x double> %add.4, <4 x double>* %scevgep9, align 32 store <4 x double> %add.4, <4 x double>* %scevgep9, align 32
%i8 = load <4 x double>, <4 x double>* %lsr.iv46, align 32 %i8 = load <4 x double>, <4 x double>* %lsr.iv46, align 32
%add.8 = fadd <4 x double> %i8, <double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00> %add.8 = fadd <4 x double> %i8, <double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00>
%scevgep8 = getelementptr <4 x double>, <4 x double>* %lsr.iv12, i64 2 %scevgep8 = getelementptr <4 x double>, <4 x double>* %lsr.iv12, i64 2
store <4 x double> %add.8, <4 x double>* %scevgep8, align 32 store <4 x double> %add.8, <4 x double>* %scevgep8, align 32
%scevgep7 = getelementptr <4 x double>, <4 x double>* %lsr.iv46, i64 1 %scevgep7 = getelementptr <4 x double>, <4 x double>* %lsr.iv46, i64 1
%i9 = load <4 x double>, <4 x double>* %scevgep7, align 32 %i9 = load <4 x double>, <4 x double>* %scevgep7, align 32
%add.12 = fadd <4 x double> %i9, <double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00> %add.12 = fadd <4 x double> %i9, <double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00>
%scevgep3 = getelementptr <4 x double>, <4 x double>* %lsr.iv12, i64 3 %scevgep3 = getelementptr <4 x double>, <4 x double>* %lsr.iv12, i64 3
store <4 x double> %add.12, <4 x double>* %scevgep3, align 32 store <4 x double> %add.12, <4 x double>* %scevgep3, align 32
%lsr.iv.next = add i32 %lsr.iv, -16 %lsr.iv.next = add i32 %lsr.iv, -16
%scevgep = getelementptr [16000 x double], [16000 x double]* %lsr.iv1, i64 0, i64 16 %scevgep = getelementptr [16000 x double], [16000 x double]* %lsr.iv1, i64 0, i64 16
load double, double* %scevgep
%i10 = bitcast double* %scevgep to [16000 x double]* %i10 = bitcast double* %scevgep to [16000 x double]*
%scevgep5 = getelementptr [16000 x double], [16000 x double]* %lsr.iv4, i64 0, i64 16 %scevgep5 = getelementptr [16000 x double], [16000 x double]* %lsr.iv4, i64 0, i64 16
load double, double* %scevgep5
%i11 = bitcast double* %scevgep5 to [16000 x double]* %i11 = bitcast double* %scevgep5 to [16000 x double]*
%exitcond.15 = icmp eq i32 %lsr.iv.next, 0 %exitcond.15 = icmp eq i32 %lsr.iv.next, 0
br i1 %exitcond.15, label %for.end, label %for.body4 br i1 %exitcond.15, label %for.end, label %for.body4
for.end: ; preds = %for.body4 for.end: ; preds = %for.body4
%inc9 = add nsw i32 %nl.018, 1 %inc9 = add nsw i32 %nl.018, 1
%exitcond = icmp eq i32 %inc9, 400000 %exitcond = icmp eq i32 %inc9, 400000
br i1 %exitcond, label %for.end10, label %for.cond2.preheader br i1 %exitcond, label %for.end10, label %for.cond2.preheader
for.end10: ; preds = %for.end for.end10: ; preds = %for.end
ret i32 0 ret i32 0
} }

llvm/test/Analysis/BasicAA/phi-speculation.ll

Show All 21 Lineswhile.body:
store i32 %0, i32* %ptr2_phi, align 4 store i32 %0, i32* %ptr2_phi, align 4
%1 = load i32, i32* %coeff, align 4 %1 = load i32, i32* %coeff, align 4
%2 = load i32, i32* %ptr_phi, align 4 %2 = load i32, i32* %ptr_phi, align 4
%mul = mul nsw i32 %1, %2 %mul = mul nsw i32 %1, %2
%add = add nsw i32 %mul, %result.09 %add = add nsw i32 %mul, %result.09
%tobool = icmp eq i32 %dec, 0 %tobool = icmp eq i32 %dec, 0
%ptr_inc = getelementptr inbounds i32, i32* %ptr_phi, i64 1 %ptr_inc = getelementptr inbounds i32, i32* %ptr_phi, i64 1
%ptr2_inc = getelementptr inbounds i32, i32* %ptr2_phi, i64 1 %ptr2_inc = getelementptr inbounds i32, i32* %ptr2_phi, i64 1
load i32, i32* %ptr_inc
load i32, i32* %ptr2_inc
br i1 %tobool, label %the_exit, label %while.body br i1 %tobool, label %the_exit, label %while.body
the_exit: the_exit:
ret i32 %add ret i32 %add
} }
; CHECK: test_noalias_2 ; CHECK: test_noalias_2
; CHECK: NoAlias: i32* %ptr_outer_phi, i32* %ptr_outer_phi2 ; CHECK-DAG: NoAlias: i32* %ptr_outer_phi, i32* %ptr_outer_phi2
; CHECK: NoAlias: i32* %ptr2_inc_outer, i32* %ptr_inc_outer ; CHECK-DAG: NoAlias: i32* %ptr2_inc_outer, i32* %ptr_inc_outer
; CHECK: NoAlias: i32* %ptr2_phi, i32* %ptr_phi ; CHECK-DAG: NoAlias: i32* %ptr2_phi, i32* %ptr_phi
; CHECK: NoAlias: i32* %ptr2_inc, i32* %ptr_inc ; CHECK-DAG: NoAlias: i32* %ptr2_inc, i32* %ptr_inc
define i32 @test_noalias_2(i32* %ptr2, i32 %count, i32* %coeff) { define i32 @test_noalias_2(i32* %ptr2, i32 %count, i32* %coeff) {
entry: entry:
%ptr = getelementptr inbounds i32, i32* %ptr2, i64 1 %ptr = getelementptr inbounds i32, i32* %ptr2, i64 1
br label %outer.while.header br label %outer.while.header
outer.while.header: outer.while.header:
%ptr_outer_phi = phi i32* [%ptr_inc_outer, %outer.while.backedge], [ %ptr, %entry] %ptr_outer_phi = phi i32* [%ptr_inc_outer, %outer.while.backedge], [ %ptr, %entry]
%ptr_outer_phi2 = phi i32* [%ptr2_inc_outer, %outer.while.backedge], [ %ptr2, %entry] %ptr_outer_phi2 = phi i32* [%ptr2_inc_outer, %outer.while.backedge], [ %ptr2, %entry]
%num.outer = phi i32 [ %count, %entry ], [ %dec.outer, %outer.while.backedge ] %num.outer = phi i32 [ %count, %entry ], [ %dec.outer, %outer.while.backedge ]
%ignore1 = load i32, i32* %ptr_outer_phi
%ignore2 = load i32, i32* %ptr_outer_phi2
br label %while.body br label %while.body
while.body: while.body:
%num = phi i32 [ %count, %outer.while.header ], [ %dec, %while.body ] %num = phi i32 [ %count, %outer.while.header ], [ %dec, %while.body ]
%ptr_phi = phi i32* [ %ptr_outer_phi, %outer.while.header ], [ %ptr_inc, %while.body ] %ptr_phi = phi i32* [ %ptr_outer_phi, %outer.while.header ], [ %ptr_inc, %while.body ]
%ptr2_phi = phi i32* [ %ptr_outer_phi2, %outer.while.header ], [ %ptr2_inc, %while.body ] %ptr2_phi = phi i32* [ %ptr_outer_phi2, %outer.while.header ], [ %ptr2_inc, %while.body ]
%result.09 = phi i32 [ 0 , %outer.while.header ], [ %add, %while.body ] %result.09 = phi i32 [ 0 , %outer.while.header ], [ %add, %while.body ]
%dec = add nsw i32 %num, -1 %dec = add nsw i32 %num, -1
%0 = load i32, i32* %ptr_phi, align 4 %0 = load i32, i32* %ptr_phi, align 4
store i32 %0, i32* %ptr2_phi, align 4 store i32 %0, i32* %ptr2_phi, align 4
%1 = load i32, i32* %coeff, align 4 %1 = load i32, i32* %coeff, align 4
%2 = load i32, i32* %ptr_phi, align 4 %2 = load i32, i32* %ptr_phi, align 4
%mul = mul nsw i32 %1, %2 %mul = mul nsw i32 %1, %2
%add = add nsw i32 %mul, %result.09 %add = add nsw i32 %mul, %result.09
%tobool = icmp eq i32 %dec, 0 %tobool = icmp eq i32 %dec, 0
%ptr_inc = getelementptr inbounds i32, i32* %ptr_phi, i64 1 %ptr_inc = getelementptr inbounds i32, i32* %ptr_phi, i64 1
%ptr2_inc = getelementptr inbounds i32, i32* %ptr2_phi, i64 1 %ptr2_inc = getelementptr inbounds i32, i32* %ptr2_phi, i64 1
load i32, i32* %ptr_inc
load i32, i32* %ptr2_inc
br i1 %tobool, label %outer.while.backedge, label %while.body br i1 %tobool, label %outer.while.backedge, label %while.body
outer.while.backedge: outer.while.backedge:
%ptr_inc_outer = getelementptr inbounds i32, i32* %ptr_phi, i64 1 %ptr_inc_outer = getelementptr inbounds i32, i32* %ptr_phi, i64 1
%ptr2_inc_outer = getelementptr inbounds i32, i32* %ptr2_phi, i64 1 %ptr2_inc_outer = getelementptr inbounds i32, i32* %ptr2_phi, i64 1
load i32, i32* %ptr_inc_outer
load i32, i32* %ptr2_inc_outer
%dec.outer = add nsw i32 %num.outer, -1 %dec.outer = add nsw i32 %num.outer, -1
%br.cond = icmp eq i32 %dec.outer, 0 %br.cond = icmp eq i32 %dec.outer, 0
br i1 %br.cond, label %the_exit, label %outer.while.header br i1 %br.cond, label %the_exit, label %outer.while.header
the_exit: the_exit:
ret i32 %add ret i32 %add
} }
; CHECK: test_noalias_3 ; CHECK: test_noalias_3
; CHECK: MayAlias: i8* %ptr2_phi, i8* %ptr_phi ; CHECK: MayAlias: i8* %ptr2_phi, i8* %ptr_phi
define i32 @test_noalias_3(i8* noalias %x, i8* noalias %y, i8* noalias %z, define i32 @test_noalias_3(i8* noalias %x, i8* noalias %y, i8* noalias %z,
i32 %count) { i32 %count) {
entry: entry:
br label %while.body br label %while.body
while.body: while.body:
%num = phi i32 [ %count, %entry ], [ %dec, %while.body ] %num = phi i32 [ %count, %entry ], [ %dec, %while.body ]
%ptr_phi = phi i8* [ %x, %entry ], [ %z, %while.body ] %ptr_phi = phi i8* [ %x, %entry ], [ %z, %while.body ]
%ptr2_phi = phi i8* [ %y, %entry ], [ %ptr_phi, %while.body ] %ptr2_phi = phi i8* [ %y, %entry ], [ %ptr_phi, %while.body ]
load i8, i8* %ptr_phi
load i8, i8* %ptr2_phi
%dec = add nsw i32 %num, -1 %dec = add nsw i32 %num, -1
%tobool = icmp eq i32 %dec, 0 %tobool = icmp eq i32 %dec, 0
br i1 %tobool, label %the_exit, label %while.body br i1 %tobool, label %the_exit, label %while.body
the_exit: the_exit:
ret i32 1 ret i32 1
} }
; CHECK-LABEL: test_different_stride_noalias ; CHECK-LABEL: test_different_stride_noalias
; CHECK: NoAlias: i16* %y.base, i8* %x.base ; CHECK: NoAlias: i8* %x.base, i16* %y.base
; CHECK: NoAlias: i16* %y, i8* %x ; CHECK: NoAlias: i8* %x, i16* %y
; CHECK: NoAlias: i16* %y.next, i8* %x.next ; CHECK: NoAlias: i8* %x.next, i16* %y.next
define void @test_different_stride_noalias(i1 %c, i8* noalias %x.base, i16* noalias %y.base) { define void @test_different_stride_noalias(i1 %c, i8* noalias %x.base, i16* noalias %y.base) {
entry: entry:
load i8, i8* %x.base
load i16, i16* %y.base
br label %loop br label %loop
loop: loop:
%x = phi i8* [ %x.base, %entry ], [ %x.next, %loop ] %x = phi i8* [ %x.base, %entry ], [ %x.next, %loop ]
%y = phi i16* [ %y.base, %entry ], [ %y.next, %loop ] %y = phi i16* [ %y.base, %entry ], [ %y.next, %loop ]
load i8, i8* %x
load i16, i16* %y
%x.next = getelementptr i8, i8* %x, i64 1 %x.next = getelementptr i8, i8* %x, i64 1
%y.next = getelementptr i16, i16* %y, i64 1 %y.next = getelementptr i16, i16* %y, i64 1
load i8, i8* %x.next
load i16, i16* %y.next
br i1 %c, label %loop, label %exit br i1 %c, label %loop, label %exit
exit: exit:
ret void ret void
} }
; CHECK-LABEL: test_no_loop_mustalias ; CHECK-LABEL: test_no_loop_mustalias
; CHECK: MustAlias: i16* %z16, i8* %z8 ; CHECK: MustAlias: i16* %z16, i8* %z8
define void @test_no_loop_mustalias(i1 %c, i8* noalias %x8, i8* noalias %y8) { define void @test_no_loop_mustalias(i1 %c, i8* noalias %x8, i8* noalias %y8) {
br i1 %c, label %if, label %else br i1 %c, label %if, label %else
if: if:
%x16 = bitcast i8* %x8 to i16* %x16 = bitcast i8* %x8 to i16*
br label %end br label %end
else: else:
%y16 = bitcast i8* %y8 to i16* %y16 = bitcast i8* %y8 to i16*
br label %end br label %end
end: end:
%z8 = phi i8* [ %x8, %if ], [ %y8, %else ] %z8 = phi i8* [ %x8, %if ], [ %y8, %else ]
%z16 = phi i16* [ %x16, %if ], [ %y16, %else ] %z16 = phi i16* [ %x16, %if ], [ %y16, %else ]
load i8, i8* %z8
load i16, i16* %z16
ret void ret void
} }
; CHECK-LABEL: test_same_stride_mustalias ; CHECK-LABEL: test_same_stride_mustalias
; CHECK: MustAlias: i4* %y.base, i8* %x.base ; CHECK: MustAlias: i8* %x.base, i4* %y.base
; CHECK: MayAlias: i4* %y, i8* %x ; CHECK: MayAlias: i8* %x, i4* %y
; CHECK: MayAlias: i4* %y.next, i8* %x.next ; CHECK: MayAlias: i8* %x.next, i4* %y.next
; TODO: (x, y) could be MustAlias ; TODO: (x, y) could be MustAlias
define void @test_same_stride_mustalias(i1 %c, i8* noalias %x.base) { define void @test_same_stride_mustalias(i1 %c, i8* noalias %x.base) {
entry: entry:
%y.base = bitcast i8* %x.base to i4* %y.base = bitcast i8* %x.base to i4*
load i8, i8* %x.base
load i4, i4* %y.base
br label %loop br label %loop
loop: loop:
%x = phi i8* [ %x.base, %entry ], [ %x.next, %loop ] %x = phi i8* [ %x.base, %entry ], [ %x.next, %loop ]
%y = phi i4* [ %y.base, %entry ], [ %y.next, %loop ] %y = phi i4* [ %y.base, %entry ], [ %y.next, %loop ]
load i8, i8* %x
load i4, i4* %y
%x.next = getelementptr i8, i8* %x, i64 1 %x.next = getelementptr i8, i8* %x, i64 1
%y.next = getelementptr i4, i4* %y, i64 1 %y.next = getelementptr i4, i4* %y, i64 1
load i8, i8* %x.next
load i4, i4* %y.next
br i1 %c, label %loop, label %exit br i1 %c, label %loop, label %exit
exit: exit:
ret void ret void
} }
; CHECK-LABEL: test_different_stride_mustalias ; CHECK-LABEL: test_different_stride_mustalias
; CHECK: MustAlias: i16* %y.base, i8* %x.base ; CHECK: MustAlias: i8* %x.base, i16* %y.base
; CHECK: MayAlias: i16* %y, i8* %x ; CHECK: MayAlias: i8* %x, i16* %y
; CHECK: MayAlias: i16* %y.next, i8* %x.next ; CHECK: MayAlias: i8* %x.next, i16* %y.next
; Even though the base pointers MustAlias, the different strides don't preserve ; Even though the base pointers MustAlias, the different strides don't preserve
; this property across iterations. ; this property across iterations.
define void @test_different_stride_mustalias(i1 %c, i8* noalias %x.base) { define void @test_different_stride_mustalias(i1 %c, i8* noalias %x.base) {
entry: entry:
%y.base = bitcast i8* %x.base to i16* %y.base = bitcast i8* %x.base to i16*
load i8, i8* %x.base
load i16, i16* %y.base
br label %loop br label %loop
loop: loop:
%x = phi i8* [ %x.base, %entry ], [ %x.next, %loop ] %x = phi i8* [ %x.base, %entry ], [ %x.next, %loop ]
%y = phi i16* [ %y.base, %entry ], [ %y.next, %loop ] %y = phi i16* [ %y.base, %entry ], [ %y.next, %loop ]
load i8, i8* %x
load i16, i16* %y
%x.next = getelementptr i8, i8* %x, i64 1 %x.next = getelementptr i8, i8* %x, i64 1
%y.next = getelementptr i16, i16* %y, i64 1 %y.next = getelementptr i16, i16* %y, i64 1
load i8, i8* %x.next
load i16, i16* %y.next
br i1 %c, label %loop, label %exit br i1 %c, label %loop, label %exit
exit: exit:
ret void ret void
} }

llvm/test/Analysis/BasicAA/pr31761.ll

Show All 9 Lines
; CHECK-DAG: MayAlias: i32* %tmp, i32* %tmp3 ; CHECK-DAG: MayAlias: i32* %tmp, i32* %tmp3
define i1 @ham(%struct.blam* %arg) { define i1 @ham(%struct.blam* %arg) {
%isNull = icmp eq %struct.blam* %arg, null %isNull = icmp eq %struct.blam* %arg, null
%tmp = getelementptr %struct.blam, %struct.blam* %arg, i64 0, i32 0 %tmp = getelementptr %struct.blam, %struct.blam* %arg, i64 0, i32 0
%tmp2 = getelementptr %struct.blam, %struct.blam* %arg, i64 0, i32 1 %tmp2 = getelementptr %struct.blam, %struct.blam* %arg, i64 0, i32 1
%select = select i1 %isNull, i32* null, i32* %tmp2 %select = select i1 %isNull, i32* null, i32* %tmp2
%tmp3 = getelementptr i32, i32* %select, i32 -1 %tmp3 = getelementptr i32, i32* %select, i32 -1
load i32, i32* %tmp
load i32, i32* %tmp3
ret i1 true ret i1 true
} }

llvm/test/Analysis/BasicAA/pr35821.ll

; RUN: opt %s -passes=aa-eval -disable-output 2>&1 | FileCheck %s ; RUN: opt %s -passes=aa-eval -disable-output -print-all-alias-modref-info 2>&1 | FileCheck %s
; CHECK: 6 Total Alias Queries Performed ; CHECK-LABEL: Function: patatino
; CHECK-NEXT: 6 no alias responses ; CHECK: NoAlias: i1* %G26, i1** %G47
define void @patatino() { define void @patatino() {
%G26 = getelementptr i1, i1* undef, i1 undef %G26 = getelementptr i1, i1* undef, i1 undef
%B20 = shl i8 -128, 16 %B20 = shl i8 -128, 16
%G47 = getelementptr i1*, i1** undef, i8 %B20 %G47 = getelementptr i1*, i1** undef, i8 %B20
load i1, i1* %G26
load i1*, i1** %G47
ret void ret void
} }

llvm/test/Analysis/BasicAA/pr35843.ll

; RUN: opt %s -passes=aa-eval -disable-output 2>&1 | FileCheck %s ; RUN: opt %s -passes=aa-eval -disable-output -print-all-alias-modref-info 2>&1 | FileCheck %s
; CHECK: 6 Total Alias Queries Performed ; CHECK-LABEL: Function: patatino
; CHECK-NEXT: 6 no alias responses ; CHECK: NoAlias: i1** %G22, i1*** %G45
define void @patatino() { define void @patatino() {
BB: BB:
%G22 = getelementptr i1*, i1** undef, i8 -1 %G22 = getelementptr i1*, i1** undef, i8 -1
%B1 = mul i66 undef, 9223372036854775808 %B1 = mul i66 undef, 9223372036854775808
%G45 = getelementptr i1**, i1*** undef, i66 %B1 %G45 = getelementptr i1**, i1*** undef, i66 %B1
load i1*, i1** %G22
load i1**, i1*** %G45
ret void ret void
} }

llvm/test/Analysis/BasicAA/pr52735.ll

; RUN: opt %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; ;
; Generated from: ; Generated from:
; ;
; int foo() { ; int foo() {
; int v; ; int v;
; asm goto("movl $1, %0" : "=m"(v)::: out); ; asm goto("movl $1, %0" : "=m"(v)::: out);
; out: ; out:
; return v; ; return v;
; } ; }
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; CHECK: MayAlias: i32* %v, void (i32*, i8*)* asm "movl $$1, $0", "=*m,X,~{dirflag},~{fpsr},~{flags}" ; CHECK: Both ModRef: Ptr: i32* %v <-> callbr void asm "movl $$1, $0", "=*m,X,~{dirflag},~{fpsr},~{flags}"(i32* nonnull elementtype(i32) %v, i8* blockaddress(@foo, %out))
define dso_local i32 @foo() { define dso_local i32 @foo() {
entry: entry:
%v = alloca i32, align 4 %v = alloca i32, align 4
%0 = bitcast i32* %v to i8* %0 = bitcast i32* %v to i8*
callbr void asm "movl $$1, $0", "=*m,X,~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) nonnull %v, i8* blockaddress(@foo, %out)) callbr void asm "movl $$1, $0", "=*m,X,~{dirflag},~{fpsr},~{flags}"(i32* elementtype(i32) nonnull %v, i8* blockaddress(@foo, %out))
to label %asm.fallthrough [label %out] to label %asm.fallthrough [label %out]
asm.fallthrough: asm.fallthrough:
br label %out br label %out
out: out:
%1 = load i32, i32* %v, align 4 %1 = load i32, i32* %v, align 4
ret i32 %1 ret i32 %1
} }

llvm/test/Analysis/BasicAA/ptrmask.ll

; RUN: opt -aa-pipeline=basic-aa -passes=aa-eval -print-no-aliases -disable-output %s 2>&1 | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes=aa-eval -print-no-aliases -disable-output %s 2>&1 | FileCheck %s
%struct = type <{ [20 x i64] }> %struct = type <{ [20 x i64] }>
; CHECK-LABEL: Function: test_noalias: 4 pointers, 1 call sites ; CHECK-LABEL: Function: test_noalias
; CHECK-NEXT: NoAlias: %struct* %ptr1, i64* %ptr2 ; CHECK-NEXT: NoAlias: %struct* %ptr1, i64* %ptr2
; CHECK-NEXT: NoAlias: %struct* %addr.ptr, i64* %ptr2 ; CHECK-NEXT: NoAlias: %struct* %addr.ptr, i64* %ptr2
; CHECK-NEXT: NoAlias: i64* %gep, i64* %ptr2 ; CHECK-NEXT: NoAlias: i64* %gep, i64* %ptr2
define void @test_noalias(%struct* noalias %ptr1, i64* %ptr2, i64 %offset) { define void @test_noalias(%struct* noalias %ptr1, i64* %ptr2, i64 %offset) {
entry: entry:
%addr.ptr = call %struct* @llvm.ptrmask.p0s_struct.p0s.struct.i64(%struct* %ptr1, i64 72057594037927928) %addr.ptr = call %struct* @llvm.ptrmask.p0s_struct.p0s.struct.i64(%struct* %ptr1, i64 72057594037927928)
load %struct, %struct* %ptr1
load %struct, %struct* %addr.ptr
store i64 10, i64* %ptr2 store i64 10, i64* %ptr2
%gep = getelementptr inbounds %struct, %struct* %addr.ptr, i64 0, i32 0, i64 %offset %gep = getelementptr inbounds %struct, %struct* %addr.ptr, i64 0, i32 0, i64 %offset
store i64 1, i64* %gep, align 8 store i64 1, i64* %gep, align 8
ret void ret void
} }
; CHECK-NEXT: Function: test_alias: 4 pointers, 1 call sites ; CHECK-NEXT: Function: test_alias
; CHECK-NOT: NoAlias ; CHECK-NOT: NoAlias
define void @test_alias(%struct* %ptr1, i64* %ptr2, i64 %offset) { define void @test_alias(%struct* %ptr1, i64* %ptr2, i64 %offset) {
entry: entry:
%addr.ptr = call %struct* @llvm.ptrmask.p0s_struct.p0s.struct.i64(%struct* %ptr1, i64 72057594037927928) %addr.ptr = call %struct* @llvm.ptrmask.p0s_struct.p0s.struct.i64(%struct* %ptr1, i64 72057594037927928)
load %struct, %struct* %ptr1
load %struct, %struct* %addr.ptr
store i64 10, i64* %ptr2 store i64 10, i64* %ptr2
%gep = getelementptr inbounds %struct, %struct* %addr.ptr, i64 0, i32 0, i64 %offset %gep = getelementptr inbounds %struct, %struct* %addr.ptr, i64 0, i32 0, i64 %offset
store i64 1, i64* %gep, align 8 store i64 1, i64* %gep, align 8
ret void ret void
} }
declare %struct* @llvm.ptrmask.p0s_struct.p0s.struct.i64(%struct*, i64) declare %struct* @llvm.ptrmask.p0s_struct.p0s.struct.i64(%struct*, i64)

llvm/test/Analysis/BasicAA/q.bad.ll

; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
target triple = "thumbv7--linux-gnueabi" target triple = "thumbv7--linux-gnueabi"
; CHECK-LABEL: test_zext_sext_amounts255 ; CHECK-LABEL: test_zext_sext_amounts255
; CHECK: NoAlias: i8* %a, i8* %b ; CHECK: NoAlias: i8* %a, i8* %b
define void @test_zext_sext_amounts255(i8* %mem) { define void @test_zext_sext_amounts255(i8* %mem) {
%sext.1 = sext i8 255 to i16 %sext.1 = sext i8 255 to i16
%sext.zext.1 = zext i16 %sext.1 to i64 %sext.zext.1 = zext i16 %sext.1 to i64
%sext.2 = sext i8 255 to i32 %sext.2 = sext i8 255 to i32
%sext.zext.2 = zext i32 %sext.2 to i64 %sext.zext.2 = zext i32 %sext.2 to i64
%a = getelementptr inbounds i8, i8* %mem, i64 %sext.zext.1 %a = getelementptr inbounds i8, i8* %mem, i64 %sext.zext.1
%b = getelementptr inbounds i8, i8* %mem, i64 %sext.zext.2 %b = getelementptr inbounds i8, i8* %mem, i64 %sext.zext.2
load i8, i8* %a
load i8, i8* %b
ret void ret void
} }
; CHECK-LABEL: test_zext_sext_amounts ; CHECK-LABEL: test_zext_sext_amounts
; CHECK: MayAlias: i8* %a, i8* %b ; CHECK: MayAlias: i8* %a, i8* %b
; %a and %b only PartialAlias as, although they're both zext(sext(%num)) they'll extend the sign by a different ; %a and %b only PartialAlias as, although they're both zext(sext(%num)) they'll extend the sign by a different
; number of bits before zext-ing the remainder. ; number of bits before zext-ing the remainder.
define void @test_zext_sext_amounts(i8* %mem, i8 %num) { define void @test_zext_sext_amounts(i8* %mem, i8 %num) {
%sext.1 = sext i8 %num to i16 %sext.1 = sext i8 %num to i16
%sext.zext.1 = zext i16 %sext.1 to i64 %sext.zext.1 = zext i16 %sext.1 to i64
%sext.2 = sext i8 %num to i32 %sext.2 = sext i8 %num to i32
%sext.zext.2 = zext i32 %sext.2 to i64 %sext.zext.2 = zext i32 %sext.2 to i64
%a = getelementptr inbounds i8, i8* %mem, i64 %sext.zext.1 %a = getelementptr inbounds i8, i8* %mem, i64 %sext.zext.1
%b = getelementptr inbounds i8, i8* %mem, i64 %sext.zext.2 %b = getelementptr inbounds i8, i8* %mem, i64 %sext.zext.2
load i8, i8* %a
load i8, i8* %b
ret void ret void
} }
; CHECK-LABEL: based_on_pr18068 ; CHECK-LABEL: based_on_pr18068
; CHECK: NoAlias: i8* %a, i8* %b ; CHECK: NoAlias: i8* %a, i8* %b
; CHECK: NoAlias: i8* %a, i8* %c ; CHECK: NoAlias: i8* %a, i8* %c
define void @based_on_pr18068(i32 %loaded, i8* %mem) { define void @based_on_pr18068(i32 %loaded, i8* %mem) {
%loaded.64 = zext i32 %loaded to i64 %loaded.64 = zext i32 %loaded to i64
%add1 = add i32 %loaded, -1 ; unsigned wraps unless %loaded == 0 %add1 = add i32 %loaded, -1 ; unsigned wraps unless %loaded == 0
%add1.64 = zext i32 %add1 to i64 ; is zext(%loaded) always != zext(%loaded - 1)? Yes -> NoAlias %add1.64 = zext i32 %add1 to i64 ; is zext(%loaded) always != zext(%loaded - 1)? Yes -> NoAlias
%sub1 = sub i32 %loaded, 1 ; unsigned wraps iff %loaded == 0 %sub1 = sub i32 %loaded, 1 ; unsigned wraps iff %loaded == 0
%sub1.64 = zext i32 %sub1 to i64 ; is zext(%loaded) always != zext(%loaded - 1)? Yes -> NoAlias %sub1.64 = zext i32 %sub1 to i64 ; is zext(%loaded) always != zext(%loaded - 1)? Yes -> NoAlias
%a = getelementptr inbounds i8, i8* %mem, i64 %loaded.64 %a = getelementptr inbounds i8, i8* %mem, i64 %loaded.64
%b = getelementptr inbounds i8, i8* %mem, i64 %add1.64 %b = getelementptr inbounds i8, i8* %mem, i64 %add1.64
%c = getelementptr inbounds i8, i8* %mem, i64 %sub1.64 %c = getelementptr inbounds i8, i8* %mem, i64 %sub1.64
load i8, i8* %a
load i8, i8* %b
load i8, i8* %c
ret void ret void
} }
; CHECK-LABEL: test_path_dependence ; CHECK-LABEL: test_path_dependence
; CHECK: MayAlias: i8* %a, i8* %b ; CHECK: MayAlias: i8* %a, i8* %b
; CHECK: MustAlias: i8* %a, i8* %c ; CHECK: MustAlias: i8* %a, i8* %c
; CHECK: MayAlias: i8* %a, i8* %d ; CHECK: MayAlias: i8* %a, i8* %d
define void @test_path_dependence(i16 %p, i8* %mem) { define void @test_path_dependence(i16 %p, i8* %mem) {
Show All 9 Linesdefine void @test_path_dependence(i16 %p, i8* %mem) {
%p.nsw.minus1.64 = zext i16 %p.nsw.minus1 to i64 ; when %p > 0x1000 (ie <= 0 as a signed number) then the zext will make this a huge positive number %p.nsw.minus1.64 = zext i16 %p.nsw.minus1 to i64 ; when %p > 0x1000 (ie <= 0 as a signed number) then the zext will make this a huge positive number
%p.nsw.64.again = add nsw i64 %p.nsw.minus1.64, 1 ; ...and so this is very much != %p %p.nsw.64.again = add nsw i64 %p.nsw.minus1.64, 1 ; ...and so this is very much != %p
%p.64 = zext i16 %p to i64 %p.64 = zext i16 %p to i64
%a = getelementptr inbounds i8, i8* %mem, i64 %p.64 %a = getelementptr inbounds i8, i8* %mem, i64 %p.64
%b = getelementptr inbounds i8, i8* %mem, i64 %p.64.again %b = getelementptr inbounds i8, i8* %mem, i64 %p.64.again
%c = getelementptr inbounds i8, i8* %mem, i64 %p.nsw.nuw.64.again %c = getelementptr inbounds i8, i8* %mem, i64 %p.nsw.nuw.64.again
%d = getelementptr inbounds i8, i8* %mem, i64 %p.nsw.64.again %d = getelementptr inbounds i8, i8* %mem, i64 %p.nsw.64.again
load i8, i8* %a
load i8, i8* %b
load i8, i8* %c
load i8, i8* %d
ret void ret void
} }
; CHECK-LABEL: test_zext_sext_255 ; CHECK-LABEL: test_zext_sext_255
; CHECK: NoAlias: i8* %a, i8* %b ; CHECK: NoAlias: i8* %a, i8* %b
define void @test_zext_sext_255(i8* %mem) { define void @test_zext_sext_255(i8* %mem) {
%zext.255 = zext i8 255 to i16 ; 0x00FF %zext.255 = zext i8 255 to i16 ; 0x00FF
%sext.255 = sext i8 255 to i16 ; 0xFFFF %sext.255 = sext i8 255 to i16 ; 0xFFFF
%zext.sext.255 = zext i16 %sext.255 to i32 ; 0x0000FFFF %zext.sext.255 = zext i16 %sext.255 to i32 ; 0x0000FFFF
%sext.zext.255 = sext i16 %zext.255 to i32 ; 0x000000FF %sext.zext.255 = sext i16 %zext.255 to i32 ; 0x000000FF
%zext.zext.sext.255 = zext i32 %zext.sext.255 to i64 %zext.zext.sext.255 = zext i32 %zext.sext.255 to i64
%zext.sext.zext.255 = zext i32 %sext.zext.255 to i64 %zext.sext.zext.255 = zext i32 %sext.zext.255 to i64
%a = getelementptr inbounds i8, i8* %mem, i64 %zext.zext.sext.255 %a = getelementptr inbounds i8, i8* %mem, i64 %zext.zext.sext.255
%b = getelementptr inbounds i8, i8* %mem, i64 %zext.sext.zext.255 %b = getelementptr inbounds i8, i8* %mem, i64 %zext.sext.zext.255
load i8, i8* %a
load i8, i8* %b
ret void ret void
} }
; CHECK-LABEL: test_zext_sext_num ; CHECK-LABEL: test_zext_sext_num
; CHECK: MayAlias: i8* %a, i8* %b ; CHECK: MayAlias: i8* %a, i8* %b
; %a and %b NoAlias if %num == 255 (see @test_zext_sext_255), but %a and %b NoAlias for other values of %num (e.g. 0) ; %a and %b NoAlias if %num == 255 (see @test_zext_sext_255), but %a and %b NoAlias for other values of %num (e.g. 0)
define void @test_zext_sext_num(i8* %mem, i8 %num) { define void @test_zext_sext_num(i8* %mem, i8 %num) {
%zext.num = zext i8 %num to i16 %zext.num = zext i8 %num to i16
%sext.num = sext i8 %num to i16 %sext.num = sext i8 %num to i16
%zext.sext.num = zext i16 %sext.num to i32 %zext.sext.num = zext i16 %sext.num to i32
%sext.zext.num = sext i16 %zext.num to i32 %sext.zext.num = sext i16 %zext.num to i32
%zext.zext.sext.num = zext i32 %zext.sext.num to i64 %zext.zext.sext.num = zext i32 %zext.sext.num to i64
%zext.sext.zext.num = zext i32 %sext.zext.num to i64 %zext.sext.zext.num = zext i32 %sext.zext.num to i64
%a = getelementptr inbounds i8, i8* %mem, i64 %zext.zext.sext.num %a = getelementptr inbounds i8, i8* %mem, i64 %zext.zext.sext.num
%b = getelementptr inbounds i8, i8* %mem, i64 %zext.sext.zext.num %b = getelementptr inbounds i8, i8* %mem, i64 %zext.sext.zext.num
load i8, i8* %a
load i8, i8* %b
ret void ret void
} }
; CHECK-LABEL: uncompressStream ; CHECK-LABEL: uncompressStream
; CHECK: MustAlias: i8* %a, i8* %b ; CHECK: MustAlias: i8* %a, i8* %b
; CHECK: NoAlias: i8* %a, i8* %c ; CHECK: NoAlias: i8* %a, i8* %c
define void @uncompressStream(i8* %mem) { define void @uncompressStream(i8* %mem) {
%zext.255 = zext i8 255 to i32 %zext.255 = zext i8 255 to i32
%sext.255 = sext i8 255 to i32 %sext.255 = sext i8 255 to i32
%a = getelementptr inbounds i8, i8* %mem, i32 255 %a = getelementptr inbounds i8, i8* %mem, i32 255
%b = getelementptr inbounds i8, i8* %mem, i32 %zext.255 %b = getelementptr inbounds i8, i8* %mem, i32 %zext.255
%c = getelementptr inbounds i8, i8* %mem, i32 %sext.255 %c = getelementptr inbounds i8, i8* %mem, i32 %sext.255
load i8, i8* %a
load i8, i8* %b
load i8, i8* %c
ret void ret void
} }
; CHECK-LABEL: constantOffsetHeuristic_i3_i32 ; CHECK-LABEL: constantOffsetHeuristic_i3_i32
; CHECK: NoAlias: i32* %a, i32* %b ; CHECK: NoAlias: i32* %a, i32* %b
; CHECK: NoAlias: i32* %a, i32* %c ; CHECK: NoAlias: i32* %a, i32* %c
; CHECK: NoAlias: i32* %b, i32* %c ; CHECK: NoAlias: i32* %b, i32* %c
define void @constantOffsetHeuristic_i3_i32(i32* %mem, i3 %val) { define void @constantOffsetHeuristic_i3_i32(i32* %mem, i3 %val) {
%zext.plus.7 = add nsw i3 %val, 7 %zext.plus.7 = add nsw i3 %val, 7
%zext.plus.4 = add nsw i3 %val, 4 %zext.plus.4 = add nsw i3 %val, 4
%zext.val = zext i3 %val to i32 %zext.val = zext i3 %val to i32
%zext.4 = zext i3 %zext.plus.4 to i32 %zext.4 = zext i3 %zext.plus.4 to i32
%zext.7 = zext i3 %zext.plus.7 to i32 %zext.7 = zext i3 %zext.plus.7 to i32
%a = getelementptr inbounds i32, i32* %mem, i32 %zext.4 %a = getelementptr inbounds i32, i32* %mem, i32 %zext.4
%b = getelementptr inbounds i32, i32* %mem, i32 %zext.7 %b = getelementptr inbounds i32, i32* %mem, i32 %zext.7
%c = getelementptr inbounds i32, i32* %mem, i32 %zext.val %c = getelementptr inbounds i32, i32* %mem, i32 %zext.val
load i32, i32* %a
load i32, i32* %b
load i32, i32* %c
ret void ret void
} }
; CHECK-LABEL: constantOffsetHeuristic_i8_i32 ; CHECK-LABEL: constantOffsetHeuristic_i8_i32
; CHECK: NoAlias: i32* %a, i32* %b ; CHECK: NoAlias: i32* %a, i32* %b
; CHECK: NoAlias: i32* %a, i32* %c ; CHECK: NoAlias: i32* %a, i32* %c
; CHECK: NoAlias: i32* %b, i32* %c ; CHECK: NoAlias: i32* %b, i32* %c
define void @constantOffsetHeuristic_i8_i32(i32* %mem, i8 %val) { define void @constantOffsetHeuristic_i8_i32(i32* %mem, i8 %val) {
%zext.plus.7 = add nsw i8 %val, 7 %zext.plus.7 = add nsw i8 %val, 7
%zext.plus.4 = add nsw i8 %val, 4 %zext.plus.4 = add nsw i8 %val, 4
%zext.val = zext i8 %val to i32 %zext.val = zext i8 %val to i32
%zext.4 = zext i8 %zext.plus.4 to i32 %zext.4 = zext i8 %zext.plus.4 to i32
%zext.7 = zext i8 %zext.plus.7 to i32 %zext.7 = zext i8 %zext.plus.7 to i32
%a = getelementptr inbounds i32, i32* %mem, i32 %zext.4 %a = getelementptr inbounds i32, i32* %mem, i32 %zext.4
%b = getelementptr inbounds i32, i32* %mem, i32 %zext.7 %b = getelementptr inbounds i32, i32* %mem, i32 %zext.7
%c = getelementptr inbounds i32, i32* %mem, i32 %zext.val %c = getelementptr inbounds i32, i32* %mem, i32 %zext.val
load i32, i32* %a
load i32, i32* %b
load i32, i32* %c
ret void ret void
} }
; CHECK-LABEL: constantOffsetHeuristic_i3_i8 ; CHECK-LABEL: constantOffsetHeuristic_i3_i8
; CHECK: MayAlias: i32* %a, i32* %b ; CHECK: MayAlias: i32* %a, i32* %b
; CHECK: NoAlias: i32* %a, i32* %c ; CHECK: NoAlias: i32* %a, i32* %c
; CHECK: MayAlias: i32* %b, i32* %c ; CHECK: MayAlias: i32* %b, i32* %c
define void @constantOffsetHeuristic_i3_i8(i8* %mem, i3 %val) { define void @constantOffsetHeuristic_i3_i8(i8* %mem, i3 %val) {
%zext.plus.7 = add nsw i3 %val, 7 %zext.plus.7 = add nsw i3 %val, 7
%zext.plus.4 = add nsw i3 %val, 4 %zext.plus.4 = add nsw i3 %val, 4
%zext.val = zext i3 %val to i32 %zext.val = zext i3 %val to i32
%zext.4 = zext i3 %zext.plus.4 to i32 %zext.4 = zext i3 %zext.plus.4 to i32
%zext.7 = zext i3 %zext.plus.7 to i32 %zext.7 = zext i3 %zext.plus.7 to i32
%a.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.4 %a.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.4
%b.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.7 %b.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.7
%c.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.val %c.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.val
%a = bitcast i8* %a.8 to i32* %a = bitcast i8* %a.8 to i32*
%b = bitcast i8* %b.8 to i32* %b = bitcast i8* %b.8 to i32*
%c = bitcast i8* %c.8 to i32* %c = bitcast i8* %c.8 to i32*
load i32, i32* %a
load i32, i32* %b
load i32, i32* %c
ret void ret void
} }
; CHECK-LABEL: constantOffsetHeuristic_i8_i8 ; CHECK-LABEL: constantOffsetHeuristic_i8_i8
; CHECK: MayAlias: i32* %a, i32* %b ; CHECK: MayAlias: i32* %a, i32* %b
; CHECK: NoAlias: i32* %a, i32* %c ; CHECK: NoAlias: i32* %a, i32* %c
; CHECK: NoAlias: i32* %b, i32* %c ; CHECK: NoAlias: i32* %b, i32* %c
define void @constantOffsetHeuristic_i8_i8(i8* %mem, i8 %val) { define void @constantOffsetHeuristic_i8_i8(i8* %mem, i8 %val) {
%zext.plus.7 = add nsw i8 %val, 7 %zext.plus.7 = add nsw i8 %val, 7
%zext.plus.4 = add nsw i8 %val, 4 %zext.plus.4 = add nsw i8 %val, 4
%zext.val = zext i8 %val to i32 %zext.val = zext i8 %val to i32
%zext.4 = zext i8 %zext.plus.4 to i32 %zext.4 = zext i8 %zext.plus.4 to i32
%zext.7 = zext i8 %zext.plus.7 to i32 %zext.7 = zext i8 %zext.plus.7 to i32
%a.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.4 %a.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.4
%b.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.7 %b.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.7
%c.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.val %c.8 = getelementptr inbounds i8, i8* %mem, i32 %zext.val
%a = bitcast i8* %a.8 to i32* %a = bitcast i8* %a.8 to i32*
%b = bitcast i8* %b.8 to i32* %b = bitcast i8* %b.8 to i32*
%c = bitcast i8* %c.8 to i32* %c = bitcast i8* %c.8 to i32*
load i32, i32* %a
load i32, i32* %b
load i32, i32* %c
ret void ret void
} }
; CHECK-LABEL: different_large_bitwidths ; CHECK-LABEL: different_large_bitwidths
; MayAlias: i64* %p1, i64* %p2 ; MayAlias: i64* %p1, i64* %p2
define void @different_large_bitwidths(i8* %a, i64 %i, i128 %j) { define void @different_large_bitwidths(i8* %a, i64 %i, i128 %j) {
%p1 = getelementptr i8, i8* %a, i64 %i %p1 = getelementptr i8, i8* %a, i64 %i
%p2 = getelementptr i8, i8* %a, i128 %j %p2 = getelementptr i8, i8* %a, i128 %j
load i8, i8* %p1
load i8, i8* %p2
ret void ret void
} }

llvm/test/Analysis/BasicAA/range.ll

; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
%struct.S = type { i32, [2 x i32], i32 } %struct.S = type { i32, [2 x i32], i32 }
%struct.S2 = type { i32, [4 x i32], [4 x i32] } %struct.S2 = type { i32, [4 x i32], [4 x i32] }
; CHECK: Function: t1 ; CHECK: Function: t1
; CHECK: NoAlias: i32* %gep1, i32* %gep2 ; CHECK: NoAlias: i32* %gep1, i32* %gep2
define void @t1(%struct.S* %s) { define void @t1(%struct.S* %s) {
%gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 1 %gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 1
%gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 0 %gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 0
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: t2_fwd ; CHECK: Function: t2_fwd
; CHECK: MayAlias: i32* %gep1, i32* %gep2 ; CHECK: MayAlias: i32* %gep1, i32* %gep2
define void @t2_fwd(%struct.S* %s, i32* %q) { define void @t2_fwd(%struct.S* %s, i32* %q) {
%in_array = load i32, i32* %q, !range !0 %in_array = load i32, i32* %q, !range !0
%gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 %in_array %gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 %in_array
%gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 0 %gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 0
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: t2_rev ; CHECK: Function: t2_rev
; CHECK: MayAlias: i32* %gep1, i32* %gep2 ; CHECK: MayAlias: i32* %gep1, i32* %gep2
define void @t2_rev(%struct.S* %s, i32* %q) { define void @t2_rev(%struct.S* %s, i32* %q) {
%in_array = load i32, i32* %q, !range !0 %in_array = load i32, i32* %q, !range !0
%gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 0 %gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 0
%gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 %in_array %gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 %in_array
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: t3_fwd ; CHECK: Function: t3_fwd
; CHECK: NoAlias: i32* %gep1, i32* %gep2 ; CHECK: NoAlias: i32* %gep1, i32* %gep2
define void @t3_fwd(%struct.S* %s, i32* %q) { define void @t3_fwd(%struct.S* %s, i32* %q) {
%knownzero = load i32, i32* %q, !range !1 %knownzero = load i32, i32* %q, !range !1
%gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 %knownzero %gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 %knownzero
%gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 1 %gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 1
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: t3_rev ; CHECK: Function: t3_rev
; CHECK: NoAlias: i32* %gep1, i32* %gep2 ; CHECK: NoAlias: i32* %gep1, i32* %gep2
define void @t3_rev(%struct.S* %s, i32* %q) { define void @t3_rev(%struct.S* %s, i32* %q) {
%knownzero = load i32, i32* %q, !range !1 %knownzero = load i32, i32* %q, !range !1
%gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 1 %gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 1
%gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 %knownzero %gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 %knownzero
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: member_after ; CHECK: Function: member_after
; CHECK: NoAlias: i32* %gep1, i32* %gep2 ; CHECK: NoAlias: i32* %gep1, i32* %gep2
define void @member_after(%struct.S* %s, i32* %q) { define void @member_after(%struct.S* %s, i32* %q) {
%in_array = load i32, i32* %q, !range !0 %in_array = load i32, i32* %q, !range !0
%gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 %in_array %gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 %in_array
%gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 2 %gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 2
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: member_after_rev ; CHECK: Function: member_after_rev
; CHECK: NoAlias: i32* %gep1, i32* %gep2 ; CHECK: NoAlias: i32* %gep1, i32* %gep2
define void @member_after_rev(%struct.S* %s, i32* %q) { define void @member_after_rev(%struct.S* %s, i32* %q) {
%in_array = load i32, i32* %q, !range !0 %in_array = load i32, i32* %q, !range !0
%gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 2 %gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 2
%gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 %in_array %gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 %in_array
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: member_before ; CHECK: Function: member_before
; CHECK: NoAlias: i32* %gep1, i32* %gep2 ; CHECK: NoAlias: i32* %gep1, i32* %gep2
define void @member_before(%struct.S* %s, i32* %q) { define void @member_before(%struct.S* %s, i32* %q) {
%in_array = load i32, i32* %q, !range !0 %in_array = load i32, i32* %q, !range !0
%gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 %in_array %gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 %in_array
%gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 0 %gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 0
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: member_before_rev ; CHECK: Function: member_before_rev
; CHECK: NoAlias: i32* %gep1, i32* %gep2 ; CHECK: NoAlias: i32* %gep1, i32* %gep2
define void @member_before_rev(%struct.S* %s, i32* %q) { define void @member_before_rev(%struct.S* %s, i32* %q) {
%in_array = load i32, i32* %q, !range !0 %in_array = load i32, i32* %q, !range !0
%gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 0 %gep2 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 0
%gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 %in_array %gep1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 %in_array
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: t5 ; CHECK-LABEL: Function: t5
; CHECK-NEXT: MayAlias: %struct.S2* %s, i32* %q ; CHECK: MayAlias: i32* %gep1, %struct.S2* %s
; CHECK-NEXT: MayAlias: %struct.S2* %s, i32* %gep1 ; CHECK: PartialAlias (off -4): i32* %gep2, %struct.S2* %s
; CHECK-NEXT: MayAlias: i32* %gep1, i32* %q ; CHECK: NoAlias: i32* %gep1, i32* %gep2
; CHECK-NEXT: PartialAlias (off 4): %struct.S2* %s, i32* %gep2
; CHECK-NEXT: MayAlias: i32* %gep2, i32* %q
; CHECK-NEXT: NoAlias: i32* %gep1, i32* %gep2
define void @t5(%struct.S2* %s, i32* %q) { define void @t5(%struct.S2* %s, i32* %q) {
%in_array = load i32, i32* %q, !range !3 %in_array = load i32, i32* %q, !range !3
%gep1 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 2, i32 %in_array %gep1 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 2, i32 %in_array
%gep2 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 1, i32 0 %gep2 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 1, i32 0
load %struct.S2, %struct.S2* %s
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: t6 ; CHECK-LABEL: Function: t6
; CHECK-NEXT: MayAlias: %struct.S2* %s, i32* %q ; CHECK: MayAlias: i32* %gep1, %struct.S2* %s
; CHECK-NEXT: MayAlias: %struct.S2* %s, i32* %gep1 ; CHECK: PartialAlias (off -16): i32* %gep2, %struct.S2* %s
; CHECK-NEXT: MayAlias: i32* %gep1, i32* %q ; CHECK: MayAlias: i32* %gep1, i32* %gep2
; CHECK-NEXT: PartialAlias (off 16): %struct.S2* %s, i32* %gep2
; CHECK-NEXT: MayAlias: i32* %gep2, i32* %q
; CHECK-NEXT: MayAlias: i32* %gep1, i32* %gep2
define void @t6(%struct.S2* %s, i32* %q) { define void @t6(%struct.S2* %s, i32* %q) {
%in_array = load i32, i32* %q, !range !3 %in_array = load i32, i32* %q, !range !3
%gep1 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 2, i32 %in_array %gep1 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 2, i32 %in_array
%gep2 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 1, i32 3 %gep2 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 1, i32 3
load %struct.S2, %struct.S2* %s
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: t7 ; CHECK-LABEL: Function: t7
; CHECK-NEXT: MayAlias: %struct.S2* %s, i32* %q ; CHECK: MayAlias: i32* %gep1, %struct.S2* %s
; CHECK-NEXT: MayAlias: %struct.S2* %s, i32* %gep1 ; CHECK: PartialAlias (off -20): i32* %gep2, %struct.S2* %s
; CHECK-NEXT: MayAlias: i32* %gep1, i32* %q ; CHECK: NoAlias: i32* %gep1, i32* %gep2
; CHECK-NEXT: PartialAlias (off 20): %struct.S2* %s, i32* %gep2
; CHECK-NEXT: MayAlias: i32* %gep2, i32* %q
; CHECK-NEXT: NoAlias: i32* %gep1, i32* %gep2
define void @t7(%struct.S2* %s, i32* %q) { define void @t7(%struct.S2* %s, i32* %q) {
%in_array = load i32, i32* %q, !range !4 %in_array = load i32, i32* %q, !range !4
%gep1 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 2, i32 %in_array %gep1 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 2, i32 %in_array
%gep2 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 2, i32 0 %gep2 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 2, i32 0
load %struct.S2, %struct.S2* %s
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: t8 ; CHECK-LABEL: Function: t8
; CHECK-NEXT: MayAlias: %struct.S2* %s, i32* %q ; CHECK: MayAlias: i32* %gep1, %struct.S2* %s
; CHECK-NEXT: MayAlias: %struct.S2* %s, i32* %gep1 ; CHECK: PartialAlias (off -24): i32* %gep2, %struct.S2* %s
; CHECK-NEXT: MayAlias: i32* %gep1, i32* %q ; CHECK: MayAlias: i32* %gep1, i32* %gep2
; CHECK-NEXT: PartialAlias (off 24): %struct.S2* %s, i32* %gep2
; CHECK-NEXT: MayAlias: i32* %gep2, i32* %q
; CHECK-NEXT: MayAlias: i32* %gep1, i32* %gep2
define void @t8(%struct.S2* %s, i32* %q) { define void @t8(%struct.S2* %s, i32* %q) {
%in_array = load i32, i32* %q, !range !4 %in_array = load i32, i32* %q, !range !4
%gep1 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 2, i32 %in_array %gep1 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 2, i32 %in_array
%gep2 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 2, i32 1 %gep2 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 2, i32 1
load %struct.S2, %struct.S2* %s
load i32, i32* %q
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: t9 ; CHECK-LABEL: Function: t9
; CHECK-NEXT: MayAlias: %struct.S2* %s, i32* %q ; CHECK: MayAlias: i32* %gep1, %struct.S2* %s
; CHECK-NEXT: MayAlias: %struct.S2* %s, i32* %gep1 ; CHECK: PartialAlias (off -20): i32* %gep2, %struct.S2* %s
; CHECK-NEXT: MayAlias: i32* %gep1, i32* %q ; CHECK: NoAlias: i32* %gep1, i32* %gep2
; CHECK-NEXT: PartialAlias (off 20): %struct.S2* %s, i32* %gep2
; CHECK-NEXT: MayAlias: i32* %gep2, i32* %q
; CHECK-NEXT: NoAlias: i32* %gep1, i32* %gep2
define void @t9(%struct.S2* %s, i32* %q) { define void @t9(%struct.S2* %s, i32* %q) {
%in_array = load i32, i32* %q, !range !5 %in_array = load i32, i32* %q, !range !5
%gep1 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 1, i32 %in_array %gep1 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 1, i32 %in_array
%gep2 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 2, i32 0 %gep2 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 2, i32 0
load %struct.S2, %struct.S2* %s
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: t10 ; CHECK-LABEL: Function: t10
; CHECK-NEXT: MayAlias: %struct.S2* %s, i32* %q ; CHECK: MayAlias: i32* %gep1, %struct.S2* %s
; CHECK-NEXT: MayAlias: %struct.S2* %s, i32* %gep1 ; CHECK: PartialAlias (off -4): i32* %gep2, %struct.S2* %s
; CHECK-NEXT: MayAlias: i32* %gep1, i32* %q ; CHECK: MayAlias: i32* %gep1, i32* %gep2
; CHECK-NEXT: PartialAlias (off 4): %struct.S2* %s, i32* %gep2
; CHECK-NEXT: MayAlias: i32* %gep2, i32* %q
; CHECK-NEXT: MayAlias: i32* %gep1, i32* %gep2
define void @t10(%struct.S2* %s, i32* %q) { define void @t10(%struct.S2* %s, i32* %q) {
%in_array = load i32, i32* %q, !range !5 %in_array = load i32, i32* %q, !range !5
%gep1 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 2, i32 %in_array %gep1 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 2, i32 %in_array
%gep2 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 1, i32 0 %gep2 = getelementptr inbounds %struct.S2, %struct.S2* %s, i64 0, i32 1, i32 0
load %struct.S2, %struct.S2* %s
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: zeroext_index ; CHECK-LABEL: Function: zeroext_index
; CHECK-NEXT: MayAlias: [256 x i32]* %s, i8* %q ; CHECK: MayAlias: i32* %gep, [256 x i32]* %s
; CHECK-NEXT: MayAlias: [256 x i32]* %s, i32* %gep
; CHECK-NEXT: MayAlias: i32* %gep, i8* %q
define void @zeroext_index([256 x i32]* %s, i8* %q) { define void @zeroext_index([256 x i32]* %s, i8* %q) {
%a = load i8, i8* %q, !range !6 %a = load i8, i8* %q, !range !6
%in_array = zext i8 %a to i32 %in_array = zext i8 %a to i32
%gep = getelementptr inbounds [256 x i32], [256 x i32]* %s, i64 0, i32 %in_array %gep = getelementptr inbounds [256 x i32], [256 x i32]* %s, i64 0, i32 %in_array
load [256 x i32], [256 x i32]* %s
load i32, i32* %gep
ret void ret void
} }
; CHECK-LABEL: Function: multiple ; CHECK-LABEL: Function: multiple
; CHECK: MayAlias: i32* %p, i32* %p.01 ; CHECK: MayAlias: i32* %p, i32* %p.01
; CHECK: MayAlias: i32* %p, i32* %p.02 ; CHECK: MayAlias: i32* %p, i32* %p.02
; CHECK: MayAlias: i32* %p.01, i32* %p.02 ; CHECK: MayAlias: i32* %p.01, i32* %p.02
; CHECK: NoAlias: i32* %p.01, i32* %p.2 ; CHECK: NoAlias: i32* %p.01, i32* %p.2
; CHECK: MayAlias: i32* %p.02, i32* %p.2 ; CHECK: MayAlias: i32* %p.02, i32* %p.2
; CHECK: NoAlias: i32* %p.01, i32* %p.3 ; CHECK: NoAlias: i32* %p.01, i32* %p.3
; CHECK: NoAlias: i32* %p.02, i32* %p.3 ; CHECK: NoAlias: i32* %p.02, i32* %p.3
define void @multiple(i32* %p, i32* %o1_ptr, i32* %o2_ptr) { define void @multiple(i32* %p, i32* %o1_ptr, i32* %o2_ptr) {
%o1 = load i32, i32* %o1_ptr, !range !0 %o1 = load i32, i32* %o1_ptr, !range !0
%o2 = load i32, i32* %o2_ptr, !range !0 %o2 = load i32, i32* %o2_ptr, !range !0
%p.01 = getelementptr i32, i32* %p, i32 %o1 ; p + [0, 1] %p.01 = getelementptr i32, i32* %p, i32 %o1 ; p + [0, 1]
%p.02 = getelementptr i32, i32* %p.01, i32 %o2 ; p + [0, 2] %p.02 = getelementptr i32, i32* %p.01, i32 %o2 ; p + [0, 2]
%p.2 = getelementptr i32, i32* %p, i32 2 %p.2 = getelementptr i32, i32* %p, i32 2
%p.3 = getelementptr i32, i32* %p, i32 3 %p.3 = getelementptr i32, i32* %p, i32 3
load i32, i32* %p
load i32, i32* %p.01
load i32, i32* %p.02
load i32, i32* %p.2
load i32, i32* %p.3
ret void ret void
} }
; p.neg1 and p.o.1 don't alias, even though the addition o+1 may overflow. ; p.neg1 and p.o.1 don't alias, even though the addition o+1 may overflow.
; While it makes INT_MIN a possible offset, offset -1 is not possible. ; While it makes INT_MIN a possible offset, offset -1 is not possible.
; CHECK-LABEL: Function: benign_overflow ; CHECK-LABEL: Function: benign_overflow
; CHECK: MayAlias: i8* %p, i8* %p.o ; CHECK: MayAlias: i8* %p, i8* %p.o
; CHECK: MayAlias: i8* %p.neg1, i8* %p.o ; CHECK: MayAlias: i8* %p.neg1, i8* %p.o
; CHECK: MayAlias: i8* %p, i8* %p.o.1 ; CHECK: MayAlias: i8* %p, i8* %p.o.1
; CHECK: NoAlias: i8* %p.neg1, i8* %p.o.1 ; CHECK: NoAlias: i8* %p.neg1, i8* %p.o.1
; CHECK: NoAlias: i8* %p.o, i8* %p.o.1 ; CHECK: NoAlias: i8* %p.o, i8* %p.o.1
define void @benign_overflow(i8* %p, i64 %o) { define void @benign_overflow(i8* %p, i64 %o) {
%c = icmp sge i64 %o, -1 %c = icmp sge i64 %o, -1
call void @llvm.assume(i1 %c) call void @llvm.assume(i1 %c)
%p.neg1 = getelementptr i8, i8* %p, i64 -1 %p.neg1 = getelementptr i8, i8* %p, i64 -1
%p.o = getelementptr i8, i8* %p, i64 %o %p.o = getelementptr i8, i8* %p, i64 %o
%p.o.1 = getelementptr i8, i8* %p.o, i64 1 %p.o.1 = getelementptr i8, i8* %p.o, i64 1
load i8, i8* %p
load i8, i8* %p.neg1
load i8, i8* %p.o
load i8, i8* %p.o.1
ret void ret void
} }
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
!0 = !{ i32 0, i32 2 } !0 = !{ i32 0, i32 2 }
!1 = !{ i32 0, i32 1 } !1 = !{ i32 0, i32 1 }
!2 = !{ i32 1, i32 2 } !2 = !{ i32 1, i32 2 }
!3 = !{ i32 -2, i32 0 } !3 = !{ i32 -2, i32 0 }
!4 = !{ i32 1, i32 536870911 } !4 = !{ i32 1, i32 536870911 }
!5 = !{ i32 -536870911, i32 4 } !5 = !{ i32 -536870911, i32 4 }
!6 = !{ i8 -2, i8 0 } !6 = !{ i8 -2, i8 0 }

llvm/test/Analysis/BasicAA/recphi.ll

; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s --check-prefixes=CHECK,NO-PHI-VALUES ; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s --check-prefixes=CHECK,NO-PHI-VALUES
; RUN: opt < %s -aa-pipeline=basic-aa -passes='require<phi-values>,aa-eval' -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s --check-prefixes=CHECK,PHI-VALUES ; RUN: opt < %s -aa-pipeline=basic-aa -passes='require<phi-values>,aa-eval' -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s --check-prefixes=CHECK,PHI-VALUES
; CHECK-LABEL: Function: simple: 5 pointers, 0 call sites ; CHECK-LABEL: Function: simple: 5 pointers, 0 call sites
; CHECK: NoAlias: float* %src1, float* %src2 ; CHECK: NoAlias: float* %src1, float* %src2
; CHECK: NoAlias: float* %phi, float* %src1 ; CHECK: NoAlias: float* %phi, float* %src1
; CHECK: MayAlias: float* %phi, float* %src2 ; CHECK: MayAlias: float* %phi, float* %src2
; CHECK: NoAlias: float* %next, float* %src1 ; CHECK: NoAlias: float* %next, float* %src1
; CHECK: MayAlias: float* %next, float* %src2 ; CHECK: MayAlias: float* %next, float* %src2
; CHECK: NoAlias: float* %next, float* %phi ; CHECK: NoAlias: float* %next, float* %phi
; CHECK: NoAlias: float* %g, float* %src1 ; CHECK: NoAlias: float* %g, float* %src1
; CHECK: NoAlias: float* %g, float* %src2 ; CHECK: NoAlias: float* %g, float* %src2
; CHECK: NoAlias: float* %g, float* %phi ; CHECK: NoAlias: float* %g, float* %phi
; CHECK: NoAlias: float* %g, float* %next ; CHECK: NoAlias: float* %g, float* %next
define void @simple(float *%src1, float * noalias %src2, i32 %n) nounwind { define void @simple(float *%src1, float * noalias %src2, i32 %n) nounwind {
entry: entry:
load float, float* %src1
load float, float* %src2
br label %loop br label %loop
loop: loop:
%phi = phi float* [ %src2, %entry ], [ %next, %loop ] %phi = phi float* [ %src2, %entry ], [ %next, %loop ]
%idx = phi i32 [ 0, %entry ], [ %idxn, %loop ] %idx = phi i32 [ 0, %entry ], [ %idxn, %loop ]
%next = getelementptr inbounds float, float* %phi, i32 1 %next = getelementptr inbounds float, float* %phi, i32 1
%g = getelementptr inbounds float, float* %src1, i32 3 %g = getelementptr inbounds float, float* %src1, i32 3
%l = load float, float* %phi %l = load float, float* %phi
load float, float* %next
%a = fadd float %l, 1.0 %a = fadd float %l, 1.0
store float %a, float* %g store float %a, float* %g
%idxn = add nsw nuw i32 %idx, 1 %idxn = add nsw nuw i32 %idx, 1
%cmp5 = icmp eq i32 %idxn, %n %cmp5 = icmp eq i32 %idxn, %n
br i1 %cmp5, label %end, label %loop br i1 %cmp5, label %end, label %loop
end: end:
ret void ret void
} }
; CHECK-LABEL: Function: notmust: 6 pointers, 0 call sites ; CHECK-LABEL: Function: notmust: 6 pointers, 0 call sites
; CHECK: MustAlias: [2 x i32]* %tab, i8* %0 ; CHECK: MustAlias: i8* %0, [2 x i32]* %tab
; CHECK: PartialAlias (off 4): [2 x i32]* %tab, i32* %arrayidx ; CHECK: PartialAlias (off -4): i32* %arrayidx, [2 x i32]* %tab
; CHECK: NoAlias: i32* %arrayidx, i8* %0 ; CHECK: NoAlias: i8* %0, i32* %arrayidx
; CHECK: MustAlias: [2 x i32]* %tab, i32* %arrayidx1 ; CHECK: MustAlias: i32* %arrayidx1, [2 x i32]* %tab
; CHECK: MustAlias: i32* %arrayidx1, i8* %0 ; CHECK: MustAlias: i8* %0, i32* %arrayidx1
; CHECK: NoAlias: i32* %arrayidx, i32* %arrayidx1 ; CHECK: NoAlias: i32* %arrayidx, i32* %arrayidx1
; CHECK: MayAlias: [2 x i32]* %tab, i32* %p.addr.05.i ; CHECK: MayAlias: i32* %incdec.ptr.i, [2 x i32]* %tab
; CHECK: MayAlias: i32* %p.addr.05.i, i8* %0 ; CHECK: NoAlias: i8* %0, i32* %incdec.ptr.i
; CHECK: MayAlias: i32* %arrayidx, i32* %p.addr.05.i
; CHECK: MayAlias: i32* %arrayidx1, i32* %p.addr.05.i
; CHECK: MayAlias: [2 x i32]* %tab, i32* %incdec.ptr.i
; CHECK: NoAlias: i32* %incdec.ptr.i, i8* %0
; CHECK: MayAlias: i32* %arrayidx, i32* %incdec.ptr.i ; CHECK: MayAlias: i32* %arrayidx, i32* %incdec.ptr.i
; CHECK: NoAlias: i32* %arrayidx1, i32* %incdec.ptr.i ; CHECK: NoAlias: i32* %arrayidx1, i32* %incdec.ptr.i
; CHECK: MayAlias: i32* %p.addr.05.i, [2 x i32]* %tab
; CHECK: MayAlias: i8* %0, i32* %p.addr.05.i
; CHECK: MayAlias: i32* %arrayidx, i32* %p.addr.05.i
; CHECK: MayAlias: i32* %arrayidx1, i32* %p.addr.05.i
; CHECK: NoAlias: i32* %incdec.ptr.i, i32* %p.addr.05.i ; CHECK: NoAlias: i32* %incdec.ptr.i, i32* %p.addr.05.i
define i32 @notmust() nounwind { define i32 @notmust() nounwind {
entry: entry:
%tab = alloca [2 x i32], align 4 %tab = alloca [2 x i32], align 4
%ignore1 = load [2 x i32], [2 x i32]* %tab
%0 = bitcast [2 x i32]* %tab to i8* %0 = bitcast [2 x i32]* %tab to i8*
%ignore2 = load i8, i8* %0
%arrayidx = getelementptr inbounds [2 x i32], [2 x i32]* %tab, i32 0, i32 1 %arrayidx = getelementptr inbounds [2 x i32], [2 x i32]* %tab, i32 0, i32 1
store i32 0, i32* %arrayidx, align 4 store i32 0, i32* %arrayidx, align 4
%arrayidx1 = getelementptr inbounds [2 x i32], [2 x i32]* %tab, i32 0, i32 0 %arrayidx1 = getelementptr inbounds [2 x i32], [2 x i32]* %tab, i32 0, i32 0
store i32 0, i32* %arrayidx1, align 4 store i32 0, i32* %arrayidx1, align 4
%1 = add i32 1, 1 %1 = add i32 1, 1
%cmp4.i = icmp slt i32 %1, 2 %cmp4.i = icmp slt i32 %1, 2
br i1 %cmp4.i, label %while.body.i, label %f.exit br i1 %cmp4.i, label %while.body.i, label %f.exit
while.body.i: ; preds = %while.body.i, %entry while.body.i: ; preds = %while.body.i, %entry
%2 = phi i32 [ 1, %while.body.i ], [ %1, %entry ] %2 = phi i32 [ 1, %while.body.i ], [ %1, %entry ]
%foo.06.i = phi i32 [ %sub.i, %while.body.i ], [ 2, %entry ] %foo.06.i = phi i32 [ %sub.i, %while.body.i ], [ 2, %entry ]
%p.addr.05.i = phi i32* [ %incdec.ptr.i, %while.body.i ], [ %arrayidx1, %entry ] %p.addr.05.i = phi i32* [ %incdec.ptr.i, %while.body.i ], [ %arrayidx1, %entry ]
%sub.i = sub nsw i32 %foo.06.i, %2 %sub.i = sub nsw i32 %foo.06.i, %2
%incdec.ptr.i = getelementptr inbounds i32, i32* %p.addr.05.i, i32 1 %incdec.ptr.i = getelementptr inbounds i32, i32* %p.addr.05.i, i32 1
%ignore3 = load i32, i32* %incdec.ptr.i
store i32 %sub.i, i32* %p.addr.05.i, align 4 store i32 %sub.i, i32* %p.addr.05.i, align 4
%cmp.i = icmp sgt i32 %sub.i, 1 %cmp.i = icmp sgt i32 %sub.i, 1
br i1 %cmp.i, label %while.body.i, label %f.exit br i1 %cmp.i, label %while.body.i, label %f.exit
f.exit: ; preds = %entry, %while.body.i f.exit: ; preds = %entry, %while.body.i
%3 = load i32, i32* %arrayidx1, align 4 %3 = load i32, i32* %arrayidx1, align 4
%cmp = icmp eq i32 %3, 2 %cmp = icmp eq i32 %3, 2
%4 = load i32, i32* %arrayidx, align 4 %4 = load i32, i32* %arrayidx, align 4
%cmp4 = icmp eq i32 %4, 1 %cmp4 = icmp eq i32 %4, 1
%or.cond = and i1 %cmp, %cmp4 %or.cond = and i1 %cmp, %cmp4
br i1 %or.cond, label %if.end, label %if.then br i1 %or.cond, label %if.end, label %if.then
if.then: ; preds = %f.exit if.then: ; preds = %f.exit
unreachable unreachable
if.end: ; preds = %f.exit if.end: ; preds = %f.exit
ret i32 0 ret i32 0
} }
; CHECK-LABEL: Function: reverse: 6 pointers, 0 call sites ; CHECK-LABEL: Function: reverse: 6 pointers, 0 call sites
; CHECK: MustAlias: [10 x i32]* %tab, i8* %0 ; CHECK: MustAlias: i8* %0, [10 x i32]* %tab
; CHECK: MustAlias: [10 x i32]* %tab, i32* %arrayidx ; CHECK: MustAlias: i32* %arrayidx, [10 x i32]* %tab
; CHECK: MustAlias: i32* %arrayidx, i8* %0 ; CHECK: MustAlias: i8* %0, i32* %arrayidx
; CHECK: PartialAlias (off 36): [10 x i32]* %tab, i32* %arrayidx1 ; CHECK: PartialAlias (off -36): i32* %arrayidx1, [10 x i32]* %tab
; CHECK: NoAlias: i32* %arrayidx1, i8* %0 ; CHECK: NoAlias: i8* %0, i32* %arrayidx1
; CHECK: NoAlias: i32* %arrayidx, i32* %arrayidx1 ; CHECK: NoAlias: i32* %arrayidx, i32* %arrayidx1
; CHECK: MayAlias: [10 x i32]* %tab, i32* %p.addr.05.i ; CHECK: MayAlias: i32* %incdec.ptr.i, [10 x i32]* %tab
; CHECK: MayAlias: i32* %p.addr.05.i, i8* %0 ; CHECK: MayAlias: i8* %0, i32* %incdec.ptr.i
; CHECK: MayAlias: i32* %arrayidx, i32* %p.addr.05.i
; CHECK: MayAlias: i32* %arrayidx1, i32* %p.addr.05.i
; CHECK: MayAlias: [10 x i32]* %tab, i32* %incdec.ptr.i
; CHECK: MayAlias: i32* %incdec.ptr.i, i8* %0
; CHECK: MayAlias: i32* %arrayidx, i32* %incdec.ptr.i ; CHECK: MayAlias: i32* %arrayidx, i32* %incdec.ptr.i
; CHECK: MayAlias: i32* %arrayidx1, i32* %incdec.ptr.i ; CHECK: MayAlias: i32* %arrayidx1, i32* %incdec.ptr.i
; CHECK: MayAlias: i32* %p.addr.05.i, [10 x i32]* %tab
; CHECK: MayAlias: i8* %0, i32* %p.addr.05.i
; CHECK: MayAlias: i32* %arrayidx, i32* %p.addr.05.i
; CHECK: MayAlias: i32* %arrayidx1, i32* %p.addr.05.i
; CHECK: NoAlias: i32* %incdec.ptr.i, i32* %p.addr.05.i ; CHECK: NoAlias: i32* %incdec.ptr.i, i32* %p.addr.05.i
define i32 @reverse() nounwind { define i32 @reverse() nounwind {
entry: entry:
%tab = alloca [10 x i32], align 4 %tab = alloca [10 x i32], align 4
%ignore1 = load [10 x i32], [10 x i32]* %tab
%0 = bitcast [10 x i32]* %tab to i8* %0 = bitcast [10 x i32]* %tab to i8*
%ignore2 = load i8, i8* %0
%arrayidx = getelementptr inbounds [10 x i32], [10 x i32]* %tab, i32 0, i32 0 %arrayidx = getelementptr inbounds [10 x i32], [10 x i32]* %tab, i32 0, i32 0
store i32 0, i32* %arrayidx, align 4 store i32 0, i32* %arrayidx, align 4
%arrayidx1 = getelementptr inbounds [10 x i32], [10 x i32]* %tab, i32 0, i32 9 %arrayidx1 = getelementptr inbounds [10 x i32], [10 x i32]* %tab, i32 0, i32 9
store i32 0, i32* %arrayidx1, align 4 store i32 0, i32* %arrayidx1, align 4
%1 = add i32 1, 1 %1 = add i32 1, 1
%cmp4.i = icmp slt i32 %1, 2 %cmp4.i = icmp slt i32 %1, 2
br i1 %cmp4.i, label %while.body.i, label %f.exit br i1 %cmp4.i, label %while.body.i, label %f.exit
while.body.i: ; preds = %while.body.i, %entry while.body.i: ; preds = %while.body.i, %entry
%2 = phi i32 [ 1, %while.body.i ], [ %1, %entry ] %2 = phi i32 [ 1, %while.body.i ], [ %1, %entry ]
%foo.06.i = phi i32 [ %sub.i, %while.body.i ], [ 2, %entry ] %foo.06.i = phi i32 [ %sub.i, %while.body.i ], [ 2, %entry ]
%p.addr.05.i = phi i32* [ %incdec.ptr.i, %while.body.i ], [ %arrayidx1, %entry ] %p.addr.05.i = phi i32* [ %incdec.ptr.i, %while.body.i ], [ %arrayidx1, %entry ]
%sub.i = sub nsw i32 %foo.06.i, %2 %sub.i = sub nsw i32 %foo.06.i, %2
%incdec.ptr.i = getelementptr inbounds i32, i32* %p.addr.05.i, i32 -1 %incdec.ptr.i = getelementptr inbounds i32, i32* %p.addr.05.i, i32 -1
%ignore3 = load i32, i32* %incdec.ptr.i
store i32 %sub.i, i32* %p.addr.05.i, align 4 store i32 %sub.i, i32* %p.addr.05.i, align 4
%cmp.i = icmp sgt i32 %sub.i, 1 %cmp.i = icmp sgt i32 %sub.i, 1
br i1 %cmp.i, label %while.body.i, label %f.exit br i1 %cmp.i, label %while.body.i, label %f.exit
f.exit: ; preds = %entry, %while.body.i f.exit: ; preds = %entry, %while.body.i
%3 = load i32, i32* %arrayidx1, align 4 %3 = load i32, i32* %arrayidx1, align 4
%cmp = icmp eq i32 %3, 2 %cmp = icmp eq i32 %3, 2
%4 = load i32, i32* %arrayidx, align 4 %4 = load i32, i32* %arrayidx, align 4
%cmp4 = icmp eq i32 %4, 1 %cmp4 = icmp eq i32 %4, 1
%or.cond = and i1 %cmp, %cmp4 %or.cond = and i1 %cmp, %cmp4
br i1 %or.cond, label %if.end, label %if.then br i1 %or.cond, label %if.end, label %if.then
if.then: ; preds = %f.exit if.then: ; preds = %f.exit
unreachable unreachable
if.end: ; preds = %f.exit if.end: ; preds = %f.exit
ret i32 0 ret i32 0
} }
; CHECK-LABEL: Function: negative: 6 pointers, 1 call sites ; CHECK-LABEL: Function: negative: 5 pointers, 1 call sites
; CHECK: NoAlias: [3 x i16]* %int_arr.10, i16** %argv.6.par ; CHECK: PartialAlias (off -4): i16* %_tmp1, [3 x i16]* %int_arr.10
; CHECK: NoAlias: i16* %_tmp1, i16** %argv.6.par
; CHECK: PartialAlias (off 4): [3 x i16]* %int_arr.10, i16* %_tmp1
; CHECK: NoAlias: i16* %ls1.9.0, i16** %argv.6.par
; CHECK: MayAlias: [3 x i16]* %int_arr.10, i16* %ls1.9.0 ; CHECK: MayAlias: [3 x i16]* %int_arr.10, i16* %ls1.9.0
; CHECK: MayAlias: i16* %_tmp1, i16* %ls1.9.0 ; CHECK: MayAlias: i16* %_tmp1, i16* %ls1.9.0
; CHECK: NoAlias: i16* %_tmp7, i16** %argv.6.par ; CHECK: MayAlias: i16* %_tmp7, [3 x i16]* %int_arr.10
; CHECK: MayAlias: [3 x i16]* %int_arr.10, i16* %_tmp7
; CHECK: MayAlias: i16* %_tmp1, i16* %_tmp7 ; CHECK: MayAlias: i16* %_tmp1, i16* %_tmp7
; CHECK: NoAlias: i16* %_tmp7, i16* %ls1.9.0 ; CHECK: NoAlias: i16* %_tmp7, i16* %ls1.9.0
; CHECK: NoAlias: i16* %_tmp11, i16** %argv.6.par ; CHECK: PartialAlias (off -2): i16* %_tmp11, [3 x i16]* %int_arr.10
; CHECK: PartialAlias (off 2): [3 x i16]* %int_arr.10, i16* %_tmp11
; CHECK: NoAlias: i16* %_tmp1, i16* %_tmp11 ; CHECK: NoAlias: i16* %_tmp1, i16* %_tmp11
; CHECK: MayAlias: i16* %_tmp11, i16* %ls1.9.0 ; CHECK: MayAlias: i16* %_tmp11, i16* %ls1.9.0
; CHECK: MayAlias: i16* %_tmp11, i16* %_tmp7 ; CHECK: MayAlias: i16* %_tmp11, i16* %_tmp7
; CHECK: Both ModRef: Ptr: i16** %argv.6.par <-> %_tmp16 = call i16 @call(i32 %_tmp13)
; CHECK: NoModRef: Ptr: [3 x i16]* %int_arr.10 <-> %_tmp16 = call i16 @call(i32 %_tmp13) ; CHECK: NoModRef: Ptr: [3 x i16]* %int_arr.10 <-> %_tmp16 = call i16 @call(i32 %_tmp13)
; CHECK: NoModRef: Ptr: i16* %_tmp1 <-> %_tmp16 = call i16 @call(i32 %_tmp13) ; CHECK: NoModRef: Ptr: i16* %_tmp1 <-> %_tmp16 = call i16 @call(i32 %_tmp13)
; CHECK: Both ModRef: Ptr: i16* %ls1.9.0 <-> %_tmp16 = call i16 @call(i32 %_tmp13) ; CHECK: Both ModRef: Ptr: i16* %ls1.9.0 <-> %_tmp16 = call i16 @call(i32 %_tmp13)
; CHECK: Both ModRef: Ptr: i16* %_tmp7 <-> %_tmp16 = call i16 @call(i32 %_tmp13) ; CHECK: Both ModRef: Ptr: i16* %_tmp7 <-> %_tmp16 = call i16 @call(i32 %_tmp13)
; CHECK: NoModRef: Ptr: i16* %_tmp11 <-> %_tmp16 = call i16 @call(i32 %_tmp13) ; CHECK: NoModRef: Ptr: i16* %_tmp11 <-> %_tmp16 = call i16 @call(i32 %_tmp13)
define i16 @negative(i16 %argc.5.par, i16** nocapture readnone %argv.6.par) { define i16 @negative(i16 %argc.5.par) {
%int_arr.10 = alloca [3 x i16], align 1 %int_arr.10 = alloca [3 x i16], align 1
load [3 x i16], [3 x i16]* %int_arr.10
%_tmp1 = getelementptr inbounds [3 x i16], [3 x i16]* %int_arr.10, i16 0, i16 2 %_tmp1 = getelementptr inbounds [3 x i16], [3 x i16]* %int_arr.10, i16 0, i16 2
load i16, i16* %_tmp1
br label %bb1 br label %bb1
bb1: ; preds = %bb1, %0 bb1: ; preds = %bb1, %0
%i.7.0 = phi i16 [ 2, %0 ], [ %_tmp5, %bb1 ] %i.7.0 = phi i16 [ 2, %0 ], [ %_tmp5, %bb1 ]
%ls1.9.0 = phi i16* [ %_tmp1, %0 ], [ %_tmp7, %bb1 ] %ls1.9.0 = phi i16* [ %_tmp1, %0 ], [ %_tmp7, %bb1 ]
store i16 %i.7.0, i16* %ls1.9.0, align 1 store i16 %i.7.0, i16* %ls1.9.0, align 1
%_tmp5 = add nsw i16 %i.7.0, -1 %_tmp5 = add nsw i16 %i.7.0, -1
%_tmp7 = getelementptr i16, i16* %ls1.9.0, i16 -1 %_tmp7 = getelementptr i16, i16* %ls1.9.0, i16 -1
load i16, i16* %_tmp7
%_tmp9 = icmp sgt i16 %i.7.0, 0 %_tmp9 = icmp sgt i16 %i.7.0, 0
br i1 %_tmp9, label %bb1, label %bb3 br i1 %_tmp9, label %bb1, label %bb3
bb3: ; preds = %bb1 bb3: ; preds = %bb1
%_tmp11 = getelementptr inbounds [3 x i16], [3 x i16]* %int_arr.10, i16 0, i16 1 %_tmp11 = getelementptr inbounds [3 x i16], [3 x i16]* %int_arr.10, i16 0, i16 1
%_tmp12 = load i16, i16* %_tmp11, align 1 %_tmp12 = load i16, i16* %_tmp11, align 1
%_tmp13 = sext i16 %_tmp12 to i32 %_tmp13 = sext i16 %_tmp12 to i32
%_tmp16 = call i16 @call(i32 %_tmp13) %_tmp16 = call i16 @call(i32 %_tmp13)
Show All 12 Lines
; CHECK: MayAlias: i8* %p, i8* %p.base ; CHECK: MayAlias: i8* %p, i8* %p.base
; CHECK: NoAlias: i8* %a, i8* %p ; CHECK: NoAlias: i8* %a, i8* %p
; CHECK: MayAlias: i8* %p.base, i8* %p.next ; CHECK: MayAlias: i8* %p.base, i8* %p.next
; CHECK: NoAlias: i8* %a, i8* %p.next ; CHECK: NoAlias: i8* %a, i8* %p.next
; CHECK: MayAlias: i8* %p, i8* %p.next ; CHECK: MayAlias: i8* %p, i8* %p.next
define void @dynamic_offset(i1 %c, i8* noalias %p.base) { define void @dynamic_offset(i1 %c, i8* noalias %p.base) {
entry: entry:
%a = alloca i8 %a = alloca i8
load i8, i8* %p.base
load i8, i8* %a
br label %loop br label %loop
loop: loop:
%p = phi i8* [ %p.base, %entry ], [ %p.next, %loop ] %p = phi i8* [ %p.base, %entry ], [ %p.next, %loop ]
%offset = call i16 @call(i32 0) %offset = call i16 @call(i32 0)
%p.next = getelementptr inbounds i8, i8* %p, i16 %offset %p.next = getelementptr inbounds i8, i8* %p, i16 %offset
load i8, i8* %p
load i8, i8* %p.next
br i1 %c, label %loop, label %exit br i1 %c, label %loop, label %exit
exit: exit:
ret void ret void
} }
; TODO: Currently yields an asymmetric result. ; TODO: Currently yields an asymmetric result.
; CHECK-LABEL: Function: symmetry ; CHECK-LABEL: Function: symmetry
; CHECK: MayAlias: i32* %p, i32* %p.base ; CHECK: MayAlias: i32* %p, i32* %p.base
; CHECK: MayAlias: i32* %p.base, i32* %p.next ; CHECK: MayAlias: i32* %p.base, i32* %p.next
; CHECK: NoAlias: i32* %p, i32* %p.next ; CHECK: NoAlias: i32* %p, i32* %p.next
; CHECK: MayAlias: i32* %p.base, i32* %result ; CHECK: MayAlias: i32* %p.base, i32* %result
; CHECK: NoAlias: i32* %p, i32* %result ; CHECK: NoAlias: i32* %p, i32* %result
; CHECK: MustAlias: i32* %p.next, i32* %result ; CHECK: MustAlias: i32* %p.next, i32* %result
define i32* @symmetry(i32* %p.base, i1 %c) { define i32* @symmetry(i32* %p.base, i1 %c) {
entry: entry:
load i32, i32* %p.base
br label %loop br label %loop
loop: loop:
%p = phi i32* [ %p.base, %entry ], [ %p.next, %loop ] %p = phi i32* [ %p.base, %entry ], [ %p.next, %loop ]
%p.next = getelementptr inbounds i32, i32* %p, i32 1 %p.next = getelementptr inbounds i32, i32* %p, i32 1
load i32, i32* %p
load i32, i32* %p.next
br i1 %c, label %loop, label %exit br i1 %c, label %loop, label %exit
exit: exit:
%result = phi i32* [ %p.next, %loop ] %result = phi i32* [ %p.next, %loop ]
load i32, i32* %result
ret i32* %result ret i32* %result
} }
; CHECK-LABEL: Function: nested_loop ; CHECK-LABEL: Function: nested_loop
; CHECK: NoAlias: i8* %a, i8* %p.base ; CHECK: NoAlias: i8* %a, i8* %p.base
; CHECK: NoAlias: i8* %a, i8* %p.outer ; CHECK: NoAlias: i8* %a, i8* %p.outer
; CHECK: NoAlias: i8* %a, i8* %p.outer.next
; NO-PHI-VALUES: MayAlias: i8* %a, i8* %p.inner ; NO-PHI-VALUES: MayAlias: i8* %a, i8* %p.inner
; PHI-VALUES: NoAlias: i8* %a, i8* %p.inner ; PHI-VALUES: NoAlias: i8* %a, i8* %p.inner
; CHECK: NoAlias: i8* %a, i8* %p.inner.next ; CHECK: NoAlias: i8* %a, i8* %p.inner.next
; CHECK: NoAlias: i8* %a, i8* %p.outer.next
define void @nested_loop(i1 %c, i1 %c2, i8* noalias %p.base) { define void @nested_loop(i1 %c, i1 %c2, i8* noalias %p.base) {
entry: entry:
%a = alloca i8 %a = alloca i8
load i8, i8* %p.base
load i8, i8* %a
br label %outer_loop br label %outer_loop
outer_loop: outer_loop:
%p.outer = phi i8* [ %p.base, %entry ], [ %p.outer.next, %outer_loop_latch ] %p.outer = phi i8* [ %p.base, %entry ], [ %p.outer.next, %outer_loop_latch ]
load i8, i8* %p.outer
br label %inner_loop br label %inner_loop
inner_loop: inner_loop:
%p.inner = phi i8* [ %p.outer, %outer_loop ], [ %p.inner.next, %inner_loop ] %p.inner = phi i8* [ %p.outer, %outer_loop ], [ %p.inner.next, %inner_loop ]
%p.inner.next = getelementptr inbounds i8, i8* %p.inner, i64 1 %p.inner.next = getelementptr inbounds i8, i8* %p.inner, i64 1
load i8, i8* %p.inner
load i8, i8* %p.inner.next
br i1 %c, label %inner_loop, label %outer_loop_latch br i1 %c, label %inner_loop, label %outer_loop_latch
outer_loop_latch: outer_loop_latch:
%p.outer.next = getelementptr inbounds i8, i8* %p.inner, i64 10 %p.outer.next = getelementptr inbounds i8, i8* %p.inner, i64 10
load i8, i8* %p.outer.next
br i1 %c2, label %outer_loop, label %exit br i1 %c2, label %outer_loop, label %exit
exit: exit:
ret void ret void
} }
; Same as the previous test case, but avoiding phi of phi. ; Same as the previous test case, but avoiding phi of phi.
; CHECK-LABEL: Function: nested_loop2 ; CHECK-LABEL: Function: nested_loop2
; CHECK: NoAlias: i8* %a, i8* %p.base ; CHECK: NoAlias: i8* %a, i8* %p.base
; CHECK: NoAlias: i8* %a, i8* %p.outer ; CHECK: NoAlias: i8* %a, i8* %p.outer
; CHECK: NoAlias: i8* %a, i8* %p.outer.next ; CHECK: NoAlias: i8* %a, i8* %p.outer.next
; CHECK: MayAlias: i8* %a, i8* %p.inner ; CHECK: MayAlias: i8* %a, i8* %p.inner
; CHECK: NoAlias: i8* %a, i8* %p.inner.next ; CHECK: NoAlias: i8* %a, i8* %p.inner.next
; TODO: (a, p.inner) could be NoAlias ; TODO: (a, p.inner) could be NoAlias
define void @nested_loop2(i1 %c, i1 %c2, i8* noalias %p.base) { define void @nested_loop2(i1 %c, i1 %c2, i8* noalias %p.base) {
entry: entry:
%a = alloca i8 %a = alloca i8
load i8, i8* %p.base
load i8, i8* %a
br label %outer_loop br label %outer_loop
outer_loop: outer_loop:
%p.outer = phi i8* [ %p.base, %entry ], [ %p.outer.next, %outer_loop_latch ] %p.outer = phi i8* [ %p.base, %entry ], [ %p.outer.next, %outer_loop_latch ]
%p.outer.next = getelementptr inbounds i8, i8* %p.outer, i64 10 %p.outer.next = getelementptr inbounds i8, i8* %p.outer, i64 10
load i8, i8* %p.outer
load i8, i8* %p.outer.next
br label %inner_loop br label %inner_loop
inner_loop: inner_loop:
%p.inner = phi i8* [ %p.outer.next, %outer_loop ], [ %p.inner.next, %inner_loop ] %p.inner = phi i8* [ %p.outer.next, %outer_loop ], [ %p.inner.next, %inner_loop ]
%p.inner.next = getelementptr inbounds i8, i8* %p.inner, i64 1 %p.inner.next = getelementptr inbounds i8, i8* %p.inner, i64 1
load i8, i8* %p.inner
load i8, i8* %p.inner.next
br i1 %c, label %inner_loop, label %outer_loop_latch br i1 %c, label %inner_loop, label %outer_loop_latch
outer_loop_latch: outer_loop_latch:
br i1 %c2, label %outer_loop, label %exit br i1 %c2, label %outer_loop, label %exit
exit: exit:
ret void ret void
} }
; CHECK-LABEL: Function: nested_loop3 ; CHECK-LABEL: Function: nested_loop3
; CHECK: NoAlias: i8* %a, i8* %p.base ; CHECK: NoAlias: i8* %a, i8* %p.base
; CHECK: NoAlias: i8* %a, i8* %p.outer ; CHECK: NoAlias: i8* %a, i8* %p.outer
; CHECK: NoAlias: i8* %a, i8* %p.outer.next ; CHECK: NoAlias: i8* %a, i8* %p.outer.next
; NO-PHI-VALUES: NoAlias: i8* %a, i8* %p.inner ; NO-PHI-VALUES: NoAlias: i8* %a, i8* %p.inner
; PHI-VALUES: MayAlias: i8* %a, i8* %p.inner ; PHI-VALUES: MayAlias: i8* %a, i8* %p.inner
; CHECK: NoAlias: i8* %a, i8* %p.inner.next ; CHECK: NoAlias: i8* %a, i8* %p.inner.next
define void @nested_loop3(i1 %c, i1 %c2, i8* noalias %p.base) { define void @nested_loop3(i1 %c, i1 %c2, i8* noalias %p.base) {
entry: entry:
%a = alloca i8 %a = alloca i8
load i8, i8* %p.base
load i8, i8* %a
br label %outer_loop br label %outer_loop
outer_loop: outer_loop:
%p.outer = phi i8* [ %p.base, %entry ], [ %p.outer.next, %outer_loop_latch ] %p.outer = phi i8* [ %p.base, %entry ], [ %p.outer.next, %outer_loop_latch ]
%p.outer.next = getelementptr inbounds i8, i8* %p.outer, i64 10 %p.outer.next = getelementptr inbounds i8, i8* %p.outer, i64 10
load i8, i8* %p.outer
load i8, i8* %p.outer.next
br label %inner_loop br label %inner_loop
inner_loop: inner_loop:
%p.inner = phi i8* [ %p.outer, %outer_loop ], [ %p.inner.next, %inner_loop ] %p.inner = phi i8* [ %p.outer, %outer_loop ], [ %p.inner.next, %inner_loop ]
%p.inner.next = getelementptr inbounds i8, i8* %p.inner, i64 1 %p.inner.next = getelementptr inbounds i8, i8* %p.inner, i64 1
load i8, i8* %p.inner
load i8, i8* %p.inner.next
br i1 %c, label %inner_loop, label %outer_loop_latch br i1 %c, label %inner_loop, label %outer_loop_latch
outer_loop_latch: outer_loop_latch:
br i1 %c2, label %outer_loop, label %exit br i1 %c2, label %outer_loop, label %exit
exit: exit:
ret void ret void
} }
; CHECK-LABEL: Function: sibling_loop ; CHECK-LABEL: Function: sibling_loop
; CHECK: NoAlias: i8* %a, i8* %p.base ; CHECK: NoAlias: i8* %a, i8* %p.base
; CHECK: NoAlias: i8* %a, i8* %p1 ; CHECK: NoAlias: i8* %a, i8* %p1
; CHECK: NoAlias: i8* %a, i8* %p1.next ; CHECK: NoAlias: i8* %a, i8* %p1.next
; CHECK: MayAlias: i8* %a, i8* %p2 ; CHECK: MayAlias: i8* %a, i8* %p2
; CHECK: NoAlias: i8* %a, i8* %p2.next ; CHECK: NoAlias: i8* %a, i8* %p2.next
; TODO: %p2 does not alias %a ; TODO: %p2 does not alias %a
define void @sibling_loop(i1 %c, i1 %c2, i8* noalias %p.base) { define void @sibling_loop(i1 %c, i1 %c2, i8* noalias %p.base) {
entry: entry:
%a = alloca i8 %a = alloca i8
load i8, i8* %p.base
load i8, i8* %a
br label %loop1 br label %loop1
loop1: loop1:
%p1 = phi i8* [ %p.base, %entry ], [ %p1.next, %loop1 ] %p1 = phi i8* [ %p.base, %entry ], [ %p1.next, %loop1 ]
%p1.next = getelementptr inbounds i8, i8* %p1, i64 10 %p1.next = getelementptr inbounds i8, i8* %p1, i64 10
load i8, i8* %p1
load i8, i8* %p1.next
br i1 %c, label %loop1, label %loop2 br i1 %c, label %loop1, label %loop2
loop2: loop2:
%p2 = phi i8* [ %p1.next, %loop1 ], [ %p2.next, %loop2 ] %p2 = phi i8* [ %p1.next, %loop1 ], [ %p2.next, %loop2 ]
%p2.next = getelementptr inbounds i8, i8* %p2, i64 1 %p2.next = getelementptr inbounds i8, i8* %p2, i64 1
load i8, i8* %p2
load i8, i8* %p2.next
br i1 %c2, label %loop2, label %exit br i1 %c2, label %loop2, label %exit
exit: exit:
ret void ret void
} }
; CHECK-LABEL: Function: sibling_loop2 ; CHECK-LABEL: Function: sibling_loop2
; CHECK: NoAlias: i8* %a, i8* %p.base ; CHECK: NoAlias: i8* %a, i8* %p.base
; CHECK: NoAlias: i8* %a, i8* %p1 ; CHECK: NoAlias: i8* %a, i8* %p1
; CHECK: NoAlias: i8* %a, i8* %p1.next ; CHECK: NoAlias: i8* %a, i8* %p1.next
; NO-PHI-VALUES: NoAlias: i8* %a, i8* %p2 ; NO-PHI-VALUES: NoAlias: i8* %a, i8* %p2
; PHI-VALUES: MayAlias: i8* %a, i8* %p2 ; PHI-VALUES: MayAlias: i8* %a, i8* %p2
; CHECK: NoAlias: i8* %a, i8* %p2.next ; CHECK: NoAlias: i8* %a, i8* %p2.next
define void @sibling_loop2(i1 %c, i1 %c2, i8* noalias %p.base) { define void @sibling_loop2(i1 %c, i1 %c2, i8* noalias %p.base) {
entry: entry:
%a = alloca i8 %a = alloca i8
load i8, i8* %p.base
load i8, i8* %a
br label %loop1 br label %loop1
loop1: loop1:
%p1 = phi i8* [ %p.base, %entry ], [ %p1.next, %loop1 ] %p1 = phi i8* [ %p.base, %entry ], [ %p1.next, %loop1 ]
%p1.next = getelementptr inbounds i8, i8* %p1, i64 10 %p1.next = getelementptr inbounds i8, i8* %p1, i64 10
load i8, i8* %p1
load i8, i8* %p1.next
br i1 %c, label %loop1, label %loop2 br i1 %c, label %loop1, label %loop2
loop2: loop2:
%p2 = phi i8* [ %p1, %loop1 ], [ %p2.next, %loop2 ] %p2 = phi i8* [ %p1, %loop1 ], [ %p2.next, %loop2 ]
%p2.next = getelementptr inbounds i8, i8* %p2, i64 1 %p2.next = getelementptr inbounds i8, i8* %p2, i64 1
load i8, i8* %p2
load i8, i8* %p2.next
br i1 %c2, label %loop2, label %exit br i1 %c2, label %loop2, label %exit
exit: exit:
ret void ret void
} }
declare i16 @call(i32) declare i16 @call(i32)

llvm/test/Analysis/BasicAA/returned.ll

Show All 11 Lines
; CHECK-DAG: MayAlias: %struct* %st, i32* %y ; CHECK-DAG: MayAlias: %struct* %st, i32* %y
; CHECK-DAG: MayAlias: %struct* %st, i32* %z ; CHECK-DAG: MayAlias: %struct* %st, i32* %z
; CHECK-DAG: NoAlias: i32* %x, i32* %y ; CHECK-DAG: NoAlias: i32* %x, i32* %y
; CHECK-DAG: NoAlias: i32* %x, i32* %z ; CHECK-DAG: NoAlias: i32* %x, i32* %z
; CHECK-DAG: NoAlias: i32* %y, i32* %z ; CHECK-DAG: NoAlias: i32* %y, i32* %z
; CHECK-DAG: MayAlias: %struct* %st, %struct* %y_12 ; CHECK-DAG: MayAlias: %struct* %st, %struct* %y_12
; CHECK-DAG: MayAlias: %struct* %y_12, i32* %x ; CHECK-DAG: MayAlias: i32* %x, %struct* %y_12
; CHECK-DAG: MayAlias: i32* %x, i80* %y_10 ; CHECK-DAG: MayAlias: i32* %x, i80* %y_10
; CHECK-DAG: MayAlias: %struct* %st, i64* %y_8 ; CHECK-DAG: MayAlias: %struct* %st, i64* %y_8
; CHECK-DAG: MayAlias: i32* %z, i64* %y_8 ; CHECK-DAG: MayAlias: i64* %y_8, i32* %z
; CHECK-DAG: NoAlias: i32* %x, i64* %y_8 ; CHECK-DAG: NoAlias: i32* %x, i64* %y_8
; CHECK-DAG: MustAlias: %struct* %y_12, i32* %y ; CHECK-DAG: MustAlias: i32* %y, %struct* %y_12
; CHECK-DAG: MustAlias: i32* %y, i64* %y_8 ; CHECK-DAG: MustAlias: i32* %y, i64* %y_8
; CHECK-DAG: MustAlias: i32* %y, i80* %y_10 ; CHECK-DAG: MustAlias: i32* %y, i80* %y_10
define void @test_simple(%struct* %st, i64 %i, i64 %j, i64 %k) { define void @test_simple(%struct* %st, i64 %i, i64 %j, i64 %k) {
%x = getelementptr inbounds %struct, %struct* %st, i64 %i, i32 0 %x = getelementptr inbounds %struct, %struct* %st, i64 %i, i32 0
%y = getelementptr inbounds %struct, %struct* %st, i64 %j, i32 1 %y = getelementptr inbounds %struct, %struct* %st, i64 %j, i32 1
%sta = call %struct* @func2(%struct* %st) %sta = call %struct* @func2(%struct* %st)
%z = getelementptr inbounds %struct, %struct* %sta, i64 %k, i32 2 %z = getelementptr inbounds %struct, %struct* %sta, i64 %k, i32 2
%y_12 = bitcast i32* %y to %struct* %y_12 = bitcast i32* %y to %struct*
%y_10 = bitcast i32* %y to i80* %y_10 = bitcast i32* %y to i80*
%ya = call i32* @func1(i32* %y) %ya = call i32* @func1(i32* %y)
%y_8 = bitcast i32* %ya to i64* %y_8 = bitcast i32* %ya to i64*
load %struct, %struct* %st
load %struct, %struct* %sta
load i32, i32* %x
load i32, i32* %y
load i32, i32* %z
load %struct, %struct* %y_12
load i80, i80* %y_10
load i64, i64* %y_8
ret void ret void
} }
declare i32* @func1(i32* returned) nounwind declare i32* @func1(i32* returned) nounwind
declare %struct* @func2(%struct* returned) nounwind declare %struct* @func2(%struct* returned) nounwind

llvm/test/Analysis/BasicAA/sequential-gep.ll

; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; CHECK: Function: t1 ; CHECK: Function: t1
; CHECK: NoAlias: i32* %gep1, i32* %gep2 ; CHECK: NoAlias: i32* %gep1, i32* %gep2
define void @t1([8 x i32]* %p, i32 %addend, i32* %q) { define void @t1([8 x i32]* %p, i32 %addend, i32* %q) {
%knownnonzero = load i32, i32* %q, !range !0 %knownnonzero = load i32, i32* %q, !range !0
%add = add nsw nuw i32 %addend, %knownnonzero %add = add nsw nuw i32 %addend, %knownnonzero
%gep1 = getelementptr [8 x i32], [8 x i32]* %p, i32 2, i32 %addend %gep1 = getelementptr [8 x i32], [8 x i32]* %p, i32 2, i32 %addend
%gep2 = getelementptr [8 x i32], [8 x i32]* %p, i32 2, i32 %add %gep2 = getelementptr [8 x i32], [8 x i32]* %p, i32 2, i32 %add
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: t2 ; CHECK: Function: t2
; CHECK: MayAlias: i32* %gep1, i32* %gep2 ; CHECK: MayAlias: i32* %gep1, i32* %gep2
define void @t2([8 x i32]* %p, i32 %addend, i32* %q) { define void @t2([8 x i32]* %p, i32 %addend, i32* %q) {
%knownnonzero = load i32, i32* %q, !range !0 %knownnonzero = load i32, i32* %q, !range !0
%add = add nsw nuw i32 %addend, %knownnonzero %add = add nsw nuw i32 %addend, %knownnonzero
%gep1 = getelementptr [8 x i32], [8 x i32]* %p, i32 1, i32 %addend %gep1 = getelementptr [8 x i32], [8 x i32]* %p, i32 1, i32 %addend
%gep2 = getelementptr [8 x i32], [8 x i32]* %p, i32 0, i32 %add %gep2 = getelementptr [8 x i32], [8 x i32]* %p, i32 0, i32 %add
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: t3 ; CHECK: Function: t3
; CHECK: MustAlias: i32* %gep1, i32* %gep2 ; CHECK: MustAlias: i32* %gep1, i32* %gep2
define void @t3([8 x i32]* %p, i32 %addend, i32* %q) { define void @t3([8 x i32]* %p, i32 %addend, i32* %q) {
%knownnonzero = load i32, i32* %q, !range !0 %knownnonzero = load i32, i32* %q, !range !0
%add = add nsw nuw i32 %addend, %knownnonzero %add = add nsw nuw i32 %addend, %knownnonzero
%gep1 = getelementptr [8 x i32], [8 x i32]* %p, i32 0, i32 %add %gep1 = getelementptr [8 x i32], [8 x i32]* %p, i32 0, i32 %add
%gep2 = getelementptr [8 x i32], [8 x i32]* %p, i32 0, i32 %add %gep2 = getelementptr [8 x i32], [8 x i32]* %p, i32 0, i32 %add
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: t4 ; CHECK: Function: t4
; CHECK: MayAlias: i32* %gep1, i32* %gep2 ; CHECK: MayAlias: i32* %gep1, i32* %gep2
define void @t4([8 x i32]* %p, i32 %addend, i32* %q) { define void @t4([8 x i32]* %p, i32 %addend, i32* %q) {
%knownnonzero = load i32, i32* %q, !range !0 %knownnonzero = load i32, i32* %q, !range !0
%add = add nsw nuw i32 %addend, %knownnonzero %add = add nsw nuw i32 %addend, %knownnonzero
%gep1 = getelementptr [8 x i32], [8 x i32]* %p, i32 1, i32 %addend %gep1 = getelementptr [8 x i32], [8 x i32]* %p, i32 1, i32 %addend
%gep2 = getelementptr [8 x i32], [8 x i32]* %p, i32 %add, i32 %add %gep2 = getelementptr [8 x i32], [8 x i32]* %p, i32 %add, i32 %add
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK: Function: t5 ; CHECK: Function: t5
; CHECK: MayAlias: i32* %gep2, i64* %bc ; CHECK: MayAlias: i64* %bc, i32* %gep2
define void @t5([8 x i32]* %p, i32 %addend, i32* %q) { define void @t5([8 x i32]* %p, i32 %addend, i32* %q) {
%knownnonzero = load i32, i32* %q, !range !0 %knownnonzero = load i32, i32* %q, !range !0
%add = add nsw nuw i32 %addend, %knownnonzero %add = add nsw nuw i32 %addend, %knownnonzero
%gep1 = getelementptr [8 x i32], [8 x i32]* %p, i32 2, i32 %addend %gep1 = getelementptr [8 x i32], [8 x i32]* %p, i32 2, i32 %addend
%gep2 = getelementptr [8 x i32], [8 x i32]* %p, i32 2, i32 %add %gep2 = getelementptr [8 x i32], [8 x i32]* %p, i32 2, i32 %add
%bc = bitcast i32* %gep1 to i64* %bc = bitcast i32* %gep1 to i64*
load i32, i32* %gep2
load i64, i64* %bc
ret void ret void
} }
; CHECK-LABEL: Function: add_non_zero_simple ; CHECK-LABEL: Function: add_non_zero_simple
; CHECK: NoAlias: i32* %gep1, i32* %gep2 ; CHECK: NoAlias: i32* %gep1, i32* %gep2
define void @add_non_zero_simple(i32* %p, i32 %addend, i32* %q) { define void @add_non_zero_simple(i32* %p, i32 %addend, i32* %q) {
%knownnonzero = load i32, i32* %q, !range !0 %knownnonzero = load i32, i32* %q, !range !0
%add = add i32 %addend, %knownnonzero %add = add i32 %addend, %knownnonzero
%gep1 = getelementptr i32, i32* %p, i32 %addend %gep1 = getelementptr i32, i32* %p, i32 %addend
%gep2 = getelementptr i32, i32* %p, i32 %add %gep2 = getelementptr i32, i32* %p, i32 %add
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK-LABEL: Function: add_non_zero_different_scales ; CHECK-LABEL: Function: add_non_zero_different_scales
; CHECK: MayAlias: i16* %gep2, i32* %gep1 ; CHECK: MayAlias: i32* %gep1, i16* %gep2
define void @add_non_zero_different_scales(i32* %p, i32 %addend, i32* %q) { define void @add_non_zero_different_scales(i32* %p, i32 %addend, i32* %q) {
%knownnonzero = load i32, i32* %q, !range !0 %knownnonzero = load i32, i32* %q, !range !0
%add = add i32 %addend, %knownnonzero %add = add i32 %addend, %knownnonzero
%p16 = bitcast i32* %p to i16* %p16 = bitcast i32* %p to i16*
%gep1 = getelementptr i32, i32* %p, i32 %addend %gep1 = getelementptr i32, i32* %p, i32 %addend
%gep2 = getelementptr i16, i16* %p16, i32 %add %gep2 = getelementptr i16, i16* %p16, i32 %add
load i32, i32* %gep1
load i16, i16* %gep2
ret void ret void
} }
; CHECK-LABEL: Function: add_non_zero_different_sizes ; CHECK-LABEL: Function: add_non_zero_different_sizes
; CHECK: NoAlias: i16* %gep1.16, i32* %gep2 ; CHECK: NoAlias: i16* %gep1.16, i32* %gep2
; CHECK: NoAlias: i16* %gep2.16, i32* %gep1 ; CHECK: NoAlias: i32* %gep1, i16* %gep2.16
; CHECK: NoAlias: i16* %gep1.16, i16* %gep2.16 ; CHECK: NoAlias: i16* %gep1.16, i16* %gep2.16
; CHECK: MayAlias: i32* %gep2, i64* %gep1.64 ; CHECK: MayAlias: i64* %gep1.64, i32* %gep2
; CHECK: MayAlias: i16* %gep2.16, i64* %gep1.64 ; CHECK: MayAlias: i64* %gep1.64, i16* %gep2.16
; CHECK: MayAlias: i32* %gep1, i64* %gep2.64 ; CHECK: MayAlias: i32* %gep1, i64* %gep2.64
; CHECK: MayAlias: i16* %gep1.16, i64* %gep2.64 ; CHECK: MayAlias: i16* %gep1.16, i64* %gep2.64
; CHECK: MayAlias: i64* %gep1.64, i64* %gep2.64 ; CHECK: MayAlias: i64* %gep1.64, i64* %gep2.64
define void @add_non_zero_different_sizes(i32* %p, i32 %addend, i32* %q) { define void @add_non_zero_different_sizes(i32* %p, i32 %addend, i32* %q) {
%knownnonzero = load i32, i32* %q, !range !0 %knownnonzero = load i32, i32* %q, !range !0
%add = add i32 %addend, %knownnonzero %add = add i32 %addend, %knownnonzero
%gep1 = getelementptr i32, i32* %p, i32 %addend %gep1 = getelementptr i32, i32* %p, i32 %addend
%gep2 = getelementptr i32, i32* %p, i32 %add %gep2 = getelementptr i32, i32* %p, i32 %add
%gep1.16 = bitcast i32* %gep1 to i16* %gep1.16 = bitcast i32* %gep1 to i16*
%gep2.16 = bitcast i32* %gep2 to i16* %gep2.16 = bitcast i32* %gep2 to i16*
%gep1.64 = bitcast i32* %gep1 to i64* %gep1.64 = bitcast i32* %gep1 to i64*
%gep2.64 = bitcast i32* %gep2 to i64* %gep2.64 = bitcast i32* %gep2 to i64*
load i32, i32* %gep1
load i32, i32* %gep2
load i16, i16* %gep1.16
load i16, i16* %gep2.16
load i64, i64* %gep1.64
load i64, i64* %gep2.64
ret void ret void
} }
; CHECK-LABEL: add_non_zero_with_offset ; CHECK-LABEL: add_non_zero_with_offset
; MayAlias: i32* %gep1, i32* %gep2 ; MayAlias: i32* %gep1, i32* %gep2
; NoAlias: i16* %gep1.16, i16* %gep2.16 ; NoAlias: i16* %gep1.16, i16* %gep2.16
define void @add_non_zero_with_offset(i32* %p, i32 %addend, i32* %q) { define void @add_non_zero_with_offset(i32* %p, i32 %addend, i32* %q) {
%knownnonzero = load i32, i32* %q, !range !0 %knownnonzero = load i32, i32* %q, !range !0
%add = add i32 %addend, %knownnonzero %add = add i32 %addend, %knownnonzero
%p.8 = bitcast i32* %p to i8* %p.8 = bitcast i32* %p to i8*
%p.off.8 = getelementptr i8, i8* %p.8, i32 2 %p.off.8 = getelementptr i8, i8* %p.8, i32 2
%p.off = bitcast i8* %p.off.8 to i32* %p.off = bitcast i8* %p.off.8 to i32*
%gep1 = getelementptr i32, i32* %p.off, i32 %addend %gep1 = getelementptr i32, i32* %p.off, i32 %addend
%gep2 = getelementptr i32, i32* %p, i32 %add %gep2 = getelementptr i32, i32* %p, i32 %add
%gep1.16 = bitcast i32* %gep1 to i16* %gep1.16 = bitcast i32* %gep1 to i16*
%gep2.16 = bitcast i32* %gep2 to i16* %gep2.16 = bitcast i32* %gep2 to i16*
load i32, i32* %gep1
load i32, i32* %gep2
load i16, i16* %gep1.16
load i16, i16* %gep2.16
ret void ret void
} }
; CHECK-LABEL: Function: add_non_zero_assume ; CHECK-LABEL: Function: add_non_zero_assume
; CHECK: NoAlias: i32* %gep1, i32* %gep2 ; CHECK: NoAlias: i32* %gep1, i32* %gep2
define void @add_non_zero_assume(i32* %p, i32 %addend, i32 %knownnonzero) { define void @add_non_zero_assume(i32* %p, i32 %addend, i32 %knownnonzero) {
%cmp = icmp ne i32 %knownnonzero, 0 %cmp = icmp ne i32 %knownnonzero, 0
call void @llvm.assume(i1 %cmp) call void @llvm.assume(i1 %cmp)
%add = add i32 %addend, %knownnonzero %add = add i32 %addend, %knownnonzero
%gep1 = getelementptr i32, i32* %p, i32 %addend %gep1 = getelementptr i32, i32* %p, i32 %addend
%gep2 = getelementptr i32, i32* %p, i32 %add %gep2 = getelementptr i32, i32* %p, i32 %add
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK-LABEL: non_zero_index_simple ; CHECK-LABEL: non_zero_index_simple
; CHECK: NoAlias: i32* %gep, i32* %p ; CHECK: NoAlias: i32* %gep, i32* %p
; CHECK: NoAlias: i16* %gep.16, i32* %p ; CHECK: NoAlias: i16* %gep.16, i32* %p
; CHECK: MayAlias: i32* %p, i64* %gep.64 ; CHECK: MayAlias: i64* %gep.64, i32* %p
define void @non_zero_index_simple(i32* %p, i32* %q) { define void @non_zero_index_simple(i32* %p, i32* %q) {
%knownnonzero = load i32, i32* %q, !range !0 %knownnonzero = load i32, i32* %q, !range !0
%gep = getelementptr i32, i32* %p, i32 %knownnonzero %gep = getelementptr i32, i32* %p, i32 %knownnonzero
%gep.16 = bitcast i32* %gep to i16* %gep.16 = bitcast i32* %gep to i16*
%gep.64 = bitcast i32* %gep to i64* %gep.64 = bitcast i32* %gep to i64*
load i32, i32* %p
load i32, i32* %gep
load i16, i16* %gep.16
load i64, i64* %gep.64
ret void ret void
} }
; CHECK-LABEL: non_zero_index_with_offset ; CHECK-LABEL: non_zero_index_with_offset
; CHECK: NoAlias: i32* %gep, i32* %p ; CHECK: MayAlias: i32* %gep, i32* %p
; CHECK: NoAlias: i16* %gep.16, i32* %p ; CHECK: NoAlias: i16* %gep.16, i32* %p
define void @non_zero_index_with_offset(i32* %p, i32* %q) { define void @non_zero_index_with_offset(i32* %p, i32* %q) {
%knownnonzero = load i32, i32* %q, !range !0 %knownnonzero = load i32, i32* %q, !range !0
%p.8 = bitcast i32* %p to i8* %p.8 = bitcast i32* %p to i8*
%p.off.8 = getelementptr i8, i8* %p.8, i32 2 %p.off.8 = getelementptr i8, i8* %p.8, i32 2
%p.off = bitcast i8* %p.off.8 to i32* %p.off = bitcast i8* %p.off.8 to i32*
%gep = getelementptr i32, i32* %p.off, i32 %knownnonzero %gep = getelementptr i32, i32* %p.off, i32 %knownnonzero
%gep.16 = bitcast i32* %gep to i16* %gep.16 = bitcast i32* %gep to i16*
load i32, i32* %p
load i32, i32* %gep
load i16, i16* %gep.16
ret void ret void
} }
; CHECK-LABEL: non_zero_index_assume ; CHECK-LABEL: non_zero_index_assume
; CHECK: NoAlias: i32* %gep, i32* %p ; CHECK: NoAlias: i32* %gep, i32* %p
define void @non_zero_index_assume(i32* %p, i32 %knownnonzero) { define void @non_zero_index_assume(i32* %p, i32 %knownnonzero) {
%cmp = icmp ne i32 %knownnonzero, 0 %cmp = icmp ne i32 %knownnonzero, 0
call void @llvm.assume(i1 %cmp) call void @llvm.assume(i1 %cmp)
%gep = getelementptr i32, i32* %p, i32 %knownnonzero %gep = getelementptr i32, i32* %p, i32 %knownnonzero
load i32, i32* %p
load i32, i32* %gep
ret void ret void
} }
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
!0 = !{ i32 1, i32 0 } !0 = !{ i32 1, i32 0 }

llvm/test/Analysis/BasicAA/struct-geps.ll

Show All 9 Lines
; CHECK-DAG: MayAlias: %struct* %st, i32* %y ; CHECK-DAG: MayAlias: %struct* %st, i32* %y
; CHECK-DAG: MayAlias: %struct* %st, i32* %z ; CHECK-DAG: MayAlias: %struct* %st, i32* %z
; CHECK-DAG: NoAlias: i32* %x, i32* %y ; CHECK-DAG: NoAlias: i32* %x, i32* %y
; CHECK-DAG: NoAlias: i32* %x, i32* %z ; CHECK-DAG: NoAlias: i32* %x, i32* %z
; CHECK-DAG: NoAlias: i32* %y, i32* %z ; CHECK-DAG: NoAlias: i32* %y, i32* %z
; CHECK-DAG: MayAlias: %struct* %st, %struct* %y_12 ; CHECK-DAG: MayAlias: %struct* %st, %struct* %y_12
; CHECK-DAG: MayAlias: %struct* %y_12, i32* %x ; CHECK-DAG: MayAlias: i32* %x, %struct* %y_12
; CHECK-DAG: MayAlias: i32* %x, i80* %y_10 ; CHECK-DAG: MayAlias: i32* %x, i80* %y_10
; CHECK-DAG: MayAlias: %struct* %st, i64* %y_8 ; CHECK-DAG: MayAlias: %struct* %st, i64* %y_8
; CHECK-DAG: MayAlias: i32* %z, i64* %y_8 ; CHECK-DAG: MayAlias: i64* %y_8, i32* %z
; CHECK-DAG: NoAlias: i32* %x, i64* %y_8 ; CHECK-DAG: NoAlias: i32* %x, i64* %y_8
; CHECK-DAG: MustAlias: %struct* %y_12, i32* %y ; CHECK-DAG: MustAlias: i32* %y, %struct* %y_12
; CHECK-DAG: MustAlias: i32* %y, i64* %y_8 ; CHECK-DAG: MustAlias: i32* %y, i64* %y_8
; CHECK-DAG: MustAlias: i32* %y, i80* %y_10 ; CHECK-DAG: MustAlias: i32* %y, i80* %y_10
define void @test_simple(%struct* %st, i64 %i, i64 %j, i64 %k) { define void @test_simple(%struct* %st, i64 %i, i64 %j, i64 %k) {
%x = getelementptr inbounds %struct, %struct* %st, i64 %i, i32 0 %x = getelementptr inbounds %struct, %struct* %st, i64 %i, i32 0
%y = getelementptr inbounds %struct, %struct* %st, i64 %j, i32 1 %y = getelementptr inbounds %struct, %struct* %st, i64 %j, i32 1
%z = getelementptr inbounds %struct, %struct* %st, i64 %k, i32 2 %z = getelementptr inbounds %struct, %struct* %st, i64 %k, i32 2
%y_12 = bitcast i32* %y to %struct* %y_12 = bitcast i32* %y to %struct*
%y_10 = bitcast i32* %y to i80* %y_10 = bitcast i32* %y to i80*
%y_8 = bitcast i32* %y to i64* %y_8 = bitcast i32* %y to i64*
load %struct, %struct* %st
load i32, i32* %x
load i32, i32* %y
load i32, i32* %z
load %struct, %struct* %y_12
load i80, i80* %y_10
load i64, i64* %y_8
ret void ret void
} }
; As the GEP is not inbounds, these pointers may alias due to overflow. ; As the GEP is not inbounds, these pointers may alias due to overflow.
; CHECK-LABEL: test_not_inbounds ; CHECK-LABEL: test_not_inbounds
; CHECK: MayAlias: i32* %x, i32* %y ; CHECK: MayAlias: i32* %x, i32* %y
define void @test_not_inbounds(%struct* %st, i64 %i, i64 %j, i64 %k) { define void @test_not_inbounds(%struct* %st, i64 %i, i64 %j, i64 %k) {
%x = getelementptr %struct, %struct* %st, i64 %i, i32 0 %x = getelementptr %struct, %struct* %st, i64 %i, i32 0
%y = getelementptr %struct, %struct* %st, i64 %j, i32 1 %y = getelementptr %struct, %struct* %st, i64 %j, i32 1
load i32, i32* %x
load i32, i32* %y
ret void ret void
} }
; CHECK-LABEL: test_in_array ; CHECK-LABEL: test_in_array
; CHECK-DAG: MayAlias: [1 x %struct]* %st, i32* %x ; CHECK-DAG: MayAlias: [1 x %struct]* %st, i32* %x
; CHECK-DAG: MayAlias: [1 x %struct]* %st, i32* %y ; CHECK-DAG: MayAlias: [1 x %struct]* %st, i32* %y
; CHECK-DAG: MayAlias: [1 x %struct]* %st, i32* %z ; CHECK-DAG: MayAlias: [1 x %struct]* %st, i32* %z
; CHECK-DAG: NoAlias: i32* %x, i32* %y ; CHECK-DAG: NoAlias: i32* %x, i32* %y
; CHECK-DAG: NoAlias: i32* %x, i32* %z ; CHECK-DAG: NoAlias: i32* %x, i32* %z
; CHECK-DAG: NoAlias: i32* %y, i32* %z ; CHECK-DAG: NoAlias: i32* %y, i32* %z
; CHECK-DAG: MayAlias: %struct* %y_12, [1 x %struct]* %st ; CHECK-DAG: MayAlias: [1 x %struct]* %st, %struct* %y_12
; CHECK-DAG: MayAlias: %struct* %y_12, i32* %x ; CHECK-DAG: MayAlias: i32* %x, %struct* %y_12
; CHECK-DAG: MayAlias: i32* %x, i80* %y_10 ; CHECK-DAG: MayAlias: i32* %x, i80* %y_10
; CHECK-DAG: MayAlias: [1 x %struct]* %st, i64* %y_8 ; CHECK-DAG: MayAlias: [1 x %struct]* %st, i64* %y_8
; CHECK-DAG: MayAlias: i32* %z, i64* %y_8 ; CHECK-DAG: MayAlias: i64* %y_8, i32* %z
; CHECK-DAG: NoAlias: i32* %x, i64* %y_8 ; CHECK-DAG: NoAlias: i32* %x, i64* %y_8
; CHECK-DAG: MustAlias: %struct* %y_12, i32* %y ; CHECK-DAG: MustAlias: i32* %y, %struct* %y_12
; CHECK-DAG: MustAlias: i32* %y, i64* %y_8 ; CHECK-DAG: MustAlias: i32* %y, i64* %y_8
; CHECK-DAG: MustAlias: i32* %y, i80* %y_10 ; CHECK-DAG: MustAlias: i32* %y, i80* %y_10
define void @test_in_array([1 x %struct]* %st, i64 %i, i64 %j, i64 %k, i64 %i1, i64 %j1, i64 %k1) { define void @test_in_array([1 x %struct]* %st, i64 %i, i64 %j, i64 %k, i64 %i1, i64 %j1, i64 %k1) {
%x = getelementptr inbounds [1 x %struct], [1 x %struct]* %st, i64 %i, i64 %i1, i32 0 %x = getelementptr inbounds [1 x %struct], [1 x %struct]* %st, i64 %i, i64 %i1, i32 0
%y = getelementptr inbounds [1 x %struct], [1 x %struct]* %st, i64 %j, i64 %j1, i32 1 %y = getelementptr inbounds [1 x %struct], [1 x %struct]* %st, i64 %j, i64 %j1, i32 1
%z = getelementptr inbounds [1 x %struct], [1 x %struct]* %st, i64 %k, i64 %k1, i32 2 %z = getelementptr inbounds [1 x %struct], [1 x %struct]* %st, i64 %k, i64 %k1, i32 2
%y_12 = bitcast i32* %y to %struct* %y_12 = bitcast i32* %y to %struct*
%y_10 = bitcast i32* %y to i80* %y_10 = bitcast i32* %y to i80*
%y_8 = bitcast i32* %y to i64* %y_8 = bitcast i32* %y to i64*
load [1 x %struct], [1 x %struct]* %st
load i32, i32* %x
load i32, i32* %y
load i32, i32* %z
load %struct, %struct* %y_12
load i80, i80* %y_10
load i64, i64* %y_8
ret void ret void
} }
; CHECK-LABEL: test_in_3d_array ; CHECK-LABEL: test_in_3d_array
; CHECK-DAG: MayAlias: [1 x [1 x [1 x %struct]]]* %st, i32* %x ; CHECK-DAG: MayAlias: [1 x [1 x [1 x %struct]]]* %st, i32* %x
; CHECK-DAG: MayAlias: [1 x [1 x [1 x %struct]]]* %st, i32* %y ; CHECK-DAG: MayAlias: [1 x [1 x [1 x %struct]]]* %st, i32* %y
; CHECK-DAG: MayAlias: [1 x [1 x [1 x %struct]]]* %st, i32* %z ; CHECK-DAG: MayAlias: [1 x [1 x [1 x %struct]]]* %st, i32* %z
; CHECK-DAG: NoAlias: i32* %x, i32* %y ; CHECK-DAG: NoAlias: i32* %x, i32* %y
; CHECK-DAG: NoAlias: i32* %x, i32* %z ; CHECK-DAG: NoAlias: i32* %x, i32* %z
; CHECK-DAG: NoAlias: i32* %y, i32* %z ; CHECK-DAG: NoAlias: i32* %y, i32* %z
; CHECK-DAG: MayAlias: %struct* %y_12, [1 x [1 x [1 x %struct]]]* %st ; CHECK-DAG: MayAlias: [1 x [1 x [1 x %struct]]]* %st, %struct* %y_12
; CHECK-DAG: MayAlias: %struct* %y_12, i32* %x ; CHECK-DAG: MayAlias: i32* %x, %struct* %y_12
; CHECK-DAG: MayAlias: i32* %x, i80* %y_10 ; CHECK-DAG: MayAlias: i32* %x, i80* %y_10
; CHECK-DAG: MayAlias: [1 x [1 x [1 x %struct]]]* %st, i64* %y_8 ; CHECK-DAG: MayAlias: [1 x [1 x [1 x %struct]]]* %st, i64* %y_8
; CHECK-DAG: MayAlias: i32* %z, i64* %y_8 ; CHECK-DAG: MayAlias: i64* %y_8, i32* %z
; CHECK-DAG: NoAlias: i32* %x, i64* %y_8 ; CHECK-DAG: NoAlias: i32* %x, i64* %y_8
; CHECK-DAG: MustAlias: %struct* %y_12, i32* %y ; CHECK-DAG: MustAlias: i32* %y, %struct* %y_12
; CHECK-DAG: MustAlias: i32* %y, i64* %y_8 ; CHECK-DAG: MustAlias: i32* %y, i64* %y_8
; CHECK-DAG: MustAlias: i32* %y, i80* %y_10 ; CHECK-DAG: MustAlias: i32* %y, i80* %y_10
define void @test_in_3d_array([1 x [1 x [1 x %struct]]]* %st, i64 %i, i64 %j, i64 %k, i64 %i1, i64 %j1, i64 %k1, i64 %i2, i64 %j2, i64 %k2, i64 %i3, i64 %j3, i64 %k3) { define void @test_in_3d_array([1 x [1 x [1 x %struct]]]* %st, i64 %i, i64 %j, i64 %k, i64 %i1, i64 %j1, i64 %k1, i64 %i2, i64 %j2, i64 %k2, i64 %i3, i64 %j3, i64 %k3) {
%x = getelementptr inbounds [1 x [1 x [1 x %struct]]], [1 x [1 x [1 x %struct]]]* %st, i64 %i, i64 %i1, i64 %i2, i64 %i3, i32 0 %x = getelementptr inbounds [1 x [1 x [1 x %struct]]], [1 x [1 x [1 x %struct]]]* %st, i64 %i, i64 %i1, i64 %i2, i64 %i3, i32 0
%y = getelementptr inbounds [1 x [1 x [1 x %struct]]], [1 x [1 x [1 x %struct]]]* %st, i64 %j, i64 %j1, i64 %j2, i64 %j3, i32 1 %y = getelementptr inbounds [1 x [1 x [1 x %struct]]], [1 x [1 x [1 x %struct]]]* %st, i64 %j, i64 %j1, i64 %j2, i64 %j3, i32 1
%z = getelementptr inbounds [1 x [1 x [1 x %struct]]], [1 x [1 x [1 x %struct]]]* %st, i64 %k, i64 %k1, i64 %k2, i64 %k3, i32 2 %z = getelementptr inbounds [1 x [1 x [1 x %struct]]], [1 x [1 x [1 x %struct]]]* %st, i64 %k, i64 %k1, i64 %k2, i64 %k3, i32 2
%y_12 = bitcast i32* %y to %struct* %y_12 = bitcast i32* %y to %struct*
%y_10 = bitcast i32* %y to i80* %y_10 = bitcast i32* %y to i80*
%y_8 = bitcast i32* %y to i64* %y_8 = bitcast i32* %y to i64*
load [1 x [1 x [1 x %struct]]], [1 x [1 x [1 x %struct]]]* %st
load i32, i32* %x
load i32, i32* %y
load i32, i32* %z
load %struct, %struct* %y_12
load i80, i80* %y_10
load i64, i64* %y_8
ret void ret void
} }
; CHECK-LABEL: test_same_underlying_object_same_indices ; CHECK-LABEL: test_same_underlying_object_same_indices
; CHECK-DAG: NoAlias: i32* %x, i32* %x2 ; CHECK-DAG: NoAlias: i32* %x, i32* %x2
; CHECK-DAG: NoAlias: i32* %y, i32* %y2 ; CHECK-DAG: NoAlias: i32* %y, i32* %y2
; CHECK-DAG: NoAlias: i32* %z, i32* %z2 ; CHECK-DAG: NoAlias: i32* %z, i32* %z2
Show All 10 Lines
define void @test_same_underlying_object_same_indices(%struct* %st, i64 %i, i64 %j, i64 %k) { define void @test_same_underlying_object_same_indices(%struct* %st, i64 %i, i64 %j, i64 %k) {
%st2 = getelementptr inbounds %struct, %struct* %st, i32 10 %st2 = getelementptr inbounds %struct, %struct* %st, i32 10
%x2 = getelementptr inbounds %struct, %struct* %st2, i64 %i, i32 0 %x2 = getelementptr inbounds %struct, %struct* %st2, i64 %i, i32 0
%y2 = getelementptr inbounds %struct, %struct* %st2, i64 %j, i32 1 %y2 = getelementptr inbounds %struct, %struct* %st2, i64 %j, i32 1
%z2 = getelementptr inbounds %struct, %struct* %st2, i64 %k, i32 2 %z2 = getelementptr inbounds %struct, %struct* %st2, i64 %k, i32 2
%x = getelementptr inbounds %struct, %struct* %st, i64 %i, i32 0 %x = getelementptr inbounds %struct, %struct* %st, i64 %i, i32 0
%y = getelementptr inbounds %struct, %struct* %st, i64 %j, i32 1 %y = getelementptr inbounds %struct, %struct* %st, i64 %j, i32 1
%z = getelementptr inbounds %struct, %struct* %st, i64 %k, i32 2 %z = getelementptr inbounds %struct, %struct* %st, i64 %k, i32 2
load i32, i32* %x
load i32, i32* %y
load i32, i32* %z
load i32, i32* %x2
load i32, i32* %y2
load i32, i32* %z2
ret void ret void
} }
; CHECK-LABEL: test_same_underlying_object_different_indices ; CHECK-LABEL: test_same_underlying_object_different_indices
; CHECK-DAG: MayAlias: i32* %x, i32* %x2 ; CHECK-DAG: MayAlias: i32* %x, i32* %x2
; CHECK-DAG: MayAlias: i32* %y, i32* %y2 ; CHECK-DAG: MayAlias: i32* %y, i32* %y2
; CHECK-DAG: MayAlias: i32* %z, i32* %z2 ; CHECK-DAG: MayAlias: i32* %z, i32* %z2
Show All 10 Lines
define void @test_same_underlying_object_different_indices(%struct* %st, i64 %i1, i64 %j1, i64 %k1, i64 %i2, i64 %k2, i64 %j2) { define void @test_same_underlying_object_different_indices(%struct* %st, i64 %i1, i64 %j1, i64 %k1, i64 %i2, i64 %k2, i64 %j2) {
%st2 = getelementptr inbounds %struct, %struct* %st, i32 10 %st2 = getelementptr inbounds %struct, %struct* %st, i32 10
%x2 = getelementptr inbounds %struct, %struct* %st2, i64 %i2, i32 0 %x2 = getelementptr inbounds %struct, %struct* %st2, i64 %i2, i32 0
%y2 = getelementptr inbounds %struct, %struct* %st2, i64 %j2, i32 1 %y2 = getelementptr inbounds %struct, %struct* %st2, i64 %j2, i32 1
%z2 = getelementptr inbounds %struct, %struct* %st2, i64 %k2, i32 2 %z2 = getelementptr inbounds %struct, %struct* %st2, i64 %k2, i32 2
%x = getelementptr inbounds %struct, %struct* %st, i64 %i1, i32 0 %x = getelementptr inbounds %struct, %struct* %st, i64 %i1, i32 0
%y = getelementptr inbounds %struct, %struct* %st, i64 %j1, i32 1 %y = getelementptr inbounds %struct, %struct* %st, i64 %j1, i32 1
%z = getelementptr inbounds %struct, %struct* %st, i64 %k1, i32 2 %z = getelementptr inbounds %struct, %struct* %st, i64 %k1, i32 2
load i32, i32* %x
load i32, i32* %y
load i32, i32* %z
load i32, i32* %x2
load i32, i32* %y2
load i32, i32* %z2
ret void ret void
} }
%struct2 = type { [1 x { i32, i32 }], [2 x { i32 }] } %struct2 = type { [1 x { i32, i32 }], [2 x { i32 }] }
; CHECK-LABEL: test_struct_in_array ; CHECK-LABEL: test_struct_in_array
; CHECK-DAG: MustAlias: i32* %x, i32* %y ; CHECK-DAG: MustAlias: i32* %x, i32* %y
define void @test_struct_in_array(%struct2* %st, i64 %i, i64 %j, i64 %k) { define void @test_struct_in_array(%struct2* %st, i64 %i, i64 %j, i64 %k) {
%x = getelementptr inbounds %struct2, %struct2* %st, i32 0, i32 1, i32 1, i32 0 %x = getelementptr inbounds %struct2, %struct2* %st, i32 0, i32 1, i32 1, i32 0
%y = getelementptr inbounds %struct2, %struct2* %st, i32 0, i32 0, i32 1, i32 1 %y = getelementptr inbounds %struct2, %struct2* %st, i32 0, i32 0, i32 1, i32 1
load i32, i32* %x
load i32, i32* %y
ret void ret void
} }
; PR27418 - Treat GEP indices with the same value but different types the same ; PR27418 - Treat GEP indices with the same value but different types the same
; CHECK-LABEL: test_different_index_types ; CHECK-LABEL: test_different_index_types
; CHECK: MustAlias: i16* %tmp1, i16* %tmp2 ; CHECK: MustAlias: i16* %tmp1, i16* %tmp2
define void @test_different_index_types([2 x i16]* %arr) { define void @test_different_index_types([2 x i16]* %arr) {
%tmp1 = getelementptr inbounds [2 x i16], [2 x i16]* %arr, i16 0, i32 1 %tmp1 = getelementptr inbounds [2 x i16], [2 x i16]* %arr, i16 0, i32 1
%tmp2 = getelementptr inbounds [2 x i16], [2 x i16]* %arr, i16 0, i16 1 %tmp2 = getelementptr inbounds [2 x i16], [2 x i16]* %arr, i16 0, i16 1
load i16, i16* %tmp1
load i16, i16* %tmp2
ret void ret void
} }

llvm/test/Analysis/BasicAA/vscale.ll

; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; getelementptr ; getelementptr
; CHECK-LABEL: gep_alloca_const_offset_1 ; CHECK-LABEL: gep_alloca_const_offset_1
; CHECK-DAG: MustAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep1 ; CHECK-DAG: MustAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep1
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep2 ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep2
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %gep2 ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %gep2
define void @gep_alloca_const_offset_1() { define void @gep_alloca_const_offset_1() {
%alloc = alloca <vscale x 4 x i32> %alloc = alloca <vscale x 4 x i32>
%gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 0 %gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 0
%gep2 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 1 %gep2 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 1
load <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc
load <vscale x 4 x i32>, <vscale x 4 x i32>* %gep1
load <vscale x 4 x i32>, <vscale x 4 x i32>* %gep2
ret void ret void
} }
; CHECK-LABEL: gep_alloca_const_offset_2 ; CHECK-LABEL: gep_alloca_const_offset_2
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep1 ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep1
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep2 ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep2
; TODO: AliasResult for gep1,gep2 can be improved as MustAlias ; TODO: AliasResult for gep1,gep2 can be improved as MustAlias
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %gep2 ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %gep2
define void @gep_alloca_const_offset_2() { define void @gep_alloca_const_offset_2() {
%alloc = alloca <vscale x 4 x i32> %alloc = alloca <vscale x 4 x i32>
%gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 1 %gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 1
%gep2 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 1 %gep2 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 1
load <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc
load <vscale x 4 x i32>, <vscale x 4 x i32>* %gep1
load <vscale x 4 x i32>, <vscale x 4 x i32>* %gep2
ret void ret void
} }
; CHECK-LABEL: gep_alloca_const_offset_3 ; CHECK-LABEL: gep_alloca_const_offset_3
; CHECK-DAG: MustAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep1 ; CHECK-DAG: MustAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep1
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %alloc, i32* %gep2 ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %alloc, i32* %gep2
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep1, i32* %gep2 ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep1, i32* %gep2
define void @gep_alloca_const_offset_3() { define void @gep_alloca_const_offset_3() {
%alloc = alloca <vscale x 4 x i32> %alloc = alloca <vscale x 4 x i32>
%gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 0 %gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 0
%gep2 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 0, i64 1 %gep2 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 0, i64 1
load <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc
load <vscale x 4 x i32>, <vscale x 4 x i32>* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK-LABEL: gep_alloca_const_offset_4 ; CHECK-LABEL: gep_alloca_const_offset_4
; CHECK-DAG: MustAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep1 ; CHECK-DAG: MustAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep1
; CHECK-DAG: MustAlias: <vscale x 4 x i32>* %alloc, i32* %gep2 ; CHECK-DAG: MustAlias: <vscale x 4 x i32>* %alloc, i32* %gep2
; CHECK-DAG: MustAlias: <vscale x 4 x i32>* %gep1, i32* %gep2 ; CHECK-DAG: MustAlias: <vscale x 4 x i32>* %gep1, i32* %gep2
define void @gep_alloca_const_offset_4() { define void @gep_alloca_const_offset_4() {
%alloc = alloca <vscale x 4 x i32> %alloc = alloca <vscale x 4 x i32>
%gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 0 %gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 0
%gep2 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 0, i64 0 %gep2 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 0, i64 0
load <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc
load <vscale x 4 x i32>, <vscale x 4 x i32>* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK-LABEL: gep_alloca_symbolic_offset ; CHECK-LABEL: gep_alloca_symbolic_offset
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep1 ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep1
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep2 ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %alloc, <vscale x 4 x i32>* %gep2
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %gep2 ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %gep2
define void @gep_alloca_symbolic_offset(i64 %idx1, i64 %idx2) { define void @gep_alloca_symbolic_offset(i64 %idx1, i64 %idx2) {
%alloc = alloca <vscale x 4 x i32> %alloc = alloca <vscale x 4 x i32>
%gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 %idx1 %gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 %idx1
%gep2 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 %idx2 %gep2 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc, i64 %idx2
load <vscale x 4 x i32>, <vscale x 4 x i32>* %alloc
load <vscale x 4 x i32>, <vscale x 4 x i32>* %gep1
load <vscale x 4 x i32>, <vscale x 4 x i32>* %gep2
ret void ret void
} }
; CHECK-LABEL: gep_same_base_const_offset ; CHECK-LABEL: gep_same_base_const_offset
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep1 ; CHECK-DAG: MayAlias: i32* %gep1, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep2 ; CHECK-DAG: MayAlias: i32* %gep2, <vscale x 4 x i32>* %p
; TODO: AliasResult for gep1,gep2 can be improved as NoAlias ; TODO: AliasResult for gep1,gep2 can be improved as NoAlias
; CHECK-DAG: MayAlias: i32* %gep1, i32* %gep2 ; CHECK-DAG: MayAlias: i32* %gep1, i32* %gep2
define void @gep_same_base_const_offset(<vscale x 4 x i32>* %p) { define void @gep_same_base_const_offset(<vscale x 4 x i32>* %p) {
%gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 1, i64 0 %gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 1, i64 0
%gep2 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 1, i64 1 %gep2 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 1, i64 1
load <vscale x 4 x i32>, <vscale x 4 x i32>* %p
load i32, i32* %gep1
load i32, i32* %gep2
ret void ret void
} }
; CHECK-LABEL: gep_same_base_symbolic_offset ; CHECK-LABEL: gep_same_base_symbolic_offset
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %p ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep2, <vscale x 4 x i32>* %p ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep2, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %gep2 ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %gep2
define void @gep_same_base_symbolic_offset(<vscale x 4 x i32>* %p, i64 %idx1, i64 %idx2) { define void @gep_same_base_symbolic_offset(<vscale x 4 x i32>* %p, i64 %idx1, i64 %idx2) {
%gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 %idx1 %gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 %idx1
%gep2 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 %idx2 %gep2 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 %idx2
load <vscale x 4 x i32>, <vscale x 4 x i32>* %p
load <vscale x 4 x i32>, <vscale x 4 x i32>* %gep1
load <vscale x 4 x i32>, <vscale x 4 x i32>* %gep2
ret void ret void
} }
; CHECK-LABEL: gep_different_base_const_offset ; CHECK-LABEL: gep_different_base_const_offset
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %p1 ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %p1
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep2, <vscale x 4 x i32>* %p2 ; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %gep2, <vscale x 4 x i32>* %p2
; CHECK-DAG: NoAlias: <vscale x 4 x i32>* %p1, <vscale x 4 x i32>* %p2 ; CHECK-DAG: NoAlias: <vscale x 4 x i32>* %p1, <vscale x 4 x i32>* %p2
; CHECK-DAG: NoAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %p2 ; CHECK-DAG: NoAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %p2
; CHECK-DAG: NoAlias: <vscale x 4 x i32>* %gep2, <vscale x 4 x i32>* %p1 ; CHECK-DAG: NoAlias: <vscale x 4 x i32>* %gep2, <vscale x 4 x i32>* %p1
; CHECK-DAG: NoAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %gep2 ; CHECK-DAG: NoAlias: <vscale x 4 x i32>* %gep1, <vscale x 4 x i32>* %gep2
define void @gep_different_base_const_offset(<vscale x 4 x i32>* noalias %p1, <vscale x 4 x i32>* noalias %p2) { define void @gep_different_base_const_offset(<vscale x 4 x i32>* noalias %p1, <vscale x 4 x i32>* noalias %p2) {
%gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p1, i64 1 %gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p1, i64 1
%gep2 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p2, i64 1 %gep2 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p2, i64 1
load <vscale x 4 x i32>, <vscale x 4 x i32>* %p1
load <vscale x 4 x i32>, <vscale x 4 x i32>* %p2
load <vscale x 4 x i32>, <vscale x 4 x i32>* %gep1
load <vscale x 4 x i32>, <vscale x 4 x i32>* %gep2
ret void ret void
} }
; getelementptr + bitcast ; getelementptr + bitcast
; CHECK-LABEL: gep_bitcast_1 ; CHECK-LABEL: gep_bitcast_1
; CHECK-DAG: MustAlias: <vscale x 4 x i32>* %p, i32* %p2 ; CHECK-DAG: MustAlias: <vscale x 4 x i32>* %p, i32* %p2
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep1 ; CHECK-DAG: MayAlias: i32* %gep1, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: i32* %gep1, i32* %p2 ; CHECK-DAG: MayAlias: i32* %gep1, i32* %p2
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep2 ; CHECK-DAG: MayAlias: i32* %gep2, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: i32* %gep1, i32* %gep2 ; CHECK-DAG: MayAlias: i32* %gep1, i32* %gep2
; CHECK-DAG: NoAlias: i32* %gep2, i32* %p2 ; CHECK-DAG: NoAlias: i32* %gep2, i32* %p2
define void @gep_bitcast_1(<vscale x 4 x i32>* %p) { define void @gep_bitcast_1(<vscale x 4 x i32>* %p) {
%gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 1, i64 0 %gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 1, i64 0
%p2 = bitcast <vscale x 4 x i32>* %p to i32* %p2 = bitcast <vscale x 4 x i32>* %p to i32*
%gep2 = getelementptr i32, i32* %p2, i64 4 %gep2 = getelementptr i32, i32* %p2, i64 4
load <vscale x 4 x i32>, <vscale x 4 x i32>* %p
load i32, i32* %gep1
load i32, i32* %gep2
load i32, i32* %p2
ret void ret void
} }
; CHECK-LABEL: gep_bitcast_2 ; CHECK-LABEL: gep_bitcast_2
; CHECK-DAG: MustAlias: <vscale x 4 x float>* %p2, <vscale x 4 x i32>* %p ; CHECK-DAG: MustAlias: <vscale x 4 x i32>* %p, <vscale x 4 x float>* %p2
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep1 ; CHECK-DAG: MayAlias: i32* %gep1, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: <vscale x 4 x float>* %p2, i32* %gep1 ; CHECK-DAG: MayAlias: i32* %gep1, <vscale x 4 x float>* %p2
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, float* %gep2 ; CHECK-DAG: MayAlias: float* %gep2, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: float* %gep2, i32* %gep1 ; CHECK-DAG: MayAlias: i32* %gep1, float* %gep2
; CHECK-DAG: MayAlias: <vscale x 4 x float>* %p2, float* %gep2 ; CHECK-DAG: MayAlias: float* %gep2, <vscale x 4 x float>* %p2
define void @gep_bitcast_2(<vscale x 4 x i32>* %p) { define void @gep_bitcast_2(<vscale x 4 x i32>* %p) {
%gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 1, i64 0 %gep1 = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 1, i64 0
%p2 = bitcast <vscale x 4 x i32>* %p to <vscale x 4 x float>* %p2 = bitcast <vscale x 4 x i32>* %p to <vscale x 4 x float>*
%gep2 = getelementptr <vscale x 4 x float>, <vscale x 4 x float>* %p2, i64 1, i64 0 %gep2 = getelementptr <vscale x 4 x float>, <vscale x 4 x float>* %p2, i64 1, i64 0
load i32, i32* %gep1
load float, float* %gep2
load <vscale x 4 x i32>, <vscale x 4 x i32>* %p
load <vscale x 4 x float>, <vscale x 4 x float>* %p2
ret void ret void
} }
; getelementptr recursion ; getelementptr recursion
; CHECK-LABEL: gep_recursion_level_1 ; CHECK-LABEL: gep_recursion_level_1
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %a ; CHECK-DAG: MayAlias: i32* %a, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: i32* %a, i32* %gep ; CHECK-DAG: MayAlias: i32* %a, i32* %gep
; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_1 ; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_1
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep ; CHECK-DAG: MayAlias: i32* %gep, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep_rec_1 ; CHECK-DAG: MayAlias: i32* %gep_rec_1, <vscale x 4 x i32>* %p
; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_1 ; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_1
define void @gep_recursion_level_1(i32* %a, <vscale x 4 x i32>* %p) { define void @gep_recursion_level_1(i32* %a, <vscale x 4 x i32>* %p) {
%gep = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 1, i64 2 %gep = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 1, i64 2
%gep_rec_1 = getelementptr i32, i32* %gep, i64 1 %gep_rec_1 = getelementptr i32, i32* %gep, i64 1
load <vscale x 4 x i32>, <vscale x 4 x i32>* %p
load i32, i32* %a
load i32, i32* %gep
load i32, i32* %gep_rec_1
ret void ret void
} }
; CHECK-LABEL: gep_recursion_level_1_bitcast ; CHECK-LABEL: gep_recursion_level_1_bitcast
; CHECK-DAG: MustAlias: <vscale x 4 x i32>* %p, i32* %a ; CHECK-DAG: MustAlias: i32* %a, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: i32* %a, i32* %gep ; CHECK-DAG: MayAlias: i32* %a, i32* %gep
; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_1 ; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_1
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep ; CHECK-DAG: MayAlias: i32* %gep, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep_rec_1 ; CHECK-DAG: MayAlias: i32* %gep_rec_1, <vscale x 4 x i32>* %p
; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_1 ; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_1
define void @gep_recursion_level_1_bitcast(i32* %a) { define void @gep_recursion_level_1_bitcast(i32* %a) {
%p = bitcast i32* %a to <vscale x 4 x i32>* %p = bitcast i32* %a to <vscale x 4 x i32>*
%gep = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 1, i64 2 %gep = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 1, i64 2
%gep_rec_1 = getelementptr i32, i32* %gep, i64 1 %gep_rec_1 = getelementptr i32, i32* %gep, i64 1
load <vscale x 4 x i32>, <vscale x 4 x i32>* %p
load i32, i32* %a
load i32, i32* %gep
load i32, i32* %gep_rec_1
ret void ret void
} }
; CHECK-LABEL: gep_recursion_level_2 ; CHECK-LABEL: gep_recursion_level_2
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %a ; CHECK-DAG: MayAlias: i32* %a, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: i32* %a, i32* %gep ; CHECK-DAG: MayAlias: i32* %a, i32* %gep
; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_1 ; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_1
; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_2 ; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_2
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep ; CHECK-DAG: MayAlias: i32* %gep, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep_rec_1 ; CHECK-DAG: MayAlias: i32* %gep_rec_1, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep_rec_2 ; CHECK-DAG: MayAlias: i32* %gep_rec_2, <vscale x 4 x i32>* %p
; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_1 ; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_1
; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_2 ; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_2
; CHECK-DAG: NoAlias: i32* %gep_rec_1, i32* %gep_rec_2 ; CHECK-DAG: NoAlias: i32* %gep_rec_1, i32* %gep_rec_2
define void @gep_recursion_level_2(i32* %a, <vscale x 4 x i32>* %p) { define void @gep_recursion_level_2(i32* %a, <vscale x 4 x i32>* %p) {
%gep = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 1, i64 2 %gep = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 1, i64 2
%gep_rec_1 = getelementptr i32, i32* %gep, i64 1 %gep_rec_1 = getelementptr i32, i32* %gep, i64 1
%gep_rec_2 = getelementptr i32, i32* %gep_rec_1, i64 1 %gep_rec_2 = getelementptr i32, i32* %gep_rec_1, i64 1
load <vscale x 4 x i32>, <vscale x 4 x i32>* %p
load i32, i32* %a
load i32, i32* %gep
load i32, i32* %gep_rec_1
load i32, i32* %gep_rec_2
ret void ret void
} }
; CHECK-LABEL: gep_recursion_max_lookup_depth_reached ; CHECK-LABEL: gep_recursion_max_lookup_depth_reached
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %a ; CHECK-DAG: MayAlias: i32* %a, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: i32* %a, i32* %gep ; CHECK-DAG: MayAlias: i32* %a, i32* %gep
; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_1 ; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_1
; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_2 ; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_2
; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_3 ; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_3
; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_4 ; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_4
; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_5 ; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_5
; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_6 ; CHECK-DAG: MayAlias: i32* %a, i32* %gep_rec_6
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep ; CHECK-DAG: MayAlias: i32* %gep, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep_rec_1 ; CHECK-DAG: MayAlias: i32* %gep_rec_1, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep_rec_2 ; CHECK-DAG: MayAlias: i32* %gep_rec_2, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep_rec_3 ; CHECK-DAG: MayAlias: i32* %gep_rec_3, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep_rec_4 ; CHECK-DAG: MayAlias: i32* %gep_rec_4, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep_rec_5 ; CHECK-DAG: MayAlias: i32* %gep_rec_5, <vscale x 4 x i32>* %p
; CHECK-DAG: MayAlias: <vscale x 4 x i32>* %p, i32* %gep_rec_6 ; CHECK-DAG: MayAlias: i32* %gep_rec_6, <vscale x 4 x i32>* %p
; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_1 ; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_1
; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_2 ; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_2
; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_3 ; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_3
; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_4 ; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_4
; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_5 ; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_5
; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_6 ; CHECK-DAG: NoAlias: i32* %gep, i32* %gep_rec_6
; CHECK-DAG: NoAlias: i32* %gep_rec_1, i32* %gep_rec_2 ; CHECK-DAG: NoAlias: i32* %gep_rec_1, i32* %gep_rec_2
; CHECK-DAG: NoAlias: i32* %gep_rec_1, i32* %gep_rec_3 ; CHECK-DAG: NoAlias: i32* %gep_rec_1, i32* %gep_rec_3
Show All 14 Lines
define void @gep_recursion_max_lookup_depth_reached(i32* %a, <vscale x 4 x i32>* %p) { define void @gep_recursion_max_lookup_depth_reached(i32* %a, <vscale x 4 x i32>* %p) {
%gep = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 1, i64 2 %gep = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %p, i64 1, i64 2
%gep_rec_1 = getelementptr i32, i32* %gep, i64 1 %gep_rec_1 = getelementptr i32, i32* %gep, i64 1
%gep_rec_2 = getelementptr i32, i32* %gep_rec_1, i64 1 %gep_rec_2 = getelementptr i32, i32* %gep_rec_1, i64 1
%gep_rec_3 = getelementptr i32, i32* %gep_rec_2, i64 1 %gep_rec_3 = getelementptr i32, i32* %gep_rec_2, i64 1
%gep_rec_4 = getelementptr i32, i32* %gep_rec_3, i64 1 %gep_rec_4 = getelementptr i32, i32* %gep_rec_3, i64 1
%gep_rec_5 = getelementptr i32, i32* %gep_rec_4, i64 1 %gep_rec_5 = getelementptr i32, i32* %gep_rec_4, i64 1
%gep_rec_6 = getelementptr i32, i32* %gep_rec_5, i64 1 %gep_rec_6 = getelementptr i32, i32* %gep_rec_5, i64 1
load <vscale x 4 x i32>, <vscale x 4 x i32>* %p
load i32, i32* %a
load i32, i32* %gep
load i32, i32* %gep_rec_1
load i32, i32* %gep_rec_2
load i32, i32* %gep_rec_3
load i32, i32* %gep_rec_4
load i32, i32* %gep_rec_5
load i32, i32* %gep_rec_6
ret void ret void
} }

llvm/test/Analysis/BasicAA/zext.ll

; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; CHECK-LABEL: test_with_zext ; CHECK-LABEL: test_with_zext
; CHECK: NoAlias: i8* %a, i8* %b ; CHECK: NoAlias: i8* %a, i8* %b
define void @test_with_zext() { define void @test_with_zext() {
%1 = tail call i8* @malloc(i64 120) %1 = tail call i8* @malloc(i64 120)
%a = getelementptr inbounds i8, i8* %1, i64 8 %a = getelementptr inbounds i8, i8* %1, i64 8
%2 = getelementptr inbounds i8, i8* %1, i64 16 %2 = getelementptr inbounds i8, i8* %1, i64 16
%3 = zext i32 3 to i64 %3 = zext i32 3 to i64
%b = getelementptr inbounds i8, i8* %2, i64 %3 %b = getelementptr inbounds i8, i8* %2, i64 %3
load i8, i8* %a
load i8, i8* %b
ret void ret void
} }
; CHECK-LABEL: test_with_lshr ; CHECK-LABEL: test_with_lshr
; CHECK: NoAlias: i8* %a, i8* %b ; CHECK: NoAlias: i8* %a, i8* %b
define void @test_with_lshr(i64 %i) { define void @test_with_lshr(i64 %i) {
%1 = tail call i8* @malloc(i64 120) %1 = tail call i8* @malloc(i64 120)
%a = getelementptr inbounds i8, i8* %1, i64 8 %a = getelementptr inbounds i8, i8* %1, i64 8
%2 = getelementptr inbounds i8, i8* %1, i64 16 %2 = getelementptr inbounds i8, i8* %1, i64 16
%3 = lshr i64 %i, 2 %3 = lshr i64 %i, 2
%b = getelementptr inbounds i8, i8* %2, i64 %3 %b = getelementptr inbounds i8, i8* %2, i64 %3
load i8, i8* %a
load i8, i8* %b
ret void ret void
} }
; CHECK-LABEL: test_with_lshr_different_sizes ; CHECK-LABEL: test_with_lshr_different_sizes
; CHECK: NoAlias: i16* %m2.idx, i8* %m1 ; CHECK: NoAlias: i8* %m1, i16* %m2.idx
define void @test_with_lshr_different_sizes(i64 %i) { define void @test_with_lshr_different_sizes(i64 %i) {
%m0 = tail call i8* @malloc(i64 120) %m0 = tail call i8* @malloc(i64 120)
%m1 = getelementptr inbounds i8, i8* %m0, i64 1 %m1 = getelementptr inbounds i8, i8* %m0, i64 1
load i8, i8* %m1
%m2 = getelementptr inbounds i8, i8* %m0, i64 2 %m2 = getelementptr inbounds i8, i8* %m0, i64 2
%idx = lshr i64 %i, 2 %idx = lshr i64 %i, 2
%m2.i16 = bitcast i8* %m2 to i16* %m2.i16 = bitcast i8* %m2 to i16*
%m2.idx = getelementptr inbounds i16, i16* %m2.i16, i64 %idx %m2.idx = getelementptr inbounds i16, i16* %m2.i16, i64 %idx
load i16, i16* %m2.idx
ret void ret void
} }
; CHECK-LABEL: test_with_a_loop ; CHECK-LABEL: test_with_a_loop
; CHECK: NoAlias: i8* %a, i8* %b ; CHECK: NoAlias: i8* %a, i8* %b
define void @test_with_a_loop(i8* %mem) { define void @test_with_a_loop(i8* %mem) {
br label %for.loop br label %for.loop
for.loop: for.loop:
%i = phi i32 [ 0, %0 ], [ %i.plus1, %for.loop ] %i = phi i32 [ 0, %0 ], [ %i.plus1, %for.loop ]
%a = getelementptr inbounds i8, i8* %mem, i64 8 %a = getelementptr inbounds i8, i8* %mem, i64 8
load i8, i8* %a
%a.plus1 = getelementptr inbounds i8, i8* %mem, i64 16 %a.plus1 = getelementptr inbounds i8, i8* %mem, i64 16
%i.64 = zext i32 %i to i64 %i.64 = zext i32 %i to i64
%b = getelementptr inbounds i8, i8* %a.plus1, i64 %i.64 %b = getelementptr inbounds i8, i8* %a.plus1, i64 %i.64
load i8, i8* %b
%i.plus1 = add nuw nsw i32 %i, 1 %i.plus1 = add nuw nsw i32 %i, 1
%cmp = icmp eq i32 %i.plus1, 10 %cmp = icmp eq i32 %i.plus1, 10
br i1 %cmp, label %for.loop.exit, label %for.loop br i1 %cmp, label %for.loop.exit, label %for.loop
for.loop.exit: for.loop.exit:
ret void ret void
} }
; CHECK-LABEL: test_with_varying_base_pointer_in_loop ; CHECK-LABEL: test_with_varying_base_pointer_in_loop
; CHECK: NoAlias: i8* %a, i8* %b ; CHECK: NoAlias: i8* %a, i8* %b
define void @test_with_varying_base_pointer_in_loop(i8* %mem.orig) { define void @test_with_varying_base_pointer_in_loop(i8* %mem.orig) {
br label %for.loop br label %for.loop
for.loop: for.loop:
%mem = phi i8* [ %mem.orig, %0 ], [ %mem.plus1, %for.loop ] %mem = phi i8* [ %mem.orig, %0 ], [ %mem.plus1, %for.loop ]
%i = phi i32 [ 0, %0 ], [ %i.plus1, %for.loop ] %i = phi i32 [ 0, %0 ], [ %i.plus1, %for.loop ]
%a = getelementptr inbounds i8, i8* %mem, i64 8 %a = getelementptr inbounds i8, i8* %mem, i64 8
load i8, i8* %a
%a.plus1 = getelementptr inbounds i8, i8* %mem, i64 16 %a.plus1 = getelementptr inbounds i8, i8* %mem, i64 16
%i.64 = zext i32 %i to i64 %i.64 = zext i32 %i to i64
%b = getelementptr inbounds i8, i8* %a.plus1, i64 %i.64 %b = getelementptr inbounds i8, i8* %a.plus1, i64 %i.64
load i8, i8* %b
%i.plus1 = add nuw nsw i32 %i, 1 %i.plus1 = add nuw nsw i32 %i, 1
%mem.plus1 = getelementptr inbounds i8, i8* %mem, i64 8 %mem.plus1 = getelementptr inbounds i8, i8* %mem, i64 8
%cmp = icmp eq i32 %i.plus1, 10 %cmp = icmp eq i32 %i.plus1, 10
br i1 %cmp, label %for.loop.exit, label %for.loop br i1 %cmp, label %for.loop.exit, label %for.loop
for.loop.exit: for.loop.exit:
ret void ret void
} }
; CHECK-LABEL: test_sign_extension ; CHECK-LABEL: test_sign_extension
; CHECK: MayAlias: i64* %b.i64, i8* %a ; CHECK: MayAlias: i8* %a, i64* %b.i64
define void @test_sign_extension(i32 %p) { define void @test_sign_extension(i32 %p) {
%1 = tail call i8* @malloc(i64 120) %1 = tail call i8* @malloc(i64 120)
%p.64 = zext i32 %p to i64 %p.64 = zext i32 %p to i64
%a = getelementptr inbounds i8, i8* %1, i64 %p.64 %a = getelementptr inbounds i8, i8* %1, i64 %p.64
load i8, i8* %a
%p.minus1 = add i32 %p, -1 %p.minus1 = add i32 %p, -1
%p.minus1.64 = zext i32 %p.minus1 to i64 %p.minus1.64 = zext i32 %p.minus1 to i64
%b.i8 = getelementptr inbounds i8, i8* %1, i64 %p.minus1.64 %b.i8 = getelementptr inbounds i8, i8* %1, i64 %p.minus1.64
%b.i64 = bitcast i8* %b.i8 to i64* %b.i64 = bitcast i8* %b.i8 to i64*
load i64, i64* %b.i64
ret void ret void
} }
; CHECK-LABEL: test_fe_tools ; CHECK-LABEL: test_fe_tools
; CHECK: MayAlias: i32* %a, i32* %b ; CHECK: MayAlias: i32* %a, i32* %b
define void @test_fe_tools([8 x i32]* %values) { define void @test_fe_tools([8 x i32]* %values) {
br label %reorder br label %reorder
for.loop: for.loop:
%i = phi i32 [ 0, %reorder ], [ %i.next, %for.loop ] %i = phi i32 [ 0, %reorder ], [ %i.next, %for.loop ]
%idxprom = zext i32 %i to i64 %idxprom = zext i32 %i to i64
%b = getelementptr inbounds [8 x i32], [8 x i32]* %values, i64 0, i64 %idxprom %b = getelementptr inbounds [8 x i32], [8 x i32]* %values, i64 0, i64 %idxprom
load i32, i32* %b
%i.next = add nuw nsw i32 %i, 1 %i.next = add nuw nsw i32 %i, 1
%1 = icmp eq i32 %i.next, 10 %cmp = icmp eq i32 %i.next, 10
br i1 %1, label %for.loop.exit, label %for.loop br i1 %cmp, label %for.loop.exit, label %for.loop
reorder: reorder:
%a = getelementptr inbounds [8 x i32], [8 x i32]* %values, i64 0, i64 1 %a = getelementptr inbounds [8 x i32], [8 x i32]* %values, i64 0, i64 1
load i32, i32* %a
br label %for.loop br label %for.loop
for.loop.exit: for.loop.exit:
ret void ret void
} }
@b = global i32 0, align 4 @b = global i32 0, align 4
@d = global i32 0, align 4 @d = global i32 0, align 4
; CHECK-LABEL: test_spec2006 ; CHECK-LABEL: test_spec2006
; CHECK: MayAlias: i32** %x, i32** %y ; CHECK: MayAlias: i32** %x, i32** %y
define void @test_spec2006() { define void @test_spec2006() {
%h = alloca [1 x [2 x i32*]], align 16 %h = alloca [1 x [2 x i32*]], align 16
%d.val = load i32, i32* @d, align 4 %d.val = load i32, i32* @d, align 4
%d.promoted = sext i32 %d.val to i64 %d.promoted = sext i32 %d.val to i64
%1 = icmp slt i32 %d.val, 2 %1 = icmp slt i32 %d.val, 2
br i1 %1, label %.lr.ph, label %3 br i1 %1, label %.lr.ph, label %bb3
.lr.ph: ; preds = %0 .lr.ph: ; preds = %0
br label %2 br label %bb2
; <label>:2 ; preds = %.lr.ph, %2 bb2:
%i = phi i32 [ %d.val, %.lr.ph ], [ %i.plus1, %2 ] %i = phi i32 [ %d.val, %.lr.ph ], [ %i.plus1, %bb2 ]
%i.promoted = sext i32 %i to i64 %i.promoted = sext i32 %i to i64
%x = getelementptr inbounds [1 x [2 x i32*]], [1 x [2 x i32*]]* %h, i64 0, i64 %d.promoted, i64 %i.promoted %x = getelementptr inbounds [1 x [2 x i32*]], [1 x [2 x i32*]]* %h, i64 0, i64 %d.promoted, i64 %i.promoted
load i32*, i32** %x
%i.plus1 = add nsw i32 %i, 1 %i.plus1 = add nsw i32 %i, 1
%cmp = icmp slt i32 %i.plus1, 2 %cmp = icmp slt i32 %i.plus1, 2
br i1 %cmp, label %2, label %3 br i1 %cmp, label %bb2, label %bb3
; <label>:3 ; preds = %._crit_edge, %0 bb3:
%y = getelementptr inbounds [1 x [2 x i32*]], [1 x [2 x i32*]]* %h, i64 0, i64 0, i64 1 %y = getelementptr inbounds [1 x [2 x i32*]], [1 x [2 x i32*]]* %h, i64 0, i64 0, i64 1
load i32*, i32** %y
ret void ret void
} }
; CHECK-LABEL: test_modulo_analysis_easy_case ; CHECK-LABEL: test_modulo_analysis_easy_case
; CHECK: NoAlias: i32** %x, i32** %y ; CHECK: NoAlias: i32** %x, i32** %y
define void @test_modulo_analysis_easy_case(i64 %i) { define void @test_modulo_analysis_easy_case(i64 %i) {
%h = alloca [1 x [2 x i32*]], align 16 %h = alloca [1 x [2 x i32*]], align 16
%x = getelementptr inbounds [1 x [2 x i32*]], [1 x [2 x i32*]]* %h, i64 0, i64 %i, i64 0 %x = getelementptr inbounds [1 x [2 x i32*]], [1 x [2 x i32*]]* %h, i64 0, i64 %i, i64 0
%y = getelementptr inbounds [1 x [2 x i32*]], [1 x [2 x i32*]]* %h, i64 0, i64 0, i64 1 %y = getelementptr inbounds [1 x [2 x i32*]], [1 x [2 x i32*]]* %h, i64 0, i64 0, i64 1
load i32*, i32** %x
load i32*, i32** %y
ret void ret void
} }
; CHECK-LABEL: test_modulo_analysis_in_loop ; CHECK-LABEL: test_modulo_analysis_in_loop
; CHECK: NoAlias: i32** %x, i32** %y ; CHECK: NoAlias: i32** %x, i32** %y
define void @test_modulo_analysis_in_loop() { define void @test_modulo_analysis_in_loop() {
%h = alloca [1 x [2 x i32*]], align 16 %h = alloca [1 x [2 x i32*]], align 16
br label %for.loop br label %for.loop
for.loop: for.loop:
%i = phi i32 [ 0, %0 ], [ %i.plus1, %for.loop ] %i = phi i32 [ 0, %0 ], [ %i.plus1, %for.loop ]
%i.promoted = sext i32 %i to i64 %i.promoted = sext i32 %i to i64
%x = getelementptr inbounds [1 x [2 x i32*]], [1 x [2 x i32*]]* %h, i64 0, i64 %i.promoted, i64 0 %x = getelementptr inbounds [1 x [2 x i32*]], [1 x [2 x i32*]]* %h, i64 0, i64 %i.promoted, i64 0
%y = getelementptr inbounds [1 x [2 x i32*]], [1 x [2 x i32*]]* %h, i64 0, i64 0, i64 1 %y = getelementptr inbounds [1 x [2 x i32*]], [1 x [2 x i32*]]* %h, i64 0, i64 0, i64 1
load i32*, i32** %x
load i32*, i32** %y
%i.plus1 = add nsw i32 %i, 1 %i.plus1 = add nsw i32 %i, 1
%cmp = icmp slt i32 %i.plus1, 2 %cmp = icmp slt i32 %i.plus1, 2
br i1 %cmp, label %for.loop, label %for.loop.exit br i1 %cmp, label %for.loop, label %for.loop.exit
for.loop.exit: for.loop.exit:
ret void ret void
} }
; CHECK-LABEL: test_modulo_analysis_with_global ; CHECK-LABEL: test_modulo_analysis_with_global
; CHECK: MayAlias: i32** %x, i32** %y ; CHECK: MayAlias: i32** %x, i32** %y
define void @test_modulo_analysis_with_global() { define void @test_modulo_analysis_with_global() {
%h = alloca [1 x [2 x i32*]], align 16 %h = alloca [1 x [2 x i32*]], align 16
%b = load i32, i32* @b, align 4 %b = load i32, i32* @b, align 4
%b.promoted = sext i32 %b to i64 %b.promoted = sext i32 %b to i64
br label %for.loop br label %for.loop
for.loop: for.loop:
%i = phi i32 [ 0, %0 ], [ %i.plus1, %for.loop ] %i = phi i32 [ 0, %0 ], [ %i.plus1, %for.loop ]
%i.promoted = sext i32 %i to i64 %i.promoted = sext i32 %i to i64
%x = getelementptr inbounds [1 x [2 x i32*]], [1 x [2 x i32*]]* %h, i64 0, i64 %i.promoted, i64 %b.promoted %x = getelementptr inbounds [1 x [2 x i32*]], [1 x [2 x i32*]]* %h, i64 0, i64 %i.promoted, i64 %b.promoted
%y = getelementptr inbounds [1 x [2 x i32*]], [1 x [2 x i32*]]* %h, i64 0, i64 0, i64 1 %y = getelementptr inbounds [1 x [2 x i32*]], [1 x [2 x i32*]]* %h, i64 0, i64 0, i64 1
load i32*, i32** %x
load i32*, i32** %y
%i.plus1 = add nsw i32 %i, 1 %i.plus1 = add nsw i32 %i, 1
%cmp = icmp slt i32 %i.plus1, 2 %cmp = icmp slt i32 %i.plus1, 2
br i1 %cmp, label %for.loop, label %for.loop.exit br i1 %cmp, label %for.loop, label %for.loop.exit
for.loop.exit: for.loop.exit:
ret void ret void
} }
; CHECK-LABEL: test_const_eval ; CHECK-LABEL: test_const_eval
; CHECK: NoAlias: i8* %a, i8* %b ; CHECK: NoAlias: i8* %a, i8* %b
define void @test_const_eval(i8* %ptr, i64 %offset) { define void @test_const_eval(i8* %ptr, i64 %offset) {
%a = getelementptr inbounds i8, i8* %ptr, i64 %offset %a = getelementptr inbounds i8, i8* %ptr, i64 %offset
%a.dup = getelementptr inbounds i8, i8* %ptr, i64 %offset %a.dup = getelementptr inbounds i8, i8* %ptr, i64 %offset
%three = zext i32 3 to i64 %three = zext i32 3 to i64
%b = getelementptr inbounds i8, i8* %a.dup, i64 %three %b = getelementptr inbounds i8, i8* %a.dup, i64 %three
load i8, i8* %a
load i8, i8* %b
ret void ret void
} }
; CHECK-LABEL: test_const_eval_scaled ; CHECK-LABEL: test_const_eval_scaled
; CHECK: MustAlias: i8* %a, i8* %b ; CHECK: MustAlias: i8* %a, i8* %b
define void @test_const_eval_scaled(i8* %ptr) { define void @test_const_eval_scaled(i8* %ptr) {
%three = zext i32 3 to i64 %three = zext i32 3 to i64
%six = mul i64 %three, 2 %six = mul i64 %three, 2
%a = getelementptr inbounds i8, i8* %ptr, i64 %six %a = getelementptr inbounds i8, i8* %ptr, i64 %six
%b = getelementptr inbounds i8, i8* %ptr, i64 6 %b = getelementptr inbounds i8, i8* %ptr, i64 6
load i8, i8* %a
load i8, i8* %b
ret void ret void
} }
; CHECK-LABEL: Function: foo ; CHECK-LABEL: Function: foo
; CHECK: MustAlias: float* %arrayidx, float* %arrayidx4.84 ; CHECK: MustAlias: float* %arrayidx, float* %arrayidx4.84
define float @foo(i32 *%A, float %rend, float** %wayar) { define float @foo(i32 *%A, float %rend, float** %wayar) {
entry: entry:
%x0 = load i32, i32* %A, align 4 %x0 = load i32, i32* %A, align 4
Show All 18 Lines
; CHECK: MustAlias: i8* %p.1, i8* %p.2 ; CHECK: MustAlias: i8* %p.1, i8* %p.2
define void @test_shl_nuw_zext(i8* %p, i32 %x) { define void @test_shl_nuw_zext(i8* %p, i32 %x) {
%shl = shl nuw i32 %x, 1 %shl = shl nuw i32 %x, 1
%shl.ext = zext i32 %shl to i64 %shl.ext = zext i32 %shl to i64
%ext = zext i32 %x to i64 %ext = zext i32 %x to i64
%ext.shl = shl nuw i64 %ext, 1 %ext.shl = shl nuw i64 %ext, 1
%p.1 = getelementptr i8, i8* %p, i64 %shl.ext %p.1 = getelementptr i8, i8* %p, i64 %shl.ext
%p.2 = getelementptr i8, i8* %p, i64 %ext.shl %p.2 = getelementptr i8, i8* %p, i64 %ext.shl
load i8, i8* %p.1
load i8, i8* %p.2
ret void ret void
} }
; CHECK-LABEL: Function: test_shl_nsw_sext ; CHECK-LABEL: Function: test_shl_nsw_sext
; CHECK: MustAlias: i8* %p.1, i8* %p.2 ; CHECK: MustAlias: i8* %p.1, i8* %p.2
define void @test_shl_nsw_sext(i8* %p, i32 %x) { define void @test_shl_nsw_sext(i8* %p, i32 %x) {
%shl = shl nsw i32 %x, 1 %shl = shl nsw i32 %x, 1
%shl.ext = sext i32 %shl to i64 %shl.ext = sext i32 %shl to i64
%ext = sext i32 %x to i64 %ext = sext i32 %x to i64
%ext.shl = shl nsw i64 %ext, 1 %ext.shl = shl nsw i64 %ext, 1
%p.1 = getelementptr i8, i8* %p, i64 %shl.ext %p.1 = getelementptr i8, i8* %p, i64 %shl.ext
%p.2 = getelementptr i8, i8* %p, i64 %ext.shl %p.2 = getelementptr i8, i8* %p, i64 %ext.shl
load i8, i8* %p.1
load i8, i8* %p.2
ret void ret void
} }
; CHECK-LABEL: Function: test_implicit_sext ; CHECK-LABEL: Function: test_implicit_sext
; CHECK: MayAlias: i8* %p.1, i8* %p.2 ; CHECK: MayAlias: i8* %p.1, i8* %p.2
define void @test_implicit_sext(i8* %p, i32 %x) { define void @test_implicit_sext(i8* %p, i32 %x) {
%add = add i32 %x, 1 %add = add i32 %x, 1
%ext = sext i32 %x to i64 %ext = sext i32 %x to i64
%ext.add = add i64 %ext, 1 %ext.add = add i64 %ext, 1
%p.1 = getelementptr i8, i8* %p, i32 %add %p.1 = getelementptr i8, i8* %p, i32 %add
%p.2 = getelementptr i8, i8* %p, i64 %ext.add %p.2 = getelementptr i8, i8* %p, i64 %ext.add
load i8, i8* %p.1
load i8, i8* %p.2
ret void ret void
} }
; CHECK-LABEL: Function: test_partial_decomposition ; CHECK-LABEL: Function: test_partial_decomposition
; CHECK: MustAlias: i8* %p.1, i8* %p.2 ; CHECK: MustAlias: i8* %p.1, i8* %p.2
define void @test_partial_decomposition(i8* %p, i32 %x) { define void @test_partial_decomposition(i8* %p, i32 %x) {
%add = add i32 %x, 1 %add = add i32 %x, 1
%add.1 = add nsw i32 %add, 1 %add.1 = add nsw i32 %add, 1
%add.2 = add nsw i32 %add, 1 %add.2 = add nsw i32 %add, 1
%p.1 = getelementptr i8, i8* %p, i32 %add.1 %p.1 = getelementptr i8, i8* %p, i32 %add.1
%p.2 = getelementptr i8, i8* %p, i32 %add.2 %p.2 = getelementptr i8, i8* %p, i32 %add.2
load i8, i8* %p.1
load i8, i8* %p.2
ret void ret void
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare noalias i8* @malloc(i64) declare noalias i8* @malloc(i64)

llvm/test/Analysis/CFLAliasAnalysis/Andersen/assign.ll

; This testcase ensures that CFL AA handles assignment in an inclusion-based ; This testcase ensures that CFL AA handles assignment in an inclusion-based
; manner ; manner
; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; CHECK-LABEL: Function: test_assign ; CHECK-LABEL: Function: test_assign
; CHECK: NoAlias: i64* %a, i64* %b ; CHECK: NoAlias: i64* %a, i64* %b
; CHECK: NoAlias: i32* %c, i64* %b ; CHECK: NoAlias: i64* %b, i32* %c
; CHECK: NoAlias: i32* %d, i64* %a ; CHECK: NoAlias: i64* %a, i32* %d
; CHECK: NoAlias: i32* %c, i32* %d ; CHECK: NoAlias: i32* %c, i32* %d
; CHECK: MayAlias: i32* %e, i64* %a ; CHECK: MayAlias: i64* %a, i32* %e
; CHECK: MayAlias: i32* %e, i64* %b ; CHECK: MayAlias: i64* %b, i32* %e
; CHECK: MayAlias: i32* %c, i32* %e ; CHECK: MayAlias: i32* %c, i32* %e
; CHECK: MayAlias: i32* %d, i32* %e ; CHECK: MayAlias: i32* %d, i32* %e
define void @test_assign(i1 %cond) { define void @test_assign(i1 %cond) {
%a = alloca i64, align 8 %a = alloca i64, align 8
%b = alloca i64, align 8 %b = alloca i64, align 8
%c = bitcast i64* %a to i32* %c = bitcast i64* %a to i32*
%d = bitcast i64* %b to i32* %d = bitcast i64* %b to i32*
%e = select i1 %cond, i32* %c, i32* %d %e = select i1 %cond, i32* %c, i32* %d
load i64, i64* %a
load i64, i64* %b
load i32, i32* %c
load i32, i32* %d
load i32, i32* %e
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Andersen/assign2.ll

; This testcase ensures that CFL AA handles assignment in an inclusion-based ; This testcase ensures that CFL AA handles assignment in an inclusion-based
; manner ; manner
; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; CHECK-LABEL: Function: test_assign2 ; CHECK-LABEL: Function: test_assign2
; CHECK: NoAlias: i32* %b, i64* %a ; CHECK: NoAlias: i64* %a, i32* %b
; CHECK: NoAlias: i32* %b, i32* %c ; CHECK: NoAlias: i32* %b, i32* %c
; CHECK: NoAlias: i32* %b, i32* %d ; CHECK: NoAlias: i32* %b, i32* %d
; CHECK: MayAlias: i32* %e, i64* %a ; CHECK: MayAlias: i64* %a, i32* %e
; CHECK: MayAlias: i32* %b, i32* %e ; CHECK: MayAlias: i32* %b, i32* %e
; CHECK: MayAlias: i32* %c, i32* %e ; CHECK: MayAlias: i32* %c, i32* %e
; CHECK: MayAlias: i32* %d, i32* %e ; CHECK: MayAlias: i32* %d, i32* %e
define void @test_assign2(i1 %cond) { define void @test_assign2(i1 %cond) {
%a = alloca i64, align 8 %a = alloca i64, align 8
%b = alloca i32, align 4 %b = alloca i32, align 4
%c = bitcast i64* %a to i32* %c = bitcast i64* %a to i32*
%d = bitcast i64* %a to i32* %d = bitcast i64* %a to i32*
%e = select i1 %cond, i32* %c, i32* %b %e = select i1 %cond, i32* %c, i32* %b
load i64, i64* %a
load i32, i32* %b
load i32, i32* %c
load i32, i32* %d
load i32, i32* %e
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Andersen/attrs-below.ll

; This testcase ensures that AliasAttrs are propagated not only on the same ; This testcase ensures that AliasAttrs are propagated not only on the same
; level but also downward. ; level but also downward.
; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; CHECK-LABEL: Function: test_attr_below ; CHECK-LABEL: Function: test_attr_below
; CHECK: MayAlias: i64* %q, i64*** %p ; CHECK-DAG: MayAlias: i64*** %p, i64* %q
; CHECK: NoAlias: i64* %esc, i64*** %p ; CHECK-DAG: NoAlias: i64* %esc, i64*** %p
; CHECK: NoAlias: i64* %esc, i64* %q ; CHECK-DAG: NoAlias: i64* %esc, i64* %q
; CHECK: MayAlias: i64* %unknown, i64*** %p ; CHECK-DAG: MayAlias: i64*** %p, i64* %unknown
; CHECK: MayAlias: i64* %q, i64* %unknown ; CHECK-DAG: MayAlias: i64* %q, i64* %unknown
; CHECK: MayAlias: i64* %esc, i64* %unknown ; CHECK-DAG: MayAlias: i64* %esc, i64* %unknown
; CHECK: MayAlias: i64* %q, i64** %pdrf ; CHECK-DAG: MayAlias: i64** %pdrf, i64* %q
; CHECK: MayAlias: i64* %esc, i64** %pdrf ; CHECK-DAG: MayAlias: i64* %esc, i64** %pdrf
; CHECK: MayAlias: i64* %unknown, i64** %pdrf ; CHECK-DAG: MayAlias: i64** %pdrf, i64* %unknown
; CHECK: MayAlias: i64* %pdrf2, i64* %q ; CHECK-DAG: MayAlias: i64* %pdrf2, i64* %q
; CHECK: MayAlias: i64* %esc, i64* %pdrf2 ; CHECK-DAG: MayAlias: i64* %esc, i64* %pdrf2
; CHECK: MayAlias: i64* %pdrf2, i64* %unknown ; CHECK-DAG: MayAlias: i64* %pdrf2, i64* %unknown
define void @test_attr_below(i64*** %p, i64* %q) { define void @test_attr_below(i64*** %p, i64* %q) {
%esc = alloca i64, align 8 %esc = alloca i64, align 8
%escint = ptrtoint i64* %esc to i64 %escint = ptrtoint i64* %esc to i64
%unknown = inttoptr i64 %escint to i64* %unknown = inttoptr i64 %escint to i64*
%pdrf = load i64**, i64*** %p %pdrf = load i64**, i64*** %p
%pdrf2 = load i64*, i64** %pdrf %pdrf2 = load i64*, i64** %pdrf
load i64, i64* %q
load i64, i64* %esc
load i64, i64* %unknown
load i64, i64* %pdrf2
ret void ret void
} }
; CHECK-LABEL: Function: test_attr_assign_below ; CHECK-LABEL: Function: test_attr_assign_below
; CHECK: MayAlias: i64** %sel, i64*** %p ; CHECK-DAG: MayAlias: i64*** %p, i64** %sel
; CHECK: MayAlias: i64* %q, i64** %sel ; CHECK-DAG: MayAlias: i64* %q, i64** %sel
; CHECK: MayAlias: i64** %a, i64** %sel ; CHECK-DAG: MayAlias: i64** %a, i64** %sel
; CHECK: MayAlias: i64** %pdrf, i64** %sel ; CHECK-DAG: MayAlias: i64** %pdrf, i64** %sel
; CHECK: MayAlias: i64** %c, i64*** %p ; CHECK-DAG: MayAlias: i64** %c, i64*** %p
; CHECK: MayAlias: i64* %q, i64** %c ; CHECK-DAG: MayAlias: i64** %c, i64* %q
; CHECK: MayAlias: i64** %a, i64** %c ; CHECK-DAG: MayAlias: i64** %a, i64** %c
; CHECK: MayAlias: i64** %c, i64** %pdrf ; CHECK-DAG: MayAlias: i64** %c, i64** %pdrf
; CHECK: MayAlias: i64** %c, i64** %sel ; CHECK-DAG: MayAlias: i64** %c, i64** %sel
; CHECK: MayAlias: i64* %d, i64*** %p ; CHECK-DAG: MayAlias: i64* %d, i64*** %p
; CHECK: MayAlias: i64* %d, i64* %q ; CHECK-DAG: MayAlias: i64* %d, i64* %q
; CHECK: MayAlias: i64* %d, i64** %pdrf ; CHECK-DAG: MayAlias: i64* %d, i64** %pdrf
; CHECK: MayAlias: i64* %d, i64** %sel ; CHECK-DAG: MayAlias: i64* %d, i64** %sel
define void @test_attr_assign_below(i64*** %p, i64* %q, i1 %cond) { define void @test_attr_assign_below(i64*** %p, i64* %q, i1 %cond) {
%a = alloca i64*, align 8 %a = alloca i64*, align 8
%pdrf = load i64**, i64*** %p %pdrf = load i64**, i64*** %p
%sel = select i1 %cond, i64** %a, i64** %pdrf %sel = select i1 %cond, i64** %a, i64** %pdrf
%b = alloca i64**, align 8 %b = alloca i64**, align 8
store i64** %sel, i64*** %b store i64** %sel, i64*** %b
%c = load i64**, i64*** %b %c = load i64**, i64*** %b
%d = load i64*, i64** %c %d = load i64*, i64** %c
load i64, i64* %q
load i64*, i64** %a
load i64*, i64** %pdrf
load i64*, i64** %sel
load i64*, i64** %c
load i64, i64* %d
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Andersen/attrs.ll

; This testcase ensures that CFL AA handles escaped values no more conservative than it should ; This testcase ensures that CFL AA handles escaped values no more conservative than it should
; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; CHECK-LABEL: Function: test_local ; CHECK-LABEL: Function: test_local
; CHECK: NoAlias: i32* %a, i32* %b ; CHECK: NoAlias: i32* %a, i32* %b
; CHECK: MayAlias: i32* %a, i32* %aAlias ; CHECK: MayAlias: i32* %a, i32* %aAlias
; CHECK: NoAlias: i32* %aAlias, i32* %b ; CHECK: NoAlias: i32* %aAlias, i32* %b
define void @test_local() { define void @test_local() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%aint = ptrtoint i32* %a to i64 %aint = ptrtoint i32* %a to i64
%aAlias = inttoptr i64 %aint to i32* %aAlias = inttoptr i64 %aint to i32*
load i32, i32* %a
load i32, i32* %b
load i32, i32* %aAlias
ret void ret void
} }
; CHECK-LABEL: Function: test_global_param ; CHECK-LABEL: Function: test_global_param
; CHECK: NoAlias: i32* %a, i32** %x ; CHECK-DAG: NoAlias: i32* %a, i32** %x
; CHECK: MayAlias: i32* %a, i32* %xload ; CHECK-DAG: MayAlias: i32* %a, i32* %xload
; CHECK: MayAlias: i32* %a, i32* %gload ; CHECK-DAG: MayAlias: i32* %a, i32* %gload
; CHECK: MayAlias: i32* %gload, i32* %xload ; CHECK-DAG: MayAlias: i32* %gload, i32* %xload
; CHECK: MayAlias: i32** %x, i32** @ext_global ; CHECK-DAG: MayAlias: i32** %x, i32** @ext_global
; CHECK: NoAlias: i32* %a, i32** @ext_global ; CHECK-DAG: NoAlias: i32* %a, i32** @ext_global
@ext_global = external global i32* @ext_global = external global i32*
define void @test_global_param(i32** %x) { define void @test_global_param(i32** %x) {
%a = alloca i32, align 4 %a = alloca i32, align 4
%aint = ptrtoint i32* %a to i64 %aint = ptrtoint i32* %a to i64
%xload = load i32*, i32** %x %xload = load i32*, i32** %x
%gload = load i32*, i32** @ext_global %gload = load i32*, i32** @ext_global
load i32, i32* %a
load i32, i32* %xload
load i32, i32* %gload
ret void ret void
} }
declare void @external_func(i32**) declare void @external_func(i32**)
; CHECK-LABEL: Function: test_external_call ; CHECK-LABEL: Function: test_external_call
; CHECK: NoAlias: i32* %b, i32* %x ; CHECK-DAG: NoAlias: i32* %b, i32* %x
; CHECK: NoAlias: i32* %b, i32** %a ; CHECK-DAG: NoAlias: i32** %a, i32* %b
; CHECK: MayAlias: i32* %c, i32* %x ; CHECK-DAG: MayAlias: i32* %c, i32* %x
; CHECK: MayAlias: i32* %c, i32** %a ; CHECK-DAG: MayAlias: i32** %a, i32* %c
; CHECK: NoAlias: i32* %b, i32* %c ; CHECK-DAG: NoAlias: i32* %b, i32* %c
define void @test_external_call(i32* %x) { define void @test_external_call(i32* %x) {
%a = alloca i32*, align 8 %a = alloca i32*, align 8
%b = alloca i32, align 4 %b = alloca i32, align 4
call void @external_func(i32** %a) call void @external_func(i32** %a)
%c = load i32*, i32** %a %c = load i32*, i32** %a
load i32, i32* %x
load i32, i32* %b
load i32, i32* %c
ret void ret void
} }
declare void @external_func_readonly(i32**) readonly declare void @external_func_readonly(i32**) readonly
; CHECK-LABEL: Function: test_external_call_func_readonly ; CHECK-LABEL: Function: test_external_call_func_readonly
; CHECK: MayAlias: i32* %c, i32* %x ; CHECK-DAG: MayAlias: i32* %c, i32* %x
; CHECK: NoAlias: i32* %c, i32** %a ; CHECK-DAG: NoAlias: i32** %a, i32* %c
define void @test_external_call_func_readonly(i32* %x) { define void @test_external_call_func_readonly(i32* %x) {
%a = alloca i32*, align 8 %a = alloca i32*, align 8
%b = alloca i32, align 4 %b = alloca i32, align 4
store i32* %x, i32** %a, align 4 store i32* %x, i32** %a, align 4
call void @external_func_readonly(i32** %a) call void @external_func_readonly(i32** %a)
%c = load i32*, i32** %a %c = load i32*, i32** %a
load i32, i32* %x
load i32, i32* %c
ret void ret void
} }
; CHECK-LABEL: Function: test_external_call_callsite_readonly ; CHECK-LABEL: Function: test_external_call_callsite_readonly
; CHECK: MayAlias: i32* %c, i32* %x ; CHECK-DAG: MayAlias: i32* %c, i32* %x
; CHECK: NoAlias: i32* %c, i32** %a ; CHECK-DAG: NoAlias: i32** %a, i32* %c
define void @test_external_call_callsite_readonly(i32* %x) { define void @test_external_call_callsite_readonly(i32* %x) {
%a = alloca i32*, align 8 %a = alloca i32*, align 8
%b = alloca i32, align 4 %b = alloca i32, align 4
store i32* %x, i32** %a, align 4 store i32* %x, i32** %a, align 4
call void @external_func(i32** %a) readonly call void @external_func(i32** %a) readonly
%c = load i32*, i32** %a %c = load i32*, i32** %a
load i32, i32* %x
load i32, i32* %c
ret void ret void
} }
declare i32* @external_func_normal_return(i32*) declare i32* @external_func_normal_return(i32*)
; CHECK-LABEL: Function: test_external_call_normal_return ; CHECK-LABEL: Function: test_external_call_normal_return
; CHECK: MayAlias: i32* %c, i32* %x ; CHECK: MayAlias: i32* %c, i32* %x
; CHECK: MayAlias: i32* %a, i32* %c ; CHECK: MayAlias: i32* %a, i32* %c
define void @test_external_call_normal_return(i32* %x) { define void @test_external_call_normal_return(i32* %x) {
%a = alloca i32, align 8 %a = alloca i32, align 8
%b = alloca i32, align 4 %b = alloca i32, align 4
%c = call i32* @external_func_normal_return(i32* %a) %c = call i32* @external_func_normal_return(i32* %a)
load i32, i32* %x
load i32, i32* %a
load i32, i32* %c
ret void ret void
} }
declare noalias i32* @external_func_noalias_return(i32*) declare noalias i32* @external_func_noalias_return(i32*)
; CHECK-LABEL: Function: test_external_call_noalias_return ; CHECK-LABEL: Function: test_external_call_noalias_return
; CHECK: NoAlias: i32* %c, i32* %x ; CHECK: NoAlias: i32* %c, i32* %x
; CHECK: NoAlias: i32* %a, i32* %c ; CHECK: NoAlias: i32* %a, i32* %c
define void @test_external_call_noalias_return(i32* %x) { define void @test_external_call_noalias_return(i32* %x) {
%a = alloca i32, align 8 %a = alloca i32, align 8
%b = alloca i32, align 4 %b = alloca i32, align 4
%c = call i32* @external_func_noalias_return(i32* %a) %c = call i32* @external_func_noalias_return(i32* %a)
load i32, i32* %x
load i32, i32* %a
load i32, i32* %c
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Andersen/basic-interproc.ll

Show All 9 Linesdefine void @noop_callee(i32* %arg1, i32* %arg2) {
store i32 0, i32* %arg2 store i32 0, i32* %arg2
ret void ret void
} }
; CHECK-LABEL: Function: test_noop ; CHECK-LABEL: Function: test_noop
; CHECK: NoAlias: i32* %a, i32* %b ; CHECK: NoAlias: i32* %a, i32* %b
define void @test_noop() { define void @test_noop() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
load i32, i32* %a
load i32, i32* %b
call void @noop_callee(i32* %a, i32* %b) call void @noop_callee(i32* %a, i32* %b)
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Andersen/cycle.ll

; This testcase ensures that CFL AA handles assignment cycles correctly ; This testcase ensures that CFL AA handles assignment cycles correctly
; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; CHECK-LABEL: Function: test_cycle ; CHECK-LABEL: Function: test_cycle
; CHECK: NoAlias: i64* %a, i64** %b ; CHECK: NoAlias: i64* %a, i64** %b
; CHECK: NoAlias: i64* %a, i64*** %c ; CHECK: NoAlias: i64* %a, i64*** %c
; CHECK: NoAlias: i64** %b, i64*** %c ; CHECK: NoAlias: i64** %b, i64*** %c
; CHECK: NoAlias: i64* %a, i64**** %d ; CHECK: NoAlias: i64* %a, i64**** %d
; CHECK: NoAlias: i64** %b, i64**** %d ; CHECK: NoAlias: i64** %b, i64**** %d
; CHECK: NoAlias: i64*** %c, i64**** %d ; CHECK: NoAlias: i64*** %c, i64**** %d
; CHECK: NoAlias: i64* %a, i64* %e ; CHECK: NoAlias: i64* %a, i64* %e
; CHECK: NoAlias: i64* %e, i64** %b ; CHECK: NoAlias: i64** %b, i64* %e
; CHECK: NoAlias: i64* %e, i64*** %c ; CHECK: NoAlias: i64*** %c, i64* %e
; CHECK: MayAlias: i64* %a, i64* %f ; CHECK: MayAlias: i64* %a, i64* %f
; CHECK: NoAlias: i64* %f, i64** %b ; CHECK: NoAlias: i64** %b, i64* %f
; CHECK: NoAlias: i64* %f, i64*** %c ; CHECK: NoAlias: i64*** %c, i64* %f
; CHECK: MayAlias: i64* %f, i64**** %d ; CHECK: MayAlias: i64**** %d, i64* %f
; CHECK: MayAlias: i64* %e, i64* %f ; CHECK: MayAlias: i64* %e, i64* %f
define void @test_cycle() { define void @test_cycle() {
%a = alloca i64, align 8 %a = alloca i64, align 8
%b = alloca i64*, align 8 %b = alloca i64*, align 8
%c = alloca i64**, align 8 %c = alloca i64**, align 8
%d = alloca i64***, align 8 %d = alloca i64***, align 8
load i64, i64* %a
store i64* %a, i64** %b store i64* %a, i64** %b
store i64** %b, i64*** %c store i64** %b, i64*** %c
store i64*** %c, i64**** %d store i64*** %c, i64**** %d
%e = bitcast i64**** %d to i64* %e = bitcast i64**** %d to i64*
load i64, i64* %e
store i64* %e, i64** %b store i64* %e, i64** %b
%f = load i64*, i64** %b %f = load i64*, i64** %b
load i64, i64* %f
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Andersen/interproc-arg-deref-escape.ll

; This testcase ensures that CFL AA answers queries soundly when callee tries ; This testcase ensures that CFL AA answers queries soundly when callee tries
; to escape the memory pointed to by its parameters ; to escape the memory pointed to by its parameters
; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
declare void @opaque(i32*) declare void @opaque(i32*)
define void @escape_arg_deref(i32** %arg) { define void @escape_arg_deref(i32** %arg) {
%arg_deref = load i32*, i32** %arg %arg_deref = load i32*, i32** %arg
call void @opaque(i32* %arg_deref) call void @opaque(i32* %arg_deref)
ret void ret void
} }
; CHECK-LABEL: Function: test_arg_deref_escape ; CHECK-LABEL: Function: test_arg_deref_escape
; CHECK: NoAlias: i32* %a, i32** %x ; CHECK-DAG: NoAlias: i32* %a, i32** %x
; CHECK: NoAlias: i32* %b, i32** %x ; CHECK-DAG: NoAlias: i32* %b, i32** %x
; CHECK: NoAlias: i32* %a, i32* %b ; CHECK-DAG: NoAlias: i32* %a, i32* %b
; CHECK: NoAlias: i32** %p, i32** %x ; CHECK-DAG: NoAlias: i32** %p, i32** %x
; CHECK: NoAlias: i32* %a, i32** %p ; CHECK-DAG: NoAlias: i32* %a, i32** %p
; CHECK: NoAlias: i32* %b, i32** %p ; CHECK-DAG: NoAlias: i32* %b, i32** %p
; CHECK: MayAlias: i32* %a, i32* %c ; CHECK-DAG: MayAlias: i32* %a, i32* %c
; CHECK: NoAlias: i32* %b, i32* %c ; CHECK-DAG: NoAlias: i32* %b, i32* %c
; CHECK: NoAlias: i32* %c, i32** %p ; CHECK-DAG: NoAlias: i32* %c, i32** %p
define void @test_arg_deref_escape(i32** %x) { define void @test_arg_deref_escape(i32** %x) {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%p = alloca i32*, align 4 %p = alloca i32*, align 4
load i32, i32* %a
load i32, i32* %b
store i32* %a, i32** %p store i32* %a, i32** %p
call void @escape_arg_deref(i32** %p) call void @escape_arg_deref(i32** %p)
%c = load i32*, i32** %x %c = load i32*, i32** %x
load i32, i32* %c
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Andersen/interproc-arg-escape.ll

; This testcase ensures that CFL AA answers queries soundly when callee tries ; This testcase ensures that CFL AA answers queries soundly when callee tries
; to escape its parameters ; to escape its parameters
; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
declare void @opaque(i32*) declare void @opaque(i32*)
define void @escape_arg(i32* %arg) { define void @escape_arg(i32* %arg) {
call void @opaque(i32* %arg) call void @opaque(i32* %arg)
ret void ret void
} }
; CHECK-LABEL: Function: test_arg_escape ; CHECK-LABEL: Function: test_arg_escape
; CHECK: NoAlias: i32* %a, i32** %x ; CHECK-DAG: NoAlias: i32* %a, i32** %x
; CHECK: NoAlias: i32* %b, i32** %x ; CHECK-DAG: NoAlias: i32* %b, i32** %x
; CHECK: NoAlias: i32* %a, i32* %b ; CHECK-DAG: NoAlias: i32* %a, i32* %b
; CHECK: NoAlias: i32* %c, i32** %x ; CHECK-DAG: NoAlias: i32* %c, i32** %x
; CHECK: NoAlias: i32* %a, i32* %c ; CHECK-DAG: NoAlias: i32* %a, i32* %c
; CHECK: NoAlias: i32* %b, i32* %c ; CHECK-DAG: NoAlias: i32* %b, i32* %c
; CHECK: MayAlias: i32* %a, i32* %d ; CHECK-DAG: MayAlias: i32* %a, i32* %d
; CHECK: MayAlias: i32* %b, i32* %d ; CHECK-DAG: MayAlias: i32* %b, i32* %d
; CHECK: NoAlias: i32* %c, i32* %d ; CHECK-DAG: NoAlias: i32* %c, i32* %d
define void @test_arg_escape(i32** %x) { define void @test_arg_escape(i32** %x) {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%c = alloca i32, align 4 %c = alloca i32, align 4
load i32, i32* %a
load i32, i32* %b
load i32, i32* %c
call void @escape_arg(i32* %a) call void @escape_arg(i32* %a)
call void @escape_arg(i32* %b) call void @escape_arg(i32* %b)
%d = load i32*, i32** %x %d = load i32*, i32** %x
load i32, i32* %d
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Andersen/interproc-ret-arg.ll

Show All 14 Lines
; NoModRef: Ptr: i32* %a <-> %c = call i32* @return_arg_callee(i32* %a, i32* %b) ; NoModRef: Ptr: i32* %a <-> %c = call i32* @return_arg_callee(i32* %a, i32* %b)
; NoModRef: Ptr: i32* %b <-> %c = call i32* @return_arg_callee(i32* %a, i32* %b) ; NoModRef: Ptr: i32* %b <-> %c = call i32* @return_arg_callee(i32* %a, i32* %b)
; NoModRef: Ptr: i32* %c <-> %c = call i32* @return_arg_callee(i32* %a, i32* %b) ; NoModRef: Ptr: i32* %c <-> %c = call i32* @return_arg_callee(i32* %a, i32* %b)
define void @test_return_arg() { define void @test_return_arg() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%c = call i32* @return_arg_callee(i32* %a, i32* %b) %c = call i32* @return_arg_callee(i32* %a, i32* %b)
load i32, i32* %a
load i32, i32* %b
load i32, i32* %c
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Andersen/interproc-ret-deref-arg-multilevel.ll

Show All 33 Lines
; Just Ref: Ptr: i32** %lpp <-> %c = call i32* @return_deref_arg_multilevel_callee(i32*** %pp) ; Just Ref: Ptr: i32** %lpp <-> %c = call i32* @return_deref_arg_multilevel_callee(i32*** %pp)
define void @test_return_deref_arg_multilevel() { define void @test_return_deref_arg_multilevel() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%p = alloca i32*, align 8 %p = alloca i32*, align 8
%pp = alloca i32**, align 8 %pp = alloca i32**, align 8
load i32, i32* %a
load i32, i32* %b
store i32* %a, i32** %p store i32* %a, i32** %p
store i32** %p, i32*** %pp store i32** %p, i32*** %pp
%c = call i32* @return_deref_arg_multilevel_callee(i32*** %pp) %c = call i32* @return_deref_arg_multilevel_callee(i32*** %pp)
load i32, i32* %c
%lpp = load i32**, i32*** %pp %lpp = load i32**, i32*** %pp
%lpp_deref = load i32*, i32** %lpp %lpp_deref = load i32*, i32** %lpp
%lp = load i32*, i32** %p %lp = load i32*, i32** %p
load i32, i32* %lpp_deref
load i32, i32* %lp
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Andersen/interproc-ret-deref-arg.ll

Show All 21 Lines
; Just Ref: Ptr: i32** %p <-> %c = call i32* @return_deref_arg_callee(i32** %p) ; Just Ref: Ptr: i32** %p <-> %c = call i32* @return_deref_arg_callee(i32** %p)
; NoModRef: Ptr: i32* %c <-> %c = call i32* @return_deref_arg_callee(i32** %p) ; NoModRef: Ptr: i32* %c <-> %c = call i32* @return_deref_arg_callee(i32** %p)
; NoModRef: Ptr: i32* %lp <-> %c = call i32* @return_deref_arg_callee(i32** %p) ; NoModRef: Ptr: i32* %lp <-> %c = call i32* @return_deref_arg_callee(i32** %p)
define void @test_return_deref_arg() { define void @test_return_deref_arg() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%p = alloca i32*, align 8 %p = alloca i32*, align 8
load i32, i32* %a
load i32, i32* %b
store i32* %a, i32** %p store i32* %a, i32** %p
%c = call i32* @return_deref_arg_callee(i32** %p) %c = call i32* @return_deref_arg_callee(i32** %p)
load i32, i32* %c
%lp = load i32*, i32** %p %lp = load i32*, i32** %p
load i32, i32* %lp
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Andersen/interproc-ret-escape.ll

Show All 21 Lines
; CHECK: NoAlias: i32* %a, i32* %d ; CHECK: NoAlias: i32* %a, i32* %d
; CHECK: MayAlias: i32* %b, i32* %d ; CHECK: MayAlias: i32* %b, i32* %d
; CHECK: MayAlias: i32* %c, i32* %d ; CHECK: MayAlias: i32* %c, i32* %d
define void @test_return_escape(i32** %x) { define void @test_return_escape(i32** %x) {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = call i32* @return_escaped_callee() %b = call i32* @return_escaped_callee()
%c = call i32* @return_escaped_callee() %c = call i32* @return_escaped_callee()
%d = load i32*, i32** %x %d = load i32*, i32** %x
load i32, i32* %a
load i32, i32* %b
load i32, i32* %c
load i32, i32* %d
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Andersen/interproc-ret-ref-arg-multilevel.ll

Show All 9 Linesdefine i32*** @return_ref_arg_multilevel_callee(i32* %arg1) {
%ptr_cast = bitcast i8* %ptr to i32*** %ptr_cast = bitcast i8* %ptr to i32***
%ptr2 = call noalias i8* @malloc(i64 8) %ptr2 = call noalias i8* @malloc(i64 8)
%ptr_cast2 = bitcast i8* %ptr2 to i32** %ptr_cast2 = bitcast i8* %ptr2 to i32**
store i32* %arg1, i32** %ptr_cast2 store i32* %arg1, i32** %ptr_cast2
store i32** %ptr_cast2, i32*** %ptr_cast store i32** %ptr_cast2, i32*** %ptr_cast
ret i32*** %ptr_cast ret i32*** %ptr_cast
} }
; CHECK-LABEL: Function: test_return_ref_arg_multilevel ; CHECK-LABEL: Function: test_return_ref_arg_multilevel
; CHECK: NoAlias: i32* %a, i32*** %b ; CHECK-DAG: NoAlias: i32* %a, i32*** %b
; CHECK: NoAlias: i32** %p, i32*** %b ; CHECK-DAG: NoAlias: i32*** %b, i32** %p
; CHECK: NoAlias: i32*** %b, i32*** %pp ; CHECK-DAG: NoAlias: i32*** %b, i32*** %pp
; CHECK: NoAlias: i32* %a, i32** %lb ; CHECK-DAG: NoAlias: i32* %a, i32** %lb
; CHECK: NoAlias: i32** %lb, i32** %p ; CHECK-DAG: NoAlias: i32** %lb, i32** %p
; CHECK: NoAlias: i32** %lb, i32*** %pp ; CHECK-DAG: NoAlias: i32** %lb, i32*** %pp
; CHECK: NoAlias: i32** %lb, i32*** %b ; CHECK-DAG: NoAlias: i32*** %b, i32** %lb
; CHECK: MayAlias: i32* %a, i32* %lb_deref ; CHECK-DAG: MayAlias: i32* %a, i32* %lb_deref
; CHECK: NoAlias: i32* %lb_deref, i32** %lpp ; CHECK-DAG: NoAlias: i32* %lb_deref, i32** %lpp
; CHECK: MayAlias: i32* %lb_deref, i32* %lpp_deref ; CHECK-DAG: MayAlias: i32* %lb_deref, i32* %lpp_deref
; CHECK: NoAlias: i32* %lpp_deref, i32** %lpp ; CHECK-DAG: NoAlias: i32** %lpp, i32* %lpp_deref
; CHECK: MayAlias: i32* %lb_deref, i32* %lp ; CHECK-DAG: MayAlias: i32* %lb_deref, i32* %lp
; CHECK: NoAlias: i32* %lp, i32** %lpp ; CHECK-DAG: NoAlias: i32* %lp, i32** %lpp
; CHECK: MayAlias: i32* %lp, i32* %lpp_deref ; CHECK-DAG: MayAlias: i32* %lp, i32* %lpp_deref
; Temporarily disable modref checks ; Temporarily disable modref checks
; Just Mod: Ptr: i32*** %b <-> %b = call i32*** @return_ref_arg_multilevel_callee(i32* %a) ; Just Mod: Ptr: i32*** %b <-> %b = call i32*** @return_ref_arg_multilevel_callee(i32* %a)
; Just Mod: Ptr: i32** %lb <-> %b = call i32*** @return_ref_arg_multilevel_callee(i32* %a) ; Just Mod: Ptr: i32** %lb <-> %b = call i32*** @return_ref_arg_multilevel_callee(i32* %a)
define void @test_return_ref_arg_multilevel() { define void @test_return_ref_arg_multilevel() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%p = alloca i32*, align 8 %p = alloca i32*, align 8
%pp = alloca i32**, align 8 %pp = alloca i32**, align 8
load i32, i32* %a
store i32* %a, i32** %p store i32* %a, i32** %p
store i32** %p, i32*** %pp store i32** %p, i32*** %pp
%b = call i32*** @return_ref_arg_multilevel_callee(i32* %a) %b = call i32*** @return_ref_arg_multilevel_callee(i32* %a)
%lb = load i32**, i32*** %b %lb = load i32**, i32*** %b
%lb_deref = load i32*, i32** %lb %lb_deref = load i32*, i32** %lb
%lpp = load i32**, i32*** %pp %lpp = load i32**, i32*** %pp
%lpp_deref = load i32*, i32** %lpp %lpp_deref = load i32*, i32** %lpp
%lp = load i32*, i32** %p %lp = load i32*, i32** %p
load i32, i32* %lb_deref
load i32, i32* %lpp_deref
load i32, i32* %lp
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Andersen/interproc-ret-ref-arg.ll

Show All 9 Linesdefine i32** @return_ref_arg_callee(i32* %arg1) {
%ptr_cast = bitcast i8* %ptr to i32** %ptr_cast = bitcast i8* %ptr to i32**
store i32* %arg1, i32** %ptr_cast store i32* %arg1, i32** %ptr_cast
ret i32** %ptr_cast ret i32** %ptr_cast
} }
; CHECK-LABEL: Function: test_return_ref_arg ; CHECK-LABEL: Function: test_return_ref_arg
; CHECK: NoAlias: i32** %b, i32** %p ; CHECK: NoAlias: i32** %b, i32** %p
; CHECK: MayAlias: i32* %a, i32* %lb ; CHECK: MayAlias: i32* %a, i32* %lb
; CHECK: NoAlias: i32* %lb, i32** %p ; CHECK: NoAlias: i32* %lb, i32** %p
; CHECK: NoAlias: i32* %lb, i32** %b ; CHECK: NoAlias: i32** %b, i32* %lb
; CHECK: NoAlias: i32* %lp, i32** %p ; CHECK: NoAlias: i32* %lp, i32** %p
; CHECK: NoAlias: i32* %lp, i32** %b ; CHECK: NoAlias: i32** %b, i32* %lp
; CHECK: MayAlias: i32* %lb, i32* %lp ; CHECK: MayAlias: i32* %lb, i32* %lp
; Temporarily disable modref checks ; Temporarily disable modref checks
; Just Mod: Ptr: i32** %b <-> %b = call i32** @return_ref_arg_callee(i32* %a) ; Just Mod: Ptr: i32** %b <-> %b = call i32** @return_ref_arg_callee(i32* %a)
define void @test_return_ref_arg() { define void @test_return_ref_arg() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%p = alloca i32*, align 8 %p = alloca i32*, align 8
load i32, i32* %a
store i32* %a, i32** %p store i32* %a, i32** %p
%b = call i32** @return_ref_arg_callee(i32* %a) %b = call i32** @return_ref_arg_callee(i32* %a)
%lb = load i32*, i32** %b %lb = load i32*, i32** %b
%lp = load i32*, i32** %p %lp = load i32*, i32** %p
load i32, i32* %lb
load i32, i32* %lp
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Andersen/interproc-ret-unknown.ll

; This testcase ensures that CFL AA answers queries soundly when callee tries ; This testcase ensures that CFL AA answers queries soundly when callee tries
; to return an unknown pointer ; to return an unknown pointer
; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
@g = external global i32 @g = external global i32
define i32* @return_unknown_callee(i32* %arg1, i32* %arg2) { define i32* @return_unknown_callee(i32* %arg1, i32* %arg2) {
ret i32* @g ret i32* @g
} }
; CHECK-LABEL: Function: test_return_unknown ; CHECK-LABEL: Function: test_return_unknown
; CHECK: NoAlias: i32* %a, i32* %b ; CHECK-DAG: NoAlias: i32* %a, i32* %b
; CHECK: MayAlias: i32* %c, i32* %x ; CHECK-DAG: MayAlias: i32* %c, i32* %x
; CHECK: NoAlias: i32* %a, i32* %c ; CHECK-DAG: NoAlias: i32* %a, i32* %c
; CHECK: NoAlias: i32* %b, i32* %c ; CHECK-DAG: NoAlias: i32* %b, i32* %c
define void @test_return_unknown(i32* %x) { define void @test_return_unknown(i32* %x) {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%c = call i32* @return_unknown_callee(i32* %a, i32* %b) %c = call i32* @return_unknown_callee(i32* %a, i32* %b)
load i32, i32* %a
load i32, i32* %b
load i32, i32* %c
load i32, i32* %x
ret void ret void
} }
@g2 = external global i32* @g2 = external global i32*
define i32** @return_unknown_callee2() { define i32** @return_unknown_callee2() {
ret i32** @g2 ret i32** @g2
} }
; CHECK-LABEL: Function: test_return_unknown2 ; CHECK-LABEL: Function: test_return_unknown2
; CHECK: MayAlias: i32* %x, i32** %a ; CHECK-DAG: MayAlias: i32** %a, i32* %x
; CHECK: MayAlias: i32* %b, i32* %x ; CHECK-DAG: MayAlias: i32* %b, i32* %x
; CHECK: MayAlias: i32* %b, i32** %a ; CHECK-DAG: MayAlias: i32** %a, i32* %b
define void @test_return_unknown2(i32* %x) { define void @test_return_unknown2(i32* %x) {
%a = call i32** @return_unknown_callee2() %a = call i32** @return_unknown_callee2()
%b = load i32*, i32** %a %b = load i32*, i32** %a
load i32, i32* %b
load i32, i32* %x
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Andersen/interproc-store-arg-multilevel.ll

Show All 15 Lines
; CHECK: NoAlias: i32* %a, i32* %b ; CHECK: NoAlias: i32* %a, i32* %b
; CHECK: NoAlias: i32* %a, i32** %lpp ; CHECK: NoAlias: i32* %a, i32** %lpp
; CHECK: NoAlias: i32* %b, i32** %lpp ; CHECK: NoAlias: i32* %b, i32** %lpp
; CHECK: MayAlias: i32** %lpp, i32** %p ; CHECK: MayAlias: i32** %lpp, i32** %p
; CHECK: MayAlias: i32* %a, i32* %lpp_deref ; CHECK: MayAlias: i32* %a, i32* %lpp_deref
; CHECK: MayAlias: i32* %b, i32* %lpp_deref ; CHECK: MayAlias: i32* %b, i32* %lpp_deref
; CHECK: NoAlias: i32* %lpp_deref, i32** %p ; CHECK: NoAlias: i32* %lpp_deref, i32** %p
; CHECK: NoAlias: i32* %lpp_deref, i32*** %pp ; CHECK: NoAlias: i32* %lpp_deref, i32*** %pp
; CHECK: NoAlias: i32* %lpp_deref, i32** %lpp ; CHECK: NoAlias: i32** %lpp, i32* %lpp_deref
; CHECK: MayAlias: i32* %a, i32* %lp ; CHECK: MayAlias: i32* %a, i32* %lp
; CHECK: NoAlias: i32* %lp, i32*** %pp ; CHECK: NoAlias: i32* %lp, i32*** %pp
; CHECK: NoAlias: i32* %lp, i32** %lpp ; CHECK: NoAlias: i32* %lp, i32** %lpp
; CHECK: MayAlias: i32* %lp, i32* %lpp_deref ; CHECK: MayAlias: i32* %lp, i32* %lpp_deref
define void @test_store_arg_multilevel() { define void @test_store_arg_multilevel() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%p = alloca i32*, align 8 %p = alloca i32*, align 8
%pp = alloca i32**, align 8 %pp = alloca i32**, align 8
load i32, i32* %a
load i32, i32* %b
store i32* %a, i32** %p store i32* %a, i32** %p
store i32** %p, i32*** %pp store i32** %p, i32*** %pp
call void @store_arg_multilevel_callee(i32*** %pp, i32* %b) call void @store_arg_multilevel_callee(i32*** %pp, i32* %b)
%lpp = load i32**, i32*** %pp %lpp = load i32**, i32*** %pp
%lpp_deref = load i32*, i32** %lpp %lpp_deref = load i32*, i32** %lpp
%lp = load i32*, i32** %p %lp = load i32*, i32** %p
load i32, i32* %lpp_deref
load i32, i32* %lp
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Andersen/interproc-store-arg-unknown.ll

; This testcase ensures that CFL AA answers queries soundly when callee tries ; This testcase ensures that CFL AA answers queries soundly when callee tries
; to mutate the memory pointed to by its parameters ; to mutate the memory pointed to by its parameters
; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
@g = external global i32 @g = external global i32
define void @store_arg_unknown_callee(i32** %arg1) { define void @store_arg_unknown_callee(i32** %arg1) {
store i32* @g, i32** %arg1 store i32* @g, i32** %arg1
ret void ret void
} }
; CHECK-LABEL: Function: test_store_arg_unknown ; CHECK-LABEL: Function: test_store_arg_unknown
; CHECK: NoAlias: i32* %x, i32** %p ; CHECK: NoAlias: i32** %p, i32* %x
; CHECK: NoAlias: i32* %a, i32** %p ; CHECK: NoAlias: i32* %a, i32** %p
; CHECK: NoAlias: i32* %b, i32** %p ; CHECK: NoAlias: i32* %b, i32** %p
; CHECK: MayAlias: i32* %lp, i32* %x ; CHECK: MayAlias: i32* %lp, i32* %x
; CHECK: MayAlias: i32* %a, i32* %lp ; CHECK: MayAlias: i32* %a, i32* %lp
; CHECK: NoAlias: i32* %b, i32* %lp ; CHECK: NoAlias: i32* %b, i32* %lp
; CHECK: NoAlias: i32* %lp, i32** %p ; CHECK: NoAlias: i32* %lp, i32** %p
define void @test_store_arg_unknown(i32* %x) { define void @test_store_arg_unknown(i32* %x) {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%p = alloca i32*, align 8 %p = alloca i32*, align 8
load i32, i32* %x
load i32, i32* %a
load i32, i32* %b
store i32* %a, i32** %p store i32* %a, i32** %p
call void @store_arg_unknown_callee(i32** %p) call void @store_arg_unknown_callee(i32** %p)
%lp = load i32*, i32** %p %lp = load i32*, i32** %p
load i32, i32* %lp
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Andersen/interproc-store-arg.ll

Show All 22 Lines
; Just Mod: Ptr: i32** %p <-> call void @store_arg_callee(i32** %p, i32* %b) ; Just Mod: Ptr: i32** %p <-> call void @store_arg_callee(i32** %p, i32* %b)
; NoModRef: Ptr: i32** %q <-> call void @store_arg_callee(i32** %p, i32* %b) ; NoModRef: Ptr: i32** %q <-> call void @store_arg_callee(i32** %p, i32* %b)
define void @test_store_arg() { define void @test_store_arg() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%p = alloca i32*, align 8 %p = alloca i32*, align 8
%q = alloca i32*, align 8 %q = alloca i32*, align 8
load i32, i32* %a
load i32, i32* %b
store i32* %a, i32** %p store i32* %a, i32** %p
store i32* %b, i32** %q store i32* %b, i32** %q
call void @store_arg_callee(i32** %p, i32* %b) call void @store_arg_callee(i32** %p, i32* %b)
%lp = load i32*, i32** %p %lp = load i32*, i32** %p
%lq = load i32*, i32** %q %lq = load i32*, i32** %q
load i32, i32* %lp
load i32, i32* %lq
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Andersen/memalias.ll

; This testcase ensures that CFL AA correctly handles simple memory alias ; This testcase ensures that CFL AA correctly handles simple memory alias
; pattern ; pattern
; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-anders-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; CHECK-LABEL: Function: test_memalias ; CHECK-LABEL: Function: test_memalias
; CHECK: NoAlias: i64* %a, i64** %b ; CHECK: NoAlias: i64* %a, i64** %b
; CHECK: NoAlias: i32** %c, i64* %a ; CHECK: NoAlias: i64* %a, i32** %c
; CHECK: MayAlias: i32* %d, i64* %a ; CHECK: MayAlias: i64* %a, i32* %d
; CHECK: NoAlias: i32* %d, i64** %b ; CHECK: NoAlias: i64** %b, i32* %d
; CHECK: NoAlias: i32* %d, i32** %c ; CHECK: NoAlias: i32** %c, i32* %d
define void @test_memalias() { define void @test_memalias() {
%a = alloca i64, align 8 %a = alloca i64, align 8
%b = alloca i64*, align 8 %b = alloca i64*, align 8
load i64, i64* %a
store i64* %a, i64** %b store i64* %a, i64** %b
%c = bitcast i64** %b to i32** %c = bitcast i64** %b to i32**
%d = load i32*, i32** %c %d = load i32*, i32** %c
load i32, i32* %d
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/arguments-globals.ll

; This testcase ensures that CFL AA gives conservative answers on variables ; This testcase ensures that CFL AA gives conservative answers on variables
; that involve arguments. ; that involve arguments.
; (Everything should alias everything, because args can alias globals, so the ; (Everything should alias everything, because args can alias globals, so the
; aliasing sets should of args+alloca+global should be combined) ; aliasing sets should of args+alloca+global should be combined)
; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-may-aliases -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; CHECK: Function: test ; CHECK: Function: test
@g = external global i32 @g = external global i32
; CHECK: MayAlias: i32* %arg1, i32* %arg2
; CHECK: NoAlias: i32* %A, i32* %arg1
; CHECK: NoAlias: i32* %A, i32* %arg2
; CHECK: MayAlias: i32* %arg1, i32* @g
; CHECK: MayAlias: i32* %arg2, i32* @g
; CHECK: MayAlias: i32* %A, i32* @g
define void @test(i1 %c, i32* %arg1, i32* %arg2) { define void @test(i1 %c, i32* %arg1, i32* %arg2) {
; CHECK: 15 Total Alias Queries Performed %A = alloca i32
; CHECK: 0 no alias responses load i32, i32* %arg1
%A = alloca i32, align 4 load i32, i32* %arg2
%B = select i1 %c, i32* %arg1, i32* %arg2 load i32, i32* %A
%C = select i1 %c, i32* @g, i32* %A load i32, i32* @g
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/arguments.ll

; This testcase ensures that CFL AA gives conservative answers on variables ; This testcase ensures that CFL AA gives conservative answers on variables
; that involve arguments. ; that involve arguments.
; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-may-aliases -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-may-aliases -disable-output 2>&1 | FileCheck %s
; CHECK: Function: test ; CHECK: Function: test
define void @test(i1 %c, i32* %arg1, i32* %arg2) { define void @test(i1 %c, i32* %arg1, i32* %arg2) {
; CHECK: 6 Total Alias Queries Performed ; CHECK: 6 Total Alias Queries Performed
; CHECK: 3 no alias responses ; CHECK: 3 no alias responses
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = select i1 %c, i32* %arg1, i32* %arg2 %b = select i1 %c, i32* %arg1, i32* %arg2
load i32, i32* %a
load i32, i32* %b
load i32, i32* %arg1
load i32, i32* %arg2
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/asm-global-bugfix.ll

; Test case for a bug where we would crash when we were requested to report ; Test case for a bug where we would crash when we were requested to report
; whether two values that didn't belong to a function (i.e. two globals, etc) ; whether two values that didn't belong to a function (i.e. two globals, etc)
; aliased. ; aliased.
; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-may-aliases -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-may-aliases -disable-output 2>&1 | FileCheck %s
@G = private unnamed_addr constant [1 x i8] c"\00", align 1 @G = private unnamed_addr constant [1 x i8] c"\00", align 1
; CHECK: Function: test_no_crash ; CHECK: Function: test_no_crash
; CHECK: 0 no alias responses ; CHECK: 0 no alias responses
define void @test_no_crash() #0 { define void @test_no_crash() #0 {
entry: entry:
call i8* asm "nop", "=r,r"( call i8* asm "nop", "=r,r"(
i8* getelementptr inbounds ([1 x i8], [1 x i8]* @G, i64 0, i64 0)) i8* getelementptr inbounds ([1 x i8], [1 x i8]* @G, i64 0, i64 0))
load [1 x i8], [1 x i8]* @G
load i8, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @G, i64 0, i64 0)
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/attr-escape.ll

; This testcase ensures that CFL AA handles escaped values no more conservative than it should ; This testcase ensures that CFL AA handles escaped values no more conservative than it should
; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; CHECK-LABEL: Function: test_local ; CHECK-LABEL: Function: test_local
; CHECK: NoAlias: i32* %a, i32* %b ; CHECK: NoAlias: i32* %a, i32* %b
; CHECK: MayAlias: i32* %a, i32* %aAlias ; CHECK: MayAlias: i32* %a, i32* %aAlias
; CHECK: NoAlias: i32* %aAlias, i32* %b ; CHECK: NoAlias: i32* %aAlias, i32* %b
define void @test_local() { define void @test_local() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%aint = ptrtoint i32* %a to i64 %aint = ptrtoint i32* %a to i64
%aAlias = inttoptr i64 %aint to i32* %aAlias = inttoptr i64 %aint to i32*
load i32, i32* %a
load i32, i32* %b
load i32, i32* %aAlias
ret void ret void
} }
; CHECK-LABEL: Function: test_global_param ; CHECK-LABEL: Function: test_global_param
; CHECK: NoAlias: i32* %a, i32** %x ; CHECK-DAG: NoAlias: i32* %a, i32** %x
; CHECK: MayAlias: i32* %a, i32* %xload ; CHECK-DAG: MayAlias: i32* %a, i32* %xload
; CHECK: MayAlias: i32* %a, i32* %gload ; CHECK-DAG: MayAlias: i32* %a, i32* %gload
; CHECK: MayAlias: i32* %gload, i32* %xload ; CHECK-DAG: MayAlias: i32* %gload, i32* %xload
; CHECK: MayAlias: i32** %x, i32** @ext_global ; CHECK-DAG: MayAlias: i32** %x, i32** @ext_global
; CHECK: NoAlias: i32* %a, i32** @ext_global ; CHECK-DAG: NoAlias: i32* %a, i32** @ext_global
@ext_global = external global i32* @ext_global = external global i32*
define void @test_global_param(i32** %x) { define void @test_global_param(i32** %x) {
%a = alloca i32, align 4 %a = alloca i32, align 4
%aint = ptrtoint i32* %a to i64 %aint = ptrtoint i32* %a to i64
%xload = load i32*, i32** %x %xload = load i32*, i32** %x
%gload = load i32*, i32** @ext_global %gload = load i32*, i32** @ext_global
load i32, i32* %a
load i32, i32* %xload
load i32, i32* %gload
ret void ret void
} }
declare void @external_func(i32**) declare void @external_func(i32**)
; CHECK-LABEL: Function: test_external_call ; CHECK-LABEL: Function: test_external_call
; CHECK: NoAlias: i32* %b, i32* %x ; CHECK-DAG: NoAlias: i32* %b, i32* %x
; CHECK: NoAlias: i32* %b, i32** %a ; CHECK-DAG: NoAlias: i32** %a, i32* %b
; CHECK: MayAlias: i32* %c, i32* %x ; CHECK-DAG: MayAlias: i32* %c, i32* %x
; CHECK: MayAlias: i32* %c, i32** %a ; CHECK-DAG: MayAlias: i32** %a, i32* %c
; CHECK: NoAlias: i32* %b, i32* %c ; CHECK-DAG: NoAlias: i32* %b, i32* %c
define void @test_external_call(i32* %x) { define void @test_external_call(i32* %x) {
%a = alloca i32*, align 8 %a = alloca i32*, align 8
%b = alloca i32, align 4 %b = alloca i32, align 4
call void @external_func(i32** %a) call void @external_func(i32** %a)
%c = load i32*, i32** %a %c = load i32*, i32** %a
load i32, i32* %x
load i32, i32* %b
load i32, i32* %c
ret void ret void
} }
declare void @external_func_readonly(i32**) readonly declare void @external_func_readonly(i32**) readonly
; CHECK-LABEL: Function: test_external_call_func_readonly ; CHECK-LABEL: Function: test_external_call_func_readonly
; CHECK: MayAlias: i32* %c, i32* %x ; CHECK-DAG: MayAlias: i32* %c, i32* %x
; CHECK: NoAlias: i32* %c, i32** %a ; CHECK-DAG: NoAlias: i32** %a, i32* %c
define void @test_external_call_func_readonly(i32* %x) { define void @test_external_call_func_readonly(i32* %x) {
%a = alloca i32*, align 8 %a = alloca i32*, align 8
%b = alloca i32, align 4 %b = alloca i32, align 4
store i32* %x, i32** %a, align 4 store i32* %x, i32** %a, align 4
call void @external_func_readonly(i32** %a) call void @external_func_readonly(i32** %a)
%c = load i32*, i32** %a %c = load i32*, i32** %a
load i32, i32* %x
load i32, i32* %c
ret void ret void
} }
; CHECK-LABEL: Function: test_external_call_callsite_readonly ; CHECK-LABEL: Function: test_external_call_callsite_readonly
; CHECK: MayAlias: i32* %c, i32* %x ; CHECK-DAG: MayAlias: i32* %c, i32* %x
; CHECK: NoAlias: i32* %c, i32** %a ; CHECK-DAG: NoAlias: i32** %a, i32* %c
define void @test_external_call_callsite_readonly(i32* %x) { define void @test_external_call_callsite_readonly(i32* %x) {
%a = alloca i32*, align 8 %a = alloca i32*, align 8
%b = alloca i32, align 4 %b = alloca i32, align 4
store i32* %x, i32** %a, align 4 store i32* %x, i32** %a, align 4
call void @external_func(i32** %a) readonly call void @external_func(i32** %a) readonly
%c = load i32*, i32** %a %c = load i32*, i32** %a
load i32, i32* %x
load i32, i32* %c
ret void ret void
} }
declare i32* @external_func_normal_return(i32*) declare i32* @external_func_normal_return(i32*)
; CHECK-LABEL: Function: test_external_call_normal_return ; CHECK-LABEL: Function: test_external_call_normal_return
; CHECK: MayAlias: i32* %c, i32* %x ; CHECK-DAG: MayAlias: i32* %c, i32* %x
; CHECK: MayAlias: i32* %a, i32* %c ; CHECK-DAG: MayAlias: i32* %a, i32* %c
define void @test_external_call_normal_return(i32* %x) { define void @test_external_call_normal_return(i32* %x) {
%a = alloca i32, align 8 %a = alloca i32, align 8
%b = alloca i32, align 4 %b = alloca i32, align 4
%c = call i32* @external_func_normal_return(i32* %a) %c = call i32* @external_func_normal_return(i32* %a)
load i32, i32* %a
load i32, i32* %x
load i32, i32* %c
ret void ret void
} }
declare noalias i32* @external_func_noalias_return(i32*) declare noalias i32* @external_func_noalias_return(i32*)
; CHECK-LABEL: Function: test_external_call_noalias_return ; CHECK-LABEL: Function: test_external_call_noalias_return
; CHECK: NoAlias: i32* %c, i32* %x ; CHECK-DAG: NoAlias: i32* %c, i32* %x
; CHECK: NoAlias: i32* %a, i32* %c ; CHECK-DAG: NoAlias: i32* %a, i32* %c
define void @test_external_call_noalias_return(i32* %x) { define void @test_external_call_noalias_return(i32* %x) {
%a = alloca i32, align 8 %a = alloca i32, align 8
%b = alloca i32, align 4 %b = alloca i32, align 4
%c = call i32* @external_func_noalias_return(i32* %a) %c = call i32* @external_func_noalias_return(i32* %a)
load i32, i32* %a
load i32, i32* %x
load i32, i32* %c
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/basic-interproc.ll

Show All 9 Linesdefine void @noop_callee(i32* %arg1, i32* %arg2) {
store i32 0, i32* %arg2 store i32 0, i32* %arg2
ret void ret void
} }
; CHECK-LABEL: Function: test_noop ; CHECK-LABEL: Function: test_noop
; CHECK: NoAlias: i32* %a, i32* %b ; CHECK: NoAlias: i32* %a, i32* %b
define void @test_noop() { define void @test_noop() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
load i32, i32* %a
load i32, i32* %b
call void @noop_callee(i32* %a, i32* %b) call void @noop_callee(i32* %a, i32* %b)
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/branch-alias.ll

Show All 19 Linesdefine void @ptr_test() #0 {
; CHECK: MayAlias: i32** %A, i32** %ShouldAliasA ; CHECK: MayAlias: i32** %A, i32** %ShouldAliasA
; CHECK-NOT: %AliasA1 ; CHECK-NOT: %AliasA1
entry: entry:
%A = alloca i32*, align 8 %A = alloca i32*, align 8
%RefCopy = alloca i64, align 8 %RefCopy = alloca i64, align 8
%i = alloca i32, align 4 %i = alloca i32, align 4
%AliasA1 = alloca i32**, align 8 %AliasA1 = alloca i32**, align 8
%ShouldAliasA = alloca i32*, align 8 %ShouldAliasA = alloca i32*, align 8
%ignore1 = load i32*, i32** %A
store i64 0, i64* %RefCopy, align 8 store i64 0, i64* %RefCopy, align 8
store i32 0, i32* %i, align 4 store i32 0, i32* %i, align 4
br label %for.cond br label %for.cond
for.cond: ; preds = %for.inc, %entry for.cond: ; preds = %for.inc, %entry
%0 = load i32, i32* %i, align 4 %0 = load i32, i32* %i, align 4
%conv = sext i32 %0 to i64 %conv = sext i32 %0 to i64
%cmp = icmp ult i64 %conv, 64 %cmp = icmp ult i64 %conv, 64
Show All 38 Lines

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/const-expr-gep.ll

Show All 15 Lines
; CHECK: Function: test ; CHECK: Function: test
; CHECK: MayAlias: i32* %D, i32* %F ; CHECK: MayAlias: i32* %D, i32* %F
; CHECK: MayAlias: i32* %D, i8* %X ; CHECK: MayAlias: i32* %D, i8* %X
; CHECK: MayAlias: i32* %F, i8* %X ; CHECK: MayAlias: i32* %F, i8* %X
define void @test() { define void @test() {
%D = getelementptr %T, %T* @G, i64 0, i32 0 %D = getelementptr %T, %T* @G, i64 0, i32 0
%F = getelementptr i32, i32* getelementptr (%T, %T* @G, i64 0, i32 0), i64 0 %F = getelementptr i32, i32* getelementptr (%T, %T* @G, i64 0, i32 0), i64 0
%X = getelementptr [10 x i8], [10 x i8]* getelementptr (%T, %T* @G, i64 0, i32 1), i64 0, i64 5 %X = getelementptr [10 x i8], [10 x i8]* getelementptr (%T, %T* @G, i64 0, i32 1), i64 0, i64 5
load i32, i32* %D
load i32, i32* %F
load i8, i8* %X
ret void ret void
} }
; CHECK: Function: simplecheck ; CHECK: Function: simplecheck
; CHECK: MayAlias: i32* %F, i32* %arg0 ; CHECK: MayAlias: i32* %F, i32* %arg0
; CHECK: MayAlias: i32* %H, i32* %arg0 ; CHECK: MayAlias: i32* %H, i32* %arg0
; CHECK: MayAlias: i32* %F, i32* %H ; CHECK: MayAlias: i32* %F, i32* %H
define void @simplecheck(i32* %arg0) { define void @simplecheck(i32* %arg0) {
%F = getelementptr i32, i32* getelementptr (%T, %T* @G, i64 0, i32 0), i64 0 %F = getelementptr i32, i32* getelementptr (%T, %T* @G, i64 0, i32 0), i64 0
%H = getelementptr %T, %T* @G2, i64 0, i32 0 %H = getelementptr %T, %T* @G2, i64 0, i32 0
load i32, i32* %arg0
load i32, i32* %F
load i32, i32* %H
ret void ret void
} }
; Ensure that CFLSteensAA properly identifies and handles escaping variables (i.e. ; Ensure that CFLSteensAA properly identifies and handles escaping variables (i.e.
; globals) in nested ConstantExprs ; globals) in nested ConstantExprs
; CHECK: Function: checkNesting ; CHECK: Function: checkNesting
; CHECK: MayAlias: i32* %A, i32* %arg0 ; CHECK: MayAlias: i32* %A, i32* %arg0
%NestedT = type { [1 x [1 x i32]] } %NestedT = type { [1 x [1 x i32]] }
@NT = external global %NestedT @NT = external global %NestedT
define void @checkNesting(i32* %arg0) { define void @checkNesting(i32* %arg0) {
%A = getelementptr [1 x i32], %A = getelementptr [1 x i32],
[1 x i32]* getelementptr [1 x i32]* getelementptr
([1 x [1 x i32]], [1 x [1 x i32]]* getelementptr (%NestedT, %NestedT* @NT, i64 0, i32 0), ([1 x [1 x i32]], [1 x [1 x i32]]* getelementptr (%NestedT, %NestedT* @NT, i64 0, i32 0),
i64 0, i64 0,
i32 0), i32 0),
i64 0, i64 0,
i32 0 i32 0
load i32, i32* %arg0
load i32, i32* %A
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/const-exprs.ll

; RUN: opt %s -S -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s ; RUN: opt %s -S -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s
; ;
; Regression: we weren't properly checking constexpr selects. ; Regression: we weren't properly checking constexpr selects.
@g = extern_weak dso_local global i32, align 4 @g = extern_weak dso_local global i32, align 4
@g2 = extern_weak dso_local global i32, align 4 @g2 = extern_weak dso_local global i32, align 4
@g3 = extern_weak dso_local global i32, align 4 @g3 = extern_weak dso_local global i32, align 4
; CHECK-LABEL: Function: foo ; CHECK-LABEL: Function: foo
; CHECK: NoAlias: i32* select (i1 icmp ne (i32* @g, i32* null), i32* @g2, i32* @g3), i32** %a ; CHECK-DAG: NoAlias: i32** %a, i32* select (i1 icmp ne (i32* @g, i32* null), i32* @g2, i32* @g3)
; CHECK: NoAlias: i32* %b, i32** %a ; CHECK-DAG: NoAlias: i32** %a, i32* %b
; CHECK: MayAlias: i32* %b, i32* select (i1 icmp ne (i32* @g, i32* null), i32* @g2, i32* @g3) ; CHECK-DAG: MayAlias: i32* %b, i32* select (i1 icmp ne (i32* @g, i32* null), i32* @g2, i32* @g3)
; CHECK: NoAlias: i32* @g2, i32** %a ; CHECK-DAG: NoAlias: i32** %a, i32* @g2
; CHECK: MayAlias: i32* @g2, i32* select (i1 icmp ne (i32* @g, i32* null), i32* @g2, i32* @g3) ; CHECK-DAG: MayAlias: i32* @g2, i32* select (i1 icmp ne (i32* @g, i32* null), i32* @g2, i32* @g3)
; CHECK: MayAlias: i32* %b, i32* @g2 ; CHECK-DAG: MayAlias: i32* %b, i32* @g2
; CHECK: NoAlias: i32* @g3, i32** %a ; CHECK-DAG: NoAlias: i32** %a, i32* @g3
; CHECK: MayAlias: i32* @g3, i32* select (i1 icmp ne (i32* @g, i32* null), i32* @g2, i32* @g3) ; CHECK-DAG: MayAlias: i32* @g3, i32* select (i1 icmp ne (i32* @g, i32* null), i32* @g2, i32* @g3)
; CHECK: MayAlias: i32* %b, i32* @g3 ; CHECK-DAG: MayAlias: i32* %b, i32* @g3
; CHECK: MayAlias: i32* @g2, i32* @g3 ; CHECK-DAG: MayAlias: i32* @g2, i32* @g3
define void @foo() { define void @foo() {
entry: entry:
%a = alloca i32*, align 8 %a = alloca i32*, align 8
load i32, i32* select (i1 icmp ne (i32* @g, i32* null), i32* @g2, i32* @g3)
store i32* select (i1 icmp ne (i32* @g, i32* null), i32* @g2, i32* @g3), i32** %a store i32* select (i1 icmp ne (i32* @g, i32* null), i32* @g2, i32* @g3), i32** %a
%b = load i32*, i32** %a %b = load i32*, i32** %a
%c = load i32, i32* %b %c = load i32, i32* %b
%d = load i32, i32* @g2 %d = load i32, i32* @g2
%e = load i32, i32* @g3 %e = load i32, i32* @g3
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/gep-index-no-alias.ll

; This testcase ensures that gep result does not alias gep indices ; This testcase ensures that gep result does not alias gep indices
; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-no-aliases -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-no-aliases -disable-output 2>&1 | FileCheck %s
; CHECK: Function: foo ; CHECK: Function: foo
; CHECK: [2 x i32]* %a, [2 x i32]* %b ; CHECK: [2 x i32]* %a, [2 x i32]* %b
define void @foo(i32 %n) { define void @foo(i32 %n) {
%a = alloca [2 x i32], align 4 %a = alloca [2 x i32], align 4
%b = alloca [2 x i32], align 4 %b = alloca [2 x i32], align 4
%c = getelementptr inbounds [2 x i32], [2 x i32]* %a, i32 0, i32 %n %c = getelementptr inbounds [2 x i32], [2 x i32]* %a, i32 0, i32 %n
%d = getelementptr inbounds [2 x i32], [2 x i32]* %b, i32 0, i32 %n %d = getelementptr inbounds [2 x i32], [2 x i32]* %b, i32 0, i32 %n
load [2 x i32], [2 x i32]* %a
load [2 x i32], [2 x i32]* %b
load i32, i32* %c
load i32, i32* %d
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/interproc-arg-deref-escape.ll

; This testcase ensures that CFL AA answers queries soundly when callee tries ; This testcase ensures that CFL AA answers queries soundly when callee tries
; to escape the memory pointed to by its parameters ; to escape the memory pointed to by its parameters
; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
declare void @opaque(i32*) declare void @opaque(i32*)
define void @escape_arg_deref(i32** %arg) { define void @escape_arg_deref(i32** %arg) {
%arg_deref = load i32*, i32** %arg %arg_deref = load i32*, i32** %arg
call void @opaque(i32* %arg_deref) call void @opaque(i32* %arg_deref)
ret void ret void
} }
; CHECK-LABEL: Function: test_arg_deref_escape ; CHECK-LABEL: Function: test_arg_deref_escape
; CHECK: NoAlias: i32* %a, i32** %x ; CHECK-DAG: NoAlias: i32* %a, i32** %x
; CHECK: NoAlias: i32* %b, i32** %x ; CHECK-DAG: NoAlias: i32* %b, i32** %x
; CHECK: NoAlias: i32* %a, i32* %b ; CHECK-DAG: NoAlias: i32* %a, i32* %b
; CHECK: NoAlias: i32** %p, i32** %x ; CHECK-DAG: NoAlias: i32** %p, i32** %x
; CHECK: NoAlias: i32* %a, i32** %p ; CHECK-DAG: NoAlias: i32* %a, i32** %p
; CHECK: NoAlias: i32* %b, i32** %p ; CHECK-DAG: NoAlias: i32* %b, i32** %p
; CHECK: MayAlias: i32* %a, i32* %c ; CHECK-DAG: MayAlias: i32* %a, i32* %c
; CHECK: NoAlias: i32* %b, i32* %c ; CHECK-DAG: NoAlias: i32* %b, i32* %c
; CHECK: NoAlias: i32* %c, i32** %p ; CHECK-DAG: NoAlias: i32* %c, i32** %p
define void @test_arg_deref_escape(i32** %x) { define void @test_arg_deref_escape(i32** %x) {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%p = alloca i32*, align 4 %p = alloca i32*, align 4
load i32, i32* %a
load i32, i32* %b
store i32* %a, i32** %p store i32* %a, i32** %p
call void @escape_arg_deref(i32** %p) call void @escape_arg_deref(i32** %p)
%c = load i32*, i32** %x %c = load i32*, i32** %x
load i32, i32* %c
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/interproc-arg-escape.ll

; This testcase ensures that CFL AA answers queries soundly when callee tries ; This testcase ensures that CFL AA answers queries soundly when callee tries
; to escape its parameters ; to escape its parameters
; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
declare void @opaque(i32*) declare void @opaque(i32*)
define void @escape_arg(i32* %arg) { define void @escape_arg(i32* %arg) {
call void @opaque(i32* %arg) call void @opaque(i32* %arg)
ret void ret void
} }
; CHECK-LABEL: Function: test_arg_escape ; CHECK-LABEL: Function: test_arg_escape
; CHECK: NoAlias: i32* %a, i32** %x ; CHECK-DAG: NoAlias: i32* %a, i32** %x
; CHECK: NoAlias: i32* %b, i32** %x ; CHECK-DAG: NoAlias: i32* %b, i32** %x
; CHECK: NoAlias: i32* %a, i32* %b ; CHECK-DAG: NoAlias: i32* %a, i32* %b
; CHECK: NoAlias: i32* %c, i32** %x ; CHECK-DAG: NoAlias: i32* %c, i32** %x
; CHECK: NoAlias: i32* %a, i32* %c ; CHECK-DAG: NoAlias: i32* %a, i32* %c
; CHECK: NoAlias: i32* %b, i32* %c ; CHECK-DAG: NoAlias: i32* %b, i32* %c
; CHECK: MayAlias: i32* %a, i32* %d ; CHECK-DAG: MayAlias: i32* %a, i32* %d
; CHECK: MayAlias: i32* %b, i32* %d ; CHECK-DAG: MayAlias: i32* %b, i32* %d
; CHECK: NoAlias: i32* %c, i32* %d ; CHECK-DAG: NoAlias: i32* %c, i32* %d
define void @test_arg_escape(i32** %x) { define void @test_arg_escape(i32** %x) {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%c = alloca i32, align 4 %c = alloca i32, align 4
load i32, i32* %a
load i32, i32* %b
load i32, i32* %c
call void @escape_arg(i32* %a) call void @escape_arg(i32* %a)
call void @escape_arg(i32* %b) call void @escape_arg(i32* %b)
%d = load i32*, i32** %x %d = load i32*, i32** %x
load i32, i32* %d
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/interproc-ret-arg.ll

Show All 11 Lines
; CHECK: NoAlias: i32* %b, i32* %c ; CHECK: NoAlias: i32* %b, i32* %c
; Temporarily disable modref checks ; Temporarily disable modref checks
; NoModRef: Ptr: i32* %b <-> %c = call i32* @return_arg_callee(i32* %a, i32* %b) ; NoModRef: Ptr: i32* %b <-> %c = call i32* @return_arg_callee(i32* %a, i32* %b)
define void @test_return_arg() { define void @test_return_arg() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
load i32, i32* %a
load i32, i32* %b
%c = call i32* @return_arg_callee(i32* %a, i32* %b) %c = call i32* @return_arg_callee(i32* %a, i32* %b)
load i32, i32* %c
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/interproc-ret-deref-arg-multilevel.ll

Show All 27 Lines
; CHECK: NoAlias: i32* %lp, i32** %lpp ; CHECK: NoAlias: i32* %lp, i32** %lpp
; CHECK: MayAlias: i32* %lp, i32* %lpp_deref ; CHECK: MayAlias: i32* %lp, i32* %lpp_deref
define void @test_return_deref_arg_multilevel() { define void @test_return_deref_arg_multilevel() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%p = alloca i32*, align 8 %p = alloca i32*, align 8
%pp = alloca i32**, align 8 %pp = alloca i32**, align 8
load i32, i32* %a
load i32, i32* %b
store i32* %a, i32** %p store i32* %a, i32** %p
store i32** %p, i32*** %pp store i32** %p, i32*** %pp
%c = call i32* @return_deref_arg_multilevel_callee(i32*** %pp) %c = call i32* @return_deref_arg_multilevel_callee(i32*** %pp)
load i32, i32* %c
%lpp = load i32**, i32*** %pp %lpp = load i32**, i32*** %pp
%lpp_deref = load i32*, i32** %lpp %lpp_deref = load i32*, i32** %lpp
%lp = load i32*, i32** %p %lp = load i32*, i32** %p
load i32, i32* %lpp_deref
load i32, i32* %lp
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/interproc-ret-deref-arg.ll

Show All 14 Lines
; CHECK: NoAlias: i32* %b, i32* %lp ; CHECK: NoAlias: i32* %b, i32* %lp
; CHECK: NoAlias: i32* %lp, i32** %p ; CHECK: NoAlias: i32* %lp, i32** %p
; CHECK: MayAlias: i32* %c, i32* %lp ; CHECK: MayAlias: i32* %c, i32* %lp
define void @test_return_deref_arg() { define void @test_return_deref_arg() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%p = alloca i32*, align 8 %p = alloca i32*, align 8
load i32, i32* %a
load i32, i32* %b
store i32* %a, i32** %p store i32* %a, i32** %p
%c = call i32* @return_deref_arg_callee(i32** %p) %c = call i32* @return_deref_arg_callee(i32** %p)
%lp = load i32*, i32** %p %lp = load i32*, i32** %p
load i32, i32* %c
load i32, i32* %lp
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/interproc-ret-escape.ll

; This testcase ensures that CFL AA answers queries soundly when callee tries ; This testcase ensures that CFL AA answers queries soundly when callee tries
; to return an escaped pointer ; to return an escaped pointer
; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
declare noalias i8* @malloc(i64) declare noalias i8* @malloc(i64)
declare void @opaque(i32*) declare void @opaque(i32*)
define i32* @return_escaped_callee() { define i32* @return_escaped_callee() {
%ptr = call noalias i8* @malloc(i64 8) %ptr = call noalias i8* @malloc(i64 8)
%ptr_cast = bitcast i8* %ptr to i32* %ptr_cast = bitcast i8* %ptr to i32*
call void @opaque(i32* %ptr_cast) call void @opaque(i32* %ptr_cast)
ret i32* %ptr_cast ret i32* %ptr_cast
} }
; CHECK-LABEL: Function: test_return_escape ; CHECK-LABEL: Function: test_return_escape
; CHECK: NoAlias: i32* %a, i32** %x ; CHECK-DAG: NoAlias: i32* %a, i32** %x
; CHECK: NoAlias: i32* %b, i32** %x ; CHECK-DAG: NoAlias: i32* %b, i32** %x
; CHECK: NoAlias: i32* %a, i32* %b ; CHECK-DAG: NoAlias: i32* %a, i32* %b
; CHECK: NoAlias: i32* %c, i32** %x ; CHECK-DAG: NoAlias: i32* %c, i32** %x
; CHECK: NoAlias: i32* %a, i32* %c ; CHECK-DAG: NoAlias: i32* %a, i32* %c
; CHECK: NoAlias: i32* %b, i32* %c ; CHECK-DAG: NoAlias: i32* %b, i32* %c
; CHECK: NoAlias: i32* %a, i32* %d ; CHECK-DAG: NoAlias: i32* %a, i32* %d
; CHECK: MayAlias: i32* %b, i32* %d ; CHECK-DAG: MayAlias: i32* %b, i32* %d
; CHECK: MayAlias: i32* %c, i32* %d ; CHECK-DAG: MayAlias: i32* %c, i32* %d
define void @test_return_escape(i32** %x) { define void @test_return_escape(i32** %x) {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = call i32* @return_escaped_callee() %b = call i32* @return_escaped_callee()
%c = call i32* @return_escaped_callee() %c = call i32* @return_escaped_callee()
load i32, i32* %a
load i32, i32* %b
load i32, i32* %c
%d = load i32*, i32** %x %d = load i32*, i32** %x
load i32, i32* %d
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/interproc-ret-ref-arg-multilevel.ll

Show All 9 Linesdefine i32*** @return_ref_arg_multilevel_callee(i32* %arg1) {
%ptr_cast = bitcast i8* %ptr to i32*** %ptr_cast = bitcast i8* %ptr to i32***
%ptr2 = call noalias i8* @malloc(i64 8) %ptr2 = call noalias i8* @malloc(i64 8)
%ptr_cast2 = bitcast i8* %ptr2 to i32** %ptr_cast2 = bitcast i8* %ptr2 to i32**
store i32* %arg1, i32** %ptr_cast2 store i32* %arg1, i32** %ptr_cast2
store i32** %ptr_cast2, i32*** %ptr_cast store i32** %ptr_cast2, i32*** %ptr_cast
ret i32*** %ptr_cast ret i32*** %ptr_cast
} }
; CHECK-LABEL: Function: test_return_ref_arg_multilevel ; CHECK-LABEL: Function: test_return_ref_arg_multilevel
; CHECK: NoAlias: i32* %a, i32*** %b ; CHECK-DAG: NoAlias: i32* %a, i32*** %b
; CHECK: NoAlias: i32** %p, i32*** %b ; CHECK-DAG: NoAlias: i32*** %b, i32** %p
; CHECK: NoAlias: i32* %a, i32** %lb ; CHECK-DAG: NoAlias: i32* %a, i32** %lb
; CHECK: NoAlias: i32** %lb, i32*** %pp ; CHECK-DAG: NoAlias: i32** %lb, i32*** %pp
; CHECK: NoAlias: i32** %lb, i32*** %b ; CHECK-DAG: NoAlias: i32*** %b, i32** %lb
; CHECK: MayAlias: i32* %a, i32* %lb_deref ; CHECK-DAG: MayAlias: i32* %a, i32* %lb_deref
; CHECK: NoAlias: i32* %lb_deref, i32** %lpp ; CHECK-DAG: NoAlias: i32* %lb_deref, i32** %lpp
; CHECK: MayAlias: i32* %lb_deref, i32* %lpp_deref ; CHECK-DAG: MayAlias: i32* %lb_deref, i32* %lpp_deref
; CHECK: NoAlias: i32* %lpp_deref, i32** %lpp ; CHECK-DAG: NoAlias: i32** %lpp, i32* %lpp_deref
; CHECK: MayAlias: i32* %lb_deref, i32* %lp ; CHECK-DAG: MayAlias: i32* %lb_deref, i32* %lp
; CHECK: NoAlias: i32* %lp, i32** %lpp ; CHECK-DAG: NoAlias: i32* %lp, i32** %lpp
; CHECK: MayAlias: i32* %lp, i32* %lpp_deref ; CHECK-DAG: MayAlias: i32* %lp, i32* %lpp_deref
; We could've proven the following facts if the analysis were inclusion-based: ; We could've proven the following facts if the analysis were inclusion-based:
; NoAlias: i32*** %b, i32*** %pp ; NoAlias: i32*** %b, i32*** %pp
; NoAlias: i32** %lb, i32** %p ; NoAlias: i32** %lb, i32** %p
define void @test_return_ref_arg_multilevel() { define void @test_return_ref_arg_multilevel() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%p = alloca i32*, align 8 %p = alloca i32*, align 8
%pp = alloca i32**, align 8 %pp = alloca i32**, align 8
load i32, i32* %a
store i32* %a, i32** %p store i32* %a, i32** %p
store i32** %p, i32*** %pp store i32** %p, i32*** %pp
%b = call i32*** @return_ref_arg_multilevel_callee(i32* %a) %b = call i32*** @return_ref_arg_multilevel_callee(i32* %a)
%lb = load i32**, i32*** %b %lb = load i32**, i32*** %b
%lb_deref = load i32*, i32** %lb %lb_deref = load i32*, i32** %lb
%lpp = load i32**, i32*** %pp %lpp = load i32**, i32*** %pp
%lpp_deref = load i32*, i32** %lpp %lpp_deref = load i32*, i32** %lpp
%lp = load i32*, i32** %p %lp = load i32*, i32** %p
load i32, i32* %lb_deref
load i32, i32* %lpp_deref
load i32, i32* %lp
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/interproc-ret-ref-arg.ll

; This testcase ensures that CFL AA answers queries soundly when callee tries ; This testcase ensures that CFL AA answers queries soundly when callee tries
; to return the reference of one of its parameters ; to return the reference of one of its parameters
; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
declare noalias i8* @malloc(i64) declare noalias i8* @malloc(i64)
define i32** @return_ref_arg_callee(i32* %arg1) { define i32** @return_ref_arg_callee(i32* %arg1) {
%ptr = call noalias i8* @malloc(i64 8) %ptr = call noalias i8* @malloc(i64 8)
%ptr_cast = bitcast i8* %ptr to i32** %ptr_cast = bitcast i8* %ptr to i32**
store i32* %arg1, i32** %ptr_cast store i32* %arg1, i32** %ptr_cast
ret i32** %ptr_cast ret i32** %ptr_cast
} }
; CHECK-LABEL: Function: test_return_ref_arg ; CHECK-LABEL: Function: test_return_ref_arg
; CHECK: MayAlias: i32* %a, i32* %lb ; CHECK: MayAlias: i32* %a, i32* %lb
; CHECK: NoAlias: i32* %lb, i32** %p ; CHECK: NoAlias: i32* %lb, i32** %p
; CHECK: NoAlias: i32* %lb, i32** %b ; CHECK: NoAlias: i32** %b, i32* %lb
; CHECK: NoAlias: i32* %lp, i32** %p ; CHECK: NoAlias: i32* %lp, i32** %p
; CHECK: NoAlias: i32* %lp, i32** %b ; CHECK: NoAlias: i32** %b, i32* %lp
; CHECK: MayAlias: i32* %lb, i32* %lp ; CHECK: MayAlias: i32* %lb, i32* %lp
; We could've proven the following facts if the analysis were inclusion-based: ; We could've proven the following facts if the analysis were inclusion-based:
; NoAlias: i32** %b, i32** %p ; NoAlias: i32** %b, i32** %p
define void @test_return_ref_arg() { define void @test_return_ref_arg() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%p = alloca i32*, align 8 %p = alloca i32*, align 8
load i32, i32* %a
store i32* %a, i32** %p store i32* %a, i32** %p
%b = call i32** @return_ref_arg_callee(i32* %a) %b = call i32** @return_ref_arg_callee(i32* %a)
%lb = load i32*, i32** %b %lb = load i32*, i32** %b
%lp = load i32*, i32** %p %lp = load i32*, i32** %p
load i32, i32* %lb
load i32, i32* %lp
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/interproc-ret-unknown.ll

Show All 10 Lines
; CHECK: NoAlias: i32* %a, i32* %b ; CHECK: NoAlias: i32* %a, i32* %b
; CHECK: MayAlias: i32* %c, i32* %x ; CHECK: MayAlias: i32* %c, i32* %x
; CHECK: NoAlias: i32* %a, i32* %c ; CHECK: NoAlias: i32* %a, i32* %c
; CHECK: NoAlias: i32* %b, i32* %c ; CHECK: NoAlias: i32* %b, i32* %c
define void @test_return_unknown(i32* %x) { define void @test_return_unknown(i32* %x) {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
load i32, i32* %x
load i32, i32* %a
load i32, i32* %b
%c = call i32* @return_unknown_callee(i32* %a, i32* %b) %c = call i32* @return_unknown_callee(i32* %a, i32* %b)
load i32, i32* %c
ret void ret void
} }
@g2 = external global i32* @g2 = external global i32*
define i32** @return_unknown_callee2() { define i32** @return_unknown_callee2() {
ret i32** @g2 ret i32** @g2
} }
; CHECK-LABEL: Function: test_return_unknown2 ; CHECK-LABEL: Function: test_return_unknown2
; CHECK: MayAlias: i32* %x, i32** %a ; CHECK: MayAlias: i32** %a, i32* %x
; CHECK: MayAlias: i32* %b, i32* %x ; CHECK: MayAlias: i32* %b, i32* %x
; CHECK: MayAlias: i32* %b, i32** %a ; CHECK: MayAlias: i32** %a, i32* %b
define void @test_return_unknown2(i32* %x) { define void @test_return_unknown2(i32* %x) {
load i32, i32* %x
%a = call i32** @return_unknown_callee2() %a = call i32** @return_unknown_callee2()
%b = load i32*, i32** %a %b = load i32*, i32** %a
load i32, i32* %b
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/interproc-store-arg-multilevel.ll

Show All 14 Lines
; CHECK-LABEL: Function: test_store_arg_multilevel ; CHECK-LABEL: Function: test_store_arg_multilevel
; CHECK: NoAlias: i32* %a, i32** %lpp ; CHECK: NoAlias: i32* %a, i32** %lpp
; CHECK: NoAlias: i32* %b, i32** %lpp ; CHECK: NoAlias: i32* %b, i32** %lpp
; CHECK: MayAlias: i32** %lpp, i32** %p ; CHECK: MayAlias: i32** %lpp, i32** %p
; CHECK: MayAlias: i32* %a, i32* %lpp_deref ; CHECK: MayAlias: i32* %a, i32* %lpp_deref
; CHECK: MayAlias: i32* %b, i32* %lpp_deref ; CHECK: MayAlias: i32* %b, i32* %lpp_deref
; CHECK: NoAlias: i32* %lpp_deref, i32** %p ; CHECK: NoAlias: i32* %lpp_deref, i32** %p
; CHECK: NoAlias: i32* %lpp_deref, i32*** %pp ; CHECK: NoAlias: i32* %lpp_deref, i32*** %pp
; CHECK: NoAlias: i32* %lpp_deref, i32** %lpp ; CHECK: NoAlias: i32** %lpp, i32* %lpp_deref
; CHECK: MayAlias: i32* %a, i32* %lp ; CHECK: MayAlias: i32* %a, i32* %lp
; CHECK: NoAlias: i32* %lp, i32*** %pp ; CHECK: NoAlias: i32* %lp, i32*** %pp
; CHECK: NoAlias: i32* %lp, i32** %lpp ; CHECK: NoAlias: i32* %lp, i32** %lpp
; CHECK: MayAlias: i32* %lp, i32* %lpp_deref ; CHECK: MayAlias: i32* %lp, i32* %lpp_deref
; We could've proven the following facts if the analysis were inclusion-based: ; We could've proven the following facts if the analysis were inclusion-based:
; NoAlias: i32* %a, i32* %b ; NoAlias: i32* %a, i32* %b
define void @test_store_arg_multilevel() { define void @test_store_arg_multilevel() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%p = alloca i32*, align 8 %p = alloca i32*, align 8
%pp = alloca i32**, align 8 %pp = alloca i32**, align 8
load i32, i32* %a
load i32, i32* %b
store i32* %a, i32** %p store i32* %a, i32** %p
store i32** %p, i32*** %pp store i32** %p, i32*** %pp
call void @store_arg_multilevel_callee(i32*** %pp, i32* %b) call void @store_arg_multilevel_callee(i32*** %pp, i32* %b)
%lpp = load i32**, i32*** %pp %lpp = load i32**, i32*** %pp
%lpp_deref = load i32*, i32** %lpp %lpp_deref = load i32*, i32** %lpp
%lp = load i32*, i32** %p %lp = load i32*, i32** %p
load i32, i32* %lpp_deref
load i32, i32* %lp
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/interproc-store-arg-unknown.ll

; This testcase ensures that CFL AA answers queries soundly when callee tries ; This testcase ensures that CFL AA answers queries soundly when callee tries
; to mutate the memory pointed to by its parameters ; to mutate the memory pointed to by its parameters
; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
@g = external global i32 @g = external global i32
define void @store_arg_unknown_callee(i32** %arg1) { define void @store_arg_unknown_callee(i32** %arg1) {
store i32* @g, i32** %arg1 store i32* @g, i32** %arg1
ret void ret void
} }
; CHECK-LABEL: Function: test_store_arg_unknown ; CHECK-LABEL: Function: test_store_arg_unknown
; CHECK: NoAlias: i32* %x, i32** %p ; CHECK: NoAlias: i32** %p, i32* %x
; CHECK: NoAlias: i32* %a, i32** %p ; CHECK: NoAlias: i32* %a, i32** %p
; CHECK: NoAlias: i32* %b, i32** %p ; CHECK: NoAlias: i32* %b, i32** %p
; CHECK: MayAlias: i32* %lp, i32* %x ; CHECK: MayAlias: i32* %lp, i32* %x
; CHECK: MayAlias: i32* %a, i32* %lp ; CHECK: MayAlias: i32* %a, i32* %lp
; CHECK: NoAlias: i32* %b, i32* %lp ; CHECK: NoAlias: i32* %b, i32* %lp
; CHECK: NoAlias: i32* %lp, i32** %p ; CHECK: NoAlias: i32* %lp, i32** %p
define void @test_store_arg_unknown(i32* %x) { define void @test_store_arg_unknown(i32* %x) {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%p = alloca i32*, align 8 %p = alloca i32*, align 8
load i32, i32* %x
load i32, i32* %a
load i32, i32* %b
store i32* %a, i32** %p store i32* %a, i32** %p
call void @store_arg_unknown_callee(i32** %p) call void @store_arg_unknown_callee(i32** %p)
%lp = load i32*, i32** %p %lp = load i32*, i32** %p
load i32, i32* %lp
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/interproc-store-arg.ll

Show All 18 Lines
; NoAlias: i32* %a, i32* %b ; NoAlias: i32* %a, i32* %b
; NoAlias: i32* %a, i32* %lq ; NoAlias: i32* %a, i32* %lq
define void @test_store_arg() { define void @test_store_arg() {
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = alloca i32, align 4 %b = alloca i32, align 4
%p = alloca i32*, align 8 %p = alloca i32*, align 8
%q = alloca i32*, align 8 %q = alloca i32*, align 8
load i32, i32* %a
load i32, i32* %b
store i32* %a, i32** %p store i32* %a, i32** %p
store i32* %b, i32** %q store i32* %b, i32** %q
call void @store_arg_callee(i32** %p, i32* %b) call void @store_arg_callee(i32** %p, i32* %b)
%lp = load i32*, i32** %p %lp = load i32*, i32** %p
%lq = load i32*, i32** %q %lq = load i32*, i32** %q
load i32, i32* %lp
load i32, i32* %lq
ret void ret void
} }
No newline at end of file

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/malloc-and-free.ll

; This testcase ensures that CFL AA handles malloc and free in a sound and precise manner ; This testcase ensures that CFL AA handles malloc and free in a sound and precise manner
; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-no-aliases -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-no-aliases -disable-output 2>&1 | FileCheck %s
declare noalias i8* @malloc(i64) declare noalias i8* @malloc(i64)
declare noalias i8* @calloc(i64, i64) declare noalias i8* @calloc(i64, i64)
declare void @free(i8* nocapture) declare void @free(i8* nocapture)
; CHECK: Function: test_malloc ; CHECK: Function: test_malloc
; CHECK: NoAlias: i8* %p, i8* %q ; CHECK: NoAlias: i8* %p, i8* %q
define void @test_malloc(i8* %p) { define void @test_malloc(i8* %p) {
%q = call i8* @malloc(i64 4) %q = call i8* @malloc(i64 4)
load i8, i8* %p
load i8, i8* %q
ret void ret void
} }
; CHECK: Function: test_calloc ; CHECK: Function: test_calloc
; CHECK: NoAlias: i8* %p, i8* %q ; CHECK: NoAlias: i8* %p, i8* %q
define void @test_calloc(i8* %p) { define void @test_calloc(i8* %p) {
%q = call i8* @calloc(i64 2, i64 4) %q = call i8* @calloc(i64 2, i64 4)
load i8, i8* %p
load i8, i8* %q
ret void ret void
} }
; CHECK: Function: test_free ; CHECK: Function: test_free
; CHECK: NoAlias: i8* %p, i8* %q ; CHECK: NoAlias: i8* %p, i8* %q
define void @test_free(i8* %p) { define void @test_free(i8* %p) {
%q = alloca i8, align 4 %q = alloca i8, align 4
call void @free(i8* %q) call void @free(i8* %q)
load i8, i8* %p
load i8, i8* %q
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/multilevel-combine.ll

Show All 20 Lines; CHECK: 4 no alias responses
%A = alloca %T, align 8 %A = alloca %T, align 8
%B = alloca %T, align 8 %B = alloca %T, align 8
%MS = select i1 %C, %T* %B, %T* %A %MS = select i1 %C, %T* %B, %T* %A
store %T* %MS, %T** %M store %T* %MS, %T** %M
%AP = load %T*, %T** %M ; PartialAlias with %A, %B %AP = load %T*, %T** %M ; PartialAlias with %A, %B
load %T, %T* %A
load %T, %T* %B
load %T, %T* %MS
load %T, %T* %AP
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/multilevel.ll

Show All 19 Lines; CHECK: 13 no alias responses
%A = alloca %T, align 8 %A = alloca %T, align 8
%B = alloca %T, align 8 %B = alloca %T, align 8
store %T* %A, %T** %M store %T* %A, %T** %M
store %T* %B, %T** %N store %T* %B, %T** %N
%AP = load %T*, %T** %M ; PartialAlias with %A %AP = load %T*, %T** %M ; PartialAlias with %A
%BP = load %T*, %T** %N ; PartialAlias with %B %BP = load %T*, %T** %N ; PartialAlias with %B
load %T, %T* %A
load %T, %T* %B
load %T, %T* %AP
load %T, %T* %BP
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/must-and-partial.ll

Show All 35 Linesentry:
%bigbase1 = bitcast i8* %base to i16* %bigbase1 = bitcast i8* %base to i16*
store i16 -1, i16* %bigbase1 store i16 -1, i16* %bigbase1
%loaded = load i8, i8* %sel %loaded = load i8, i8* %sel
ret i8 %loaded ret i8 %loaded
} }
; Incoming pointer arguments should not be PartialAlias because we do not know their initial state ; Incoming pointer arguments should not be MayAlias because we do not know their initial state
; even if they are nocapture ; even if they are nocapture
; CHECK: MayAlias: double* %A, double* %Index ; CHECK: MayAlias: double* %A, double* %Index
define void @testr2(double* nocapture readonly %A, double* nocapture readonly %Index) { define void @testr2(double* nocapture readonly %A, double* nocapture readonly %Index) {
%arrayidx22 = getelementptr inbounds double, double* %Index, i64 2 %arrayidx22 = getelementptr inbounds double, double* %Index, i64 2
%1 = load double, double* %arrayidx22 %1 = load double, double* %arrayidx22
%arrayidx25 = getelementptr inbounds double, double* %A, i64 2 %arrayidx25 = getelementptr inbounds double, double* %A, i64 2
%2 = load double, double* %arrayidx25 %2 = load double, double* %arrayidx25
%3 = fneg double %1 %3 = fneg double %1
%mul26 = fmul double %3, %2 %mul26 = fmul double %3, %2
load double, double* %A
load double, double* %Index
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/opaque-call-alias.ll

; We previously had a case where we would put results from a no-args call in ; We previously had a case where we would put results from a no-args call in
; its own stratified set. This would make cases like the one in @test say that ; its own stratified set. This would make cases like the one in @test say that
; nothing (except %Escapes and %Arg) can alias ; nothing (except %Escapes and %Arg) can alias
; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; CHECK: Function: test ; CHECK: Function: test
; CHECK: NoAlias: i8* %Arg, i8* %Escapes ; CHECK: NoAlias: i8* %Arg, i8* %Escapes
; CHECK: MayAlias: i8* %Arg, i8* %Retrieved ; CHECK: MayAlias: i8* %Arg, i8* %Retrieved
; CHECK: MayAlias: i8* %Escapes, i8* %Retrieved ; CHECK: MayAlias: i8* %Escapes, i8* %Retrieved
define void @test(i8* %Arg) { define void @test(i8* %Arg) {
%Noalias = alloca i8 %Noalias = alloca i8
%Escapes = alloca i8 %Escapes = alloca i8
load i8, i8* %Arg
load i8, i8* %Escapes
call void @set_thepointer(i8* %Escapes) call void @set_thepointer(i8* %Escapes)
%Retrieved = call i8* @get_thepointer() %Retrieved = call i8* @get_thepointer()
load i8, i8* %Retrieved
ret void ret void
} }
declare void @set_thepointer(i8* %P) declare void @set_thepointer(i8* %P)
declare i8* @get_thepointer() declare i8* @get_thepointer()

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/pr27213.ll

Show All 10 Lines
; CHECK-LABEL: Function: bar ; CHECK-LABEL: Function: bar
; CHECK: MayAlias: i32* %A, i32* %B ; CHECK: MayAlias: i32* %A, i32* %B
; CHECK: MayAlias: i32* %A, i32* %arrayidx ; CHECK: MayAlias: i32* %A, i32* %arrayidx
; CHECK: MayAlias: i32* %B, i32* %arrayidx ; CHECK: MayAlias: i32* %B, i32* %arrayidx
define void @bar(i32* %A, i32* %B) { define void @bar(i32* %A, i32* %B) {
entry: entry:
store i32 0, i32* %A, align 4 store i32 0, i32* %A, align 4
load i32, i32* %B
%arrayidx = getelementptr inbounds i32, i32* %B, i64 1 %arrayidx = getelementptr inbounds i32, i32* %B, i64 1
store i32 0, i32* %arrayidx, align 4 store i32 0, i32* %arrayidx, align 4
ret void ret void
} }
@G = global i32 0 @G = global i32 0
; CHECK-LABEL: Function: baz ; CHECK-LABEL: Function: baz
Show All 12 Lines

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/stratified-attrs-indexing.ll

Show All 11 Linesdefine void @test(i1 %cond,
i32* %arg1, i32* %arg2, i32* %arg3, i32* %arg4, i32* %arg5, i32* %arg1, i32* %arg2, i32* %arg3, i32* %arg4, i32* %arg5,
i32* %arg6, i32* %arg7, i32* %arg8, i32* %arg9, i32* %arg10, i32* %arg6, i32* %arg7, i32* %arg8, i32* %arg9, i32* %arg10,
i32* %arg11, i32* %arg12, i32* %arg13, i32* %arg14, i32* %arg15, i32* %arg11, i32* %arg12, i32* %arg13, i32* %arg14, i32* %arg15,
i32* %arg16, i32* %arg17, i32* %arg18, i32* %arg19, i32* %arg20, i32* %arg16, i32* %arg17, i32* %arg18, i32* %arg19, i32* %arg20,
i32* %arg21, i32* %arg22, i32* %arg23, i32* %arg24, i32* %arg25, i32* %arg21, i32* %arg22, i32* %arg23, i32* %arg24, i32* %arg25,
i32* %arg26, i32* %arg27, i32* %arg28, i32* %arg29, i32* %arg30, i32* %arg26, i32* %arg27, i32* %arg28, i32* %arg29, i32* %arg30,
i32* %arg31, i32* %arg32, i32* %arg33, i32* %arg34, i32* %arg35) { i32* %arg31, i32* %arg32, i32* %arg33, i32* %arg34, i32* %arg35) {
; CHECK: 946 Total Alias Queries Performed ; CHECK: 45 Total Alias Queries Performed
; CHECK: 43 no alias responses (4.5%) ; CHECK: 9 no alias responses (20.0%)
%a = alloca i32, align 4 %a = alloca i32, align 4
%b = select i1 %cond, i32* %arg35, i32* %arg34 load i32, i32* %a
%c = select i1 %cond, i32* %arg34, i32* %arg33 load i32, i32* %arg27
%d = select i1 %cond, i32* %arg33, i32* %arg32 load i32, i32* %arg28
%e = select i1 %cond, i32* %arg32, i32* %arg31 load i32, i32* %arg29
%f = select i1 %cond, i32* %arg31, i32* %arg30 load i32, i32* %arg30
%g = select i1 %cond, i32* %arg30, i32* %arg29 load i32, i32* %arg31
%h = select i1 %cond, i32* %arg29, i32* %arg28 load i32, i32* %arg32
%i = select i1 %cond, i32* %arg28, i32* %arg27 load i32, i32* %arg33
load i32, i32* %arg34
load i32, i32* %arg35
ret void ret void
} }

llvm/test/Analysis/CFLAliasAnalysis/Steensgaard/va.ll

; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -aa-pipeline=cfl-steens-aa -passes=aa-eval -print-all-alias-modref-info -disable-output 2>&1 | FileCheck %s
; CHECK-LABEL: Function: test1 ; CHECK-LABEL: Function: test1
; CHECK: MayAlias: i32* %X, i32* %tmp ; CHECK-DAG: MayAlias: i32* %X, i32* %tmp
; CHECK: MayAlias: i32* %tmp, i8** %ap ; CHECK-DAG: MayAlias: i8** %ap, i32* %tmp
; CHECK: NoAlias: i8** %ap, i8** %aq ; CHECK-DAG: NoAlias: i8** %ap, i8** %aq
; CHECK: MayAlias: i32* %tmp, i8** %aq ; CHECK-DAG: MayAlias: i8** %aq, i32* %tmp
define i32* @test1(i32* %X, ...) { define i32* @test1(i32* %X, ...) {
; Initialize variable argument processing ; Initialize variable argument processing
%ap = alloca i8* %ap = alloca i8*
%ap2 = bitcast i8** %ap to i8* %ap2 = bitcast i8** %ap to i8*
call void @llvm.va_start(i8* %ap2) call void @llvm.va_start(i8* %ap2)
; Read a single pointer argument ; Read a single pointer argument
%tmp = va_arg i8** %ap, i32* %tmp = va_arg i8** %ap, i32*
; Demonstrate usage of llvm.va_copy and llvm.va_end ; Demonstrate usage of llvm.va_copy and llvm.va_end
%aq = alloca i8* %aq = alloca i8*
%aq2 = bitcast i8** %aq to i8* %aq2 = bitcast i8** %aq to i8*
call void @llvm.va_copy(i8* %aq2, i8* %ap2) call void @llvm.va_copy(i8* %aq2, i8* %ap2)
call void @llvm.va_end(i8* %aq2) call void @llvm.va_end(i8* %aq2)
; Stop processing of arguments. ; Stop processing of arguments.
call void @llvm.va_end(i8* %ap2) call void @llvm.va_end(i8* %ap2)
load i32, i32* %X
load i8*, i8** %ap
load i8*, i8** %aq
load i32, i32* %tmp
ret i32* %tmp ret i32* %tmp
} }
declare void @llvm.va_start(i8*) declare void @llvm.va_start(i8*)
declare void @llvm.va_copy(i8*, i8*) declare void @llvm.va_copy(i8*, i8*)
declare void @llvm.va_end(i8*) declare void @llvm.va_end(i8*)

llvm/test/Analysis/GlobalsModRef/addrspacecast.ll

; RUN: opt -aa-pipeline=globals-aa,basic-aa -passes='require<globals-aa>,aa-eval' -print-all-alias-modref-info -disable-output %s 2>&1 | FileCheck %s ; RUN: opt -aa-pipeline=globals-aa,basic-aa -passes='require<globals-aa>,aa-eval' -print-all-alias-modref-info -disable-output %s 2>&1 | FileCheck %s
@g0 = internal addrspace(3) global i32 undef @g0 = internal addrspace(3) global i32 undef
; CHECK-LABEL: test1 ; CHECK-LABEL: test1
; CHECK-DAG: NoAlias: i32* %gp, i32* %p ; CHECK-DAG: NoAlias: i32* %gp, i32* %p
; CHECK-DAG: NoAlias: i32 addrspace(3)* @g0, i32* %p ; CHECK-DAG: NoAlias: i32* %p, i32 addrspace(3)* @g0
; CHECK-DAG: MustAlias: i32 addrspace(3)* @g0, i32* %gp ; CHECK-DAG: MustAlias: i32* %gp, i32 addrspace(3)* @g0
define i32 @test1(i32* %p) { define i32 @test1(i32* %p) {
load i32, i32 addrspace(3)* @g0
%gp = addrspacecast i32 addrspace(3)* @g0 to i32* %gp = addrspacecast i32 addrspace(3)* @g0 to i32*
store i32 0, i32* %gp store i32 0, i32* %gp
store i32 1, i32* %p store i32 1, i32* %p
%v = load i32, i32* %gp %v = load i32, i32* %gp
ret i32 %v ret i32 %v
} }

llvm/test/Analysis/ScalarEvolution/scev-aa.ll

; RUN: opt -disable-output < %s -aa-pipeline=scev-aa -passes=aa-eval -print-all-alias-modref-info \ ; RUN: opt -disable-output < %s -aa-pipeline=scev-aa -passes=aa-eval -print-all-alias-modref-info \
; RUN: 2>&1 | FileCheck %s ; RUN: 2>&1 | FileCheck %s
; At the time of this writing, -basic-aa misses the example of the form ; At the time of this writing, -basic-aa misses the example of the form
; A[i+(j+1)] != A[i+j], which can arise from multi-dimensional array references, ; A[i+(j+1)] != A[i+j], which can arise from multi-dimensional array references,
; and the example of the form A[0] != A[i+1], where i+1 is known to be positive. ; and the example of the form A[0] != A[i+1], where i+1 is known to be positive.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64"
; p[i] and p[i+1] don't alias. ; p[i] and p[i+1] don't alias.
; CHECK: Function: loop: 3 pointers, 0 call sites ; CHECK-LABEL: Function: loop
; CHECK: NoAlias: double* %pi, double* %pi.next ; CHECK: NoAlias: double* %pi, double* %pi.next
define void @loop(double* nocapture %p, i64 %n) nounwind { define void @loop(double* nocapture %p, i64 %n) nounwind {
entry: entry:
%j = icmp sgt i64 %n, 0 %j = icmp sgt i64 %n, 0
br i1 %j, label %bb, label %return br i1 %j, label %bb, label %return
bb: bb:
Show All 9 Linesbb:
br i1 %exitcond, label %return, label %bb br i1 %exitcond, label %return, label %bb
return: return:
ret void ret void
} }
; Slightly more involved: p[j][i], p[j][i+1], and p[j+1][i] don't alias. ; Slightly more involved: p[j][i], p[j][i+1], and p[j+1][i] don't alias.
; CHECK: Function: nestedloop: 4 pointers, 0 call sites ; CHECK-LABEL: Function: nestedloop
; CHECK: NoAlias: double* %pi.j, double* %pi.next.j ; CHECK: NoAlias: double* %pi.j, double* %pi.next.j
; CHECK: NoAlias: double* %pi.j, double* %pi.j.next ; CHECK: NoAlias: double* %pi.j, double* %pi.j.next
; CHECK: NoAlias: double* %pi.j.next, double* %pi.next.j ; CHECK: NoAlias: double* %pi.j.next, double* %pi.next.j
define void @nestedloop(double* nocapture %p, i64 %m) nounwind { define void @nestedloop(double* nocapture %p, i64 %m) nounwind {
entry: entry:
%k = icmp sgt i64 %m, 0 %k = icmp sgt i64 %m, 0
br i1 %k, label %guard, label %return br i1 %k, label %guard, label %return
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
; Even more involved: same as nestedloop, but with a variable extent. ; Even more involved: same as nestedloop, but with a variable extent.
; When n is 1, p[j+1][i] does alias p[j][i+1], and there's no way to ; When n is 1, p[j+1][i] does alias p[j][i+1], and there's no way to
; prove whether n will be greater than 1, so that relation will always ; prove whether n will be greater than 1, so that relation will always
; by MayAlias. The loop is guarded by a n > 0 test though, so ; by MayAlias. The loop is guarded by a n > 0 test though, so
; p[j+1][i] and p[j][i] can theoretically be determined to be NoAlias, ; p[j+1][i] and p[j][i] can theoretically be determined to be NoAlias,
; however the analysis currently doesn't do that. ; however the analysis currently doesn't do that.
; TODO: Make the analysis smarter and turn that MayAlias into a NoAlias. ; TODO: Make the analysis smarter and turn that MayAlias into a NoAlias.
; CHECK: Function: nestedloop_more: 4 pointers, 0 call sites ; CHECK-LABEL: Function: nestedloop_more
; CHECK: NoAlias: double* %pi.j, double* %pi.next.j ; CHECK: NoAlias: double* %pi.j, double* %pi.next.j
; CHECK: MayAlias: double* %pi.j, double* %pi.j.next ; CHECK: MayAlias: double* %pi.j, double* %pi.j.next
define void @nestedloop_more(double* nocapture %p, i64 %n, i64 %m) nounwind { define void @nestedloop_more(double* nocapture %p, i64 %n, i64 %m) nounwind {
entry: entry:
%k = icmp sgt i64 %m, 0 %k = icmp sgt i64 %m, 0
br i1 %k, label %guard, label %return br i1 %k, label %guard, label %return
Show All 39 Lines
; ScalarEvolution expands field offsets into constants, which allows it to ; ScalarEvolution expands field offsets into constants, which allows it to
; do aggressive analysis. Contrast this with BasicAA, which works by ; do aggressive analysis. Contrast this with BasicAA, which works by
; recognizing GEP idioms. ; recognizing GEP idioms.
%struct.A = type { %struct.B, i32, i32 } %struct.A = type { %struct.B, i32, i32 }
%struct.B = type { double } %struct.B = type { double }
; CHECK: Function: foo: 7 pointers, 0 call sites ; CHECK-LABEL: Function: foo
; CHECK: NoAlias: %struct.B* %B, i32* %Z ; CHECK-DAG: NoAlias: %struct.B* %B, i32* %Z
; CHECK: NoAlias: %struct.B* %B, %struct.B* %C ; CHECK-DAG: NoAlias: %struct.B* %B, %struct.B* %C
; CHECK: MustAlias: %struct.B* %C, i32* %Z ; CHECK-DAG: MustAlias: %struct.B* %C, i32* %Z
; CHECK: NoAlias: %struct.B* %B, i32* %X ; CHECK-DAG: NoAlias: %struct.B* %B, i32* %X
; CHECK: MustAlias: i32* %X, i32* %Z ; CHECK-DAG: MustAlias: i32* %X, i32* %Z
; CHECK: MustAlias: %struct.B* %C, i32* %Y ; CHECK-DAG: MustAlias: %struct.B* %C, i32* %Y
; CHECK: MustAlias: i32* %X, i32* %Y ; CHECK-DAG: MustAlias: i32* %X, i32* %Y
define void @foo() { define void @foo() {
entry: entry:
%A = alloca %struct.A %A = alloca %struct.A
%B = getelementptr %struct.A, %struct.A* %A, i32 0, i32 0 %B = getelementptr %struct.A, %struct.A* %A, i32 0, i32 0
%Q = bitcast %struct.B* %B to %struct.A* %Q = bitcast %struct.B* %B to %struct.A*
%Z = getelementptr %struct.A, %struct.A* %Q, i32 0, i32 1 %Z = getelementptr %struct.A, %struct.A* %Q, i32 0, i32 1
%C = getelementptr %struct.B, %struct.B* %B, i32 1 %C = getelementptr %struct.B, %struct.B* %B, i32 1
%X = bitcast %struct.B* %C to i32* %X = bitcast %struct.B* %C to i32*
%Y = getelementptr %struct.A, %struct.A* %A, i32 0, i32 1 %Y = getelementptr %struct.A, %struct.A* %A, i32 0, i32 1
load %struct.B, %struct.B* %B
load %struct.B, %struct.B* %C
load i32, i32* %X
load i32, i32* %Y
load i32, i32* %Z
ret void ret void
} }
; CHECK: Function: bar: 7 pointers, 0 call sites ; CHECK-LABEL: Function: bar
; CHECK: NoAlias: %struct.B* %N, i32* %P ; CHECK-DAG: NoAlias: %struct.B* %N, i32* %P
; CHECK: NoAlias: %struct.B* %N, %struct.B* %R ; CHECK-DAG: NoAlias: %struct.B* %N, %struct.B* %R
; CHECK: MustAlias: %struct.B* %R, i32* %P ; CHECK-DAG: MustAlias: i32* %P, %struct.B* %R
; CHECK: NoAlias: %struct.B* %N, i32* %W ; CHECK-DAG: NoAlias: %struct.B* %N, i32* %W
; CHECK: MustAlias: i32* %P, i32* %W ; CHECK-DAG: MustAlias: i32* %P, i32* %W
; CHECK: MustAlias: %struct.B* %R, i32* %V ; CHECK-DAG: MustAlias: %struct.B* %R, i32* %V
; CHECK: MustAlias: i32* %V, i32* %W ; CHECK-DAG: MustAlias: i32* %V, i32* %W
define void @bar() { define void @bar() {
%M = alloca %struct.A %M = alloca %struct.A
%N = getelementptr %struct.A, %struct.A* %M, i32 0, i32 0 %N = getelementptr %struct.A, %struct.A* %M, i32 0, i32 0
%O = bitcast %struct.B* %N to %struct.A* %O = bitcast %struct.B* %N to %struct.A*
%P = getelementptr %struct.A, %struct.A* %O, i32 0, i32 1 %P = getelementptr %struct.A, %struct.A* %O, i32 0, i32 1
%R = getelementptr %struct.B, %struct.B* %N, i32 1 %R = getelementptr %struct.B, %struct.B* %N, i32 1
%W = bitcast %struct.B* %R to i32* %W = bitcast %struct.B* %R to i32*
%V = getelementptr %struct.A, %struct.A* %M, i32 0, i32 1 %V = getelementptr %struct.A, %struct.A* %M, i32 0, i32 1
load %struct.B, %struct.B* %N
load %struct.B, %struct.B* %R
load i32, i32* %P
load i32, i32* %V
load i32, i32* %W
ret void ret void
} }
; CHECK: Function: nonnegative: 2 pointers, 0 call sites ; CHECK: Function: nonnegative: 2 pointers, 0 call sites
; CHECK: NoAlias: i64* %arrayidx, i64* %p ; CHECK: NoAlias: i64* %arrayidx, i64* %p
define void @nonnegative(i64* %p) nounwind { define void @nonnegative(i64* %p) nounwind {
entry: entry:
br label %for.body br label %for.body
for.body: ; preds = %entry, %for.body for.body: ; preds = %entry, %for.body
%i = phi i64 [ %inc, %for.body ], [ 0, %entry ] ; <i64> [#uses=2] %i = phi i64 [ %inc, %for.body ], [ 0, %entry ] ; <i64> [#uses=2]
%inc = add nsw i64 %i, 1 ; <i64> [#uses=2] %inc = add nsw i64 %i, 1 ; <i64> [#uses=2]
%arrayidx = getelementptr inbounds i64, i64* %p, i64 %inc %arrayidx = getelementptr inbounds i64, i64* %p, i64 %inc
store i64 0, i64* %arrayidx store i64 0, i64* %arrayidx
%tmp6 = load i64, i64* %p ; <i64> [#uses=1] %tmp6 = load i64, i64* %p ; <i64> [#uses=1]
%cmp = icmp slt i64 %inc, %tmp6 ; <i1> [#uses=1] %cmp = icmp slt i64 %inc, %tmp6 ; <i1> [#uses=1]
br i1 %cmp, label %for.body, label %for.end br i1 %cmp, label %for.body, label %for.end
for.end: ; preds = %for.body, %entry for.end: ; preds = %for.body, %entry
ret void ret void
} }
; CHECK: Function: test_no_dom: 3 pointers, 0 call sites ; CHECK-LABEL: Function: test_no_dom: 3 pointers, 0 call sites
; CHECK: MayAlias: double* %addr1, double* %data ; CHECK: MayAlias: double* %addr1, double* %data
; CHECK: NoAlias: double* %addr2, double* %data ; CHECK: NoAlias: double* %addr2, double* %data
; CHECK: MayAlias: double* %addr1, double* %addr2 ; CHECK: MayAlias: double* %addr1, double* %addr2
; In this case, checking %addr1 and %add2 involves two addrecs in two ; In this case, checking %addr1 and %add2 involves two addrecs in two
; different loops where neither dominates the other. This used to crash ; different loops where neither dominates the other. This used to crash
; because we expected the arguments to an AddExpr to have a strict ; because we expected the arguments to an AddExpr to have a strict
; dominance order. ; dominance order.
define void @test_no_dom(double* %data) { define void @test_no_dom(double* %data) {
entry: entry:
load double, double* %data
br label %for.body br label %for.body
for.body: for.body:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.latch ] %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.latch ]
%indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
br i1 undef, label %subloop1, label %subloop2 br i1 undef, label %subloop1, label %subloop2
subloop1: subloop1:
Show All 16 Linesfor.latch:
br label %for.body br label %for.body
for.end: for.end:
ret void ret void
} }
declare double* @get_addr(i32 %i) declare double* @get_addr(i32 %i)
; CHECK: Function: test_no_dom2: 3 pointers, 2 call sites ; CHECK-LABEL: Function: test_no_dom2: 3 pointers, 2 call sites
; CHECK: MayAlias: double* %addr1, double* %data ; CHECK: MayAlias: double* %addr1, double* %data
; CHECK: MayAlias: double* %addr2, double* %data ; CHECK: MayAlias: double* %addr2, double* %data
; CHECK: MayAlias: double* %addr1, double* %addr2 ; CHECK: MayAlias: double* %addr1, double* %addr2
; In this case, checking %addr1 and %add2 involves two addrecs in two ; In this case, checking %addr1 and %add2 involves two addrecs in two
; different loops where neither dominates the other. This is analogous ; different loops where neither dominates the other. This is analogous
; to test_no_dom, but involves SCEVUnknown as opposed to SCEVAddRecExpr. ; to test_no_dom, but involves SCEVUnknown as opposed to SCEVAddRecExpr.
define void @test_no_dom2(double* %data) { define void @test_no_dom2(double* %data) {
entry: entry:
load double, double* %data
br label %for.body br label %for.body
for.body: for.body:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.latch ] %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.latch ]
%indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
br i1 undef, label %subloop1, label %subloop2 br i1 undef, label %subloop1, label %subloop2
subloop1: subloop1:
Show All 15 Lines
for.latch: for.latch:
br label %for.body br label %for.body
for.end: for.end:
ret void ret void
} }
; CHECK: Function: test_dom: 3 pointers, 0 call sites ; CHECK-LABEL: Function: test_dom: 3 pointers, 0 call sites
; CHECK: MayAlias: double* %addr1, double* %data ; CHECK: MayAlias: double* %addr1, double* %data
; CHECK: NoAlias: double* %addr2, double* %data ; CHECK: NoAlias: double* %addr2, double* %data
; CHECK: NoAlias: double* %addr1, double* %addr2 ; CHECK: NoAlias: double* %addr1, double* %addr2
; This is a variant of test_non_dom where the second subloop is ; This is a variant of test_non_dom where the second subloop is
; dominated by the first. As a result of that, we can nest the ; dominated by the first. As a result of that, we can nest the
; addrecs and cancel out the %data base pointer. ; addrecs and cancel out the %data base pointer.
define void @test_dom(double* %data) { define void @test_dom(double* %data) {
entry: entry:
load double, double* %data
br label %for.body br label %for.body
for.body: for.body:
%indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.latch ] %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.latch ]
%indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
br label %subloop1 br label %subloop1
subloop1: subloop1:
Show All 13 Linessubloop2:
br i1 %cmp2, label %subloop2, label %for.latch br i1 %cmp2, label %subloop2, label %for.latch
for.latch: for.latch:
br label %for.body br label %for.body
for.end: for.end:
ret void ret void
} }
; CHECK: 17 no alias responses
; CHECK: 32 may alias responses
; CHECK: 18 must alias responses

llvm/test/CodeGen/AMDGPU/amdgpu-alias-analysis.ll

; RUN: opt -mtriple=amdgcn-- -data-layout=A5 -passes=aa-eval -aa-pipeline=amdgpu-aa -print-all-alias-modref-info -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -mtriple=amdgcn-- -data-layout=A5 -passes=aa-eval -aa-pipeline=amdgpu-aa -print-all-alias-modref-info -disable-output < %s 2>&1 | FileCheck %s
; RUN: opt -mtriple=r600-- -data-layout=A5 -passes=aa-eval -aa-pipeline=amdgpu-aa -print-all-alias-modref-info -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -mtriple=r600-- -data-layout=A5 -passes=aa-eval -aa-pipeline=amdgpu-aa -print-all-alias-modref-info -disable-output < %s 2>&1 | FileCheck %s
; CHECK: NoAlias: i8 addrspace(1)* %p1, i8 addrspace(5)* %p ; CHECK-LABEL: Function: test
; CHECK: NoAlias: i8 addrspace(5)* %p, i8 addrspace(1)* %p1
define void @test(i8 addrspace(5)* %p, i8 addrspace(1)* %p1) { define void @test(i8 addrspace(5)* %p, i8 addrspace(1)* %p1) {
load i8, i8 addrspace(5)* %p
load i8, i8 addrspace(1)* %p1
ret void ret void
} }
; CHECK: MayAlias: i8 addrspace(1)* %p1, i8 addrspace(4)* %p ; CHECK-LABEL: Function: test_constant_vs_global
; CHECK: MayAlias: i8 addrspace(4)* %p, i8 addrspace(1)* %p1
define void @test_constant_vs_global(i8 addrspace(4)* %p, i8 addrspace(1)* %p1) { define void @test_constant_vs_global(i8 addrspace(4)* %p, i8 addrspace(1)* %p1) {
load i8, i8 addrspace(4)* %p
load i8, i8 addrspace(1)* %p1
ret void ret void
} }
; CHECK: MayAlias: i8 addrspace(1)* %p, i8 addrspace(4)* %p1 ; CHECK: MayAlias: i8 addrspace(1)* %p, i8 addrspace(4)* %p1
define void @test_global_vs_constant(i8 addrspace(1)* %p, i8 addrspace(4)* %p1) { define void @test_global_vs_constant(i8 addrspace(1)* %p, i8 addrspace(4)* %p1) {
load i8, i8 addrspace(1)* %p
load i8, i8 addrspace(4)* %p1
ret void ret void
} }
; CHECK: MayAlias: i8 addrspace(1)* %p1, i8 addrspace(6)* %p ; CHECK: MayAlias: i8 addrspace(6)* %p, i8 addrspace(1)* %p1
define void @test_constant_32bit_vs_global(i8 addrspace(6)* %p, i8 addrspace(1)* %p1) { define void @test_constant_32bit_vs_global(i8 addrspace(6)* %p, i8 addrspace(1)* %p1) {
load i8, i8 addrspace(6)* %p
load i8, i8 addrspace(1)* %p1
ret void ret void
} }
; CHECK: MayAlias: i8 addrspace(4)* %p1, i8 addrspace(6)* %p ; CHECK: MayAlias: i8 addrspace(6)* %p, i8 addrspace(4)* %p1
define void @test_constant_32bit_vs_constant(i8 addrspace(6)* %p, i8 addrspace(4)* %p1) { define void @test_constant_32bit_vs_constant(i8 addrspace(6)* %p, i8 addrspace(4)* %p1) {
load i8, i8 addrspace(6)* %p
load i8, i8 addrspace(4)* %p1
ret void ret void
} }
; CHECK: MayAlias: i8 addrspace(999)* %p0, i8* %p ; CHECK: MayAlias: i8* %p, i8 addrspace(999)* %p0
define void @test_0_999(i8 addrspace(0)* %p, i8 addrspace(999)* %p0) { define void @test_0_999(i8 addrspace(0)* %p, i8 addrspace(999)* %p0) {
load i8, i8 addrspace(0)* %p
load i8, i8 addrspace(999)* %p0
ret void ret void
} }
; CHECK: MayAlias: i8 addrspace(999)* %p, i8* %p1 ; CHECK: MayAlias: i8 addrspace(999)* %p, i8* %p1
define void @test_999_0(i8 addrspace(999)* %p, i8 addrspace(0)* %p1) { define void @test_999_0(i8 addrspace(999)* %p, i8 addrspace(0)* %p1) {
load i8, i8 addrspace(999)* %p
load i8, i8 addrspace(0)* %p1
ret void ret void
} }
; CHECK: MayAlias: i8 addrspace(1)* %p, i8 addrspace(999)* %p1 ; CHECK: MayAlias: i8 addrspace(1)* %p, i8 addrspace(999)* %p1
define void @test_1_999(i8 addrspace(1)* %p, i8 addrspace(999)* %p1) { define void @test_1_999(i8 addrspace(1)* %p, i8 addrspace(999)* %p1) {
load i8, i8 addrspace(1)* %p
load i8, i8 addrspace(999)* %p1
ret void ret void
} }
; CHECK: MayAlias: i8 addrspace(1)* %p1, i8 addrspace(999)* %p ; CHECK: MayAlias: i8 addrspace(999)* %p, i8 addrspace(1)* %p1
define void @test_999_1(i8 addrspace(999)* %p, i8 addrspace(1)* %p1) { define void @test_999_1(i8 addrspace(999)* %p, i8 addrspace(1)* %p1) {
load i8, i8 addrspace(999)* %p
load i8, i8 addrspace(1)* %p1
ret void ret void
} }
; CHECK: NoAlias: i8 addrspace(2)* %p, i8* %p1 ; CHECK: NoAlias: i8 addrspace(2)* %p, i8* %p1
define void @test_region_vs_flat(i8 addrspace(2)* %p, i8 addrspace(0)* %p1) { define void @test_region_vs_flat(i8 addrspace(2)* %p, i8 addrspace(0)* %p1) {
load i8, i8 addrspace(2)* %p
load i8, i8 addrspace(0)* %p1
ret void ret void
} }
; CHECK: NoAlias: i8 addrspace(1)* %p1, i8 addrspace(2)* %p ; CHECK: NoAlias: i8 addrspace(2)* %p, i8 addrspace(1)* %p1
define void @test_region_vs_global(i8 addrspace(2)* %p, i8 addrspace(1)* %p1) { define void @test_region_vs_global(i8 addrspace(2)* %p, i8 addrspace(1)* %p1) {
load i8, i8 addrspace(2)* %p
load i8, i8 addrspace(1)* %p1
ret void ret void
} }
; CHECK: MayAlias: i8 addrspace(2)* %p, i8 addrspace(2)* %p1 ; CHECK: MayAlias: i8 addrspace(2)* %p, i8 addrspace(2)* %p1
define void @test_region(i8 addrspace(2)* %p, i8 addrspace(2)* %p1) { define void @test_region(i8 addrspace(2)* %p, i8 addrspace(2)* %p1) {
load i8, i8 addrspace(2)* %p
load i8, i8 addrspace(2)* %p1
ret void ret void
} }
; CHECK: NoAlias: i8 addrspace(2)* %p, i8 addrspace(3)* %p1 ; CHECK: NoAlias: i8 addrspace(2)* %p, i8 addrspace(3)* %p1
define void @test_region_vs_group(i8 addrspace(2)* %p, i8 addrspace(3)* %p1) { define void @test_region_vs_group(i8 addrspace(2)* %p, i8 addrspace(3)* %p1) {
load i8, i8 addrspace(2)* %p
load i8, i8 addrspace(3)* %p1
ret void ret void
} }
; CHECK: NoAlias: i8 addrspace(2)* %p, i8 addrspace(4)* %p1 ; CHECK: NoAlias: i8 addrspace(2)* %p, i8 addrspace(4)* %p1
define void @test_region_vs_constant(i8 addrspace(2)* %p, i8 addrspace(4)* %p1) { define void @test_region_vs_constant(i8 addrspace(2)* %p, i8 addrspace(4)* %p1) {
load i8, i8 addrspace(2)* %p
load i8, i8 addrspace(4)* %p1
ret void ret void
} }
; CHECK: NoAlias: i8 addrspace(2)* %p, i8 addrspace(5)* %p1 ; CHECK: NoAlias: i8 addrspace(2)* %p, i8 addrspace(5)* %p1
define void @test_region_vs_private(i8 addrspace(2)* %p, i8 addrspace(5)* %p1) { define void @test_region_vs_private(i8 addrspace(2)* %p, i8 addrspace(5)* %p1) {
load i8, i8 addrspace(2)* %p
load i8, i8 addrspace(5)* %p1
ret void ret void
} }
; CHECK: NoAlias: i8 addrspace(2)* %p, i8 addrspace(6)* %p1 ; CHECK: NoAlias: i8 addrspace(2)* %p, i8 addrspace(6)* %p1
define void @test_region_vs_const32(i8 addrspace(2)* %p, i8 addrspace(6)* %p1) { define void @test_region_vs_const32(i8 addrspace(2)* %p, i8 addrspace(6)* %p1) {
load i8, i8 addrspace(2)* %p
load i8, i8 addrspace(6)* %p1
ret void ret void
} }
; CHECK: MayAlias: i8 addrspace(7)* %p, i8* %p1 ; CHECK: MayAlias: i8 addrspace(7)* %p, i8* %p1
define void @test_7_0(i8 addrspace(7)* %p, i8 addrspace(0)* %p1) { define void @test_7_0(i8 addrspace(7)* %p, i8 addrspace(0)* %p1) {
load i8, i8 addrspace(7)* %p
load i8, i8 addrspace(0)* %p1
ret void ret void
} }
; CHECK: MayAlias: i8 addrspace(1)* %p1, i8 addrspace(7)* %p ; CHECK: MayAlias: i8 addrspace(7)* %p, i8 addrspace(1)* %p1
define void @test_7_1(i8 addrspace(7)* %p, i8 addrspace(1)* %p1) { define void @test_7_1(i8 addrspace(7)* %p, i8 addrspace(1)* %p1) {
load i8, i8 addrspace(7)* %p
load i8, i8 addrspace(1)* %p1
ret void ret void
} }
; CHECK: NoAlias: i8 addrspace(2)* %p1, i8 addrspace(7)* %p ; CHECK: NoAlias: i8 addrspace(7)* %p, i8 addrspace(2)* %p1
define void @test_7_2(i8 addrspace(7)* %p, i8 addrspace(2)* %p1) { define void @test_7_2(i8 addrspace(7)* %p, i8 addrspace(2)* %p1) {
load i8, i8 addrspace(7)* %p
load i8, i8 addrspace(2)* %p1
ret void ret void
} }
; CHECK: NoAlias: i8 addrspace(3)* %p1, i8 addrspace(7)* %p ; CHECK: NoAlias: i8 addrspace(7)* %p, i8 addrspace(3)* %p1
define void @test_7_3(i8 addrspace(7)* %p, i8 addrspace(3)* %p1) { define void @test_7_3(i8 addrspace(7)* %p, i8 addrspace(3)* %p1) {
load i8, i8 addrspace(7)* %p
load i8, i8 addrspace(3)* %p1
ret void ret void
} }
; CHECK: MayAlias: i8 addrspace(4)* %p1, i8 addrspace(7)* %p ; CHECK: MayAlias: i8 addrspace(7)* %p, i8 addrspace(4)* %p1
define void @test_7_4(i8 addrspace(7)* %p, i8 addrspace(4)* %p1) { define void @test_7_4(i8 addrspace(7)* %p, i8 addrspace(4)* %p1) {
load i8, i8 addrspace(7)* %p
load i8, i8 addrspace(4)* %p1
ret void ret void
} }
; CHECK: NoAlias: i8 addrspace(5)* %p1, i8 addrspace(7)* %p ; CHECK: NoAlias: i8 addrspace(7)* %p, i8 addrspace(5)* %p1
define void @test_7_5(i8 addrspace(7)* %p, i8 addrspace(5)* %p1) { define void @test_7_5(i8 addrspace(7)* %p, i8 addrspace(5)* %p1) {
load i8, i8 addrspace(7)* %p
load i8, i8 addrspace(5)* %p1
ret void ret void
} }
; CHECK: MayAlias: i8 addrspace(6)* %p1, i8 addrspace(7)* %p ; CHECK: MayAlias: i8 addrspace(7)* %p, i8 addrspace(6)* %p1
define void @test_7_6(i8 addrspace(7)* %p, i8 addrspace(6)* %p1) { define void @test_7_6(i8 addrspace(7)* %p, i8 addrspace(6)* %p1) {
load i8, i8 addrspace(7)* %p
load i8, i8 addrspace(6)* %p1
ret void ret void
} }
; CHECK: MayAlias: i8 addrspace(7)* %p, i8 addrspace(7)* %p1 ; CHECK: MayAlias: i8 addrspace(7)* %p, i8 addrspace(7)* %p1
define void @test_7_7(i8 addrspace(7)* %p, i8 addrspace(7)* %p1) { define void @test_7_7(i8 addrspace(7)* %p, i8 addrspace(7)* %p1) {
load i8, i8 addrspace(7)* %p
load i8, i8 addrspace(7)* %p1
ret void ret void
} }
@cst = internal addrspace(4) global i8* undef, align 4 @cst = internal addrspace(4) global i8* undef, align 4
; CHECK-LABEL: Function: test_8_0 ; CHECK-LABEL: Function: test_8_0
; CHECK: NoAlias: i8 addrspace(3)* %p, i8* %p1 ; CHECK-DAG: NoAlias: i8 addrspace(3)* %p, i8* %p1
; CHECK: NoAlias: i8 addrspace(3)* %p, i8* addrspace(4)* @cst ; CHECK-DAG: NoAlias: i8 addrspace(3)* %p, i8* addrspace(4)* @cst
; CHECK: MayAlias: i8* %p1, i8* addrspace(4)* @cst ; CHECK-DAG: MayAlias: i8* %p1, i8* addrspace(4)* @cst
define void @test_8_0(i8 addrspace(3)* %p) { define void @test_8_0(i8 addrspace(3)* %p) {
%p1 = load i8*, i8* addrspace(4)* @cst %p1 = load i8*, i8* addrspace(4)* @cst
load i8, i8 addrspace(3)* %p
load i8, i8* %p1
ret void ret void
} }
; CHECK-LABEL: Function: test_8_1 ; CHECK-LABEL: Function: test_8_1
; CHECK: NoAlias: i8 addrspace(5)* %p, i8* %p1 ; CHECK-DAG: NoAlias: i8 addrspace(5)* %p, i8* %p1
; CHECK: NoAlias: i8 addrspace(5)* %p, i8* addrspace(4)* @cst ; CHECK-DAG: NoAlias: i8 addrspace(5)* %p, i8* addrspace(4)* @cst
; CHECK: MayAlias: i8* %p1, i8* addrspace(4)* @cst ; CHECK-DAG: MayAlias: i8* %p1, i8* addrspace(4)* @cst
define void @test_8_1(i8 addrspace(5)* %p) { define void @test_8_1(i8 addrspace(5)* %p) {
%p1 = load i8*, i8* addrspace(4)* @cst %p1 = load i8*, i8* addrspace(4)* @cst
load i8, i8 addrspace(5)* %p
load i8, i8* %p1
ret void ret void
} }
; CHECK-LABEL: Function: test_8_2 ; CHECK-LABEL: Function: test_8_2
; CHECK: NoAlias: i8 addrspace(5)* %p1, i8* %p ; CHECK: NoAlias: i8* %p, i8 addrspace(5)* %p1
define amdgpu_kernel void @test_8_2(i8* %p) { define amdgpu_kernel void @test_8_2(i8* %p) {
%p1 = alloca i8, align 1, addrspace(5) %p1 = alloca i8, align 1, addrspace(5)
load i8, i8* %p
load i8, i8 addrspace(5)* %p1
ret void ret void
} }
; CHECK-LABEL: Function: test_8_3 ; CHECK-LABEL: Function: test_8_3
; CHECK: MayAlias: i8 addrspace(5)* %p1, i8* %p ; CHECK: MayAlias: i8* %p, i8 addrspace(5)* %p1
; TODO: So far, %p1 may still alias to %p. As it's not captured at all, it ; TODO: So far, %p1 may still alias to %p. As it's not captured at all, it
; should be NoAlias. ; should be NoAlias.
define void @test_8_3(i8* %p) { define void @test_8_3(i8* %p) {
%p1 = alloca i8, align 1, addrspace(5) %p1 = alloca i8, align 1, addrspace(5)
load i8, i8* %p
load i8, i8 addrspace(5)* %p1
ret void ret void
} }
@shm = internal addrspace(3) global i8 undef, align 4 @shm = internal addrspace(3) global i8 undef, align 4
; CHECK-LABEL: Function: test_8_4 ; CHECK-LABEL: Function: test_8_4
; CHECK: NoAlias: i8 addrspace(3)* %p1, i8* %p ; CHECK: NoAlias: i8* %p, i8 addrspace(3)* %p1
; CHECK: NoAlias: i8 addrspace(3)* @shm, i8* %p ; CHECK: NoAlias: i8* %p, i8 addrspace(3)* @shm
; CHECK: MayAlias: i8 addrspace(3)* %p1, i8 addrspace(3)* @shm ; CHECK: MayAlias: i8 addrspace(3)* %p1, i8 addrspace(3)* @shm
define amdgpu_kernel void @test_8_4(i8* %p) { define amdgpu_kernel void @test_8_4(i8* %p) {
%p1 = getelementptr i8, i8 addrspace(3)* @shm, i32 0 %p1 = getelementptr i8, i8 addrspace(3)* @shm, i32 0
load i8, i8* %p
load i8, i8 addrspace(3)* %p1
load i8, i8 addrspace(3)* @shm
ret void ret void
} }
; CHECK-LABEL: Function: test_8_5 ; CHECK-LABEL: Function: test_8_5
; CHECK: MayAlias: i8 addrspace(3)* %p1, i8* %p ; CHECK: MayAlias: i8* %p, i8 addrspace(3)* %p1
; CHECK: MayAlias: i8 addrspace(3)* @shm, i8* %p ; CHECK: MayAlias: i8* %p, i8 addrspace(3)* @shm
; CHECK: MayAlias: i8 addrspace(3)* %p1, i8 addrspace(3)* @shm ; CHECK: MayAlias: i8 addrspace(3)* %p1, i8 addrspace(3)* @shm
; TODO: So far, %p1 may still alias to %p. As it's not captured at all, it ; TODO: So far, %p1 may still alias to %p. As it's not captured at all, it
; should be NoAlias. ; should be NoAlias.
define void @test_8_5(i8* %p) { define void @test_8_5(i8* %p) {
%p1 = getelementptr i8, i8 addrspace(3)* @shm, i32 0 %p1 = getelementptr i8, i8 addrspace(3)* @shm, i32 0
load i8, i8* %p
load i8, i8 addrspace(3)* %p1
load i8, i8 addrspace(3)* @shm
ret void ret void
} }

llvm/test/CodeGen/AMDGPU/r600.amdgpu-alias-analysis.ll

; RUN: opt -mtriple=r600-- -passes='default<O3>,aa-eval' -print-all-alias-modref-info -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -mtriple=r600-- -passes='default<O3>,aa-eval' -print-all-alias-modref-info -disable-output < %s 2>&1 | FileCheck %s
; CHECK: MayAlias: i8 addrspace(5)* %p, i8 addrspace(999)* %p1 ; CHECK: MayAlias: i8 addrspace(5)* %p, i8 addrspace(999)* %p1
define amdgpu_kernel void @test(i8 addrspace(5)* %p, i8 addrspace(999)* %p1) { define amdgpu_kernel void @test(i8 addrspace(5)* %p, i8 addrspace(999)* %p1) {
load volatile i8, i8 addrspace(5)* %p
load volatile i8, i8 addrspace(999)* %p1
ret void ret void
} }