[Inliner][NPM] Fix various tests under NPM

[aeubanks]

Summary

alloca-dbgdeclare-merge.ll:
alloca-merge-align.ll:
array_merge.ll:
NPM inliner does not merge allocas

delete-call.ll:
NPM inliner does not delete readonly calls

externally_available.ll:
NPM inliner does not delete available_externally functions

inline-cold-callee.ll:
inline-hot-callee.ll:
inline-hot-callee.ll has a comment saying it only applies to legacy PM,
I assume same for inline-cold-callee.ll

devirtualize-2.ll:
inline-hot-callsite:
monster_scc.ll:
pr22285.ll:
already has legacy and new PM RUN lines

inline-cold.ll:
profile-summary required to see callee as cold

prof-update-sample.ll:
profile-summary required to update branch_weights

[davidxl]

Are the new PM inliner issues being looked into too?

[davidxl]

lgtm

[aeubanks]

There are other failing tests that look like real issues that I will look into. These are just a first pass over the failing tests that were more obvious to handle.
I read that the NPM inliner isn't supposed to handle so many weird cases like merging allocas, deleting readonly calls, etc, so those tests are pinned to the legacy inliner.

llvm/test/Transforms/Inline/alloca-dbgdeclare-merge.ll

 ;  bbb[20] = 1;
 ;}
 ;
 ;void h() {
 ;  f();
 ;  g();
 ;}
 ;
