test/Other/cgscc-devirt-iteration.ll

   1 ; The CGSCC pass manager includes an SCC iteration utility that tracks indirect
   2 ; calls that are turned into direct calls (devirtualization) and re-visits the
   3 ; SCC to expose those calls to the SCC-based IPO passes. We trigger
   4 ; devirtualization here with GVN which forwards a store through a load and to
   5 ; an indirect call.
   6 ;
   7 ; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(function-attrs,function(gvn,instcombine))' -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=BEFORE
   8 ; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(devirt<1>(function-attrs,function(gvn,instcombine)))' -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=AFTER --check-prefix=AFTER1
   9 ; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(devirt<2>(function-attrs,function(gvn,instcombine)))' -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=AFTER --check-prefix=AFTER2
  10 ;
  11 ; We also verify that the real O2 pipeline catches these cases.
  12 ; RUN: opt -aa-pipeline=basic-aa -passes='default<O2>' -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=AFTER --check-prefix=AFTER2
  13
  14 declare void @readnone() readnone
  15 ; CHECK: Function Attrs: readnone
  16 ; CHECK-NEXT: declare void @readnone()
  17
  18 declare void @unknown()
  19 ; CHECK-NOT: Function Attrs
  20 ; CHECK-LABEL: declare void @unknown(){{ *$}}
  21
  22 ; The @test1 function checks that when we refine an indirect call to a direct
  23 ; call we revisit the SCC passes to reflect the more precise information. This
  24 ; is the basic functionality.
  25
  26 define void @test1() {
  27 ; BEFORE-NOT: Function Attrs
  28 ; AFTER: Function Attrs: readnone
  29 ; CHECK-LABEL: define void @test1()
  30 entry:
  31   %fptr = alloca void ()*
  32   store void ()* @readnone, void ()** %fptr
  33   %f = load void ()*, void ()** %fptr
  34   call void %f()
  35   ret void
  36 }
  37
  38 ; The @test2_* functions check that when we need multiple (in this case 2)
  39 ; repetitions to compute some state that is incrementally exposed with each
  40 ; one, the limit on repetitions is enforced. So we make progress with
  41 ; one repetition but not as much as with three.
  42 ;
  43 ; This is somewhat awkward to test because we have to contrive to have a state
  44 ; repetition triggered and observed with very few passes. The technique here
  45 ; is to have one indirect call that can only be resolved when the entire SCC is
  46 ; deduced as readonly, and mark that indirect call at the call site as readonly
  47 ; to make that possible. This forces us to first deduce readonly, then
  48 ; devirtualize again, and then deduce readnone.
  49
  50 declare void @readnone_with_arg(void ()**) readnone
  51 ; CHECK: Function Attrs: readnone
  52 ; CHECK-LABEL: declare void @readnone_with_arg(void ()**)
  53
  54 define void @test2_a(void ()** %ignore) {
  55 ; BEFORE-NOT: Function Attrs
  56 ; AFTER1: Function Attrs: readonly
  57 ; AFTER2: Function Attrs: readnone
  58 ; BEFORE: define void @test2_a(void ()** %ignore)
  59 ; AFTER: define void @test2_a(void ()** readnone %ignore)
  60 entry:
  61   %f1ptr = alloca void (void ()**)*
  62   store void (void ()**)* @readnone_with_arg, void (void ()**)** %f1ptr
  63   %f1 = load void (void ()**)*, void (void ()**)** %f1ptr
  64   ; This indirect call is the first to be resolved, allowing us to deduce
  65   ; readonly but not (yet) readnone.
  66   call void %f1(void ()** %ignore)
  67 ; CHECK: call void @readnone_with_arg(void ()** %ignore)
  68
  69   ; Bogus call to test2_b to make this a cycle.
  70   call void @test2_b()
  71
  72   ret void
  73 }
  74
  75 define void @test2_b() {
  76 ; BEFORE-NOT: Function Attrs
  77 ; AFTER1: Function Attrs: readonly
  78 ; AFTER2: Function Attrs: readnone
  79 ; CHECK-LABEL: define void @test2_b()
  80 entry:
  81   %f2ptr = alloca void ()*
  82   store void ()* @readnone, void ()** %f2ptr
  83   ; Call the other function here to prevent forwarding until the SCC has had
  84   ; function attrs deduced.
  85   call void @test2_a(void ()** %f2ptr)
  86
  87   %f2 = load void ()*, void ()** %f2ptr
  88   ; This is the second indirect call to be resolved, and can only be resolved
  89   ; after we deduce 'readonly' for the rest of the SCC. Once it is
  90   ; devirtualized, we can deduce readnone for the SCC.
  91   call void %f2() readonly
  92 ; BEFORE: call void %f2()
  93 ; AFTER: call void @readnone()
  94
  95   ret void
  96 }
  97
  98 declare i8* @memcpy(i8*, i8*, i64)
  99 ; CHECK-LABEL: i8* @memcpy(
 100
 101 ; The @test3 function checks that when we refine an indirect call to an
 102 ; intrinsic we still revisit the SCC pass. This also covers cases where the
 103 ; value handle itself doesn't persist due to the nature of how instcombine
 104 ; creates the memcpy intrinsic call, and we rely on the count of indirect calls
 105 ; decreasing and the count of direct calls increasing.
 106 ; Adding 'noinline' attribute to force attributes for improved matching.
 107 define void @test3(i8* %src, i8* %dest, i64 %size) noinline {
 108 ; CHECK: Function Attrs
 109 ; CHECK-NOT: read
 110 ; CHECK-SAME: noinline
 111 ; BEFORE-LABEL: define void @test3(i8* %src, i8* %dest, i64 %size)
 112 ; AFTER-LABEL: define void @test3(i8* nocapture readonly %src, i8* nocapture %dest, i64 %size)
 113   %fptr = alloca i8* (i8*, i8*, i64)*
 114   store i8* (i8*, i8*, i64)* @memcpy, i8* (i8*, i8*, i64)** %fptr
 115   %f = load i8* (i8*, i8*, i64)*, i8* (i8*, i8*, i64)** %fptr
 116   call i8* %f(i8* %dest, i8* %src, i64 %size)
 117 ; CHECK: call void @llvm.memcpy
 118   ret void
 119 }
 120
 121 ; A boring function that just keeps our declarations around.
 122 define void @keep(i8** %sink) {
 123 ; CHECK-NOT: Function Attrs
 124 ; CHECK-LABEL: define void @keep(
 125 entry:
 126   store volatile i8* bitcast (void ()* @readnone to i8*), i8** %sink
 127   store volatile i8* bitcast (void ()* @unknown to i8*), i8** %sink
 128   store volatile i8* bitcast (i8* (i8*, i8*, i64)* @memcpy to i8*), i8** %sink
 129   call void @unknown()
 130   ret void
 131 }