1; REQUIRES: asserts 2; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s 3 4target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 5target triple = "x86_64-unknown-unknown" 6 7define i32 @outer1(i32* %ptr, i32 %i) { 8 %C = call i32 @inner1(i32* %ptr, i32 %i) 9 ret i32 %C 10} 11 12; zext from i32 to i64 is free. 13; CHECK: Analyzing call of inner1 14; CHECK: NumInstructionsSimplified: 3 15; CHECK: NumInstructions: 4 16define i32 @inner1(i32* %ptr, i32 %i) { 17 %E = zext i32 %i to i64 18 %G = getelementptr inbounds i32, i32* %ptr, i64 %E 19 %L = load i32, i32* %G 20 ret i32 %L 21} 22 23define i16 @outer2(i8* %ptr) { 24 %C = call i16 @inner2(i8* %ptr) 25 ret i16 %C 26} 27 28; It is an ExtLoad. 29; CHECK: Analyzing call of inner2 30; CHECK: NumInstructionsSimplified: 2 31; CHECK: NumInstructions: 3 32define i16 @inner2(i8* %ptr) { 33 %L = load i8, i8* %ptr 34 %E = zext i8 %L to i16 35 ret i16 %E 36} 37 38define i16 @outer3(i8* %ptr) { 39 %C = call i16 @inner3(i8* %ptr) 40 ret i16 %C 41} 42 43; It is an ExtLoad. 44; CHECK: Analyzing call of inner3 45; CHECK: NumInstructionsSimplified: 2 46; CHECK: NumInstructions: 3 47define i16 @inner3(i8* %ptr) { 48 %L = load i8, i8* %ptr 49 %E = sext i8 %L to i16 50 ret i16 %E 51} 52 53define i32 @outer4(i8* %ptr) { 54 %C = call i32 @inner4(i8* %ptr) 55 ret i32 %C 56} 57 58; It is an ExtLoad. 59; CHECK: Analyzing call of inner4 60; CHECK: NumInstructionsSimplified: 2 61; CHECK: NumInstructions: 3 62define i32 @inner4(i8* %ptr) { 63 %L = load i8, i8* %ptr 64 %E = zext i8 %L to i32 65 ret i32 %E 66} 67 68define i32 @outer5(i8* %ptr) { 69 %C = call i32 @inner5(i8* %ptr) 70 ret i32 %C 71} 72 73; It is an ExtLoad. 74; CHECK: Analyzing call of inner5 75; CHECK: NumInstructionsSimplified: 2 76; CHECK: NumInstructions: 3 77define i32 @inner5(i8* %ptr) { 78 %L = load i8, i8* %ptr 79 %E = sext i8 %L to i32 80 ret i32 %E 81} 82 83define i32 @outer6(i16* %ptr) { 84 %C = call i32 @inner6(i16* %ptr) 85 ret i32 %C 86} 87 88; It is an ExtLoad. 89; CHECK: Analyzing call of inner6 90; CHECK: NumInstructionsSimplified: 2 91; CHECK: NumInstructions: 3 92define i32 @inner6(i16* %ptr) { 93 %L = load i16, i16* %ptr 94 %E = zext i16 %L to i32 95 ret i32 %E 96} 97 98define i32 @outer7(i16* %ptr) { 99 %C = call i32 @inner7(i16* %ptr) 100 ret i32 %C 101} 102 103; It is an ExtLoad. 104; CHECK: Analyzing call of inner7 105; CHECK: NumInstructionsSimplified: 2 106; CHECK: NumInstructions: 3 107define i32 @inner7(i16* %ptr) { 108 %L = load i16, i16* %ptr 109 %E = sext i16 %L to i32 110 ret i32 %E 111} 112 113define i64 @outer8(i8* %ptr) { 114 %C = call i64 @inner8(i8* %ptr) 115 ret i64 %C 116} 117 118; It is an ExtLoad. 119; CHECK: Analyzing call of inner8 120; CHECK: NumInstructionsSimplified: 2 121; CHECK: NumInstructions: 3 122define i64 @inner8(i8* %ptr) { 123 %L = load i8, i8* %ptr 124 %E = zext i8 %L to i64 125 ret i64 %E 126} 127 128define i64 @outer9(i8* %ptr) { 129 %C = call i64 @inner9(i8* %ptr) 130 ret i64 %C 131} 132 133; It is an ExtLoad. 134; CHECK: Analyzing call of inner9 135; CHECK: NumInstructionsSimplified: 2 136; CHECK: NumInstructions: 3 137define i64 @inner9(i8* %ptr) { 138 %L = load i8, i8* %ptr 139 %E = sext i8 %L to i64 140 ret i64 %E 141} 142 143define i64 @outer10(i16* %ptr) { 144 %C = call i64 @inner10(i16* %ptr) 145 ret i64 %C 146} 147 148; It is an ExtLoad. 149; CHECK: Analyzing call of inner10 150; CHECK: NumInstructionsSimplified: 2 151; CHECK: NumInstructions: 3 152define i64 @inner10(i16* %ptr) { 153 %L = load i16, i16* %ptr 154 %E = zext i16 %L to i64 155 ret i64 %E 156} 157 158define i64 @outer11(i16* %ptr) { 159 %C = call i64 @inner11(i16* %ptr) 160 ret i64 %C 161} 162 163; It is an ExtLoad. 164; CHECK: Analyzing call of inner11 165; CHECK: NumInstructionsSimplified: 2 166; CHECK: NumInstructions: 3 167define i64 @inner11(i16* %ptr) { 168 %L = load i16, i16* %ptr 169 %E = sext i16 %L to i64 170 ret i64 %E 171} 172 173define i64 @outer12(i32* %ptr) { 174 %C = call i64 @inner12(i32* %ptr) 175 ret i64 %C 176} 177 178; It is an ExtLoad. 179; CHECK: Analyzing call of inner12 180; CHECK: NumInstructionsSimplified: 2 181; CHECK: NumInstructions: 3 182define i64 @inner12(i32* %ptr) { 183 %L = load i32, i32* %ptr 184 %E = zext i32 %L to i64 185 ret i64 %E 186} 187 188define i64 @outer13(i32* %ptr) { 189 %C = call i64 @inner13(i32* %ptr) 190 ret i64 %C 191} 192 193; It is an ExtLoad. 194; CHECK: Analyzing call of inner13 195; CHECK: NumInstructionsSimplified: 2 196; CHECK: NumInstructions: 3 197define i64 @inner13(i32* %ptr) { 198 %L = load i32, i32* %ptr 199 %E = sext i32 %L to i64 200 ret i64 %E 201} 202