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