3ab9e8b818
Summary: There were segfaults as we modified and iterated the instruction maps in the cache at the same time. This was happening because we created new instructions while we populated the cache. This fix changes the order in which we perform these actions. First, the caches for the whole module are created, then we start to create abstract attributes. I don't have a unit test but the LLVM test suite exposes this problem. Reviewers: uenoku, sstefan1 Subscribers: hiraditya, bollu, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D67232 llvm-svn: 372105
355 lines
12 KiB
LLVM
355 lines
12 KiB
LLVM
; RUN: opt -functionattrs -S < %s | FileCheck %s --check-prefix=FNATTR
|
|
; RUN: opt -attributor -attributor-manifest-internal -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=2 -S < %s | FileCheck %s --check-prefix=ATTRIBUTOR
|
|
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
|
|
|
|
; Test cases designed for the nosync function attribute.
|
|
; FIXME's are used to indicate problems and missing attributes.
|
|
|
|
; struct RT {
|
|
; char A;
|
|
; int B[10][20];
|
|
; char C;
|
|
; };
|
|
; struct ST {
|
|
; int X;
|
|
; double Y;
|
|
; struct RT Z;
|
|
; };
|
|
;
|
|
; int *foo(struct ST *s) {
|
|
; return &s[1].Z.B[5][13];
|
|
; }
|
|
|
|
; TEST 1
|
|
; non-convergent and readnone implies nosync
|
|
%struct.RT = type { i8, [10 x [20 x i32]], i8 }
|
|
%struct.ST = type { i32, double, %struct.RT }
|
|
|
|
; FNATTR: Function Attrs: norecurse nounwind optsize readnone ssp uwtable
|
|
; FNATTR-NEXT: define nonnull i32* @foo(%struct.ST* readnone %s)
|
|
; ATTRIBUTOR: Function Attrs: nofree nosync nounwind optsize readnone ssp uwtable
|
|
; ATTRIBUTOR-NEXT: define nonnull i32* @foo(%struct.ST* "no-capture-maybe-returned" %s)
|
|
define i32* @foo(%struct.ST* %s) nounwind uwtable readnone optsize ssp {
|
|
entry:
|
|
%arrayidx = getelementptr inbounds %struct.ST, %struct.ST* %s, i64 1, i32 2, i32 1, i64 5, i64 13
|
|
ret i32* %arrayidx
|
|
}
|
|
|
|
; TEST 2
|
|
; atomic load with monotonic ordering
|
|
; int load_monotonic(_Atomic int *num) {
|
|
; int n = atomic_load_explicit(num, memory_order_relaxed);
|
|
; return n;
|
|
; }
|
|
|
|
; FNATTR: Function Attrs: nofree norecurse nounwind uwtable
|
|
; FNATTR-NEXT: define i32 @load_monotonic(i32* nocapture readonly %0)
|
|
; ATTRIBUTOR: Function Attrs: nofree norecurse nosync nounwind uwtable
|
|
; ATTRIBUTOR-NEXT: define i32 @load_monotonic(i32* nocapture readonly %0)
|
|
define i32 @load_monotonic(i32* nocapture readonly %0) norecurse nounwind uwtable {
|
|
%2 = load atomic i32, i32* %0 monotonic, align 4
|
|
ret i32 %2
|
|
}
|
|
|
|
|
|
; TEST 3
|
|
; atomic store with monotonic ordering.
|
|
; void store_monotonic(_Atomic int *num) {
|
|
; atomic_load_explicit(num, memory_order_relaxed);
|
|
; }
|
|
|
|
; FNATTR: Function Attrs: nofree norecurse nounwind uwtable
|
|
; FNATTR-NEXT: define void @store_monotonic(i32* nocapture %0)
|
|
; ATTRIBUTOR: Function Attrs: nofree norecurse nosync nounwind uwtable
|
|
; ATTRIBUTOR-NEXT: define void @store_monotonic(i32* nocapture %0)
|
|
define void @store_monotonic(i32* nocapture %0) norecurse nounwind uwtable {
|
|
store atomic i32 10, i32* %0 monotonic, align 4
|
|
ret void
|
|
}
|
|
|
|
; TEST 4 - negative, should not deduce nosync
|
|
; atomic load with acquire ordering.
|
|
; int load_acquire(_Atomic int *num) {
|
|
; int n = atomic_load_explicit(num, memory_order_acquire);
|
|
; return n;
|
|
; }
|
|
|
|
; FNATTR: Function Attrs: nofree norecurse nounwind uwtable
|
|
; FNATTR-NEXT: define i32 @load_acquire(i32* nocapture readonly %0)
|
|
; ATTRIBUTOR: Function Attrs: nofree norecurse nounwind uwtable
|
|
; ATTRIBUTOR-NOT: nosync
|
|
; ATTRIBUTOR-NEXT: define i32 @load_acquire(i32* nocapture readonly %0)
|
|
define i32 @load_acquire(i32* nocapture readonly %0) norecurse nounwind uwtable {
|
|
%2 = load atomic i32, i32* %0 acquire, align 4
|
|
ret i32 %2
|
|
}
|
|
|
|
; TEST 5 - negative, should not deduce nosync
|
|
; atomic load with release ordering
|
|
; void load_release(_Atomic int *num) {
|
|
; atomic_store_explicit(num, 10, memory_order_release);
|
|
; }
|
|
|
|
; FNATTR: Function Attrs: nofree norecurse nounwind uwtable
|
|
; FNATTR-NEXT: define void @load_release(i32* nocapture %0)
|
|
; ATTRIBUTOR: Function Attrs: nofree norecurse nounwind uwtable
|
|
; ATTRIBUTOR-NOT: nosync
|
|
; ATTRIBUTOR-NEXT: define void @load_release(i32* nocapture %0)
|
|
define void @load_release(i32* nocapture %0) norecurse nounwind uwtable {
|
|
store atomic volatile i32 10, i32* %0 release, align 4
|
|
ret void
|
|
}
|
|
|
|
; TEST 6 - negative volatile, relaxed atomic
|
|
|
|
; FNATTR: Function Attrs: nofree norecurse nounwind uwtable
|
|
; FNATTR-NEXT: define void @load_volatile_release(i32* nocapture %0)
|
|
; ATTRIBUTOR: Function Attrs: nofree norecurse nounwind uwtable
|
|
; ATTRIBUTOR-NOT: nosync
|
|
; ATTRIBUTOR-NEXT: define void @load_volatile_release(i32* nocapture %0)
|
|
define void @load_volatile_release(i32* nocapture %0) norecurse nounwind uwtable {
|
|
store atomic volatile i32 10, i32* %0 release, align 4
|
|
ret void
|
|
}
|
|
|
|
; TEST 7 - negative, should not deduce nosync
|
|
; volatile store.
|
|
; void volatile_store(volatile int *num) {
|
|
; *num = 14;
|
|
; }
|
|
|
|
; FNATTR: Function Attrs: nofree norecurse nounwind uwtable
|
|
; FNATTR-NEXT: define void @volatile_store(i32* %0)
|
|
; ATTRIBUTOR: Function Attrs: nofree norecurse nounwind uwtable
|
|
; ATTRIBUTOR-NOT: nosync
|
|
; ATTRIBUTOR-NEXT: define void @volatile_store(i32* %0)
|
|
define void @volatile_store(i32* %0) norecurse nounwind uwtable {
|
|
store volatile i32 14, i32* %0, align 4
|
|
ret void
|
|
}
|
|
|
|
; TEST 8 - negative, should not deduce nosync
|
|
; volatile load.
|
|
; int volatile_load(volatile int *num) {
|
|
; int n = *num;
|
|
; return n;
|
|
; }
|
|
|
|
; FNATTR: Function Attrs: nofree norecurse nounwind uwtable
|
|
; FNATTR-NEXT: define i32 @volatile_load(i32* %0)
|
|
; ATTRIBUTOR: Function Attrs: nofree norecurse nounwind uwtable
|
|
; ATTRIBUTOR-NOT: nosync
|
|
; ATTRIBUTOR-NEXT: define i32 @volatile_load(i32* %0)
|
|
define i32 @volatile_load(i32* %0) norecurse nounwind uwtable {
|
|
%2 = load volatile i32, i32* %0, align 4
|
|
ret i32 %2
|
|
}
|
|
|
|
; TEST 9
|
|
|
|
; FNATTR: Function Attrs: noinline nosync nounwind uwtable
|
|
; FNATTR-NEXT: declare void @nosync_function()
|
|
; ATTRIBUTOR: Function Attrs: noinline nosync nounwind uwtable
|
|
; ATTRIBUTOR-NEXT: declare void @nosync_function()
|
|
declare void @nosync_function() noinline nounwind uwtable nosync
|
|
|
|
; FNATTR: Function Attrs: noinline nounwind uwtable
|
|
; FNATTR-NEXT: define void @call_nosync_function()
|
|
; ATTRIBUTOR: Function Attrs: noinline nosync nounwind uwtable
|
|
; ATTRIBUTOR-next: define void @call_nosync_function()
|
|
define void @call_nosync_function() nounwind uwtable noinline {
|
|
tail call void @nosync_function() noinline nounwind uwtable
|
|
ret void
|
|
}
|
|
|
|
; TEST 10 - negative, should not deduce nosync
|
|
|
|
; FNATTR: Function Attrs: noinline nounwind uwtable
|
|
; FNATTR-NEXT: declare void @might_sync()
|
|
; ATTRIBUTOR: Function Attrs: noinline nounwind uwtable
|
|
; ATTRIBUTOR-NEXT: declare void @might_sync()
|
|
declare void @might_sync() noinline nounwind uwtable
|
|
|
|
; FNATTR: Function Attrs: noinline nounwind uwtable
|
|
; FNATTR-NEXT: define void @call_might_sync()
|
|
; ATTRIBUTOR: Function Attrs: noinline nounwind uwtable
|
|
; ATTRIBUTOR-NOT: nosync
|
|
; ATTRIBUTOR-NEXT: define void @call_might_sync()
|
|
define void @call_might_sync() nounwind uwtable noinline {
|
|
tail call void @might_sync() noinline nounwind uwtable
|
|
ret void
|
|
}
|
|
|
|
; TEST 11 - positive, should deduce nosync
|
|
; volatile operation in same scc but dead. Call volatile_load defined in TEST 8.
|
|
|
|
; FNATTR: Function Attrs: nofree noinline nounwind uwtable
|
|
; FNATTR-NEXT: define i32 @scc1(i32* %0)
|
|
; ATTRIBUTOR: Function Attrs: nofree noinline noreturn nosync nounwind uwtable
|
|
; ATTRIBUTOR-NEXT: define i32 @scc1(i32* nocapture %0)
|
|
define i32 @scc1(i32* %0) noinline nounwind uwtable {
|
|
tail call void @scc2(i32* %0);
|
|
%val = tail call i32 @volatile_load(i32* %0);
|
|
ret i32 %val;
|
|
}
|
|
|
|
; FNATTR: Function Attrs: nofree noinline nounwind uwtable
|
|
; FNATTR-NEXT: define void @scc2(i32* %0)
|
|
; ATTRIBUTOR: Function Attrs: nofree noinline noreturn nosync nounwind uwtable
|
|
; ATTRIBUTOR-NEXT: define void @scc2(i32* nocapture %0)
|
|
define void @scc2(i32* %0) noinline nounwind uwtable {
|
|
tail call i32 @scc1(i32* %0);
|
|
ret void;
|
|
}
|
|
|
|
; TEST 12 - fences, negative
|
|
;
|
|
; void foo1(int *a, std::atomic<bool> flag){
|
|
; *a = 100;
|
|
; atomic_thread_fence(std::memory_order_release);
|
|
; flag.store(true, std::memory_order_relaxed);
|
|
; }
|
|
;
|
|
; void bar(int *a, std::atomic<bool> flag){
|
|
; while(!flag.load(std::memory_order_relaxed))
|
|
; ;
|
|
;
|
|
; atomic_thread_fence(std::memory_order_acquire);
|
|
; int b = *a;
|
|
; }
|
|
|
|
%"struct.std::atomic" = type { %"struct.std::__atomic_base" }
|
|
%"struct.std::__atomic_base" = type { i8 }
|
|
|
|
; FNATTR: Function Attrs: nofree norecurse nounwind
|
|
; FNATTR-NEXT: define void @foo1(i32* nocapture %0, %"struct.std::atomic"* nocapture %1)
|
|
; ATTRIBUTOR-NOT: nosync
|
|
; ATTRIBUTOR: define void @foo1(i32* nocapture %0, %"struct.std::atomic"* nocapture %1)
|
|
define void @foo1(i32* %0, %"struct.std::atomic"* %1) {
|
|
store i32 100, i32* %0, align 4
|
|
fence release
|
|
%3 = getelementptr inbounds %"struct.std::atomic", %"struct.std::atomic"* %1, i64 0, i32 0, i32 0
|
|
store atomic i8 1, i8* %3 monotonic, align 1
|
|
ret void
|
|
}
|
|
|
|
; FNATTR: Function Attrs: nofree norecurse nounwind
|
|
; FNATTR-NEXT: define void @bar(i32* nocapture readnone %0, %"struct.std::atomic"* nocapture readonly %1)
|
|
; ATTRIBUTOR-NOT: nosync
|
|
; ATTRIBUTOR: define void @bar(i32* nocapture %0, %"struct.std::atomic"* nocapture %1)
|
|
define void @bar(i32* %0, %"struct.std::atomic"* %1) {
|
|
%3 = getelementptr inbounds %"struct.std::atomic", %"struct.std::atomic"* %1, i64 0, i32 0, i32 0
|
|
br label %4
|
|
|
|
4: ; preds = %4, %2
|
|
%5 = load atomic i8, i8* %3 monotonic, align 1
|
|
%6 = and i8 %5, 1
|
|
%7 = icmp eq i8 %6, 0
|
|
br i1 %7, label %4, label %8
|
|
|
|
8: ; preds = %4
|
|
fence acquire
|
|
ret void
|
|
}
|
|
|
|
; TEST 13 - Fence syncscope("singlethread") seq_cst
|
|
; FNATTR: Function Attrs: nofree norecurse nounwind
|
|
; FNATTR-NEXT: define void @foo1_singlethread(i32* nocapture %0, %"struct.std::atomic"* nocapture %1)
|
|
; ATTRIBUTOR: Function Attrs: nofree nosync
|
|
; ATTRIBUTOR: define void @foo1_singlethread(i32* nocapture %0, %"struct.std::atomic"* nocapture %1)
|
|
define void @foo1_singlethread(i32* %0, %"struct.std::atomic"* %1) {
|
|
store i32 100, i32* %0, align 4
|
|
fence syncscope("singlethread") release
|
|
%3 = getelementptr inbounds %"struct.std::atomic", %"struct.std::atomic"* %1, i64 0, i32 0, i32 0
|
|
store atomic i8 1, i8* %3 monotonic, align 1
|
|
ret void
|
|
}
|
|
|
|
; FNATTR: Function Attrs: nofree norecurse nounwind
|
|
; FNATTR-NEXT: define void @bar_singlethread(i32* nocapture readnone %0, %"struct.std::atomic"* nocapture readonly %1)
|
|
; ATTRIBUTOR: Function Attrs: nofree nosync
|
|
; ATTRIBUTOR: define void @bar_singlethread(i32* nocapture %0, %"struct.std::atomic"* nocapture %1)
|
|
define void @bar_singlethread(i32* %0, %"struct.std::atomic"* %1) {
|
|
%3 = getelementptr inbounds %"struct.std::atomic", %"struct.std::atomic"* %1, i64 0, i32 0, i32 0
|
|
br label %4
|
|
|
|
4: ; preds = %4, %2
|
|
%5 = load atomic i8, i8* %3 monotonic, align 1
|
|
%6 = and i8 %5, 1
|
|
%7 = icmp eq i8 %6, 0
|
|
br i1 %7, label %4, label %8
|
|
|
|
8: ; preds = %4
|
|
fence syncscope("singlethread") acquire
|
|
ret void
|
|
}
|
|
|
|
declare void @llvm.memcpy(i8* %dest, i8* %src, i32 %len, i1 %isvolatile)
|
|
declare void @llvm.memset(i8* %dest, i8 %val, i32 %len, i1 %isvolatile)
|
|
|
|
; TEST 14 - negative, checking volatile intrinsics.
|
|
|
|
; It is odd to add nocapture but a result of the llvm.memcpy nocapture.
|
|
;
|
|
; ATTRIBUTOR: Function Attrs: nounwind
|
|
; ATTRIBUTOR-NOT: nosync
|
|
; ATTRIBUTOR-NEXT: define i32 @memcpy_volatile(i8* nocapture %ptr1, i8* nocapture %ptr2)
|
|
define i32 @memcpy_volatile(i8* %ptr1, i8* %ptr2) {
|
|
call void @llvm.memcpy(i8* %ptr1, i8* %ptr2, i32 8, i1 1)
|
|
ret i32 4
|
|
}
|
|
|
|
; TEST 15 - positive, non-volatile intrinsic.
|
|
|
|
; It is odd to add nocapture but a result of the llvm.memset nocapture.
|
|
;
|
|
; ATTRIBUTOR: Function Attrs: nosync
|
|
; ATTRIBUTOR-NEXT: define i32 @memset_non_volatile(i8* nocapture %ptr1, i8 %val)
|
|
define i32 @memset_non_volatile(i8* %ptr1, i8 %val) {
|
|
call void @llvm.memset(i8* %ptr1, i8 %val, i32 8, i1 0)
|
|
ret i32 4
|
|
}
|
|
|
|
; TEST 16 - negative, inline assembly.
|
|
|
|
; ATTRIBUTOR: define i32 @inline_asm_test(i32 %x)
|
|
define i32 @inline_asm_test(i32 %x) {
|
|
call i32 asm "bswap $0", "=r,r"(i32 %x)
|
|
ret i32 4
|
|
}
|
|
|
|
declare void @readnone_test() convergent readnone
|
|
|
|
; ATTRIBUTOR: define void @convergent_readnone()
|
|
; TEST 17 - negative. Convergent
|
|
define void @convergent_readnone(){
|
|
call void @readnone_test()
|
|
ret void
|
|
}
|
|
|
|
; ATTRIBUTOR: Function Attrs: nounwind
|
|
; ATTRIBUTOR-NEXT: declare void @llvm.x86.sse2.clflush(i8*)
|
|
declare void @llvm.x86.sse2.clflush(i8*)
|
|
@a = common global i32 0, align 4
|
|
|
|
; TEST 18 - negative. Synchronizing intrinsic
|
|
|
|
; ATTRIBUTOR: Function Attrs: nounwind
|
|
; ATTRIBUTOR-NOT: nosync
|
|
; ATTRIBUTOR-NEXT: define void @i_totally_sync()
|
|
define void @i_totally_sync() {
|
|
tail call void @llvm.x86.sse2.clflush(i8* bitcast (i32* @a to i8*))
|
|
ret void
|
|
}
|
|
|
|
declare float @llvm.cos(float %val) readnone
|
|
|
|
; TEST 19 - positive, readnone & non-convergent intrinsic.
|
|
|
|
; ATTRIBUTOR: Function Attrs: nosync nounwind
|
|
; ATTRIBUTOR-NEXT: define i32 @cos_test(float %x)
|
|
define i32 @cos_test(float %x) {
|
|
call float @llvm.cos(float %x)
|
|
ret i32 4
|
|
}
|