[test][Inliner] Split inline-cost test files

[aeubanks]

Summary

The NPM CGSCCPassManager does not operate on the SCCs in the same order
as the legacy PM. These tests assume that the SCCs would be processed in
the order they are declared in the file, but the NPM processes them
backwards.

So split each test via split-file and test each one individually. This
makes these tests pass under the NPM.

[aeubanks]

Ping.
Would it be better to just split the test into multiple files instad of using split-file?

[MaskRay]

In D89574#2366681, @aeubanks wrote:

Ping.
Would it be better to just split the test into multiple files instad of using split-file?

Apologize for the slow response. I think split-file is better than multiple files in this case, but I want to understand the deep issue here. It seems that ModuleToPostOrderCGSCCPassAdaptor has a reversed processing order (as opposed to the source order) when the functions are independent. This seems unfortunate as this can make all such kind of tests difficult to write.

• legacy PM: lib/Analysis/CallGraphSCCPass.cpp:541 SCCs are processed in order
• new PM: include/llvm/Analysis/CGSCCPassManager.h:907 SCCs are processed in the reversed order

I am working on this patch:

--- a/llvm/lib/Analysis/LazyCallGraph.cpp
+++ b/llvm/lib/Analysis/LazyCallGraph.cpp
@@ -1731,7 +1731,7 @@ void LazyCallGraph::buildRefSCCs() {
 
   // The roots will be popped of a stack, so use reverse to get a less
   // surprising order. This doesn't change any of the semantics anywhere.
-  std::reverse(Roots.begin(), Roots.end());
+  //std::reverse(Roots.begin(), Roots.end());
 
   buildGenericSCCs(
       Roots,

[MaskRay]

D90566 can address the issue without touching ext.ll files.

llvm/test/Transforms/Inline/AArch64/ext.ll

 ; REQUIRES: asserts
-; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
-
-target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
-target triple = "aarch64--linux-gnu"
+; RUN: split-file --no-leading-lines %s %t
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/1 2>&1 | FileCheck %t/1
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/2 2>&1 | FileCheck %t/2
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/3 2>&1 | FileCheck %t/3
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/4 2>&1 | FileCheck %t/4
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/5 2>&1 | FileCheck %t/5
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/6 2>&1 | FileCheck %t/6
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/7 2>&1 | FileCheck %t/7
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/8 2>&1 | FileCheck %t/8
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/9 2>&1 | FileCheck %t/9
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/10 2>&1 | FileCheck %t/10
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/11 2>&1 | FileCheck %t/11
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/12 2>&1 | FileCheck %t/12
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/13 2>&1 | FileCheck %t/13
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/14 2>&1 | FileCheck %t/14
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/15 2>&1 | FileCheck %t/15
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/16 2>&1 | FileCheck %t/16
 
+;--- 1
 define i32 @outer1(i32* %ptr, i32 %i) {
   %C = call i32 @inner1(i32* %ptr, i32 %i)
   ret i32 %C
 }
 
 ; sext can be folded into gep.
 ; CHECK: Analyzing call of inner1
 ; CHECK: NumInstructionsSimplified: 3
 ; CHECK: NumInstructions: 4
 define i32 @inner1(i32* %ptr, i32 %i) {
   %E = sext i32 %i to i64
   %G = getelementptr inbounds i32, i32* %ptr, i64 %E
   %L = load i32, i32* %G
   ret i32 %L
 }
 
+;--- 2
 define i32 @outer2(i32* %ptr, i32 %i) {
   %C = call i32 @inner2(i32* %ptr, i32 %i)
   ret i32 %C
 }
 
 ; zext from i32 to i64 is free.
 ; CHECK: Analyzing call of inner2
 ; CHECK: NumInstructionsSimplified: 3
 ; CHECK: NumInstructions: 4
 define i32 @inner2(i32* %ptr, i32 %i) {
   %E = zext i32 %i to i64
   %G = getelementptr inbounds i32, i32* %ptr, i64 %E
   %L = load i32, i32* %G
   ret i32 %L
 }
 
+;--- 3
 define i32 @outer3(i32* %ptr, i16 %i) {
   %C = call i32 @inner3(i32* %ptr, i16 %i)
   ret i32 %C
 }
 
 ; zext can be folded into gep.
 ; CHECK: Analyzing call of inner3
 ; CHECK: NumInstructionsSimplified: 3
 ; CHECK: NumInstructions: 4
 define i32 @inner3(i32* %ptr, i16 %i) {
   %E = zext i16 %i to i64
   %G = getelementptr inbounds i32, i32* %ptr, i64 %E
   %L = load i32, i32* %G
   ret i32 %L
 }
 
+;--- 4
 define i16 @outer4(i8* %ptr) {
   %C = call i16 @inner4(i8* %ptr)
   ret i16 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner4
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i16 @inner4(i8* %ptr) {
   %L = load i8, i8* %ptr
   %E = zext i8 %L to i16
   ret i16 %E
 }
 
+;--- 5
 define i16 @outer5(i8* %ptr) {
   %C = call i16 @inner5(i8* %ptr)
   ret i16 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner5
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i16 @inner5(i8* %ptr) {
   %L = load i8, i8* %ptr
   %E = sext i8 %L to i16
   ret i16 %E
 }
 
+;--- 6
 define i32 @outer6(i8* %ptr) {
   %C = call i32 @inner6(i8* %ptr)
   ret i32 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner6
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i32 @inner6(i8* %ptr) {
   %L = load i8, i8* %ptr
   %E = zext i8 %L to i32
   ret i32 %E
 }
 
+;--- 7
 define i32 @outer7(i8* %ptr) {
   %C = call i32 @inner7(i8* %ptr)
   ret i32 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner7
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i32 @inner7(i8* %ptr) {
   %L = load i8, i8* %ptr
   %E = sext i8 %L to i32
   ret i32 %E
 }
 
+;--- 8
 define i32 @outer8(i16* %ptr) {
   %C = call i32 @inner8(i16* %ptr)
   ret i32 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner8
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i32 @inner8(i16* %ptr) {
   %L = load i16, i16* %ptr
   %E = zext i16 %L to i32
   ret i32 %E
 }
 
+;--- 9
 define i32 @outer9(i16* %ptr) {
   %C = call i32 @inner9(i16* %ptr)
   ret i32 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner9
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i32 @inner9(i16* %ptr) {
   %L = load i16, i16* %ptr
   %E = sext i16 %L to i32
   ret i32 %E
 }
 
+;--- 10
 define i64 @outer10(i8* %ptr) {
   %C = call i64 @inner10(i8* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner10
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner10(i8* %ptr) {
   %L = load i8, i8* %ptr
   %E = zext i8 %L to i64
   ret i64 %E
 }
 
+;--- 11
 define i64 @outer11(i8* %ptr) {
   %C = call i64 @inner11(i8* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner11
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner11(i8* %ptr) {
   %L = load i8, i8* %ptr
   %E = sext i8 %L to i64
   ret i64 %E
 }
 
+;--- 12
 define i64 @outer12(i16* %ptr) {
   %C = call i64 @inner12(i16* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner12
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner12(i16* %ptr) {
   %L = load i16, i16* %ptr
   %E = zext i16 %L to i64
   ret i64 %E
 }
 
+;--- 13
 define i64 @outer13(i16* %ptr) {
   %C = call i64 @inner13(i16* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner13
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner13(i16* %ptr) {
   %L = load i16, i16* %ptr
   %E = sext i16 %L to i64
   ret i64 %E
 }
 
+;--- 14
 define i64 @outer14(i32* %ptr) {
   %C = call i64 @inner14(i32* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner14
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner14(i32* %ptr) {
   %L = load i32, i32* %ptr
   %E = zext i32 %L to i64
   ret i64 %E
 }
 
+;--- 15
 define i64 @outer15(i32* %ptr) {
   %C = call i64 @inner15(i32* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner15
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner15(i32* %ptr) {
   %L = load i32, i32* %ptr
   %E = sext i32 %L to i64
   ret i64 %E
 }
 
+;--- 16
 define i64 @outer16(i32 %V1, i64 %V2) {
   %C = call i64 @inner16(i32 %V1, i64 %V2)
   ret i64 %C
 }
 
 ; sext can be folded into shl.
 ; CHECK: Analyzing call of inner16
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 4
 define i64 @inner16(i32 %V1, i64 %V2) {
   %E = sext i32 %V1 to i64
   %S = shl i64 %E, 3
   %A = add i64 %V2, %S
   ret i64 %A
 }

llvm/test/Transforms/Inline/AArch64/gep-cost.ll

 ; REQUIRES: asserts
-; RUN: opt -inline -mtriple=aarch64--linux-gnu -mcpu=kryo -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
-
-target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
-target triple = "aarch64--linux-gnu"
+; RUN: split-file --no-leading-lines %s %t
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -mcpu=kryo -S -debug-only=inline-cost < %t/1 2>&1 | FileCheck %t/1
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -mcpu=kryo -S -debug-only=inline-cost < %t/2 2>&1 | FileCheck %t/2
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -mcpu=kryo -S -debug-only=inline-cost < %t/3 2>&1 | FileCheck %t/3
 
+;--- 1
 define void @outer1([4 x i32]* %ptr, i32 %i) {
   call void @inner1([4 x i32]* %ptr, i32 %i)
   ret void
 }
 
-define void @outer2([4 x i32]* %ptr, i32 %i) {
-  call void @inner2([4 x i32]* %ptr, i32 %i)
-  ret void
-}
-
-define void @outer3([4 x i32]* %ptr, i32 %j) {
-  call void @inner3([4 x i32]* %ptr, i32 0, i32 %j)
-  ret void
-}
-
 ; The gep in inner1() is reg+reg, which is a legal addressing mode for AArch64.
 ; Thus, both the gep and ret can be simplified.
 ; CHECK: Analyzing call of inner1
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 2
 define void @inner1([4 x i32]* %ptr, i32 %i) {
   %G = getelementptr inbounds [4 x i32], [4 x i32]* %ptr, i32 0, i32 %i
   ret void
 }
 
+;--- 2
+define void @outer2([4 x i32]* %ptr, i32 %i) {
+  call void @inner2([4 x i32]* %ptr, i32 %i)
+  ret void
+}
+
 ; The gep in inner2() is reg+imm+reg, which is not a legal addressing mode for
 ; AArch64.  Thus, only the ret can be simplified and not the gep.
 ; CHECK: Analyzing call of inner2
 ; CHECK: NumInstructionsSimplified: 1
 ; CHECK: NumInstructions: 2
 define void @inner2([4 x i32]* %ptr, i32 %i) {
   %G = getelementptr inbounds [4 x i32], [4 x i32]* %ptr, i32 1, i32 %i
   ret void
 }
 
+;--- 3
+define void @outer3([4 x i32]* %ptr, i32 %j) {
+  call void @inner3([4 x i32]* %ptr, i32 0, i32 %j)
+  ret void
+}
+
 ; The gep in inner3() is reg+reg because %i is a known constant from the
 ; callsite. This case is a legal addressing mode for AArch64.  Thus, both the
 ; gep and ret can be simplified.
 ; CHECK: Analyzing call of inner3
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 2
 define void @inner3([4 x i32]* %ptr, i32 %i, i32 %j) {
   %G = getelementptr inbounds [4 x i32], [4 x i32]* %ptr, i32 %i, i32 %j
   ret void
 }

llvm/test/Transforms/Inline/AArch64/logical-and-or.ll

 ; REQUIRES: asserts
-; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
-
-target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
-target triple = "aarch64--linux-gnu"
+; RUN: split-file --no-leading-lines %s %t
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/1 2>&1 | FileCheck %t/1
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/2 2>&1 | FileCheck %t/2
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/3 2>&1 | FileCheck %t/3
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/4 2>&1 | FileCheck %t/4
+; RUN: opt -inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %t/5 2>&1 | FileCheck %t/5
 
+;--- 1
 ; FIXME: Once the 'or' or 'and' is simplified the second compare is dead, but
 ; the inline cost model has already added the cost.
 
 define i1 @outer1(i32 %a) {
   %C = call i1 @inner1(i32 0, i32 %a)
   ret i1 %C
 }
 
 ; CHECK: Analyzing call of inner1
 ; CHECK: NumInstructionsSimplified: 3
 ; CHECK: NumInstructions: 4
 define i1 @inner1(i32 %a, i32 %b) {
   %tobool = icmp eq i32 %a, 0         ; Simplifies to true
   %tobool1 = icmp eq i32 %b, 0        ; Should be dead once 'or' is simplified
   %or.cond = or i1 %tobool, %tobool1  ; Simplifies to true
   ret i1 %or.cond                     ; Simplifies to ret i1 true
 }
 
+;--- 2
 define i1 @outer2(i32 %a) {
   %C = call i1 @inner2(i32 1, i32 %a)
   ret i1 %C
 }
 
 ; CHECK: Analyzing call of inner2
 ; CHECK: NumInstructionsSimplified: 3
 ; CHECK: NumInstructions: 4
 define i1 @inner2(i32 %a, i32 %b) {
   %tobool = icmp eq i32 %a, 0          ; Simplifies to false
   %tobool1 = icmp eq i32 %b, 0         ; Should be dead once 'and' is simplified
   %and.cond = and i1 %tobool, %tobool1 ; Simplifies to false
   ret i1 %and.cond                     ; Simplifies to ret i1 false
 }
 
 
+;--- 3
 define i32 @outer3(i32 %a) {
   %C = call i32 @inner3(i32 4294967295, i32 %a)
   ret i32 %C
 }
 
 ; CHECK: Analyzing call of inner3
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 2
 define i32 @inner3(i32 %a, i32 %b) {
   %or.cond = or i32 %a, %b         ; Simplifies to 4294967295
   ret i32 %or.cond                 ; Simplifies to ret i32 4294967295
 }
 
 
+;--- 4
 define i32 @outer4(i32 %a) {
   %C = call i32 @inner4(i32 0, i32 %a)
   ret i32 %C
 }
 
 ; CHECK: Analyzing call of inner4
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 2
 define i32 @inner4(i32 %a, i32 %b) {
   %and.cond = and i32 %a, %b       ; Simplifies to 0
   ret i32 %and.cond                ; Simplifies to ret i32 0
 }
 
+;--- 5
 define i1 @outer5(i32 %a) {
   %C = call i1 @inner5(i32 0, i32 %a)
   ret i1 %C
 }
 
 ; CHECK: Analyzing call of inner5
 ; CHECK: NumInstructionsSimplified: 4
 ; CHECK: NumInstructions: 5

llvm/test/Transforms/Inline/PowerPC/ext.ll

 ; REQUIRES: asserts
-; RUN: opt -inline -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
-
-target datalayout = "E-m:e-i64:64-n32:64"
-target triple = "powerpc64le-ibm-linux-gnu"
+; RUN: split-file --no-leading-lines %s %t
+; RUN: opt -inline -mtriple=powerpc64le-ibm-linux-gnu -S -debug-only=inline-cost < %t/1 2>&1 | FileCheck %t/1
+; RUN: opt -inline -mtriple=powerpc64le-ibm-linux-gnu -S -debug-only=inline-cost < %t/2 2>&1 | FileCheck %t/2
+; RUN: opt -inline -mtriple=powerpc64le-ibm-linux-gnu -S -debug-only=inline-cost < %t/3 2>&1 | FileCheck %t/3
+; RUN: opt -inline -mtriple=powerpc64le-ibm-linux-gnu -S -debug-only=inline-cost < %t/4 2>&1 | FileCheck %t/4
+; RUN: opt -inline -mtriple=powerpc64le-ibm-linux-gnu -S -debug-only=inline-cost < %t/5 2>&1 | FileCheck %t/5
+; RUN: opt -inline -mtriple=powerpc64le-ibm-linux-gnu -S -debug-only=inline-cost < %t/6 2>&1 | FileCheck %t/6
+; RUN: opt -inline -mtriple=powerpc64le-ibm-linux-gnu -S -debug-only=inline-cost < %t/7 2>&1 | FileCheck %t/7
+; RUN: opt -inline -mtriple=powerpc64le-ibm-linux-gnu -S -debug-only=inline-cost < %t/8 2>&1 | FileCheck %t/8
+; RUN: opt -inline -mtriple=powerpc64le-ibm-linux-gnu -S -debug-only=inline-cost < %t/9 2>&1 | FileCheck %t/9
 
+;--- 1
 define i16 @outer1(i8* %ptr) {
   %C = call i16 @inner1(i8* %ptr)
   ret i16 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner1
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i16 @inner1(i8* %ptr) {
   %L = load i8, i8* %ptr
   %E = zext i8 %L to i16
   ret i16 %E
 }
 
+;--- 2
 define i32 @outer2(i8* %ptr) {
   %C = call i32 @inner2(i8* %ptr)
   ret i32 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner2
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i32 @inner2(i8* %ptr) {
   %L = load i8, i8* %ptr
   %E = zext i8 %L to i32
   ret i32 %E
 }
 
+;--- 3
 define i32 @outer3(i16* %ptr) {
   %C = call i32 @inner3(i16* %ptr)
   ret i32 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner3
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i32 @inner3(i16* %ptr) {
   %L = load i16, i16* %ptr
   %E = zext i16 %L to i32
   ret i32 %E
 }
 
+;--- 4
 define i32 @outer4(i16* %ptr) {
   %C = call i32 @inner4(i16* %ptr)
   ret i32 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner4
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i32 @inner4(i16* %ptr) {
   %L = load i16, i16* %ptr
   %E = sext i16 %L to i32
   ret i32 %E
 }
 
+;--- 5
 define i64 @outer5(i8* %ptr) {
   %C = call i64 @inner5(i8* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner5
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner5(i8* %ptr) {
   %L = load i8, i8* %ptr
   %E = zext i8 %L to i64
   ret i64 %E
 }
 
+;--- 6
 define i64 @outer6(i16* %ptr) {
   %C = call i64 @inner6(i16* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner6
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner6(i16* %ptr) {
   %L = load i16, i16* %ptr
   %E = zext i16 %L to i64
   ret i64 %E
 }
 
+;--- 7
 define i64 @outer7(i16* %ptr) {
   %C = call i64 @inner7(i16* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner7
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner7(i16* %ptr) {
   %L = load i16, i16* %ptr
   %E = sext i16 %L to i64
   ret i64 %E
 }
 
+;--- 8
 define i64 @outer8(i32* %ptr) {
   %C = call i64 @inner8(i32* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner8
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner8(i32* %ptr) {
   %L = load i32, i32* %ptr
   %E = zext i32 %L to i64
   ret i64 %E
 }
 
+;--- 9
 define i64 @outer9(i32* %ptr) {
   %C = call i64 @inner9(i32* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner9
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner9(i32* %ptr) {
   %L = load i32, i32* %ptr
   %E = sext i32 %L to i64
   ret i64 %E
 }

llvm/test/Transforms/Inline/X86/ext.ll

 ; REQUIRES: asserts
-; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
-
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-unknown"
+; RUN: split-file --no-leading-lines %s %t
+; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %t/1 2>&1 | FileCheck %t/1
+; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %t/2 2>&1 | FileCheck %t/2
+; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %t/3 2>&1 | FileCheck %t/3
+; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %t/4 2>&1 | FileCheck %t/4
+; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %t/5 2>&1 | FileCheck %t/5
+; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %t/6 2>&1 | FileCheck %t/6
+; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %t/7 2>&1 | FileCheck %t/7
+; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %t/8 2>&1 | FileCheck %t/8
+; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %t/9 2>&1 | FileCheck %t/9
+; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %t/10 2>&1 | FileCheck %t/10
+; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %t/11 2>&1 | FileCheck %t/11
+; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %t/12 2>&1 | FileCheck %t/12
+; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %t/13 2>&1 | FileCheck %t/13
 
+;--- 1
 define i32 @outer1(i32* %ptr, i32 %i) {
   %C = call i32 @inner1(i32* %ptr, i32 %i)
   ret i32 %C
 }
 
 ; zext from i32 to i64 is free.
 ; CHECK: Analyzing call of inner1
 ; CHECK: NumInstructionsSimplified: 3
 ; CHECK: NumInstructions: 4
 define i32 @inner1(i32* %ptr, i32 %i) {
   %E = zext i32 %i to i64
   %G = getelementptr inbounds i32, i32* %ptr, i64 %E
   %L = load i32, i32* %G
   ret i32 %L
 }
 
+;--- 2
 define i16 @outer2(i8* %ptr) {
   %C = call i16 @inner2(i8* %ptr)
   ret i16 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner2
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i16 @inner2(i8* %ptr) {
   %L = load i8, i8* %ptr
   %E = zext i8 %L to i16
   ret i16 %E
 }
 
+;--- 3
 define i16 @outer3(i8* %ptr) {
   %C = call i16 @inner3(i8* %ptr)
   ret i16 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner3
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i16 @inner3(i8* %ptr) {
   %L = load i8, i8* %ptr
   %E = sext i8 %L to i16
   ret i16 %E
 }
 
+;--- 4
 define i32 @outer4(i8* %ptr) {
   %C = call i32 @inner4(i8* %ptr)
   ret i32 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner4
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i32 @inner4(i8* %ptr) {
   %L = load i8, i8* %ptr
   %E = zext i8 %L to i32
   ret i32 %E
 }
 
+;--- 5
 define i32 @outer5(i8* %ptr) {
   %C = call i32 @inner5(i8* %ptr)
   ret i32 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner5
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i32 @inner5(i8* %ptr) {
   %L = load i8, i8* %ptr
   %E = sext i8 %L to i32
   ret i32 %E
 }
 
+;--- 6
 define i32 @outer6(i16* %ptr) {
   %C = call i32 @inner6(i16* %ptr)
   ret i32 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner6
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i32 @inner6(i16* %ptr) {
   %L = load i16, i16* %ptr
   %E = zext i16 %L to i32
   ret i32 %E
 }
 
+;--- 7
 define i32 @outer7(i16* %ptr) {
   %C = call i32 @inner7(i16* %ptr)
   ret i32 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner7
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i32 @inner7(i16* %ptr) {
   %L = load i16, i16* %ptr
   %E = sext i16 %L to i32
   ret i32 %E
 }
 
+;--- 8
 define i64 @outer8(i8* %ptr) {
   %C = call i64 @inner8(i8* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner8
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner8(i8* %ptr) {
   %L = load i8, i8* %ptr
   %E = zext i8 %L to i64
   ret i64 %E
 }
 
+;--- 9
 define i64 @outer9(i8* %ptr) {
   %C = call i64 @inner9(i8* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner9
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner9(i8* %ptr) {
   %L = load i8, i8* %ptr
   %E = sext i8 %L to i64
   ret i64 %E
 }
 
+;--- 10
 define i64 @outer10(i16* %ptr) {
   %C = call i64 @inner10(i16* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner10
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner10(i16* %ptr) {
   %L = load i16, i16* %ptr
   %E = zext i16 %L to i64
   ret i64 %E
 }
 
+;--- 11
 define i64 @outer11(i16* %ptr) {
   %C = call i64 @inner11(i16* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner11
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner11(i16* %ptr) {
   %L = load i16, i16* %ptr
   %E = sext i16 %L to i64
   ret i64 %E
 }
 
+;--- 12
 define i64 @outer12(i32* %ptr) {
   %C = call i64 @inner12(i32* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner12
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner12(i32* %ptr) {
   %L = load i32, i32* %ptr
   %E = zext i32 %L to i64
   ret i64 %E
 }
 
+;--- 13
 define i64 @outer13(i32* %ptr) {
   %C = call i64 @inner13(i32* %ptr)
   ret i64 %C
 }
 
 ; It is an ExtLoad.
 ; CHECK: Analyzing call of inner13
 ; CHECK: NumInstructionsSimplified: 2
 ; CHECK: NumInstructions: 3
 define i64 @inner13(i32* %ptr) {
   %L = load i32, i32* %ptr
   %E = sext i32 %L to i64
   ret i64 %E
 }