mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-03 18:29:48 +00:00
on a per-callsite walk of the called function's instructions, in breadth-first order over the potentially reachable set of basic blocks. This is a major shift in how inline cost analysis works to improve the accuracy and rationality of inlining decisions. A brief outline of the algorithm this moves to: - Build a simplification mapping based on the callsite arguments to the function arguments. - Push the entry block onto a worklist of potentially-live basic blocks. - Pop the first block off of the *front* of the worklist (for breadth-first ordering) and walk its instructions using a custom InstVisitor. - For each instruction's operands, re-map them based on the simplification mappings available for the given callsite. - Compute any simplification possible of the instruction after re-mapping, and store that back int othe simplification mapping. - Compute any bonuses, costs, or other impacts of the instruction on the cost metric. - When the terminator is reached, replace any conditional value in the terminator with any simplifications from the mapping we have, and add any successors which are not proven to be dead from these simplifications to the worklist. - Pop the next block off of the front of the worklist, and repeat. - As soon as the cost of inlining exceeds the threshold for the callsite, stop analyzing the function in order to bound cost. The primary goal of this algorithm is to perfectly handle dead code paths. We do not want any code in trivially dead code paths to impact inlining decisions. The previous metric was *extremely* flawed here, and would always subtract the average cost of two successors of a conditional branch when it was proven to become an unconditional branch at the callsite. There was no handling of wildly different costs between the two successors, which would cause inlining when the path actually taken was too large, and no inlining when the path actually taken was trivially simple. There was also no handling of the code *path*, only the immediate successors. These problems vanish completely now. See the added regression tests for the shiny new features -- we skip recursive function calls, SROA-killing instructions, and high cost complex CFG structures when dead at the callsite being analyzed. Switching to this algorithm required refactoring the inline cost interface to accept the actual threshold rather than simply returning a single cost. The resulting interface is pretty bad, and I'm planning to do lots of interface cleanup after this patch. Several other refactorings fell out of this, but I've tried to minimize them for this patch. =/ There is still more cleanup that can be done here. Please point out anything that you see in review. I've worked really hard to try to mirror at least the spirit of all of the previous heuristics in the new model. It's not clear that they are all correct any more, but I wanted to minimize the change in this single patch, it's already a bit ridiculous. One heuristic that is *not* yet mirrored is to allow inlining of functions with a dynamic alloca *if* the caller has a dynamic alloca. I will add this back, but I think the most reasonable way requires changes to the inliner itself rather than just the cost metric, and so I've deferred this for a subsequent patch. The test case is XFAIL-ed until then. As mentioned in the review mail, this seems to make Clang run about 1% to 2% faster in -O0, but makes its binary size grow by just under 4%. I've looked into the 4% growth, and it can be fixed, but requires changes to other parts of the inliner. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@153812 91177308-0d34-0410-b5e6-96231b3b80d8
111 lines
3.0 KiB
LLVM
111 lines
3.0 KiB
LLVM
; The inliner should never inline recursive functions into other functions.
|
|
; This effectively is just peeling off the first iteration of a loop, and the
|
|
; inliner heuristics are not set up for this.
|
|
|
|
; RUN: opt -inline %s -S | FileCheck %s
|
|
|
|
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"
|
|
target triple = "x86_64-apple-darwin10.3"
|
|
|
|
@g = common global i32 0 ; <i32*> [#uses=1]
|
|
|
|
define internal void @foo(i32 %x) nounwind ssp {
|
|
entry:
|
|
%0 = icmp slt i32 %x, 0 ; <i1> [#uses=1]
|
|
br i1 %0, label %return, label %bb
|
|
|
|
bb: ; preds = %entry
|
|
%1 = sub nsw i32 %x, 1 ; <i32> [#uses=1]
|
|
call void @foo(i32 %1) nounwind ssp
|
|
store volatile i32 1, i32* @g, align 4
|
|
ret void
|
|
|
|
return: ; preds = %entry
|
|
ret void
|
|
}
|
|
|
|
|
|
;; CHECK: @bonk
|
|
;; CHECK: call void @foo(i32 42)
|
|
define void @bonk() nounwind ssp {
|
|
entry:
|
|
call void @foo(i32 42) nounwind ssp
|
|
ret void
|
|
}
|
|
|
|
|
|
|
|
;; Here is an indirect case that should not be infinitely inlined.
|
|
|
|
define internal void @f1(i32 %x, i8* %Foo, i8* %Bar) nounwind ssp {
|
|
entry:
|
|
%0 = bitcast i8* %Bar to void (i32, i8*, i8*)*
|
|
%1 = sub nsw i32 %x, 1
|
|
call void %0(i32 %1, i8* %Foo, i8* %Bar) nounwind
|
|
store volatile i32 42, i32* @g, align 4
|
|
ret void
|
|
}
|
|
|
|
define internal void @f2(i32 %x, i8* %Foo, i8* %Bar) nounwind ssp {
|
|
entry:
|
|
%0 = icmp slt i32 %x, 0 ; <i1> [#uses=1]
|
|
br i1 %0, label %return, label %bb
|
|
|
|
bb: ; preds = %entry
|
|
%1 = bitcast i8* %Foo to void (i32, i8*, i8*)* ; <void (i32, i8*, i8*)*> [#uses=1]
|
|
call void %1(i32 %x, i8* %Foo, i8* %Bar) nounwind
|
|
store volatile i32 13, i32* @g, align 4
|
|
ret void
|
|
|
|
return: ; preds = %entry
|
|
ret void
|
|
}
|
|
|
|
|
|
; CHECK: @top_level
|
|
; CHECK: call void @f2(i32 122
|
|
; Here we inline one instance of the cycle, but we don't want to completely
|
|
; unroll it.
|
|
define void @top_level() nounwind ssp {
|
|
entry:
|
|
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
|
|
ret void
|
|
}
|
|
|
|
|
|
; Check that a recursive function, when called with a constant that makes the
|
|
; recursive path dead code can actually be inlined.
|
|
define i32 @fib(i32 %i) {
|
|
entry:
|
|
%is.zero = icmp eq i32 %i, 0
|
|
br i1 %is.zero, label %zero.then, label %zero.else
|
|
|
|
zero.then:
|
|
ret i32 0
|
|
|
|
zero.else:
|
|
%is.one = icmp eq i32 %i, 1
|
|
br i1 %is.one, label %one.then, label %one.else
|
|
|
|
one.then:
|
|
ret i32 1
|
|
|
|
one.else:
|
|
%i1 = sub i32 %i, 1
|
|
%f1 = call i32 @fib(i32 %i1)
|
|
%i2 = sub i32 %i, 2
|
|
%f2 = call i32 @fib(i32 %i2)
|
|
%f = add i32 %f1, %f2
|
|
ret i32 %f
|
|
}
|
|
|
|
define i32 @fib_caller() {
|
|
; CHECK: @fib_caller
|
|
; CHECK-NOT: call
|
|
; CHECK: ret
|
|
%f1 = call i32 @fib(i32 0)
|
|
%f2 = call i32 @fib(i32 1)
|
|
%result = add i32 %f1, %f2
|
|
ret i32 %result
|
|
}
|