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

   1 ; REQUIRES: asserts
   2 ; RUN: opt -passes=inline -mtriple=aarch64--linux-gnu -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
   3
   4 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
   5 target triple = "aarch64--linux-gnu"
   6
   7 define i32 @outer1(ptr %ptr, i32 %i) {
   8   %C = call i32 @inner1(ptr %ptr, i32 %i)
   9   ret i32 %C
  10 }
  11
  12 ; sext can be folded into gep.
  13 ; CHECK: Analyzing call of inner1
  14 ; CHECK: NumInstructionsSimplified: 3
  15 ; CHECK: NumInstructions: 4
  16 define i32 @inner1(ptr %ptr, i32 %i) {
  17   %E = sext i32 %i to i64
  18   %G = getelementptr inbounds i32, ptr %ptr, i64 %E
  19   %L = load i32, ptr %G
  20   ret i32 %L
  21 }
  22
  23 define i32 @outer2(ptr %ptr, i32 %i) {
  24   %C = call i32 @inner2(ptr %ptr, i32 %i)
  25   ret i32 %C
  26 }
  27
  28 ; zext from i32 to i64 is free.
  29 ; CHECK: Analyzing call of inner2
  30 ; CHECK: NumInstructionsSimplified: 3
  31 ; CHECK: NumInstructions: 4
  32 define i32 @inner2(ptr %ptr, i32 %i) {
  33   %E = zext i32 %i to i64
  34   %G = getelementptr inbounds i32, ptr %ptr, i64 %E
  35   %L = load i32, ptr %G
  36   ret i32 %L
  37 }
  38
  39 define i32 @outer3(ptr %ptr, i16 %i) {
  40   %C = call i32 @inner3(ptr %ptr, i16 %i)
  41   ret i32 %C
  42 }
  43
  44 ; zext can be folded into gep.
  45 ; CHECK: Analyzing call of inner3
  46 ; CHECK: NumInstructionsSimplified: 3
  47 ; CHECK: NumInstructions: 4
  48 define i32 @inner3(ptr %ptr, i16 %i) {
  49   %E = zext i16 %i to i64
  50   %G = getelementptr inbounds i32, ptr %ptr, i64 %E
  51   %L = load i32, ptr %G
  52   ret i32 %L
  53 }
  54
  55 define i16 @outer4(ptr %ptr) {
  56   %C = call i16 @inner4(ptr %ptr)
  57   ret i16 %C
  58 }
  59
  60 ; It is an ExtLoad.
  61 ; CHECK: Analyzing call of inner4
  62 ; CHECK: NumInstructionsSimplified: 2
  63 ; CHECK: NumInstructions: 3
  64 define i16 @inner4(ptr %ptr) {
  65   %L = load i8, ptr %ptr
  66   %E = zext i8 %L to i16
  67   ret i16 %E
  68 }
  69
  70 define i16 @outer5(ptr %ptr) {
  71   %C = call i16 @inner5(ptr %ptr)
  72   ret i16 %C
  73 }
  74
  75 ; It is an ExtLoad.
  76 ; CHECK: Analyzing call of inner5
  77 ; CHECK: NumInstructionsSimplified: 2
  78 ; CHECK: NumInstructions: 3
  79 define i16 @inner5(ptr %ptr) {
  80   %L = load i8, ptr %ptr
  81   %E = sext i8 %L to i16
  82   ret i16 %E
  83 }
  84
  85 define i32 @outer6(ptr %ptr) {
  86   %C = call i32 @inner6(ptr %ptr)
  87   ret i32 %C
  88 }
  89
  90 ; It is an ExtLoad.
  91 ; CHECK: Analyzing call of inner6
  92 ; CHECK: NumInstructionsSimplified: 2
  93 ; CHECK: NumInstructions: 3
  94 define i32 @inner6(ptr %ptr) {
  95   %L = load i8, ptr %ptr
  96   %E = zext i8 %L to i32
  97   ret i32 %E
  98 }
  99
 100 define i32 @outer7(ptr %ptr) {
 101   %C = call i32 @inner7(ptr %ptr)
 102   ret i32 %C
 103 }
 104
 105 ; It is an ExtLoad.
 106 ; CHECK: Analyzing call of inner7
 107 ; CHECK: NumInstructionsSimplified: 2
 108 ; CHECK: NumInstructions: 3
 109 define i32 @inner7(ptr %ptr) {
 110   %L = load i8, ptr %ptr
 111   %E = sext i8 %L to i32
 112   ret i32 %E
 113 }
 114
 115 define i32 @outer8(ptr %ptr) {
 116   %C = call i32 @inner8(ptr %ptr)
 117   ret i32 %C
 118 }
 119
 120 ; It is an ExtLoad.
 121 ; CHECK: Analyzing call of inner8
 122 ; CHECK: NumInstructionsSimplified: 2
 123 ; CHECK: NumInstructions: 3
 124 define i32 @inner8(ptr %ptr) {
 125   %L = load i16, ptr %ptr
 126   %E = zext i16 %L to i32
 127   ret i32 %E
 128 }
 129
 130 define i32 @outer9(ptr %ptr) {
 131   %C = call i32 @inner9(ptr %ptr)
 132   ret i32 %C
 133 }
 134
 135 ; It is an ExtLoad.
 136 ; CHECK: Analyzing call of inner9
 137 ; CHECK: NumInstructionsSimplified: 2
 138 ; CHECK: NumInstructions: 3
 139 define i32 @inner9(ptr %ptr) {
 140   %L = load i16, ptr %ptr
 141   %E = sext i16 %L to i32
 142   ret i32 %E
 143 }
 144
 145 define i64 @outer10(ptr %ptr) {
 146   %C = call i64 @inner10(ptr %ptr)
 147   ret i64 %C
 148 }
 149
 150 ; It is an ExtLoad.
 151 ; CHECK: Analyzing call of inner10
 152 ; CHECK: NumInstructionsSimplified: 2
 153 ; CHECK: NumInstructions: 3
 154 define i64 @inner10(ptr %ptr) {
 155   %L = load i8, ptr %ptr
 156   %E = zext i8 %L to i64
 157   ret i64 %E
 158 }
 159
 160 define i64 @outer11(ptr %ptr) {
 161   %C = call i64 @inner11(ptr %ptr)
 162   ret i64 %C
 163 }
 164
 165 ; It is an ExtLoad.
 166 ; CHECK: Analyzing call of inner11
 167 ; CHECK: NumInstructionsSimplified: 2
 168 ; CHECK: NumInstructions: 3
 169 define i64 @inner11(ptr %ptr) {
 170   %L = load i8, ptr %ptr
 171   %E = sext i8 %L to i64
 172   ret i64 %E
 173 }
 174
 175 define i64 @outer12(ptr %ptr) {
 176   %C = call i64 @inner12(ptr %ptr)
 177   ret i64 %C
 178 }
 179
 180 ; It is an ExtLoad.
 181 ; CHECK: Analyzing call of inner12
 182 ; CHECK: NumInstructionsSimplified: 2
 183 ; CHECK: NumInstructions: 3
 184 define i64 @inner12(ptr %ptr) {
 185   %L = load i16, ptr %ptr
 186   %E = zext i16 %L to i64
 187   ret i64 %E
 188 }
 189
 190 define i64 @outer13(ptr %ptr) {
 191   %C = call i64 @inner13(ptr %ptr)
 192   ret i64 %C
 193 }
 194
 195 ; It is an ExtLoad.
 196 ; CHECK: Analyzing call of inner13
 197 ; CHECK: NumInstructionsSimplified: 2
 198 ; CHECK: NumInstructions: 3
 199 define i64 @inner13(ptr %ptr) {
 200   %L = load i16, ptr %ptr
 201   %E = sext i16 %L to i64
 202   ret i64 %E
 203 }
 204
 205 define i64 @outer14(ptr %ptr) {
 206   %C = call i64 @inner14(ptr %ptr)
 207   ret i64 %C
 208 }
 209
 210 ; It is an ExtLoad.
 211 ; CHECK: Analyzing call of inner14
 212 ; CHECK: NumInstructionsSimplified: 2
 213 ; CHECK: NumInstructions: 3
 214 define i64 @inner14(ptr %ptr) {
 215   %L = load i32, ptr %ptr
 216   %E = zext i32 %L to i64
 217   ret i64 %E
 218 }
 219
 220 define i64 @outer15(ptr %ptr) {
 221   %C = call i64 @inner15(ptr %ptr)
 222   ret i64 %C
 223 }
 224
 225 ; It is an ExtLoad.
 226 ; CHECK: Analyzing call of inner15
 227 ; CHECK: NumInstructionsSimplified: 2
 228 ; CHECK: NumInstructions: 3
 229 define i64 @inner15(ptr %ptr) {
 230   %L = load i32, ptr %ptr
 231   %E = sext i32 %L to i64
 232   ret i64 %E
 233 }
 234
 235 define i64 @outer16(i32 %V1, i64 %V2) {
 236   %C = call i64 @inner16(i32 %V1, i64 %V2)
 237   ret i64 %C
 238 }
 239
 240 ; sext can be folded into shl.
 241 ; CHECK: Analyzing call of inner16
 242 ; CHECK: NumInstructionsSimplified: 2
 243 ; CHECK: NumInstructions: 4
 244 define i64 @inner16(i32 %V1, i64 %V2) {
 245   %E = sext i32 %V1 to i64
 246   %S = shl i64 %E, 3
 247   %A = add i64 %V2, %S
 248   ret i64 %A
 249 }