test/Transforms/Inline/noinline-recursive-fn.ll

   1 ; The inliner should never inline recursive functions into other functions.
   2 ; This effectively is just peeling off the first iteration of a loop, and the
   3 ; inliner heuristics are not set up for this.
   4
   5 ; RUN: opt -inline -S < %s | FileCheck %s
   6
   7 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"
   8 target triple = "x86_64-apple-darwin10.3"
   9
  10 @g = common global i32 0                          ; <i32*> [#uses=1]
  11
  12 define internal void @foo(i32 %x) nounwind ssp {
  13 entry:
  14   %0 = icmp slt i32 %x, 0                         ; <i1> [#uses=1]
  15   br i1 %0, label %return, label %bb
  16
  17 bb:                                               ; preds = %entry
  18   %1 = sub nsw i32 %x, 1                          ; <i32> [#uses=1]
  19   call void @foo(i32 %1) nounwind ssp
  20   store volatile i32 1, i32* @g, align 4
  21   ret void
  22
  23 return:                                           ; preds = %entry
  24   ret void
  25 }
  26
  27
  28 ;; CHECK-LABEL: @bonk(
  29 ;; CHECK: call void @foo(i32 42)
  30 define void @bonk() nounwind ssp {
  31 entry:
  32   call void @foo(i32 42) nounwind ssp
  33   ret void
  34 }
  35
  36
  37
  38 ;; Here is an indirect case that should not be infinitely inlined.
  39
  40 define internal void @f1(i32 %x, i8* %Foo, i8* %Bar) nounwind ssp {
  41 entry:
  42   %0 = bitcast i8* %Bar to void (i32, i8*, i8*)*
  43   %1 = sub nsw i32 %x, 1
  44   call void %0(i32 %1, i8* %Foo, i8* %Bar) nounwind
  45   store volatile i32 42, i32* @g, align 4
  46   ret void
  47 }
  48
  49 define internal void @f2(i32 %x, i8* %Foo, i8* %Bar) nounwind ssp {
  50 entry:
  51   %0 = icmp slt i32 %x, 0                         ; <i1> [#uses=1]
  52   br i1 %0, label %return, label %bb
  53
  54 bb:                                               ; preds = %entry
  55   %1 = bitcast i8* %Foo to void (i32, i8*, i8*)*  ; <void (i32, i8*, i8*)*> [#uses=1]
  56   call void %1(i32 %x, i8* %Foo, i8* %Bar) nounwind
  57   store volatile i32 13, i32* @g, align 4
  58   ret void
  59
  60 return:                                           ; preds = %entry
  61   ret void
  62 }
  63
  64
  65 ; CHECK-LABEL: @top_level(
  66 ; CHECK: call void @f2(i32 122
  67 ; Here we inline one instance of the cycle, but we don't want to completely
  68 ; unroll it.
  69 define void @top_level() nounwind ssp {
  70 entry:
  71   call void @f2(i32 123, i8* bitcast (void (i32, i8*, i8*)* @f1 to i8*), i8* bitcast (void (i32, i8*, i8*)* @f2 to i8*)) nounwind ssp
  72   ret void
  73 }
  74
  75
  76 ; Check that a recursive function, when called with a constant that makes the
  77 ; recursive path dead code can actually be inlined.
  78 define i32 @fib(i32 %i) {
  79 entry:
  80   %is.zero = icmp eq i32 %i, 0
  81   br i1 %is.zero, label %zero.then, label %zero.else
  82
  83 zero.then:
  84   ret i32 0
  85
  86 zero.else:
  87   %is.one = icmp eq i32 %i, 1
  88   br i1 %is.one, label %one.then, label %one.else
  89
  90 one.then:
  91   ret i32 1
  92
  93 one.else:
  94   %i1 = sub i32 %i, 1
  95   %f1 = call i32 @fib(i32 %i1)
  96   %i2 = sub i32 %i, 2
  97   %f2 = call i32 @fib(i32 %i2)
  98   %f = add i32 %f1, %f2
  99   ret i32 %f
 100 }
 101
 102 define i32 @fib_caller() {
 103 ; CHECK-LABEL: @fib_caller(
 104 ; CHECK-NOT: call
 105 ; CHECK: ret
 106   %f1 = call i32 @fib(i32 0)
 107   %f2 = call i32 @fib(i32 1)
 108   %result = add i32 %f1, %f2
 109   ret i32 %result
 110 }