-; RUN: opt -always-inline -S < %s | FileCheck %s
+; RUN: opt -always-inline -S -enable-new-pm=0 < %s | FileCheck %s
 
 ; FIXME: Why does the dbg.declare for "aaa" occur later in @h than the
 ; dbg.declare for "bbb"? I'd expect the opposite, given @f is inlined earlier.
 ;
 ; CHECK:      define void @h()
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT:   %[[AI:.*]] = alloca [100 x i8]
 ; CHECK-NEXT:   call void @llvm.dbg.declare(metadata [100 x i8]* %[[AI]], metadata [[BBB:![0-9]+]]

llvm/test/Transforms/Inline/alloca-merge-align.ll

-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -inline -S -enable-new-pm=0 | 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-f128:128:128-v128:128:128-n32:64"
 target triple = "powerpc64-unknown-linux-gnu"
 
 %struct.s = type { i32, i32 }
 
 define void @foo(%struct.s* byval nocapture readonly %a) {
 entry:

llvm/test/Transforms/Inline/array_merge.ll

-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -inline -S -enable-new-pm=0 | FileCheck %s
 ; 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]

llvm/test/Transforms/Inline/delete-call.ll

 ; REQUIRES: asserts
-; RUN: opt -S -inline -stats < %s 2>&1 | FileCheck %s
+; RUN: opt -S -inline -stats -enable-new-pm=0 < %s 2>&1 | FileCheck %s
 ; CHECK: Number of functions inlined
 
-; RUN: opt -S -inline -function-attrs -stats < %s 2>&1 | FileCheck -check-prefix=CHECK-FUNCTIONATTRS %s
+; RUN: opt -S -inline -function-attrs -stats -enable-new-pm=0 < %s 2>&1 | FileCheck -check-prefix=CHECK-FUNCTIONATTRS %s
 ; CHECK-FUNCTIONATTRS: Number of call sites deleted, not inlined
 
 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-n8:16:32"
 target triple = "i386-apple-darwin9.8"
 
 define internal i32 @test(i32 %x, i32 %y, i32 %z) nounwind {
 entry:
   %0 = add nsw i32 %y, %z                         ; <i32> [#uses=1]

llvm/test/Transforms/Inline/devirtualize-2.ll

-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -inline -S -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='cgscc(devirt<4>(inline))' -S | FileCheck %s
 ; PR4834
 
 define i32 @test1() {
   %funcall1_ = call fastcc i32 ()* () @f1()
   %executecommandptr1_ = call i32 %funcall1_()
   ret i32 %executecommandptr1_
 }

llvm/test/Transforms/Inline/devirtualize-3.ll

-; RUN: opt -basic-aa -inline -S -sroa -gvn -instcombine < %s | FileCheck %s
+; RUN: opt -basic-aa -S -O2 < %s | FileCheck %s
 ; PR5009
 
 ; CHECK: define i32 @main() 
 ; CHECK-NEXT: entry:
 ; CHECK-NEXT:  call void @exit(i32 38) 
 
 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.0.0"

llvm/test/Transforms/Inline/externally_available.ll

-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -inline -S -enable-new-pm=0 | FileCheck %s
 
 define available_externally i32 @test_function() {
 ; CHECK-NOT: @test_function
 entry:
   ret i32 4
 }
 
 

llvm/test/Transforms/Inline/inline-cold-callee.ll

-; RUN: opt < %s -inline -inlinecold-threshold=0 -S | FileCheck %s
+; RUN: opt < %s -inline -inlinecold-threshold=0 -S -enable-new-pm=0 | FileCheck %s
 
 ; This tests that a cold callee gets the (lower) inlinecold-threshold even without
 ; Cold hint and does not get inlined because the cost exceeds the inlinecold-threshold.
 ; A callee with identical body does gets inlined because cost fits within the
 ; inline-threshold
 
 define i32 @callee1(i32 %x) !prof !21 {
   %x1 = add i32 %x, 1

llvm/test/Transforms/Inline/inline-cold.ll

-; RUN: opt < %s -inline -S -inlinecold-threshold=25 | FileCheck %s
+; RUN: opt < %s -inline -S -inlinecold-threshold=25 -enable-new-pm=0 | FileCheck %s
+; RUN: opt < %s -passes='require<profile-summary>,cgscc(inline)' -S -inlinecold-threshold=25 | FileCheck %s
 ; Test that functions with attribute Cold are not inlined while the 
 ; same function without attribute Cold will be inlined.
 
-; RUN: opt < %s -inline -S -inline-threshold=600 | FileCheck %s -check-prefix=OVERRIDE
+; RUN: opt < %s -inline -S -inline-threshold=600 -enable-new-pm=0 | FileCheck %s -check-prefix=OVERRIDE
+; RUN: opt < %s -passes='require<profile-summary>,cgscc(inline)' -S -inline-threshold=600 -enable-new-pm=0 | FileCheck %s -check-prefix=OVERRIDE
 ; The command line argument for inline-threshold should override
 ; the default cold threshold, so a cold function with size bigger
 ; than the default cold threshold (225) will be inlined.
 
-; RUN: opt < %s -inline -S | FileCheck %s -check-prefix=DEFAULT
+; RUN: opt < %s -inline -S -enable-new-pm=0 | FileCheck %s -check-prefix=DEFAULT
+; RUN: opt < %s -passes='require<profile-summary>,cgscc(inline)' -S | FileCheck %s -check-prefix=DEFAULT
 ; The same cold function will not be inlined with the default behavior.
 
 @a = global i32 4
 
 ; This function should be larger than the cold threshold (75), but smaller
 ; than the regular threshold.
 ; Function Attrs: nounwind readnone uwtable
 define i32 @simpleFunction(i32 %a) #0 {

llvm/test/Transforms/Inline/inline-hot-callee.ll

-; RUN: opt < %s -inline -inline-threshold=0 -inlinehint-threshold=100 -S | FileCheck %s
+; RUN: opt < %s -inline -inline-threshold=0 -inlinehint-threshold=100 -S -enable-new-pm=0 | FileCheck %s
 
 ; This tests that a hot callee gets the (higher) inlinehint-threshold even
 ; without inline hints and gets inlined because the cost is less than
 ; inlinehint-threshold. A cold callee with identical body does not get inlined
 ; because cost exceeds the inline-threshold. This test is relevant only when the
 ; old pass manager is used.
 
 define i32 @callee1(i32 %x) !prof !21 {

llvm/test/Transforms/Inline/inline-hot-callsite.ll

 ; This tests that a hot callsite gets the (higher) inlinehint-threshold even without
 ; without inline hints and gets inlined because the cost is less than
 ; inlinehint-threshold. A cold callee with identical body does not get inlined because
 ; cost exceeds the inline-threshold
 
-; RUN: opt < %s -inline -inline-threshold=0 -hot-callsite-threshold=100 -S | FileCheck %s
+; RUN: opt < %s -inline -inline-threshold=0 -hot-callsite-threshold=100 -S -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='require<profile-summary>,cgscc(inline)' -inline-threshold=0 -hot-callsite-threshold=100 -S | FileCheck %s
 
 ; Run this with the default O2 pipeline to test that profile summary analysis
 ; is available during inlining.
 ; RUN: opt < %s -passes='default<O2>' -inline-threshold=0 -hot-callsite-threshold=100 -S | FileCheck %s
 
 define i32 @callee1(i32 %x) {
   %x1 = add i32 %x, 1

llvm/test/Transforms/Inline/monster_scc.ll

 ;     else
 ;       f<false, N + 1>(B + 1, E);
 ;   }
 ;   template <> void f<false, MAX>(bool *B, bool *E) { return f<false, 0>(B, E); }
 ;   template <> void f<true, MAX>(bool *B, bool *E) { return f<true, 0>(B, E); }
 ;
 ;   void test(bool *B, bool *E) { f<false, 0>(B, E); }
 ;
-; RUN: opt -S < %s -inline -inline-threshold=150 | FileCheck %s --check-prefixes=CHECK,OLD
+; RUN: opt -S < %s -inline -inline-threshold=150 -enable-new-pm=0 | FileCheck %s --check-prefixes=CHECK,OLD
 ; RUN: opt -S < %s -passes=inline -inline-threshold=150 | FileCheck %s --check-prefixes=CHECK,NEW
 ; RUN: opt -S < %s -passes=inliner-wrapper -inline-threshold=150 | FileCheck %s --check-prefixes=CHECK,NEW
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 declare void @_Z1gi(i32)
 
 ; CHECK-LABEL: define void @_Z1fILb0ELi0EEvPbS0_(

llvm/test/Transforms/Inline/pr22285.ll

-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -inline -S -enable-new-pm=0 | FileCheck %s
 ; RUN: opt < %s -passes='cgscc(inline),globaldce' -S | FileCheck %s
 
 $f1 = comdat any
 ; CHECK-NOT: $f1 = comdat any
 
 define void @f2() {
   call void @f1()
   ret void
 }
 ; CHECK-LABEL: define void @f2
 
 define linkonce_odr void @f1() comdat {
   ret void
 }
 ; CHECK-NOT: define linkonce_odr void @f1() comdat

llvm/test/Transforms/Inline/prof-update-sample.ll

-; RUN: opt < %s -inline -S | FileCheck %s
+; RUN: opt < %s -inline -S -enable-new-pm=0 | FileCheck %s
+; RUN: opt < %s -passes='require<profile-summary>,cgscc(inline)' -S | FileCheck %s
 ; Checks if inliner updates branch_weights annotation for call instructions.
 
 declare void @ext();
 declare void @ext1();
 @func = global void ()* null
 
 ; CHECK: define void @callee(i32 %n) !prof ![[ENTRY_COUNT:[0-9]*]]
 define void  @callee(i32 %n) !prof !15 {