Index: llvm/test/Analysis/BasicAA/cs-cs.ll =================================================================== --- llvm/test/Analysis/BasicAA/cs-cs.ll +++ llvm/test/Analysis/BasicAA/cs-cs.ll @@ -1,14 +1,28 @@ -; 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 -o %t 2>&1 | FileCheck %s --check-prefix=ALIAS +; RUN: FileCheck %s <%t 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" +; CHECK: Function Attrs: nocallback nofree nounwind willreturn memory(argmem: write) +; CHECK-NEXT: declare void @llvm.memset.p0.i64({{.*}}) [[ATTRSET:#[0-9]+]] declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1) #0 +; CHECK: Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite) +; CHECK-NEXT: declare void @llvm.memcpy.p0.p0.i64({{.*}}) [[ATTRCPY:#[0-9]+]] declare void @llvm.memcpy.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1) #0 +; CHECK: Function Attrs: nosync nounwind willreturn memory(argmem: readwrite) +; CHECK-NEXT: declare void @llvm.memcpy.element.unordered.atomic.p0.p0.i64({{.*}}) [[ATTRATOMIC:#[0-9]+]] declare void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i32) #0 +; CHECK: Function Attrs: noinline nounwind memory(read) +; CHECK-NEXT: declare void @a_readonly_func(ptr) [[ATTR3:#[0-9]+]] declare void @a_readonly_func(ptr) #1 + +; CHECK: Function Attrs: noinline nounwind memory(write) +; CHECK-NEXT: declare void @a_writeonly_func(ptr) [[ATTR4:#[0-9]+]] declare void @a_writeonly_func(ptr) #2 +; CHECK: Function Attrs: nounwind ssp +; CHECK-NEXT: define void @test2(ptr %P, ptr %Q) [[ATTR5:#[0-9]+]] define void @test2(ptr %P, ptr %Q) #3 { load i8, ptr %P load i8, ptr %Q @@ -16,17 +30,19 @@ tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) ret void -; CHECK-LABEL: Function: test2: +; ALIAS-LABEL: Function: test2: -; CHECK: MayAlias: i8* %P, i8* %Q -; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Both ModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Both ModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: MayAlias: i8* %P, i8* %Q +; ALIAS: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Both ModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Both ModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) } +; CHECK: Function Attrs: nounwind ssp +; CHECK-NEXT: define void @test2_atomic(ptr %P, ptr %Q) [[ATTR5]] define void @test2_atomic(ptr %P, ptr %Q) #3 { load i8, ptr %P load i8, ptr %Q @@ -34,17 +50,19 @@ tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) ret void -; CHECK-LABEL: Function: test2_atomic: +; ALIAS-LABEL: Function: test2_atomic: -; CHECK: MayAlias: i8* %P, i8* %Q -; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) -; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) -; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) -; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) -; CHECK: Both ModRef: tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) <-> tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) -; CHECK: Both ModRef: tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) <-> tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) +; ALIAS: MayAlias: i8* %P, i8* %Q +; ALIAS: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) +; ALIAS: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) +; ALIAS: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) +; ALIAS: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) +; ALIAS: Both ModRef: tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) <-> tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) +; ALIAS: Both ModRef: tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) <-> tail call void @llvm.memcpy.element.unordered.atomic.p0.p0.i64(ptr align 1 %P, ptr align 1 %Q, i64 12, i32 1) } +; CHECK: Function Attrs: nounwind ssp +; CHECK-NEXT: define void @test2a(ptr noalias %P, ptr noalias %Q) [[ATTR5]] define void @test2a(ptr noalias %P, ptr noalias %Q) #3 { load i8, ptr %P load i8, ptr %Q @@ -52,17 +70,19 @@ tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) ret void -; CHECK-LABEL: Function: test2a: +; ALIAS-LABEL: Function: test2a: -; CHECK: NoAlias: i8* %P, i8* %Q -; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: NoAlias: i8* %P, i8* %Q +; ALIAS: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) } +; CHECK: Function Attrs: nounwind ssp +; CHECK-NEXT: define void @test2b(ptr noalias %P, ptr noalias %Q) [[ATTR5]] define void @test2b(ptr noalias %P, ptr noalias %Q) #3 { load i8, ptr %P load i8, ptr %Q @@ -72,21 +92,23 @@ tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) ret void -; CHECK-LABEL: Function: test2b: +; ALIAS-LABEL: Function: test2b: -; CHECK: NoAlias: i8* %P, i8* %Q -; CHECK: NoAlias: i8* %P, i8* %R -; CHECK: NoAlias: i8* %Q, i8* %R -; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: NoModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: NoModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) -; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) -; CHECK: NoModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) -; CHECK: NoModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: NoAlias: i8* %P, i8* %Q +; ALIAS: NoAlias: i8* %P, i8* %R +; ALIAS: NoAlias: i8* %Q, i8* %R +; ALIAS: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: NoModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: NoModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) +; ALIAS: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) +; ALIAS: NoModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) +; ALIAS: NoModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) } +; CHECK: Function Attrs: nounwind ssp +; CHECK-NEXT: define void @test2c(ptr noalias %P, ptr noalias %Q) [[ATTR5]] define void @test2c(ptr noalias %P, ptr noalias %Q) #3 { load i8, ptr %P load i8, ptr %Q @@ -96,21 +118,23 @@ tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) ret void -; CHECK-LABEL: Function: test2c: +; ALIAS-LABEL: Function: test2c: -; CHECK: NoAlias: i8* %P, i8* %Q -; CHECK: NoAlias: i8* %P, i8* %R -; CHECK: NoAlias: i8* %Q, i8* %R -; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: NoModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) -; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: NoAlias: i8* %P, i8* %Q +; ALIAS: NoAlias: i8* %P, i8* %R +; ALIAS: NoAlias: i8* %Q, i8* %R +; ALIAS: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: NoModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) +; ALIAS: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) } +; CHECK: Function Attrs: nounwind ssp +; CHECK-NEXT: define void @test2d(ptr noalias %P, ptr noalias %Q) [[ATTR5]] define void @test2d(ptr noalias %P, ptr noalias %Q) #3 { load i8, ptr %P load i8, ptr %Q @@ -120,21 +144,23 @@ tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) ret void -; CHECK-LABEL: Function: test2d: +; ALIAS-LABEL: Function: test2d: -; CHECK: NoAlias: i8* %P, i8* %Q -; CHECK: NoAlias: i8* %P, i8* %R -; CHECK: NoAlias: i8* %Q, i8* %R -; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: NoModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: NoModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) -; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) -; CHECK: NoModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) -; CHECK: NoModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: NoAlias: i8* %P, i8* %Q +; ALIAS: NoAlias: i8* %P, i8* %R +; ALIAS: NoAlias: i8* %Q, i8* %R +; ALIAS: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: NoModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: NoModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) +; ALIAS: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) +; ALIAS: NoModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) +; ALIAS: NoModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) } +; CHECK: Function Attrs: nounwind ssp +; CHECK-NEXT: define void @test2e(ptr noalias %P, ptr noalias %Q) [[ATTR5]] define void @test2e(ptr noalias %P, ptr noalias %Q) #3 { load i8, ptr %P load i8, ptr %Q @@ -144,21 +170,23 @@ tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) ret void -; CHECK-LABEL: Function: test2e: +; ALIAS-LABEL: Function: test2e: -; CHECK: NoAlias: i8* %P, i8* %Q -; CHECK: NoAlias: i8* %P, i8* %R -; CHECK: NoAlias: i8* %Q, i8* %R -; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: NoModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) -; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: NoAlias: i8* %P, i8* %Q +; ALIAS: NoAlias: i8* %P, i8* %R +; ALIAS: NoAlias: i8* %Q, i8* %R +; ALIAS: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: NoModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) +; ALIAS: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %R, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) } +; CHECK: Function Attrs: nounwind ssp +; CHECK-NEXT: define void @test3(ptr %P, ptr %Q) [[ATTR5]] define void @test3(ptr %P, ptr %Q) #3 { load i8, ptr %P load i8, ptr %Q @@ -166,17 +194,19 @@ tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) ret void -; CHECK-LABEL: Function: test3: +; ALIAS-LABEL: Function: test3: -; CHECK: MayAlias: i8* %P, i8* %Q -; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 8, i1 false) -; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 8, i1 false) -; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Both ModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 8, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Both ModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 8, i1 false) +; ALIAS: MayAlias: i8* %P, i8* %Q +; ALIAS: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 8, i1 false) +; ALIAS: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 8, i1 false) +; ALIAS: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Both ModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 8, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Both ModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 8, i1 false) } +; CHECK: Function Attrs: nounwind ssp +; CHECK-NEXT: define void @test3a(ptr noalias %P, ptr noalias %Q) [[ATTR5]] define void @test3a(ptr noalias %P, ptr noalias %Q) #3 { load i8, ptr %P load i8, ptr %Q @@ -184,17 +214,19 @@ tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) ret void -; CHECK-LABEL: Function: test3a: +; ALIAS-LABEL: Function: test3a: -; CHECK: NoAlias: i8* %P, i8* %Q -; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 8, i1 false) -; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 8, i1 false) -; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 8, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 8, i1 false) +; ALIAS: NoAlias: i8* %P, i8* %Q +; ALIAS: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 8, i1 false) +; ALIAS: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 8, i1 false) +; ALIAS: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 8, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 8, i1 false) } +; CHECK: Function Attrs: nounwind ssp +; CHECK-NEXT: define void @test4(ptr %P, ptr noalias %Q) [[ATTR5]] define void @test4(ptr %P, ptr noalias %Q) #3 { load i8, ptr %P load i8, ptr %Q @@ -202,17 +234,19 @@ tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) ret void -; CHECK-LABEL: Function: test4: +; ALIAS-LABEL: Function: test4: -; CHECK: NoAlias: i8* %P, i8* %Q -; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memset.p0.i64(ptr %P, i8 42, i64 8, i1 false) -; CHECK: NoModRef: Ptr: i8* %Q <-> tail call void @llvm.memset.p0.i64(ptr %P, i8 42, i64 8, i1 false) -; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: tail call void @llvm.memset.p0.i64(ptr %P, i8 42, i64 8, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memset.p0.i64(ptr %P, i8 42, i64 8, i1 false) +; ALIAS: NoAlias: i8* %P, i8* %Q +; ALIAS: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memset.p0.i64(ptr %P, i8 42, i64 8, i1 false) +; ALIAS: NoModRef: Ptr: i8* %Q <-> tail call void @llvm.memset.p0.i64(ptr %P, i8 42, i64 8, i1 false) +; ALIAS: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: tail call void @llvm.memset.p0.i64(ptr %P, i8 42, i64 8, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memset.p0.i64(ptr %P, i8 42, i64 8, i1 false) } +; CHECK: Function Attrs: nounwind ssp +; CHECK-NEXT: define void @test5(ptr %P, ptr %Q, ptr %R) [[ATTR5]] define void @test5(ptr %P, ptr %Q, ptr %R) #3 { load i8, ptr %P load i8, ptr %Q @@ -221,21 +255,23 @@ tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) ret void -; CHECK-LABEL: Function: test5: +; ALIAS-LABEL: Function: test5: -; CHECK: MayAlias: i8* %P, i8* %Q -; CHECK: MayAlias: i8* %P, i8* %R -; CHECK: MayAlias: i8* %Q, i8* %R -; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Both ModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) -; CHECK: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) -; CHECK: Both ModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) -; CHECK: Both ModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) -; CHECK: Both ModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: MayAlias: i8* %P, i8* %Q +; ALIAS: MayAlias: i8* %P, i8* %R +; ALIAS: MayAlias: i8* %Q, i8* %R +; ALIAS: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Both ModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Both ModRef: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) +; ALIAS: Both ModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) +; ALIAS: Both ModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) +; ALIAS: Both ModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) +; ALIAS: Both ModRef: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) } +; CHECK: Function Attrs: nounwind ssp +; CHECK-NEXT: define void @test5a(ptr noalias %P, ptr noalias %Q, ptr noalias %R) [[ATTR5]] define void @test5a(ptr noalias %P, ptr noalias %Q, ptr noalias %R) nounwind ssp { load i8, ptr %P load i8, ptr %Q @@ -244,53 +280,65 @@ tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) ret void -; CHECK-LABEL: Function: test5a: +; ALIAS-LABEL: Function: test5a: -; CHECK: NoAlias: i8* %P, i8* %Q -; CHECK: NoAlias: i8* %P, i8* %R -; CHECK: NoAlias: i8* %Q, i8* %R -; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: NoModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) -; CHECK: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) -; CHECK: NoModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) -; CHECK: Just Ref: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) -; CHECK: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) -; CHECK: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: NoAlias: i8* %P, i8* %Q +; ALIAS: NoAlias: i8* %P, i8* %R +; ALIAS: NoAlias: i8* %Q, i8* %R +; ALIAS: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Ref: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: NoModRef: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) +; ALIAS: Just Mod: Ptr: i8* %P <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) +; ALIAS: NoModRef: Ptr: i8* %Q <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) +; ALIAS: Just Ref: Ptr: i8* %R <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) +; ALIAS: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) +; ALIAS: Just Mod: tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %R, i64 12, i1 false) <-> tail call void @llvm.memcpy.p0.p0.i64(ptr %P, ptr %Q, i64 12, i1 false) } +; CHECK: Function Attrs: nounwind ssp +; CHECK-NEXT: define void @test6(ptr %P) [[ATTR5]] define void @test6(ptr %P) #3 { load i8, ptr %P call void @llvm.memset.p0.i64(ptr align 8 %P, i8 -51, i64 32, i1 false) call void @a_readonly_func(ptr %P) ret void -; CHECK-LABEL: Function: test6: +; ALIAS-LABEL: Function: test6: -; CHECK: Just Mod: Ptr: i8* %P <-> call void @llvm.memset.p0.i64(ptr align 8 %P, i8 -51, i64 32, i1 false) -; CHECK: Just Ref: Ptr: i8* %P <-> call void @a_readonly_func(ptr %P) -; CHECK: Just Mod: call void @llvm.memset.p0.i64(ptr align 8 %P, i8 -51, i64 32, i1 false) <-> call void @a_readonly_func(ptr %P) -; CHECK: Just Ref: call void @a_readonly_func(ptr %P) <-> call void @llvm.memset.p0.i64(ptr align 8 %P, i8 -51, i64 32, i1 false) +; ALIAS: Just Mod: Ptr: i8* %P <-> call void @llvm.memset.p0.i64(ptr align 8 %P, i8 -51, i64 32, i1 false) +; ALIAS: Just Ref: Ptr: i8* %P <-> call void @a_readonly_func(ptr %P) +; ALIAS: Just Mod: call void @llvm.memset.p0.i64(ptr align 8 %P, i8 -51, i64 32, i1 false) <-> call void @a_readonly_func(ptr %P) +; ALIAS: Just Ref: call void @a_readonly_func(ptr %P) <-> call void @llvm.memset.p0.i64(ptr align 8 %P, i8 -51, i64 32, i1 false) } +; CHECK: Function Attrs: nounwind ssp +; CHECK-NEXT: define void @test7(ptr %P) [[ATTR5]] define void @test7(ptr %P) #3 { load i8, ptr %P call void @a_writeonly_func(ptr %P) call void @a_readonly_func(ptr %P) ret void -; CHECK-LABEL: Function: test7: +; ALIAS-LABEL: Function: test7: -; CHECK: Just Mod: Ptr: i8* %P <-> call void @a_writeonly_func(ptr %P) -; CHECK: Just Ref: Ptr: i8* %P <-> call void @a_readonly_func(ptr %P) -; CHECK: Just Mod: call void @a_writeonly_func(ptr %P) <-> call void @a_readonly_func(ptr %P) -; CHECK: Just Ref: call void @a_readonly_func(ptr %P) <-> call void @a_writeonly_func(ptr %P) +; ALIAS: Just Mod: Ptr: i8* %P <-> call void @a_writeonly_func(ptr %P) +; ALIAS: Just Ref: Ptr: i8* %P <-> call void @a_readonly_func(ptr %P) +; ALIAS: Just Mod: call void @a_writeonly_func(ptr %P) <-> call void @a_readonly_func(ptr %P) +; ALIAS: Just Ref: call void @a_readonly_func(ptr %P) <-> call void @a_writeonly_func(ptr %P) } +; CHECK: Function Attrs: nounwind memory(inaccessiblemem: readwrite) +; CHECK-NEXT: declare void @an_inaccessiblememonly_func() [[ATTR6:#[0-9]+]] declare void @an_inaccessiblememonly_func() #4 +; CHECK: Function Attrs: nounwind memory(argmem: readwrite, inaccessiblemem: readwrite) +; CHECK-NEXT: declare void @an_inaccessibleorargmemonly_func(ptr) [[ATTR7:#[0-9]+]] declare void @an_inaccessibleorargmemonly_func(ptr) #5 +; CHECK: Function Attrs: nounwind memory(argmem: readwrite) +; CHECK-NEXT: declare void @an_argmemonly_func(ptr) [[ATTR8:#[0-9]+]] declare void @an_argmemonly_func(ptr) #0 +; CHECK-NOT: Function Attrs: +; CHECK: define void @test8(ptr %p) define void @test8(ptr %p) { entry: %q = getelementptr i8, ptr %p, i64 16 @@ -304,36 +352,41 @@ call void @an_argmemonly_func(ptr %q) ret void -; CHECK-LABEL: Function: test8 -; CHECK: NoModRef: Ptr: i8* %p <-> call void @an_inaccessiblememonly_func() -; CHECK: NoModRef: Ptr: i8* %q <-> call void @an_inaccessiblememonly_func() -; CHECK: Both ModRef: Ptr: i8* %p <-> call void @an_inaccessibleorargmemonly_func(ptr %q) -; CHECK: Both ModRef: Ptr: i8* %q <-> call void @an_inaccessibleorargmemonly_func(ptr %q) -; CHECK: Both ModRef: Ptr: i8* %p <-> call void @an_argmemonly_func(ptr %q) -; CHECK: Both ModRef: Ptr: i8* %q <-> call void @an_argmemonly_func(ptr %q) -; CHECK: Just Ref: call void @a_readonly_func(ptr %p) <-> call void @an_inaccessiblememonly_func() -; CHECK: Just Ref: call void @a_readonly_func(ptr %p) <-> call void @an_inaccessibleorargmemonly_func(ptr %q) -; CHECK: Just Ref: call void @a_readonly_func(ptr %p) <-> call void @an_argmemonly_func(ptr %q) -; CHECK: Both ModRef: call void @an_inaccessiblememonly_func() <-> call void @a_readonly_func(ptr %p) -; CHECK: Both ModRef: call void @an_inaccessiblememonly_func() <-> call void @a_writeonly_func(ptr %q) -; CHECK: Both ModRef: call void @an_inaccessiblememonly_func() <-> call void @an_inaccessiblememonly_func() -; CHECK: Both ModRef: call void @an_inaccessiblememonly_func() <-> call void @an_inaccessibleorargmemonly_func(ptr %q) -; CHECK: NoModRef: call void @an_inaccessiblememonly_func() <-> call void @an_argmemonly_func(ptr %q) -; CHECK: Just Mod: call void @a_writeonly_func(ptr %q) <-> call void @an_inaccessiblememonly_func() -; CHECK: Just Mod: call void @a_writeonly_func(ptr %q) <-> call void @an_inaccessibleorargmemonly_func(ptr %q) -; CHECK: Just Mod: call void @a_writeonly_func(ptr %q) <-> call void @an_argmemonly_func(ptr %q) -; CHECK: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) <-> call void @a_readonly_func(ptr %p) -; CHECK: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) <-> call void @a_writeonly_func(ptr %q) -; CHECK: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) <-> call void @an_inaccessiblememonly_func() -; CHECK: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) <-> call void @an_argmemonly_func(ptr %q) -; CHECK: Both ModRef: call void @an_argmemonly_func(ptr %q) <-> call void @a_readonly_func(ptr %p) -; CHECK: Both ModRef: call void @an_argmemonly_func(ptr %q) <-> call void @a_writeonly_func(ptr %q) -; CHECK: NoModRef: call void @an_argmemonly_func(ptr %q) <-> call void @an_inaccessiblememonly_func() -; CHECK: Both ModRef: call void @an_argmemonly_func(ptr %q) <-> call void @an_inaccessibleorargmemonly_func(ptr %q) +; ALIAS-LABEL: Function: test8 +; ALIAS: NoModRef: Ptr: i8* %p <-> call void @an_inaccessiblememonly_func() +; ALIAS: NoModRef: Ptr: i8* %q <-> call void @an_inaccessiblememonly_func() +; ALIAS: Both ModRef: Ptr: i8* %p <-> call void @an_inaccessibleorargmemonly_func(ptr %q) +; ALIAS: Both ModRef: Ptr: i8* %q <-> call void @an_inaccessibleorargmemonly_func(ptr %q) +; ALIAS: Both ModRef: Ptr: i8* %p <-> call void @an_argmemonly_func(ptr %q) +; ALIAS: Both ModRef: Ptr: i8* %q <-> call void @an_argmemonly_func(ptr %q) +; ALIAS: Just Ref: call void @a_readonly_func(ptr %p) <-> call void @an_inaccessiblememonly_func() +; ALIAS: Just Ref: call void @a_readonly_func(ptr %p) <-> call void @an_inaccessibleorargmemonly_func(ptr %q) +; ALIAS: Just Ref: call void @a_readonly_func(ptr %p) <-> call void @an_argmemonly_func(ptr %q) +; ALIAS: Both ModRef: call void @an_inaccessiblememonly_func() <-> call void @a_readonly_func(ptr %p) +; ALIAS: Both ModRef: call void @an_inaccessiblememonly_func() <-> call void @a_writeonly_func(ptr %q) +; ALIAS: Both ModRef: call void @an_inaccessiblememonly_func() <-> call void @an_inaccessiblememonly_func() +; ALIAS: Both ModRef: call void @an_inaccessiblememonly_func() <-> call void @an_inaccessibleorargmemonly_func(ptr %q) +; ALIAS: NoModRef: call void @an_inaccessiblememonly_func() <-> call void @an_argmemonly_func(ptr %q) +; ALIAS: Just Mod: call void @a_writeonly_func(ptr %q) <-> call void @an_inaccessiblememonly_func() +; ALIAS: Just Mod: call void @a_writeonly_func(ptr %q) <-> call void @an_inaccessibleorargmemonly_func(ptr %q) +; ALIAS: Just Mod: call void @a_writeonly_func(ptr %q) <-> call void @an_argmemonly_func(ptr %q) +; ALIAS: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) <-> call void @a_readonly_func(ptr %p) +; ALIAS: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) <-> call void @a_writeonly_func(ptr %q) +; ALIAS: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) <-> call void @an_inaccessiblememonly_func() +; ALIAS: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) <-> call void @an_argmemonly_func(ptr %q) +; ALIAS: Both ModRef: call void @an_argmemonly_func(ptr %q) <-> call void @a_readonly_func(ptr %p) +; ALIAS: Both ModRef: call void @an_argmemonly_func(ptr %q) <-> call void @a_writeonly_func(ptr %q) +; ALIAS: NoModRef: call void @an_argmemonly_func(ptr %q) <-> call void @an_inaccessiblememonly_func() +; ALIAS: Both ModRef: call void @an_argmemonly_func(ptr %q) <-> call void @an_inaccessibleorargmemonly_func(ptr %q) } ;; test that MustAlias is set for calls when no MayAlias is found. +; CHECK: Function Attrs: nounwind memory(argmem: readwrite) +; CHECK-NEXT: declare void @another_argmemonly_func(ptr, ptr) [[ATTR8]] declare void @another_argmemonly_func(ptr, ptr) #0 + +; CHECK-NOT: Function Attrs: +; CHECK: define void @test8a(ptr noalias %p, ptr noalias %q) define void @test8a(ptr noalias %p, ptr noalias %q) { entry: load i8, ptr %p @@ -341,10 +394,13 @@ call void @another_argmemonly_func(ptr %p, ptr %q) ret void -; CHECK-LABEL: Function: test8a -; CHECK: Both ModRef: Ptr: i8* %p <-> call void @another_argmemonly_func(ptr %p, ptr %q) -; CHECK: Both ModRef: Ptr: i8* %q <-> call void @another_argmemonly_func(ptr %p, ptr %q) +; ALIAS-LABEL: Function: test8a +; ALIAS: Both ModRef: Ptr: i8* %p <-> call void @another_argmemonly_func(ptr %p, ptr %q) +; ALIAS: Both ModRef: Ptr: i8* %q <-> call void @another_argmemonly_func(ptr %p, ptr %q) } + +; CHECK-NOT: Function Attrs: +; CHECK: define void @test8b(ptr %p, ptr %q) define void @test8b(ptr %p, ptr %q) { entry: load i8, ptr %p @@ -352,15 +408,17 @@ call void @another_argmemonly_func(ptr %p, ptr %q) ret void -; CHECK-LABEL: Function: test8b -; CHECK: Both ModRef: Ptr: i8* %p <-> call void @another_argmemonly_func(ptr %p, ptr %q) -; CHECK: Both ModRef: Ptr: i8* %q <-> call void @another_argmemonly_func(ptr %p, ptr %q) +; ALIAS-LABEL: Function: test8b +; ALIAS: Both ModRef: Ptr: i8* %p <-> call void @another_argmemonly_func(ptr %p, ptr %q) +; ALIAS: Both ModRef: Ptr: i8* %q <-> call void @another_argmemonly_func(ptr %p, ptr %q) } ;; test that unknown operand bundle has unknown effect to the heap +; CHECK-NOT: Function Attrs: +; CHECK: define void @test9(ptr %p) define void @test9(ptr %p) { -; CHECK-LABEL: Function: test9 +; ALIAS-LABEL: Function: test9 entry: %q = getelementptr i8, ptr %p, i64 16 load i8, ptr %p @@ -371,78 +429,69 @@ call void @an_argmemonly_func(ptr %q) [ "unknown"() ] ret void -; CHECK: Both ModRef: Ptr: i8* %p <-> call void @a_readonly_func(ptr %p) [ "unknown"() ] -; CHECK: Both ModRef: Ptr: i8* %q <-> call void @a_readonly_func(ptr %p) [ "unknown"() ] -; CHECK: Both ModRef: Ptr: i8* %p <-> call void @an_inaccessiblememonly_func() [ "unknown"() ] -; CHECK: Both ModRef: Ptr: i8* %q <-> call void @an_inaccessiblememonly_func() [ "unknown"() ] -; CHECK: Both ModRef: Ptr: i8* %p <-> call void @an_inaccessibleorargmemonly_func(ptr %q) [ "unknown"() ] -; CHECK: Both ModRef: Ptr: i8* %q <-> call void @an_inaccessibleorargmemonly_func(ptr %q) [ "unknown"() ] -; CHECK: Both ModRef: Ptr: i8* %p <-> call void @an_argmemonly_func(ptr %q) [ "unknown"() ] -; CHECK: Both ModRef: Ptr: i8* %q <-> call void @an_argmemonly_func(ptr %q) [ "unknown"() ] -; CHECK: Both ModRef: call void @a_readonly_func(ptr %p) [ "unknown"() ] <-> call void @an_inaccessiblememonly_func() [ "unknown"() ] -; CHECK: Both ModRef: call void @a_readonly_func(ptr %p) [ "unknown"() ] <-> call void @an_inaccessibleorargmemonly_func(ptr %q) [ "unknown"() ] -; CHECK: Both ModRef: call void @a_readonly_func(ptr %p) [ "unknown"() ] <-> call void @an_argmemonly_func(ptr %q) [ "unknown"() ] -; CHECK: Both ModRef: call void @an_inaccessiblememonly_func() [ "unknown"() ] <-> call void @a_readonly_func(ptr %p) [ "unknown"() ] -; CHECK: Both ModRef: call void @an_inaccessiblememonly_func() [ "unknown"() ] <-> call void @an_inaccessibleorargmemonly_func(ptr %q) [ "unknown"() ] -; CHECK: Both ModRef: call void @an_inaccessiblememonly_func() [ "unknown"() ] <-> call void @an_argmemonly_func(ptr %q) [ "unknown"() ] -; CHECK: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) [ "unknown"() ] <-> call void @a_readonly_func(ptr %p) [ "unknown"() ] -; CHECK: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) [ "unknown"() ] <-> call void @an_inaccessiblememonly_func() [ "unknown"() ] -; CHECK: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) [ "unknown"() ] <-> call void @an_argmemonly_func(ptr %q) [ "unknown"() ] -; CHECK: Both ModRef: call void @an_argmemonly_func(ptr %q) [ "unknown"() ] <-> call void @a_readonly_func(ptr %p) [ "unknown"() ] -; CHECK: Both ModRef: call void @an_argmemonly_func(ptr %q) [ "unknown"() ] <-> call void @an_inaccessiblememonly_func() [ "unknown"() ] -; CHECK: Both ModRef: call void @an_argmemonly_func(ptr %q) [ "unknown"() ] <-> call void @an_inaccessibleorargmemonly_func(ptr %q) [ "unknown"() ] +; ALIAS: Both ModRef: Ptr: i8* %p <-> call void @a_readonly_func(ptr %p) [ "unknown"() ] +; ALIAS: Both ModRef: Ptr: i8* %q <-> call void @a_readonly_func(ptr %p) [ "unknown"() ] +; ALIAS: Both ModRef: Ptr: i8* %p <-> call void @an_inaccessiblememonly_func() [ "unknown"() ] +; ALIAS: Both ModRef: Ptr: i8* %q <-> call void @an_inaccessiblememonly_func() [ "unknown"() ] +; ALIAS: Both ModRef: Ptr: i8* %p <-> call void @an_inaccessibleorargmemonly_func(ptr %q) [ "unknown"() ] +; ALIAS: Both ModRef: Ptr: i8* %q <-> call void @an_inaccessibleorargmemonly_func(ptr %q) [ "unknown"() ] +; ALIAS: Both ModRef: Ptr: i8* %p <-> call void @an_argmemonly_func(ptr %q) [ "unknown"() ] +; ALIAS: Both ModRef: Ptr: i8* %q <-> call void @an_argmemonly_func(ptr %q) [ "unknown"() ] +; ALIAS: Both ModRef: call void @a_readonly_func(ptr %p) [ "unknown"() ] <-> call void @an_inaccessiblememonly_func() [ "unknown"() ] +; ALIAS: Both ModRef: call void @a_readonly_func(ptr %p) [ "unknown"() ] <-> call void @an_inaccessibleorargmemonly_func(ptr %q) [ "unknown"() ] +; ALIAS: Both ModRef: call void @a_readonly_func(ptr %p) [ "unknown"() ] <-> call void @an_argmemonly_func(ptr %q) [ "unknown"() ] +; ALIAS: Both ModRef: call void @an_inaccessiblememonly_func() [ "unknown"() ] <-> call void @a_readonly_func(ptr %p) [ "unknown"() ] +; ALIAS: Both ModRef: call void @an_inaccessiblememonly_func() [ "unknown"() ] <-> call void @an_inaccessibleorargmemonly_func(ptr %q) [ "unknown"() ] +; ALIAS: Both ModRef: call void @an_inaccessiblememonly_func() [ "unknown"() ] <-> call void @an_argmemonly_func(ptr %q) [ "unknown"() ] +; ALIAS: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) [ "unknown"() ] <-> call void @a_readonly_func(ptr %p) [ "unknown"() ] +; ALIAS: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) [ "unknown"() ] <-> call void @an_inaccessiblememonly_func() [ "unknown"() ] +; ALIAS: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) [ "unknown"() ] <-> call void @an_argmemonly_func(ptr %q) [ "unknown"() ] +; ALIAS: Both ModRef: call void @an_argmemonly_func(ptr %q) [ "unknown"() ] <-> call void @a_readonly_func(ptr %p) [ "unknown"() ] +; ALIAS: Both ModRef: call void @an_argmemonly_func(ptr %q) [ "unknown"() ] <-> call void @an_inaccessiblememonly_func() [ "unknown"() ] +; ALIAS: Both ModRef: call void @an_argmemonly_func(ptr %q) [ "unknown"() ] <-> call void @an_inaccessibleorargmemonly_func(ptr %q) [ "unknown"() ] } ;; test callsite overwrite of unknown operand bundle +; CHECK-NOT: Function Attrs: +; CHECK: define void @test10(ptr %p) define void @test10(ptr %p) { -; CHECK-LABEL: Function: test10 +; ALIAS-LABEL: Function: test10 entry: %q = getelementptr i8, ptr %p, i64 16 load i8, ptr %p load i8, ptr %q + ; CHECK: call void @a_readonly_func({{.*}}) [[ATTR9:#[0-9]+]] call void @a_readonly_func(ptr %p) #6 [ "unknown"() ] + ; CHECK: call void @an_inaccessiblememonly_func({{.*}}) [[ATTR10:#[0-9]+]] call void @an_inaccessiblememonly_func() #7 [ "unknown"() ] + ; CHECK: call void @an_inaccessibleorargmemonly_func({{.*}}) [[ATTR11:#[0-9]+]] call void @an_inaccessibleorargmemonly_func(ptr %q) #8 [ "unknown"() ] + ; CHECK: call void @an_argmemonly_func({{.*}}) [[ATTR12:#[0-9]+]] call void @an_argmemonly_func(ptr %q) #9 [ "unknown"() ] ret void -; CHECK: Just Ref: Ptr: i8* %p <-> call void @a_readonly_func(ptr %p) #9 [ "unknown"() ] -; CHECK: Just Ref: Ptr: i8* %q <-> call void @a_readonly_func(ptr %p) #9 [ "unknown"() ] -; CHECK: NoModRef: Ptr: i8* %p <-> call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] -; CHECK: NoModRef: Ptr: i8* %q <-> call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] -; CHECK: Both ModRef: Ptr: i8* %p <-> call void @an_inaccessibleorargmemonly_func(ptr %q) #11 [ "unknown"() ] -; CHECK: Both ModRef: Ptr: i8* %q <-> call void @an_inaccessibleorargmemonly_func(ptr %q) #11 [ "unknown"() ] -; CHECK: Both ModRef: Ptr: i8* %p <-> call void @an_argmemonly_func(ptr %q) #12 [ "unknown"() ] -; CHECK: Both ModRef: Ptr: i8* %q <-> call void @an_argmemonly_func(ptr %q) #12 [ "unknown"() ] -; CHECK: Just Ref: call void @a_readonly_func(ptr %p) #9 [ "unknown"() ] <-> call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] -; CHECK: Just Ref: call void @a_readonly_func(ptr %p) #9 [ "unknown"() ] <-> call void @an_inaccessibleorargmemonly_func(ptr %q) #11 [ "unknown"() ] -; CHECK: Just Ref: call void @a_readonly_func(ptr %p) #9 [ "unknown"() ] <-> call void @an_argmemonly_func(ptr %q) #12 [ "unknown"() ] -; CHECK: Both ModRef: call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] <-> call void @a_readonly_func(ptr %p) #9 [ "unknown"() ] -; CHECK: Both ModRef: call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] <-> call void @an_inaccessibleorargmemonly_func(ptr %q) #11 [ "unknown"() ] -; CHECK: NoModRef: call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] <-> call void @an_argmemonly_func(ptr %q) #12 [ "unknown"() ] -; CHECK: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) #11 [ "unknown"() ] <-> call void @a_readonly_func(ptr %p) #9 [ "unknown"() ] -; CHECK: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) #11 [ "unknown"() ] <-> call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] -; CHECK: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) #11 [ "unknown"() ] <-> call void @an_argmemonly_func(ptr %q) #12 [ "unknown"() ] -; CHECK: Both ModRef: call void @an_argmemonly_func(ptr %q) #12 [ "unknown"() ] <-> call void @a_readonly_func(ptr %p) #9 [ "unknown"() ] -; CHECK: NoModRef: call void @an_argmemonly_func(ptr %q) #12 [ "unknown"() ] <-> call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] -; CHECK: Both ModRef: call void @an_argmemonly_func(ptr %q) #12 [ "unknown"() ] <-> call void @an_inaccessibleorargmemonly_func(ptr %q) #11 [ "unknown"() ] +; ALIAS: Just Ref: Ptr: i8* %p <-> call void @a_readonly_func(ptr %p) #9 [ "unknown"() ] +; ALIAS: Just Ref: Ptr: i8* %q <-> call void @a_readonly_func(ptr %p) #9 [ "unknown"() ] +; ALIAS: NoModRef: Ptr: i8* %p <-> call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] +; ALIAS: NoModRef: Ptr: i8* %q <-> call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] +; ALIAS: Both ModRef: Ptr: i8* %p <-> call void @an_inaccessibleorargmemonly_func(ptr %q) #11 [ "unknown"() ] +; ALIAS: Both ModRef: Ptr: i8* %q <-> call void @an_inaccessibleorargmemonly_func(ptr %q) #11 [ "unknown"() ] +; ALIAS: Both ModRef: Ptr: i8* %p <-> call void @an_argmemonly_func(ptr %q) #12 [ "unknown"() ] +; ALIAS: Both ModRef: Ptr: i8* %q <-> call void @an_argmemonly_func(ptr %q) #12 [ "unknown"() ] +; ALIAS: Just Ref: call void @a_readonly_func(ptr %p) #9 [ "unknown"() ] <-> call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] +; ALIAS: Just Ref: call void @a_readonly_func(ptr %p) #9 [ "unknown"() ] <-> call void @an_inaccessibleorargmemonly_func(ptr %q) #11 [ "unknown"() ] +; ALIAS: Just Ref: call void @a_readonly_func(ptr %p) #9 [ "unknown"() ] <-> call void @an_argmemonly_func(ptr %q) #12 [ "unknown"() ] +; ALIAS: Both ModRef: call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] <-> call void @a_readonly_func(ptr %p) #9 [ "unknown"() ] +; ALIAS: Both ModRef: call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] <-> call void @an_inaccessibleorargmemonly_func(ptr %q) #11 [ "unknown"() ] +; ALIAS: NoModRef: call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] <-> call void @an_argmemonly_func(ptr %q) #12 [ "unknown"() ] +; ALIAS: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) #11 [ "unknown"() ] <-> call void @a_readonly_func(ptr %p) #9 [ "unknown"() ] +; ALIAS: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) #11 [ "unknown"() ] <-> call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] +; ALIAS: Both ModRef: call void @an_inaccessibleorargmemonly_func(ptr %q) #11 [ "unknown"() ] <-> call void @an_argmemonly_func(ptr %q) #12 [ "unknown"() ] +; ALIAS: Both ModRef: call void @an_argmemonly_func(ptr %q) #12 [ "unknown"() ] <-> call void @a_readonly_func(ptr %p) #9 [ "unknown"() ] +; ALIAS: NoModRef: call void @an_argmemonly_func(ptr %q) #12 [ "unknown"() ] <-> call void @an_inaccessiblememonly_func() #10 [ "unknown"() ] +; ALIAS: Both ModRef: call void @an_argmemonly_func(ptr %q) #12 [ "unknown"() ] <-> call void @an_inaccessibleorargmemonly_func(ptr %q) #11 [ "unknown"() ] } - -; CHECK: attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: write) } -; CHECK-NEXT: attributes #1 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } -; CHECK-NEXT: attributes #2 = { nosync nounwind willreturn memory(argmem: readwrite) } -; CHECK-NEXT: attributes #3 = { noinline nounwind memory(read) } -; CHECK-NEXT: attributes #4 = { noinline nounwind memory(write) } -; CHECK-NEXT: attributes #5 = { nounwind ssp } -; CHECK-NEXT: attributes #6 = { nounwind memory(inaccessiblemem: readwrite) } -; CHECK-NEXT: attributes #7 = { nounwind memory(argmem: readwrite, inaccessiblemem: readwrite) } -; CHECK-NEXT: attributes #8 = { nounwind memory(argmem: readwrite) } -; CHECK-NEXT: attributes #9 = { memory(read) } -; CHECK-NEXT: attributes #10 = { memory(inaccessiblemem: readwrite) } -; CHECK-NEXT: attributes #11 = { memory(argmem: readwrite, inaccessiblemem: readwrite) } -; CHECK-NEXT: attributes #12 = { memory(argmem: readwrite) } - attributes #0 = { argmemonly nounwind } attributes #1 = { noinline nounwind readonly } attributes #2 = { noinline nounwind writeonly } @@ -453,3 +502,17 @@ attributes #7 = { inaccessiblememonly } attributes #8 = { inaccessiblemem_or_argmemonly } attributes #9 = { argmemonly } + +; CHECK-DAG: attributes [[ATTRSET]] = { nocallback nofree nounwind willreturn memory(argmem: write) } +; CHECK-DAG: attributes [[ATTRCPY]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } +; CHECK-DAG: attributes [[ATTRATOMIC]] = { nosync nounwind willreturn memory(argmem: readwrite) } +; CHECK-DAG: attributes [[ATTR3]] = { noinline nounwind memory(read) } +; CHECK-DAG: attributes [[ATTR4]] = { noinline nounwind memory(write) } +; CHECK-DAG: attributes [[ATTR5]] = { nounwind ssp } +; CHECK-DAG: attributes [[ATTR6]] = { nounwind memory(inaccessiblemem: readwrite) } +; CHECK-DAG: attributes [[ATTR7]] = { nounwind memory(argmem: readwrite, inaccessiblemem: readwrite) } +; CHECK-DAG: attributes [[ATTR8]] = { nounwind memory(argmem: readwrite) } +; CHECK-DAG: attributes [[ATTR9]] = { memory(read) } +; CHECK-DAG: attributes [[ATTR10]] = { memory(inaccessiblemem: readwrite) } +; CHECK-DAG: attributes [[ATTR11]] = { memory(argmem: readwrite, inaccessiblemem: readwrite) } +; CHECK-DAG: attributes [[ATTR12]] = { memory(argmem: readwrite) }