| ; RUN: opt < %s -passes=inline -inline-threshold=20 -S | FileCheck %s |
| ; RUN: opt < %s -passes='cgscc(inline)' -inline-threshold=20 -S | FileCheck %s |
| |
| define internal i32 @callee1(i32 %A, i32 %B) { |
| %C = sdiv i32 %A, %B |
| ret i32 %C |
| } |
| |
| define i32 @caller1() { |
| ; CHECK-LABEL: define i32 @caller1( |
| ; CHECK-NEXT: ret i32 3 |
| |
| %X = call i32 @callee1( i32 10, i32 3 ) |
| ret i32 %X |
| } |
| |
| define i32 @caller2() { |
| ; Check that we can constant-prop through instructions after inlining callee21 |
| ; to get constants in the inlined callsite to callee22. |
| ; FIXME: Currently, the threshold is fixed at 20 because we don't perform |
| ; *recursive* cost analysis to realize that the nested call site will definitely |
| ; inline and be cheap. We should eventually do that and lower the threshold here |
| ; to 1. |
| ; |
| ; CHECK-LABEL: @caller2( |
| ; CHECK-NOT: call void @callee2 |
| ; CHECK: ret |
| |
| %x = call i32 @callee21(i32 42, i32 48) |
| ret i32 %x |
| } |
| |
| define i32 @callee21(i32 %x, i32 %y) { |
| %sub = sub i32 %y, %x |
| %result = call i32 @callee22(i32 %sub) |
| ret i32 %result |
| } |
| |
| declare ptr @getptr() |
| |
| define i32 @callee22(i32 %x) { |
| %icmp = icmp ugt i32 %x, 42 |
| br i1 %icmp, label %bb.true, label %bb.false |
| bb.true: |
| ; This block musn't be counted in the inline cost. |
| %x1 = add i32 %x, 1 |
| %x2 = add i32 %x1, 1 |
| %x3 = add i32 %x2, 1 |
| %x4 = add i32 %x3, 1 |
| %x5 = add i32 %x4, 1 |
| %x6 = add i32 %x5, 1 |
| %x7 = add i32 %x6, 1 |
| %x8 = add i32 %x7, 1 |
| |
| ret i32 %x8 |
| bb.false: |
| ret i32 %x |
| } |
| |
| define i32 @caller3() { |
| ; Check that even if the expensive path is hidden behind several basic blocks, |
| ; it doesn't count toward the inline cost when constant-prop proves those paths |
| ; dead. |
| ; |
| ; CHECK-LABEL: @caller3( |
| ; CHECK-NOT: call |
| ; CHECK: ret i32 6 |
| |
| entry: |
| %x = call i32 @callee3(i32 42, i32 48) |
| ret i32 %x |
| } |
| |
| define i32 @callee3(i32 %x, i32 %y) { |
| %sub = sub i32 %y, %x |
| %icmp = icmp ugt i32 %sub, 42 |
| br i1 %icmp, label %bb.true, label %bb.false |
| |
| bb.true: |
| %icmp2 = icmp ult i32 %sub, 64 |
| br i1 %icmp2, label %bb.true.true, label %bb.true.false |
| |
| bb.true.true: |
| ; This block musn't be counted in the inline cost. |
| %x1 = add i32 %x, 1 |
| %x2 = add i32 %x1, 1 |
| %x3 = add i32 %x2, 1 |
| %x4 = add i32 %x3, 1 |
| %x5 = add i32 %x4, 1 |
| %x6 = add i32 %x5, 1 |
| %x7 = add i32 %x6, 1 |
| %x8 = add i32 %x7, 1 |
| br label %bb.merge |
| |
| bb.true.false: |
| ; This block musn't be counted in the inline cost. |
| %y1 = add i32 %y, 1 |
| %y2 = add i32 %y1, 1 |
| %y3 = add i32 %y2, 1 |
| %y4 = add i32 %y3, 1 |
| %y5 = add i32 %y4, 1 |
| %y6 = add i32 %y5, 1 |
| %y7 = add i32 %y6, 1 |
| %y8 = add i32 %y7, 1 |
| br label %bb.merge |
| |
| bb.merge: |
| %result = phi i32 [ %x8, %bb.true.true ], [ %y8, %bb.true.false ] |
| ret i32 %result |
| |
| bb.false: |
| ret i32 %sub |
| } |
| |
| declare {i8, i1} @llvm.uadd.with.overflow.i8(i8 %a, i8 %b) |
| |
| define i8 @caller4(i8 %z) { |
| ; Check that we can constant fold through intrinsics such as the |
| ; overflow-detecting arithmetic intrinsics. These are particularly important |
| ; as they are used heavily in standard library code and generic C++ code where |
| ; the arguments are oftent constant but complete generality is required. |
| ; |
| ; CHECK-LABEL: @caller4( |
| ; CHECK-NOT: call |
| ; CHECK: ret i8 -1 |
| |
| entry: |
| %x = call i8 @callee4(i8 254, i8 14, i8 %z) |
| ret i8 %x |
| } |
| |
| define i8 @callee4(i8 %x, i8 %y, i8 %z) { |
| %uadd = call {i8, i1} @llvm.uadd.with.overflow.i8(i8 %x, i8 %y) |
| %o = extractvalue {i8, i1} %uadd, 1 |
| br i1 %o, label %bb.true, label %bb.false |
| |
| bb.true: |
| ret i8 -1 |
| |
| bb.false: |
| ; This block musn't be counted in the inline cost. |
| %z1 = add i8 %z, 1 |
| %z2 = add i8 %z1, 1 |
| %z3 = add i8 %z2, 1 |
| %z4 = add i8 %z3, 1 |
| %z5 = add i8 %z4, 1 |
| %z6 = add i8 %z5, 1 |
| %z7 = add i8 %z6, 1 |
| %z8 = add i8 %z7, 1 |
| ret i8 %z8 |
| } |
| |
| define i64 @caller5(i64 %y) { |
| ; Check that we can round trip constants through various kinds of casts etc w/o |
| ; losing track of the constant prop in the inline cost analysis. |
| ; |
| ; CHECK-LABEL: @caller5( |
| ; CHECK-NOT: call |
| ; CHECK: ret i64 -1 |
| |
| entry: |
| %x = call i64 @callee5(i64 42, i64 %y) |
| ret i64 %x |
| } |
| |
| define i64 @callee5(i64 %x, i64 %y) { |
| %inttoptr = inttoptr i64 %x to ptr |
| %ptrtoint = ptrtoint ptr %inttoptr to i64 |
| %trunc = trunc i64 %ptrtoint to i32 |
| %zext = zext i32 %trunc to i64 |
| %cmp = icmp eq i64 %zext, 42 |
| br i1 %cmp, label %bb.true, label %bb.false |
| |
| bb.true: |
| ret i64 -1 |
| |
| bb.false: |
| ; This block musn't be counted in the inline cost. |
| %y1 = add i64 %y, 1 |
| %y2 = add i64 %y1, 1 |
| %y3 = add i64 %y2, 1 |
| %y4 = add i64 %y3, 1 |
| %y5 = add i64 %y4, 1 |
| %y6 = add i64 %y5, 1 |
| %y7 = add i64 %y6, 1 |
| %y8 = add i64 %y7, 1 |
| ret i64 %y8 |
| } |
| |
| define float @caller6() { |
| ; Check that we can constant-prop through fcmp instructions |
| ; |
| ; CHECK-LABEL: @caller6( |
| ; CHECK-NOT: call |
| ; CHECK: ret |
| %x = call float @callee6(float 42.0) |
| ret float %x |
| } |
| |
| define float @callee6(float %x) { |
| %icmp = fcmp ugt float %x, 42.0 |
| br i1 %icmp, label %bb.true, label %bb.false |
| |
| bb.true: |
| ; This block musn't be counted in the inline cost. |
| %x1 = fadd float %x, 1.0 |
| %x2 = fadd float %x1, 1.0 |
| %x3 = fadd float %x2, 1.0 |
| %x4 = fadd float %x3, 1.0 |
| %x5 = fadd float %x4, 1.0 |
| %x6 = fadd float %x5, 1.0 |
| %x7 = fadd float %x6, 1.0 |
| %x8 = fadd float %x7, 1.0 |
| ret float %x8 |
| |
| bb.false: |
| ret float %x |
| } |
| |
| |
| |
| define i32 @PR13412.main() { |
| ; This is a somewhat complicated three layer subprogram that was reported to |
| ; compute the wrong value for a branch due to assuming that an argument |
| ; mid-inline couldn't be equal to another pointer. |
| ; |
| ; After inlining, the branch should point directly to the exit block, not to |
| ; the intermediate block. |
| ; CHECK: @PR13412.main |
| ; CHECK: br i1 true, label %[[TRUE_DEST:.*]], label %[[FALSE_DEST:.*]] |
| ; CHECK: [[FALSE_DEST]]: |
| ; CHECK-NEXT: call void @PR13412.fail() |
| ; CHECK: [[TRUE_DEST]]: |
| ; CHECK-NEXT: ret i32 0 |
| |
| entry: |
| %i1 = alloca i64 |
| store i64 0, ptr %i1 |
| %call = call i1 @PR13412.first(ptr %i1, ptr %i1) |
| br i1 %call, label %cond.end, label %cond.false |
| |
| cond.false: |
| call void @PR13412.fail() |
| br label %cond.end |
| |
| cond.end: |
| ret i32 0 |
| } |
| |
| define internal i1 @PR13412.first(ptr %a, ptr %b) { |
| entry: |
| %call = call ptr @PR13412.second(ptr %a, ptr %b) |
| %cmp = icmp eq ptr %call, %b |
| ret i1 %cmp |
| } |
| |
| declare void @PR13412.fail() |
| |
| define internal ptr @PR13412.second(ptr %a, ptr %b) { |
| entry: |
| %sub.ptr.lhs.cast = ptrtoint ptr %b to i64 |
| %sub.ptr.rhs.cast = ptrtoint ptr %a to i64 |
| %sub.ptr.sub = sub i64 %sub.ptr.lhs.cast, %sub.ptr.rhs.cast |
| %sub.ptr.div = ashr exact i64 %sub.ptr.sub, 2 |
| %cmp = icmp ugt i64 %sub.ptr.div, 1 |
| br i1 %cmp, label %if.then, label %if.end3 |
| |
| if.then: |
| %0 = load i32, ptr %a |
| %1 = load i32, ptr %b |
| %cmp1 = icmp eq i32 %0, %1 |
| br i1 %cmp1, label %return, label %if.end3 |
| |
| if.end3: |
| br label %return |
| |
| return: |
| %retval.0 = phi ptr [ %b, %if.end3 ], [ %a, %if.then ] |
| ret ptr %retval.0 |
| } |
| |
| declare i32 @PR28802.external(i32 returned %p1) |
| |
| define internal i32 @PR28802.callee() { |
| entry: |
| br label %cont |
| |
| cont: |
| %0 = phi i32 [ 0, %entry ] |
| %call = call i32 @PR28802.external(i32 %0) |
| ret i32 %call |
| } |
| |
| define i32 @PR28802() { |
| entry: |
| %call = call i32 @PR28802.callee() |
| ret i32 %call |
| } |
| |
| ; CHECK-LABEL: define i32 @PR28802( |
| ; CHECK: %[[call:.*]] = call i32 @PR28802.external(i32 0) |
| ; CHECK: ret i32 %[[call]] |
| |
| define internal i32 @PR28848.callee(i32 %p2, i1 %c) { |
| entry: |
| br i1 %c, label %cond.end, label %cond.true |
| |
| cond.true: |
| br label %cond.end |
| |
| cond.end: |
| %cond = phi i32 [ 0, %cond.true ], [ %p2, %entry ] |
| %or = or i32 %cond, %p2 |
| ret i32 %or |
| } |
| |
| define i32 @PR28848() { |
| entry: |
| %call = call i32 @PR28848.callee(i32 0, i1 false) |
| ret i32 %call |
| } |
| ; CHECK-LABEL: define i32 @PR28848( |
| ; CHECK: ret i32 0 |
| |
| define internal void @callee7(i16 %param1, i16 %param2) { |
| entry: |
| br label %bb |
| |
| bb: |
| %phi = phi i16 [ %param2, %entry ] |
| %add = add i16 %phi, %param1 |
| ret void |
| } |
| |
| declare i16 @caller7.external(i16 returned) |
| |
| define void @caller7() { |
| bb1: |
| %call = call i16 @caller7.external(i16 1) |
| call void @callee7(i16 0, i16 %call) |
| ret void |
| } |
| ; CHECK-LABEL: define void @caller7( |
| ; CHECK: %call = call i16 @caller7.external(i16 1) |
| ; CHECK-NEXT: ret void |
| |
| define float @caller8(float %y) { |
| ; Check that we can constant-prop through fneg instructions |
| ; |
| ; CHECK-LABEL: @caller8( |
| ; CHECK-NOT: call |
| ; CHECK: ret |
| %x = call float @callee8(float -42.0, float %y) |
| ret float %x |
| } |
| |
| define float @callee8(float %x, float %y) { |
| %neg = fneg float %x |
| %icmp = fcmp ugt float %neg, 42.0 |
| br i1 %icmp, label %bb.true, label %bb.false |
| |
| bb.true: |
| ; This block musn't be counted in the inline cost. |
| %y1 = fadd float %y, 1.0 |
| %y2 = fadd float %y1, 1.0 |
| %y3 = fadd float %y2, 1.0 |
| %y4 = fadd float %y3, 1.0 |
| %y5 = fadd float %y4, 1.0 |
| %y6 = fadd float %y5, 1.0 |
| %y7 = fadd float %y6, 1.0 |
| %y8 = fadd float %y7, 1.0 |
| ret float %y8 |
| |
| bb.false: |
| ret float %x |
| } |