maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/test/Transforms/Inline/array_merge.ll

27 lines
690 B
LLVM
Raw Normal View History

Change tests from "opt %s" to "opt < %s" so that opt doesn't see the input filename so that opt doesn't print the input filename in the output so that grep lines in the tests don't unintentionally match strings in the input filename. llvm-svn: 81537
2009-09-12 02:01:28 +08:00
; RUN: opt < %s -inline -S | FileCheck %s
Implement a new optimization in the inliner: if inlining multiple calls into a function and if the calls bring in arrays, try to merge them together to reduce stack size. For example, in the testcase we'd previously end up with 4 allocas, now we end up with 2 allocas. As described in the comments, this is not really the ideal solution to this problem, but it is surprisingly effective. For example, on 176.gcc, we end up eliminating 67 arrays at "gccas" time and another 24 at "llvm-ld" time. One piece of concern that I didn't look into: at -O0 -g with forced inlining this will almost certainly result in worse debug info. I think this is acceptable though given that this is a case of "debugging optimized code", and we don't want debug info to prevent the optimizer from doing things anyway. llvm-svn: 80215
2009-08-27 14:29:33 +08:00
; rdar://7173846
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin10.0"
define internal void @foo() nounwind ssp {
entry:
%A = alloca [100 x i32]
%B = alloca [100 x i32]
call void @bar([100 x i32]* %A, [100 x i32]* %B) nounwind
ret void
}
declare void @bar([100 x i32]*, [100 x i32]*)
define void @test() nounwind ssp {
entry:
; CHECK: @test()
; CHECK-NEXT: entry:
; CHECK-NEXT: %A.i = alloca
; CHECK-NEXT: %B.i = alloca
Commit test change, forgotten as part of r131838. llvm-svn: 131839
2011-05-22 13:31:47 +08:00
; CHECK-NOT: alloca
Implement a new optimization in the inliner: if inlining multiple calls into a function and if the calls bring in arrays, try to merge them together to reduce stack size. For example, in the testcase we'd previously end up with 4 allocas, now we end up with 2 allocas. As described in the comments, this is not really the ideal solution to this problem, but it is surprisingly effective. For example, on 176.gcc, we end up eliminating 67 arrays at "gccas" time and another 24 at "llvm-ld" time. One piece of concern that I didn't look into: at -O0 -g with forced inlining this will almost certainly result in worse debug info. I think this is acceptable though given that this is a case of "debugging optimized code", and we don't want debug info to prevent the optimizer from doing things anyway. llvm-svn: 80215
2009-08-27 14:29:33 +08:00
call void @foo() nounwind
call void @foo() nounwind
ret void
}