llvm/test/CodeGen/AArch64/fexplog.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 3
   2 ; RUN: llc -mtriple=aarch64 -verify-machineinstrs %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-SD
   3 ; RUN: llc -mtriple=aarch64 -global-isel -verify-machineinstrs %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-GI
   4
   5 define double @exp_f64(double %a) {
   6 ; CHECK-LABEL: exp_f64:
   7 ; CHECK:       // %bb.0: // %entry
   8 ; CHECK-NEXT:    b exp
   9 entry:
  10   %c = call double @llvm.exp.f64(double %a)
  11   ret double %c
  12 }
  13
  14 define float @exp_f32(float %a) {
  15 ; CHECK-LABEL: exp_f32:
  16 ; CHECK:       // %bb.0: // %entry
  17 ; CHECK-NEXT:    b expf
  18 entry:
  19   %c = call float @llvm.exp.f32(float %a)
  20   ret float %c
  21 }
  22
  23 define half @exp_f16(half %a) {
  24 ; CHECK-LABEL: exp_f16:
  25 ; CHECK:       // %bb.0: // %entry
  26 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
  27 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
  28 ; CHECK-NEXT:    .cfi_offset w30, -16
  29 ; CHECK-NEXT:    fcvt s0, h0
  30 ; CHECK-NEXT:    bl expf
  31 ; CHECK-NEXT:    fcvt h0, s0
  32 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
  33 ; CHECK-NEXT:    ret
  34 entry:
  35   %c = call half @llvm.exp.f16(half %a)
  36   ret half %c
  37 }
  38
  39 define <1 x double> @exp_v1f64(<1 x double> %x) {
  40 ; CHECK-LABEL: exp_v1f64:
  41 ; CHECK:       // %bb.0:
  42 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
  43 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
  44 ; CHECK-NEXT:    .cfi_offset w30, -16
  45 ; CHECK-NEXT:    bl exp
  46 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
  47 ; CHECK-NEXT:    ret
  48   %c = call <1 x double> @llvm.exp.v1f64(<1 x double> %x)
  49   ret <1 x double> %c
  50 }
  51
  52 define <2 x double> @exp_v2f64(<2 x double> %a) {
  53 ; CHECK-SD-LABEL: exp_v2f64:
  54 ; CHECK-SD:       // %bb.0: // %entry
  55 ; CHECK-SD-NEXT:    sub sp, sp, #48
  56 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
  57 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
  58 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
  59 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
  60 ; CHECK-SD-NEXT:    mov d0, v0.d[1]
  61 ; CHECK-SD-NEXT:    bl exp
  62 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
  63 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
  64 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
  65 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
  66 ; CHECK-SD-NEXT:    bl exp
  67 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
  68 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
  69 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
  70 ; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
  71 ; CHECK-SD-NEXT:    add sp, sp, #48
  72 ; CHECK-SD-NEXT:    ret
  73 ;
  74 ; CHECK-GI-LABEL: exp_v2f64:
  75 ; CHECK-GI:       // %bb.0: // %entry
  76 ; CHECK-GI-NEXT:    sub sp, sp, #32
  77 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
  78 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
  79 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
  80 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
  81 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
  82 ; CHECK-GI-NEXT:    mov d8, v0.d[1]
  83 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
  84 ; CHECK-GI-NEXT:    bl exp
  85 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
  86 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
  87 ; CHECK-GI-NEXT:    fmov d0, d8
  88 ; CHECK-GI-NEXT:    bl exp
  89 ; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
  90 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
  91 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
  92 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
  93 ; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
  94 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
  95 ; CHECK-GI-NEXT:    add sp, sp, #32
  96 ; CHECK-GI-NEXT:    ret
  97 entry:
  98   %c = call <2 x double> @llvm.exp.v2f64(<2 x double> %a)
  99   ret <2 x double> %c
 100 }
 101
 102 define <3 x double> @exp_v3f64(<3 x double> %a) {
 103 ; CHECK-SD-LABEL: exp_v3f64:
 104 ; CHECK-SD:       // %bb.0: // %entry
 105 ; CHECK-SD-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
 106 ; CHECK-SD-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
 107 ; CHECK-SD-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
 108 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 32
 109 ; CHECK-SD-NEXT:    .cfi_offset w30, -8
 110 ; CHECK-SD-NEXT:    .cfi_offset b8, -16
 111 ; CHECK-SD-NEXT:    .cfi_offset b9, -24
 112 ; CHECK-SD-NEXT:    .cfi_offset b10, -32
 113 ; CHECK-SD-NEXT:    fmov d8, d2
 114 ; CHECK-SD-NEXT:    fmov d9, d1
 115 ; CHECK-SD-NEXT:    bl exp
 116 ; CHECK-SD-NEXT:    fmov d10, d0
 117 ; CHECK-SD-NEXT:    fmov d0, d9
 118 ; CHECK-SD-NEXT:    bl exp
 119 ; CHECK-SD-NEXT:    fmov d9, d0
 120 ; CHECK-SD-NEXT:    fmov d0, d8
 121 ; CHECK-SD-NEXT:    bl exp
 122 ; CHECK-SD-NEXT:    fmov d1, d9
 123 ; CHECK-SD-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
 124 ; CHECK-SD-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
 125 ; CHECK-SD-NEXT:    fmov d2, d0
 126 ; CHECK-SD-NEXT:    fmov d0, d10
 127 ; CHECK-SD-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
 128 ; CHECK-SD-NEXT:    ret
 129 ;
 130 ; CHECK-GI-LABEL: exp_v3f64:
 131 ; CHECK-GI:       // %bb.0: // %entry
 132 ; CHECK-GI-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
 133 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
 134 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
 135 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
 136 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
 137 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
 138 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
 139 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
 140 ; CHECK-GI-NEXT:    fmov d8, d1
 141 ; CHECK-GI-NEXT:    fmov d9, d2
 142 ; CHECK-GI-NEXT:    bl exp
 143 ; CHECK-GI-NEXT:    fmov d10, d0
 144 ; CHECK-GI-NEXT:    fmov d0, d8
 145 ; CHECK-GI-NEXT:    bl exp
 146 ; CHECK-GI-NEXT:    fmov d8, d0
 147 ; CHECK-GI-NEXT:    fmov d0, d9
 148 ; CHECK-GI-NEXT:    bl exp
 149 ; CHECK-GI-NEXT:    fmov d1, d8
 150 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
 151 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
 152 ; CHECK-GI-NEXT:    fmov d2, d0
 153 ; CHECK-GI-NEXT:    fmov d0, d10
 154 ; CHECK-GI-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
 155 ; CHECK-GI-NEXT:    ret
 156 entry:
 157   %c = call <3 x double> @llvm.exp.v3f64(<3 x double> %a)
 158   ret <3 x double> %c
 159 }
 160
 161 define <4 x double> @exp_v4f64(<4 x double> %a) {
 162 ; CHECK-SD-LABEL: exp_v4f64:
 163 ; CHECK-SD:       // %bb.0: // %entry
 164 ; CHECK-SD-NEXT:    sub sp, sp, #64
 165 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
 166 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
 167 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 168 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 169 ; CHECK-SD-NEXT:    mov d0, v0.d[1]
 170 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
 171 ; CHECK-SD-NEXT:    bl exp
 172 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
 173 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 174 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 175 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
 176 ; CHECK-SD-NEXT:    bl exp
 177 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 178 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
 179 ; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
 180 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 181 ; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
 182 ; CHECK-SD-NEXT:    mov d0, v0.d[1]
 183 ; CHECK-SD-NEXT:    bl exp
 184 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
 185 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 186 ; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
 187 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
 188 ; CHECK-SD-NEXT:    bl exp
 189 ; CHECK-SD-NEXT:    fmov d1, d0
 190 ; CHECK-SD-NEXT:    ldp q2, q0, [sp] // 32-byte Folded Reload
 191 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
 192 ; CHECK-SD-NEXT:    mov v1.d[1], v2.d[0]
 193 ; CHECK-SD-NEXT:    add sp, sp, #64
 194 ; CHECK-SD-NEXT:    ret
 195 ;
 196 ; CHECK-GI-LABEL: exp_v4f64:
 197 ; CHECK-GI:       // %bb.0: // %entry
 198 ; CHECK-GI-NEXT:    sub sp, sp, #80
 199 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
 200 ; CHECK-GI-NEXT:    str x30, [sp, #64] // 8-byte Folded Spill
 201 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
 202 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
 203 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
 204 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
 205 ; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
 206 ; CHECK-GI-NEXT:    mov d8, v0.d[1]
 207 ; CHECK-GI-NEXT:    mov d9, v1.d[1]
 208 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
 209 ; CHECK-GI-NEXT:    bl exp
 210 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
 211 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
 212 ; CHECK-GI-NEXT:    fmov d0, d8
 213 ; CHECK-GI-NEXT:    bl exp
 214 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
 215 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 216 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 217 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
 218 ; CHECK-GI-NEXT:    bl exp
 219 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
 220 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
 221 ; CHECK-GI-NEXT:    fmov d0, d9
 222 ; CHECK-GI-NEXT:    bl exp
 223 ; CHECK-GI-NEXT:    ldp q1, q2, [sp, #16] // 32-byte Folded Reload
 224 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
 225 ; CHECK-GI-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
 226 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
 227 ; CHECK-GI-NEXT:    mov v2.d[1], v1.d[0]
 228 ; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
 229 ; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
 230 ; CHECK-GI-NEXT:    mov v0.16b, v2.16b
 231 ; CHECK-GI-NEXT:    add sp, sp, #80
 232 ; CHECK-GI-NEXT:    ret
 233 entry:
 234   %c = call <4 x double> @llvm.exp.v4f64(<4 x double> %a)
 235   ret <4 x double> %c
 236 }
 237
 238 define <2 x float> @exp_v2f32(<2 x float> %a) {
 239 ; CHECK-SD-LABEL: exp_v2f32:
 240 ; CHECK-SD:       // %bb.0: // %entry
 241 ; CHECK-SD-NEXT:    sub sp, sp, #48
 242 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
 243 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
 244 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 245 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
 246 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 247 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
 248 ; CHECK-SD-NEXT:    bl expf
 249 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
 250 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 251 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 252 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
 253 ; CHECK-SD-NEXT:    bl expf
 254 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 255 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
 256 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
 257 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
 258 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
 259 ; CHECK-SD-NEXT:    add sp, sp, #48
 260 ; CHECK-SD-NEXT:    ret
 261 ;
 262 ; CHECK-GI-LABEL: exp_v2f32:
 263 ; CHECK-GI:       // %bb.0: // %entry
 264 ; CHECK-GI-NEXT:    sub sp, sp, #32
 265 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
 266 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
 267 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
 268 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
 269 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
 270 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
 271 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
 272 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
 273 ; CHECK-GI-NEXT:    bl expf
 274 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 275 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
 276 ; CHECK-GI-NEXT:    fmov s0, s8
 277 ; CHECK-GI-NEXT:    bl expf
 278 ; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
 279 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 280 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
 281 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
 282 ; CHECK-GI-NEXT:    mov v1.s[1], v0.s[0]
 283 ; CHECK-GI-NEXT:    fmov d0, d1
 284 ; CHECK-GI-NEXT:    add sp, sp, #32
 285 ; CHECK-GI-NEXT:    ret
 286 entry:
 287   %c = call <2 x float> @llvm.exp.v2f32(<2 x float> %a)
 288   ret <2 x float> %c
 289 }
 290
 291 define <3 x float> @exp_v3f32(<3 x float> %a) {
 292 ; CHECK-SD-LABEL: exp_v3f32:
 293 ; CHECK-SD:       // %bb.0: // %entry
 294 ; CHECK-SD-NEXT:    sub sp, sp, #48
 295 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
 296 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
 297 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 298 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 299 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
 300 ; CHECK-SD-NEXT:    bl expf
 301 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
 302 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 303 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 304 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
 305 ; CHECK-SD-NEXT:    bl expf
 306 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
 307 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
 308 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
 309 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 310 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 311 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
 312 ; CHECK-SD-NEXT:    bl expf
 313 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
 314 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
 315 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
 316 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
 317 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
 318 ; CHECK-SD-NEXT:    add sp, sp, #48
 319 ; CHECK-SD-NEXT:    ret
 320 ;
 321 ; CHECK-GI-LABEL: exp_v3f32:
 322 ; CHECK-GI:       // %bb.0: // %entry
 323 ; CHECK-GI-NEXT:    sub sp, sp, #64
 324 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #32] // 16-byte Folded Spill
 325 ; CHECK-GI-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
 326 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 64
 327 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
 328 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
 329 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
 330 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
 331 ; CHECK-GI-NEXT:    mov s9, v0.s[2]
 332 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
 333 ; CHECK-GI-NEXT:    bl expf
 334 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 335 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 336 ; CHECK-GI-NEXT:    fmov s0, s8
 337 ; CHECK-GI-NEXT:    bl expf
 338 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 339 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
 340 ; CHECK-GI-NEXT:    fmov s0, s9
 341 ; CHECK-GI-NEXT:    bl expf
 342 ; CHECK-GI-NEXT:    ldp q2, q1, [sp] // 32-byte Folded Reload
 343 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 344 ; CHECK-GI-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
 345 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #32] // 16-byte Folded Reload
 346 ; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
 347 ; CHECK-GI-NEXT:    mov v1.s[2], v0.s[0]
 348 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
 349 ; CHECK-GI-NEXT:    add sp, sp, #64
 350 ; CHECK-GI-NEXT:    ret
 351 entry:
 352   %c = call <3 x float> @llvm.exp.v3f32(<3 x float> %a)
 353   ret <3 x float> %c
 354 }
 355
 356 define <4 x float> @exp_v4f32(<4 x float> %a) {
 357 ; CHECK-SD-LABEL: exp_v4f32:
 358 ; CHECK-SD:       // %bb.0: // %entry
 359 ; CHECK-SD-NEXT:    sub sp, sp, #48
 360 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
 361 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
 362 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 363 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 364 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
 365 ; CHECK-SD-NEXT:    bl expf
 366 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
 367 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 368 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 369 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
 370 ; CHECK-SD-NEXT:    bl expf
 371 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
 372 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
 373 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
 374 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 375 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 376 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
 377 ; CHECK-SD-NEXT:    bl expf
 378 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
 379 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
 380 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
 381 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 382 ; CHECK-SD-NEXT:    mov s0, v0.s[3]
 383 ; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
 384 ; CHECK-SD-NEXT:    bl expf
 385 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
 386 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
 387 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
 388 ; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
 389 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
 390 ; CHECK-SD-NEXT:    add sp, sp, #48
 391 ; CHECK-SD-NEXT:    ret
 392 ;
 393 ; CHECK-GI-LABEL: exp_v4f32:
 394 ; CHECK-GI:       // %bb.0: // %entry
 395 ; CHECK-GI-NEXT:    sub sp, sp, #80
 396 ; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
 397 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
 398 ; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
 399 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
 400 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
 401 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
 402 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
 403 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
 404 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
 405 ; CHECK-GI-NEXT:    mov s9, v0.s[2]
 406 ; CHECK-GI-NEXT:    mov s10, v0.s[3]
 407 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
 408 ; CHECK-GI-NEXT:    bl expf
 409 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 410 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
 411 ; CHECK-GI-NEXT:    fmov s0, s8
 412 ; CHECK-GI-NEXT:    bl expf
 413 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 414 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 415 ; CHECK-GI-NEXT:    fmov s0, s9
 416 ; CHECK-GI-NEXT:    bl expf
 417 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 418 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
 419 ; CHECK-GI-NEXT:    fmov s0, s10
 420 ; CHECK-GI-NEXT:    bl expf
 421 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #16] // 32-byte Folded Reload
 422 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 423 ; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
 424 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
 425 ; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
 426 ; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
 427 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
 428 ; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
 429 ; CHECK-GI-NEXT:    mov v1.s[3], v0.s[0]
 430 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
 431 ; CHECK-GI-NEXT:    add sp, sp, #80
 432 ; CHECK-GI-NEXT:    ret
 433 entry:
 434   %c = call <4 x float> @llvm.exp.v4f32(<4 x float> %a)
 435   ret <4 x float> %c
 436 }
 437
 438 define <8 x float> @exp_v8f32(<8 x float> %a) {
 439 ; CHECK-SD-LABEL: exp_v8f32:
 440 ; CHECK-SD:       // %bb.0: // %entry
 441 ; CHECK-SD-NEXT:    sub sp, sp, #64
 442 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
 443 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
 444 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 445 ; CHECK-SD-NEXT:    stp q0, q1, [sp] // 32-byte Folded Spill
 446 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
 447 ; CHECK-SD-NEXT:    bl expf
 448 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
 449 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
 450 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 451 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
 452 ; CHECK-SD-NEXT:    bl expf
 453 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
 454 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
 455 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
 456 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
 457 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 458 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
 459 ; CHECK-SD-NEXT:    bl expf
 460 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
 461 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
 462 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
 463 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 464 ; CHECK-SD-NEXT:    mov s0, v0.s[3]
 465 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
 466 ; CHECK-SD-NEXT:    bl expf
 467 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
 468 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
 469 ; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
 470 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 471 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
 472 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
 473 ; CHECK-SD-NEXT:    bl expf
 474 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
 475 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 476 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 477 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
 478 ; CHECK-SD-NEXT:    bl expf
 479 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
 480 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
 481 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
 482 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 483 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 484 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
 485 ; CHECK-SD-NEXT:    bl expf
 486 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
 487 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
 488 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
 489 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 490 ; CHECK-SD-NEXT:    mov s0, v0.s[3]
 491 ; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
 492 ; CHECK-SD-NEXT:    bl expf
 493 ; CHECK-SD-NEXT:    fmov s2, s0
 494 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
 495 ; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
 496 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
 497 ; CHECK-SD-NEXT:    mov v1.s[3], v2.s[0]
 498 ; CHECK-SD-NEXT:    add sp, sp, #64
 499 ; CHECK-SD-NEXT:    ret
 500 ;
 501 ; CHECK-GI-LABEL: exp_v8f32:
 502 ; CHECK-GI:       // %bb.0: // %entry
 503 ; CHECK-GI-NEXT:    sub sp, sp, #176
 504 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #112] // 16-byte Folded Spill
 505 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #128] // 16-byte Folded Spill
 506 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #144] // 16-byte Folded Spill
 507 ; CHECK-GI-NEXT:    str x30, [sp, #160] // 8-byte Folded Spill
 508 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
 509 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
 510 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
 511 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
 512 ; CHECK-GI-NEXT:    .cfi_offset b10, -40
 513 ; CHECK-GI-NEXT:    .cfi_offset b11, -48
 514 ; CHECK-GI-NEXT:    .cfi_offset b12, -56
 515 ; CHECK-GI-NEXT:    .cfi_offset b13, -64
 516 ; CHECK-GI-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
 517 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
 518 ; CHECK-GI-NEXT:    mov s9, v0.s[2]
 519 ; CHECK-GI-NEXT:    mov s10, v0.s[3]
 520 ; CHECK-GI-NEXT:    mov s11, v1.s[1]
 521 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
 522 ; CHECK-GI-NEXT:    mov s12, v1.s[2]
 523 ; CHECK-GI-NEXT:    mov s13, v1.s[3]
 524 ; CHECK-GI-NEXT:    bl expf
 525 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 526 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
 527 ; CHECK-GI-NEXT:    fmov s0, s8
 528 ; CHECK-GI-NEXT:    bl expf
 529 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 530 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
 531 ; CHECK-GI-NEXT:    fmov s0, s9
 532 ; CHECK-GI-NEXT:    bl expf
 533 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 534 ; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
 535 ; CHECK-GI-NEXT:    fmov s0, s10
 536 ; CHECK-GI-NEXT:    bl expf
 537 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 538 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
 539 ; CHECK-GI-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
 540 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
 541 ; CHECK-GI-NEXT:    bl expf
 542 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 543 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
 544 ; CHECK-GI-NEXT:    fmov s0, s11
 545 ; CHECK-GI-NEXT:    bl expf
 546 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 547 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 548 ; CHECK-GI-NEXT:    fmov s0, s12
 549 ; CHECK-GI-NEXT:    bl expf
 550 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 551 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
 552 ; CHECK-GI-NEXT:    fmov s0, s13
 553 ; CHECK-GI-NEXT:    bl expf
 554 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #48] // 32-byte Folded Reload
 555 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
 556 ; CHECK-GI-NEXT:    ldr x30, [sp, #160] // 8-byte Folded Reload
 557 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #144] // 16-byte Folded Reload
 558 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #128] // 16-byte Folded Reload
 559 ; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
 560 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
 561 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #112] // 16-byte Folded Reload
 562 ; CHECK-GI-NEXT:    mov v3.s[1], v2.s[0]
 563 ; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
 564 ; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
 565 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
 566 ; CHECK-GI-NEXT:    mov v3.s[2], v2.s[0]
 567 ; CHECK-GI-NEXT:    ldr q2, [sp, #80] // 16-byte Folded Reload
 568 ; CHECK-GI-NEXT:    mov v1.s[3], v2.s[0]
 569 ; CHECK-GI-NEXT:    mov v3.s[3], v0.s[0]
 570 ; CHECK-GI-NEXT:    mov v2.16b, v1.16b
 571 ; CHECK-GI-NEXT:    mov v1.16b, v3.16b
 572 ; CHECK-GI-NEXT:    mov v0.16b, v2.16b
 573 ; CHECK-GI-NEXT:    add sp, sp, #176
 574 ; CHECK-GI-NEXT:    ret
 575 entry:
 576   %c = call <8 x float> @llvm.exp.v8f32(<8 x float> %a)
 577   ret <8 x float> %c
 578 }
 579
 580 define <7 x half> @exp_v7f16(<7 x half> %a) {
 581 ; CHECK-SD-LABEL: exp_v7f16:
 582 ; CHECK-SD:       // %bb.0: // %entry
 583 ; CHECK-SD-NEXT:    sub sp, sp, #48
 584 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
 585 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
 586 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 587 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
 588 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 589 ; CHECK-SD-NEXT:    fcvt s0, h1
 590 ; CHECK-SD-NEXT:    bl expf
 591 ; CHECK-SD-NEXT:    fcvt h0, s0
 592 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 593 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 594 ; CHECK-SD-NEXT:    fcvt s0, h0
 595 ; CHECK-SD-NEXT:    bl expf
 596 ; CHECK-SD-NEXT:    fcvt h0, s0
 597 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 598 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
 599 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 600 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 601 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
 602 ; CHECK-SD-NEXT:    fcvt s0, h0
 603 ; CHECK-SD-NEXT:    bl expf
 604 ; CHECK-SD-NEXT:    fcvt h0, s0
 605 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 606 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
 607 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 608 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
 609 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
 610 ; CHECK-SD-NEXT:    fcvt s0, h0
 611 ; CHECK-SD-NEXT:    bl expf
 612 ; CHECK-SD-NEXT:    fcvt h0, s0
 613 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 614 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
 615 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 616 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
 617 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
 618 ; CHECK-SD-NEXT:    fcvt s0, h0
 619 ; CHECK-SD-NEXT:    bl expf
 620 ; CHECK-SD-NEXT:    fcvt h0, s0
 621 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 622 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
 623 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 624 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
 625 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
 626 ; CHECK-SD-NEXT:    fcvt s0, h0
 627 ; CHECK-SD-NEXT:    bl expf
 628 ; CHECK-SD-NEXT:    fcvt h0, s0
 629 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 630 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
 631 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 632 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
 633 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
 634 ; CHECK-SD-NEXT:    fcvt s0, h0
 635 ; CHECK-SD-NEXT:    bl expf
 636 ; CHECK-SD-NEXT:    fcvt h0, s0
 637 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 638 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
 639 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 640 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
 641 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
 642 ; CHECK-SD-NEXT:    fcvt s0, h0
 643 ; CHECK-SD-NEXT:    bl expf
 644 ; CHECK-SD-NEXT:    fcvt h1, s0
 645 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 646 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
 647 ; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
 648 ; CHECK-SD-NEXT:    add sp, sp, #48
 649 ; CHECK-SD-NEXT:    ret
 650 ;
 651 ; CHECK-GI-LABEL: exp_v7f16:
 652 ; CHECK-GI:       // %bb.0: // %entry
 653 ; CHECK-GI-NEXT:    sub sp, sp, #160
 654 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #96] // 16-byte Folded Spill
 655 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #112] // 16-byte Folded Spill
 656 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #128] // 16-byte Folded Spill
 657 ; CHECK-GI-NEXT:    str x30, [sp, #144] // 8-byte Folded Spill
 658 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 160
 659 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
 660 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
 661 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
 662 ; CHECK-GI-NEXT:    .cfi_offset b10, -40
 663 ; CHECK-GI-NEXT:    .cfi_offset b11, -48
 664 ; CHECK-GI-NEXT:    .cfi_offset b12, -56
 665 ; CHECK-GI-NEXT:    .cfi_offset b13, -64
 666 ; CHECK-GI-NEXT:    mov h8, v0.h[1]
 667 ; CHECK-GI-NEXT:    mov h9, v0.h[2]
 668 ; CHECK-GI-NEXT:    mov h10, v0.h[3]
 669 ; CHECK-GI-NEXT:    mov h11, v0.h[4]
 670 ; CHECK-GI-NEXT:    mov h12, v0.h[5]
 671 ; CHECK-GI-NEXT:    mov h13, v0.h[6]
 672 ; CHECK-GI-NEXT:    fcvt s0, h0
 673 ; CHECK-GI-NEXT:    bl expf
 674 ; CHECK-GI-NEXT:    fcvt s1, h8
 675 ; CHECK-GI-NEXT:    fcvt h0, s0
 676 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
 677 ; CHECK-GI-NEXT:    fmov s0, s1
 678 ; CHECK-GI-NEXT:    bl expf
 679 ; CHECK-GI-NEXT:    fcvt s1, h9
 680 ; CHECK-GI-NEXT:    fcvt h0, s0
 681 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
 682 ; CHECK-GI-NEXT:    fmov s0, s1
 683 ; CHECK-GI-NEXT:    bl expf
 684 ; CHECK-GI-NEXT:    fcvt s1, h10
 685 ; CHECK-GI-NEXT:    fcvt h0, s0
 686 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
 687 ; CHECK-GI-NEXT:    fmov s0, s1
 688 ; CHECK-GI-NEXT:    bl expf
 689 ; CHECK-GI-NEXT:    fcvt s1, h11
 690 ; CHECK-GI-NEXT:    fcvt h0, s0
 691 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
 692 ; CHECK-GI-NEXT:    fmov s0, s1
 693 ; CHECK-GI-NEXT:    bl expf
 694 ; CHECK-GI-NEXT:    fcvt s1, h12
 695 ; CHECK-GI-NEXT:    fcvt h0, s0
 696 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 697 ; CHECK-GI-NEXT:    fmov s0, s1
 698 ; CHECK-GI-NEXT:    bl expf
 699 ; CHECK-GI-NEXT:    fcvt s1, h13
 700 ; CHECK-GI-NEXT:    fcvt h0, s0
 701 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
 702 ; CHECK-GI-NEXT:    fmov s0, s1
 703 ; CHECK-GI-NEXT:    bl expf
 704 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #64] // 32-byte Folded Reload
 705 ; CHECK-GI-NEXT:    fcvt h0, s0
 706 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #128] // 16-byte Folded Reload
 707 ; CHECK-GI-NEXT:    ldr x30, [sp, #144] // 8-byte Folded Reload
 708 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #112] // 16-byte Folded Reload
 709 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
 710 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #32] // 32-byte Folded Reload
 711 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #96] // 16-byte Folded Reload
 712 ; CHECK-GI-NEXT:    mov v1.h[2], v3.h[0]
 713 ; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
 714 ; CHECK-GI-NEXT:    ldp q2, q3, [sp] // 32-byte Folded Reload
 715 ; CHECK-GI-NEXT:    mov v1.h[4], v3.h[0]
 716 ; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
 717 ; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
 718 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
 719 ; CHECK-GI-NEXT:    add sp, sp, #160
 720 ; CHECK-GI-NEXT:    ret
 721 entry:
 722   %c = call <7 x half> @llvm.exp.v7f16(<7 x half> %a)
 723   ret <7 x half> %c
 724 }
 725
 726 define <4 x half> @exp_v4f16(<4 x half> %a) {
 727 ; CHECK-SD-LABEL: exp_v4f16:
 728 ; CHECK-SD:       // %bb.0: // %entry
 729 ; CHECK-SD-NEXT:    sub sp, sp, #48
 730 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
 731 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
 732 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 733 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
 734 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
 735 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 736 ; CHECK-SD-NEXT:    fcvt s0, h1
 737 ; CHECK-SD-NEXT:    bl expf
 738 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 739 ; CHECK-SD-NEXT:    fcvt h0, s0
 740 ; CHECK-SD-NEXT:    fcvt s1, h1
 741 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 742 ; CHECK-SD-NEXT:    fmov s0, s1
 743 ; CHECK-SD-NEXT:    bl expf
 744 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 745 ; CHECK-SD-NEXT:    fcvt h2, s0
 746 ; CHECK-SD-NEXT:    mov h1, v1.h[2]
 747 ; CHECK-SD-NEXT:    fcvt s0, h1
 748 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
 749 ; CHECK-SD-NEXT:    mov v2.h[1], v1.h[0]
 750 ; CHECK-SD-NEXT:    str q2, [sp] // 16-byte Folded Spill
 751 ; CHECK-SD-NEXT:    bl expf
 752 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 753 ; CHECK-SD-NEXT:    fcvt h2, s0
 754 ; CHECK-SD-NEXT:    mov h1, v1.h[3]
 755 ; CHECK-SD-NEXT:    fcvt s0, h1
 756 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
 757 ; CHECK-SD-NEXT:    mov v1.h[2], v2.h[0]
 758 ; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
 759 ; CHECK-SD-NEXT:    bl expf
 760 ; CHECK-SD-NEXT:    fcvt h1, s0
 761 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 762 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
 763 ; CHECK-SD-NEXT:    mov v0.h[3], v1.h[0]
 764 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
 765 ; CHECK-SD-NEXT:    add sp, sp, #48
 766 ; CHECK-SD-NEXT:    ret
 767 ;
 768 ; CHECK-GI-LABEL: exp_v4f16:
 769 ; CHECK-GI:       // %bb.0: // %entry
 770 ; CHECK-GI-NEXT:    sub sp, sp, #80
 771 ; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
 772 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
 773 ; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
 774 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
 775 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
 776 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
 777 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
 778 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
 779 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
 780 ; CHECK-GI-NEXT:    mov h8, v0.h[1]
 781 ; CHECK-GI-NEXT:    mov h9, v0.h[2]
 782 ; CHECK-GI-NEXT:    mov h10, v0.h[3]
 783 ; CHECK-GI-NEXT:    fcvt s0, h0
 784 ; CHECK-GI-NEXT:    bl expf
 785 ; CHECK-GI-NEXT:    fcvt s1, h8
 786 ; CHECK-GI-NEXT:    fcvt h0, s0
 787 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
 788 ; CHECK-GI-NEXT:    fmov s0, s1
 789 ; CHECK-GI-NEXT:    bl expf
 790 ; CHECK-GI-NEXT:    fcvt s1, h9
 791 ; CHECK-GI-NEXT:    fcvt h0, s0
 792 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 793 ; CHECK-GI-NEXT:    fmov s0, s1
 794 ; CHECK-GI-NEXT:    bl expf
 795 ; CHECK-GI-NEXT:    fcvt s1, h10
 796 ; CHECK-GI-NEXT:    fcvt h0, s0
 797 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
 798 ; CHECK-GI-NEXT:    fmov s0, s1
 799 ; CHECK-GI-NEXT:    bl expf
 800 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #16] // 32-byte Folded Reload
 801 ; CHECK-GI-NEXT:    fcvt h0, s0
 802 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
 803 ; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
 804 ; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
 805 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
 806 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
 807 ; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
 808 ; CHECK-GI-NEXT:    mov v1.h[3], v0.h[0]
 809 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
 810 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
 811 ; CHECK-GI-NEXT:    add sp, sp, #80
 812 ; CHECK-GI-NEXT:    ret
 813 entry:
 814   %c = call <4 x half> @llvm.exp.v4f16(<4 x half> %a)
 815   ret <4 x half> %c
 816 }
 817
 818 define <8 x half> @exp_v8f16(<8 x half> %a) {
 819 ; CHECK-SD-LABEL: exp_v8f16:
 820 ; CHECK-SD:       // %bb.0: // %entry
 821 ; CHECK-SD-NEXT:    sub sp, sp, #48
 822 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
 823 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
 824 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 825 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
 826 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
 827 ; CHECK-SD-NEXT:    fcvt s0, h1
 828 ; CHECK-SD-NEXT:    bl expf
 829 ; CHECK-SD-NEXT:    fcvt h0, s0
 830 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 831 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 832 ; CHECK-SD-NEXT:    fcvt s0, h0
 833 ; CHECK-SD-NEXT:    bl expf
 834 ; CHECK-SD-NEXT:    fcvt h0, s0
 835 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 836 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
 837 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 838 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 839 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
 840 ; CHECK-SD-NEXT:    fcvt s0, h0
 841 ; CHECK-SD-NEXT:    bl expf
 842 ; CHECK-SD-NEXT:    fcvt h0, s0
 843 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 844 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
 845 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 846 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
 847 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
 848 ; CHECK-SD-NEXT:    fcvt s0, h0
 849 ; CHECK-SD-NEXT:    bl expf
 850 ; CHECK-SD-NEXT:    fcvt h0, s0
 851 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 852 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
 853 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 854 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
 855 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
 856 ; CHECK-SD-NEXT:    fcvt s0, h0
 857 ; CHECK-SD-NEXT:    bl expf
 858 ; CHECK-SD-NEXT:    fcvt h0, s0
 859 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 860 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
 861 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 862 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
 863 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
 864 ; CHECK-SD-NEXT:    fcvt s0, h0
 865 ; CHECK-SD-NEXT:    bl expf
 866 ; CHECK-SD-NEXT:    fcvt h0, s0
 867 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 868 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
 869 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 870 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
 871 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
 872 ; CHECK-SD-NEXT:    fcvt s0, h0
 873 ; CHECK-SD-NEXT:    bl expf
 874 ; CHECK-SD-NEXT:    fcvt h0, s0
 875 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
 876 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
 877 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 878 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
 879 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
 880 ; CHECK-SD-NEXT:    fcvt s0, h0
 881 ; CHECK-SD-NEXT:    bl expf
 882 ; CHECK-SD-NEXT:    fcvt h1, s0
 883 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 884 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
 885 ; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
 886 ; CHECK-SD-NEXT:    add sp, sp, #48
 887 ; CHECK-SD-NEXT:    ret
 888 ;
 889 ; CHECK-GI-LABEL: exp_v8f16:
 890 ; CHECK-GI:       // %bb.0: // %entry
 891 ; CHECK-GI-NEXT:    sub sp, sp, #176
 892 ; CHECK-GI-NEXT:    str d14, [sp, #112] // 8-byte Folded Spill
 893 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #120] // 16-byte Folded Spill
 894 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #136] // 16-byte Folded Spill
 895 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #152] // 16-byte Folded Spill
 896 ; CHECK-GI-NEXT:    str x30, [sp, #168] // 8-byte Folded Spill
 897 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
 898 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
 899 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
 900 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
 901 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
 902 ; CHECK-GI-NEXT:    .cfi_offset b11, -40
 903 ; CHECK-GI-NEXT:    .cfi_offset b12, -48
 904 ; CHECK-GI-NEXT:    .cfi_offset b13, -56
 905 ; CHECK-GI-NEXT:    .cfi_offset b14, -64
 906 ; CHECK-GI-NEXT:    mov h8, v0.h[1]
 907 ; CHECK-GI-NEXT:    mov h9, v0.h[2]
 908 ; CHECK-GI-NEXT:    mov h10, v0.h[3]
 909 ; CHECK-GI-NEXT:    mov h11, v0.h[4]
 910 ; CHECK-GI-NEXT:    mov h12, v0.h[5]
 911 ; CHECK-GI-NEXT:    mov h13, v0.h[6]
 912 ; CHECK-GI-NEXT:    mov h14, v0.h[7]
 913 ; CHECK-GI-NEXT:    fcvt s0, h0
 914 ; CHECK-GI-NEXT:    bl expf
 915 ; CHECK-GI-NEXT:    fcvt s1, h8
 916 ; CHECK-GI-NEXT:    fcvt h0, s0
 917 ; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
 918 ; CHECK-GI-NEXT:    fmov s0, s1
 919 ; CHECK-GI-NEXT:    bl expf
 920 ; CHECK-GI-NEXT:    fcvt s1, h9
 921 ; CHECK-GI-NEXT:    fcvt h0, s0
 922 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
 923 ; CHECK-GI-NEXT:    fmov s0, s1
 924 ; CHECK-GI-NEXT:    bl expf
 925 ; CHECK-GI-NEXT:    fcvt s1, h10
 926 ; CHECK-GI-NEXT:    fcvt h0, s0
 927 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
 928 ; CHECK-GI-NEXT:    fmov s0, s1
 929 ; CHECK-GI-NEXT:    bl expf
 930 ; CHECK-GI-NEXT:    fcvt s1, h11
 931 ; CHECK-GI-NEXT:    fcvt h0, s0
 932 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
 933 ; CHECK-GI-NEXT:    fmov s0, s1
 934 ; CHECK-GI-NEXT:    bl expf
 935 ; CHECK-GI-NEXT:    fcvt s1, h12
 936 ; CHECK-GI-NEXT:    fcvt h0, s0
 937 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
 938 ; CHECK-GI-NEXT:    fmov s0, s1
 939 ; CHECK-GI-NEXT:    bl expf
 940 ; CHECK-GI-NEXT:    fcvt s1, h13
 941 ; CHECK-GI-NEXT:    fcvt h0, s0
 942 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
 943 ; CHECK-GI-NEXT:    fmov s0, s1
 944 ; CHECK-GI-NEXT:    bl expf
 945 ; CHECK-GI-NEXT:    fcvt s1, h14
 946 ; CHECK-GI-NEXT:    fcvt h0, s0
 947 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
 948 ; CHECK-GI-NEXT:    fmov s0, s1
 949 ; CHECK-GI-NEXT:    bl expf
 950 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #80] // 32-byte Folded Reload
 951 ; CHECK-GI-NEXT:    fcvt h0, s0
 952 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #152] // 16-byte Folded Reload
 953 ; CHECK-GI-NEXT:    ldr x30, [sp, #168] // 8-byte Folded Reload
 954 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #136] // 16-byte Folded Reload
 955 ; CHECK-GI-NEXT:    ldr d14, [sp, #112] // 8-byte Folded Reload
 956 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
 957 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #48] // 32-byte Folded Reload
 958 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #120] // 16-byte Folded Reload
 959 ; CHECK-GI-NEXT:    mov v1.h[2], v3.h[0]
 960 ; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
 961 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
 962 ; CHECK-GI-NEXT:    mov v1.h[4], v3.h[0]
 963 ; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
 964 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
 965 ; CHECK-GI-NEXT:    mov v1.h[6], v2.h[0]
 966 ; CHECK-GI-NEXT:    mov v1.h[7], v0.h[0]
 967 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
 968 ; CHECK-GI-NEXT:    add sp, sp, #176
 969 ; CHECK-GI-NEXT:    ret
 970 entry:
 971   %c = call <8 x half> @llvm.exp.v8f16(<8 x half> %a)
 972   ret <8 x half> %c
 973 }
 974
 975 define <16 x half> @exp_v16f16(<16 x half> %a) {
 976 ; CHECK-SD-LABEL: exp_v16f16:
 977 ; CHECK-SD:       // %bb.0: // %entry
 978 ; CHECK-SD-NEXT:    sub sp, sp, #64
 979 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
 980 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
 981 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
 982 ; CHECK-SD-NEXT:    stp q1, q0, [sp] // 32-byte Folded Spill
 983 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
 984 ; CHECK-SD-NEXT:    fcvt s0, h1
 985 ; CHECK-SD-NEXT:    bl expf
 986 ; CHECK-SD-NEXT:    fcvt h0, s0
 987 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
 988 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 989 ; CHECK-SD-NEXT:    fcvt s0, h0
 990 ; CHECK-SD-NEXT:    bl expf
 991 ; CHECK-SD-NEXT:    fcvt h0, s0
 992 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
 993 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
 994 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
 995 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
 996 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
 997 ; CHECK-SD-NEXT:    fcvt s0, h0
 998 ; CHECK-SD-NEXT:    bl expf
 999 ; CHECK-SD-NEXT:    fcvt h0, s0
1000 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1001 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
1002 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1003 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
1004 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1005 ; CHECK-SD-NEXT:    fcvt s0, h0
1006 ; CHECK-SD-NEXT:    bl expf
1007 ; CHECK-SD-NEXT:    fcvt h0, s0
1008 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1009 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
1010 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1011 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
1012 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1013 ; CHECK-SD-NEXT:    fcvt s0, h0
1014 ; CHECK-SD-NEXT:    bl expf
1015 ; CHECK-SD-NEXT:    fcvt h0, s0
1016 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1017 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
1018 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1019 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
1020 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1021 ; CHECK-SD-NEXT:    fcvt s0, h0
1022 ; CHECK-SD-NEXT:    bl expf
1023 ; CHECK-SD-NEXT:    fcvt h0, s0
1024 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1025 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
1026 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1027 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
1028 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1029 ; CHECK-SD-NEXT:    fcvt s0, h0
1030 ; CHECK-SD-NEXT:    bl expf
1031 ; CHECK-SD-NEXT:    fcvt h0, s0
1032 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1033 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
1034 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1035 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
1036 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1037 ; CHECK-SD-NEXT:    fcvt s0, h0
1038 ; CHECK-SD-NEXT:    bl expf
1039 ; CHECK-SD-NEXT:    fcvt h0, s0
1040 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1041 ; CHECK-SD-NEXT:    mov v1.h[7], v0.h[0]
1042 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1043 ; CHECK-SD-NEXT:    mov h0, v0.h[1]
1044 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1045 ; CHECK-SD-NEXT:    fcvt s0, h0
1046 ; CHECK-SD-NEXT:    bl expf
1047 ; CHECK-SD-NEXT:    fcvt h0, s0
1048 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1049 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1050 ; CHECK-SD-NEXT:    fcvt s0, h0
1051 ; CHECK-SD-NEXT:    bl expf
1052 ; CHECK-SD-NEXT:    fcvt h0, s0
1053 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1054 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
1055 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1056 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1057 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
1058 ; CHECK-SD-NEXT:    fcvt s0, h0
1059 ; CHECK-SD-NEXT:    bl expf
1060 ; CHECK-SD-NEXT:    fcvt h0, s0
1061 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1062 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
1063 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1064 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
1065 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1066 ; CHECK-SD-NEXT:    fcvt s0, h0
1067 ; CHECK-SD-NEXT:    bl expf
1068 ; CHECK-SD-NEXT:    fcvt h0, s0
1069 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1070 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
1071 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1072 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
1073 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1074 ; CHECK-SD-NEXT:    fcvt s0, h0
1075 ; CHECK-SD-NEXT:    bl expf
1076 ; CHECK-SD-NEXT:    fcvt h0, s0
1077 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1078 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
1079 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1080 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
1081 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1082 ; CHECK-SD-NEXT:    fcvt s0, h0
1083 ; CHECK-SD-NEXT:    bl expf
1084 ; CHECK-SD-NEXT:    fcvt h0, s0
1085 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1086 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
1087 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1088 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
1089 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1090 ; CHECK-SD-NEXT:    fcvt s0, h0
1091 ; CHECK-SD-NEXT:    bl expf
1092 ; CHECK-SD-NEXT:    fcvt h0, s0
1093 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1094 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
1095 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1096 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
1097 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1098 ; CHECK-SD-NEXT:    fcvt s0, h0
1099 ; CHECK-SD-NEXT:    bl expf
1100 ; CHECK-SD-NEXT:    fmov s1, s0
1101 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
1102 ; CHECK-SD-NEXT:    fcvt h2, s1
1103 ; CHECK-SD-NEXT:    ldp q1, q0, [sp, #16] // 32-byte Folded Reload
1104 ; CHECK-SD-NEXT:    mov v1.h[7], v2.h[0]
1105 ; CHECK-SD-NEXT:    add sp, sp, #64
1106 ; CHECK-SD-NEXT:    ret
1107 ;
1108 ; CHECK-GI-LABEL: exp_v16f16:
1109 ; CHECK-GI:       // %bb.0: // %entry
1110 ; CHECK-GI-NEXT:    sub sp, sp, #320
1111 ; CHECK-GI-NEXT:    stp d15, d14, [sp, #240] // 16-byte Folded Spill
1112 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #256] // 16-byte Folded Spill
1113 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #272] // 16-byte Folded Spill
1114 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #288] // 16-byte Folded Spill
1115 ; CHECK-GI-NEXT:    stp x29, x30, [sp, #304] // 16-byte Folded Spill
1116 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 320
1117 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
1118 ; CHECK-GI-NEXT:    .cfi_offset w29, -16
1119 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
1120 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
1121 ; CHECK-GI-NEXT:    .cfi_offset b10, -40
1122 ; CHECK-GI-NEXT:    .cfi_offset b11, -48
1123 ; CHECK-GI-NEXT:    .cfi_offset b12, -56
1124 ; CHECK-GI-NEXT:    .cfi_offset b13, -64
1125 ; CHECK-GI-NEXT:    .cfi_offset b14, -72
1126 ; CHECK-GI-NEXT:    .cfi_offset b15, -80
1127 ; CHECK-GI-NEXT:    mov v2.16b, v1.16b
1128 ; CHECK-GI-NEXT:    str q1, [sp, #80] // 16-byte Folded Spill
1129 ; CHECK-GI-NEXT:    mov h14, v1.h[1]
1130 ; CHECK-GI-NEXT:    mov h1, v1.h[2]
1131 ; CHECK-GI-NEXT:    mov h15, v0.h[1]
1132 ; CHECK-GI-NEXT:    mov h8, v0.h[2]
1133 ; CHECK-GI-NEXT:    mov h9, v0.h[3]
1134 ; CHECK-GI-NEXT:    mov h10, v0.h[4]
1135 ; CHECK-GI-NEXT:    mov h11, v0.h[5]
1136 ; CHECK-GI-NEXT:    mov h12, v0.h[6]
1137 ; CHECK-GI-NEXT:    mov h13, v0.h[7]
1138 ; CHECK-GI-NEXT:    fcvt s0, h0
1139 ; CHECK-GI-NEXT:    str h1, [sp, #16] // 2-byte Folded Spill
1140 ; CHECK-GI-NEXT:    mov h1, v2.h[3]
1141 ; CHECK-GI-NEXT:    str h1, [sp, #32] // 2-byte Folded Spill
1142 ; CHECK-GI-NEXT:    mov h1, v2.h[4]
1143 ; CHECK-GI-NEXT:    str h1, [sp, #48] // 2-byte Folded Spill
1144 ; CHECK-GI-NEXT:    mov h1, v2.h[5]
1145 ; CHECK-GI-NEXT:    str h1, [sp, #64] // 2-byte Folded Spill
1146 ; CHECK-GI-NEXT:    mov h1, v2.h[6]
1147 ; CHECK-GI-NEXT:    str h1, [sp, #96] // 2-byte Folded Spill
1148 ; CHECK-GI-NEXT:    mov h1, v2.h[7]
1149 ; CHECK-GI-NEXT:    str h1, [sp, #160] // 2-byte Folded Spill
1150 ; CHECK-GI-NEXT:    bl expf
1151 ; CHECK-GI-NEXT:    fcvt s1, h15
1152 ; CHECK-GI-NEXT:    fcvt h0, s0
1153 ; CHECK-GI-NEXT:    str q0, [sp, #192] // 16-byte Folded Spill
1154 ; CHECK-GI-NEXT:    fmov s0, s1
1155 ; CHECK-GI-NEXT:    bl expf
1156 ; CHECK-GI-NEXT:    fcvt s1, h8
1157 ; CHECK-GI-NEXT:    fcvt h0, s0
1158 ; CHECK-GI-NEXT:    str q0, [sp, #128] // 16-byte Folded Spill
1159 ; CHECK-GI-NEXT:    fmov s0, s1
1160 ; CHECK-GI-NEXT:    bl expf
1161 ; CHECK-GI-NEXT:    fcvt s1, h9
1162 ; CHECK-GI-NEXT:    fcvt h0, s0
1163 ; CHECK-GI-NEXT:    str q0, [sp, #224] // 16-byte Folded Spill
1164 ; CHECK-GI-NEXT:    fmov s0, s1
1165 ; CHECK-GI-NEXT:    bl expf
1166 ; CHECK-GI-NEXT:    fcvt s1, h10
1167 ; CHECK-GI-NEXT:    fcvt h0, s0
1168 ; CHECK-GI-NEXT:    str q0, [sp, #208] // 16-byte Folded Spill
1169 ; CHECK-GI-NEXT:    fmov s0, s1
1170 ; CHECK-GI-NEXT:    bl expf
1171 ; CHECK-GI-NEXT:    fcvt s1, h11
1172 ; CHECK-GI-NEXT:    fcvt h0, s0
1173 ; CHECK-GI-NEXT:    str q0, [sp, #176] // 16-byte Folded Spill
1174 ; CHECK-GI-NEXT:    fmov s0, s1
1175 ; CHECK-GI-NEXT:    bl expf
1176 ; CHECK-GI-NEXT:    fcvt s1, h12
1177 ; CHECK-GI-NEXT:    fcvt h0, s0
1178 ; CHECK-GI-NEXT:    str q0, [sp, #144] // 16-byte Folded Spill
1179 ; CHECK-GI-NEXT:    fmov s0, s1
1180 ; CHECK-GI-NEXT:    bl expf
1181 ; CHECK-GI-NEXT:    fcvt s1, h13
1182 ; CHECK-GI-NEXT:    fcvt h0, s0
1183 ; CHECK-GI-NEXT:    str q0, [sp, #112] // 16-byte Folded Spill
1184 ; CHECK-GI-NEXT:    fmov s0, s1
1185 ; CHECK-GI-NEXT:    bl expf
1186 ; CHECK-GI-NEXT:    ldr q1, [sp, #80] // 16-byte Folded Reload
1187 ; CHECK-GI-NEXT:    fcvt h0, s0
1188 ; CHECK-GI-NEXT:    fcvt s1, h1
1189 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
1190 ; CHECK-GI-NEXT:    fmov s0, s1
1191 ; CHECK-GI-NEXT:    bl expf
1192 ; CHECK-GI-NEXT:    fcvt s1, h14
1193 ; CHECK-GI-NEXT:    fcvt h0, s0
1194 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1195 ; CHECK-GI-NEXT:    fmov s0, s1
1196 ; CHECK-GI-NEXT:    bl expf
1197 ; CHECK-GI-NEXT:    ldr h1, [sp, #16] // 2-byte Folded Reload
1198 ; CHECK-GI-NEXT:    fcvt h0, s0
1199 ; CHECK-GI-NEXT:    fcvt s1, h1
1200 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1201 ; CHECK-GI-NEXT:    fmov s0, s1
1202 ; CHECK-GI-NEXT:    bl expf
1203 ; CHECK-GI-NEXT:    ldr h1, [sp, #32] // 2-byte Folded Reload
1204 ; CHECK-GI-NEXT:    fcvt h0, s0
1205 ; CHECK-GI-NEXT:    fcvt s1, h1
1206 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
1207 ; CHECK-GI-NEXT:    fmov s0, s1
1208 ; CHECK-GI-NEXT:    bl expf
1209 ; CHECK-GI-NEXT:    ldr h1, [sp, #48] // 2-byte Folded Reload
1210 ; CHECK-GI-NEXT:    fcvt h0, s0
1211 ; CHECK-GI-NEXT:    fcvt s1, h1
1212 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
1213 ; CHECK-GI-NEXT:    fmov s0, s1
1214 ; CHECK-GI-NEXT:    bl expf
1215 ; CHECK-GI-NEXT:    ldr h1, [sp, #64] // 2-byte Folded Reload
1216 ; CHECK-GI-NEXT:    fcvt h0, s0
1217 ; CHECK-GI-NEXT:    fcvt s1, h1
1218 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
1219 ; CHECK-GI-NEXT:    fmov s0, s1
1220 ; CHECK-GI-NEXT:    bl expf
1221 ; CHECK-GI-NEXT:    ldr h1, [sp, #96] // 2-byte Folded Reload
1222 ; CHECK-GI-NEXT:    fcvt h0, s0
1223 ; CHECK-GI-NEXT:    fcvt s1, h1
1224 ; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
1225 ; CHECK-GI-NEXT:    fmov s0, s1
1226 ; CHECK-GI-NEXT:    bl expf
1227 ; CHECK-GI-NEXT:    ldr h1, [sp, #160] // 2-byte Folded Reload
1228 ; CHECK-GI-NEXT:    fcvt h0, s0
1229 ; CHECK-GI-NEXT:    fcvt s1, h1
1230 ; CHECK-GI-NEXT:    str q0, [sp, #160] // 16-byte Folded Spill
1231 ; CHECK-GI-NEXT:    fmov s0, s1
1232 ; CHECK-GI-NEXT:    bl expf
1233 ; CHECK-GI-NEXT:    ldr q3, [sp, #192] // 16-byte Folded Reload
1234 ; CHECK-GI-NEXT:    ldr q2, [sp, #128] // 16-byte Folded Reload
1235 ; CHECK-GI-NEXT:    ldp x29, x30, [sp, #304] // 16-byte Folded Reload
1236 ; CHECK-GI-NEXT:    mov v3.h[1], v2.h[0]
1237 ; CHECK-GI-NEXT:    ldp q1, q2, [sp] // 32-byte Folded Reload
1238 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #288] // 16-byte Folded Reload
1239 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #272] // 16-byte Folded Reload
1240 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
1241 ; CHECK-GI-NEXT:    ldr q2, [sp, #224] // 16-byte Folded Reload
1242 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #256] // 16-byte Folded Reload
1243 ; CHECK-GI-NEXT:    mov v3.h[2], v2.h[0]
1244 ; CHECK-GI-NEXT:    ldr q2, [sp, #32] // 16-byte Folded Reload
1245 ; CHECK-GI-NEXT:    ldp d15, d14, [sp, #240] // 16-byte Folded Reload
1246 ; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
1247 ; CHECK-GI-NEXT:    ldr q2, [sp, #208] // 16-byte Folded Reload
1248 ; CHECK-GI-NEXT:    mov v3.h[3], v2.h[0]
1249 ; CHECK-GI-NEXT:    ldr q2, [sp, #48] // 16-byte Folded Reload
1250 ; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
1251 ; CHECK-GI-NEXT:    ldr q2, [sp, #176] // 16-byte Folded Reload
1252 ; CHECK-GI-NEXT:    mov v3.h[4], v2.h[0]
1253 ; CHECK-GI-NEXT:    ldr q2, [sp, #64] // 16-byte Folded Reload
1254 ; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
1255 ; CHECK-GI-NEXT:    ldr q2, [sp, #144] // 16-byte Folded Reload
1256 ; CHECK-GI-NEXT:    mov v3.h[5], v2.h[0]
1257 ; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
1258 ; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
1259 ; CHECK-GI-NEXT:    fcvt h2, s0
1260 ; CHECK-GI-NEXT:    ldr q0, [sp, #112] // 16-byte Folded Reload
1261 ; CHECK-GI-NEXT:    mov v3.h[6], v0.h[0]
1262 ; CHECK-GI-NEXT:    ldr q0, [sp, #160] // 16-byte Folded Reload
1263 ; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
1264 ; CHECK-GI-NEXT:    ldr q0, [sp, #80] // 16-byte Folded Reload
1265 ; CHECK-GI-NEXT:    mov v3.h[7], v0.h[0]
1266 ; CHECK-GI-NEXT:    mov v1.h[7], v2.h[0]
1267 ; CHECK-GI-NEXT:    mov v0.16b, v3.16b
1268 ; CHECK-GI-NEXT:    add sp, sp, #320
1269 ; CHECK-GI-NEXT:    ret
1270 entry:
1271   %c = call <16 x half> @llvm.exp.v16f16(<16 x half> %a)
1272   ret <16 x half> %c
1273 }
1274
1275 define double @exp2_f64(double %a) {
1276 ; CHECK-LABEL: exp2_f64:
1277 ; CHECK:       // %bb.0: // %entry
1278 ; CHECK-NEXT:    b exp2
1279 entry:
1280   %c = call double @llvm.exp2.f64(double %a)
1281   ret double %c
1282 }
1283
1284 define float @exp2_f32(float %a) {
1285 ; CHECK-LABEL: exp2_f32:
1286 ; CHECK:       // %bb.0: // %entry
1287 ; CHECK-NEXT:    b exp2f
1288 entry:
1289   %c = call float @llvm.exp2.f32(float %a)
1290   ret float %c
1291 }
1292
1293 define half @exp2_f16(half %a) {
1294 ; CHECK-LABEL: exp2_f16:
1295 ; CHECK:       // %bb.0: // %entry
1296 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
1297 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
1298 ; CHECK-NEXT:    .cfi_offset w30, -16
1299 ; CHECK-NEXT:    fcvt s0, h0
1300 ; CHECK-NEXT:    bl exp2f
1301 ; CHECK-NEXT:    fcvt h0, s0
1302 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
1303 ; CHECK-NEXT:    ret
1304 entry:
1305   %c = call half @llvm.exp2.f16(half %a)
1306   ret half %c
1307 }
1308
1309 define <1 x double> @exp2_v1f64(<1 x double> %x) {
1310 ; CHECK-LABEL: exp2_v1f64:
1311 ; CHECK:       // %bb.0:
1312 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
1313 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
1314 ; CHECK-NEXT:    .cfi_offset w30, -16
1315 ; CHECK-NEXT:    bl exp2
1316 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
1317 ; CHECK-NEXT:    ret
1318   %c = call <1 x double> @llvm.exp2.v1f64(<1 x double> %x)
1319   ret <1 x double> %c
1320 }
1321
1322 define <2 x double> @exp2_v2f64(<2 x double> %a) {
1323 ; CHECK-SD-LABEL: exp2_v2f64:
1324 ; CHECK-SD:       // %bb.0: // %entry
1325 ; CHECK-SD-NEXT:    sub sp, sp, #48
1326 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1327 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
1328 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
1329 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1330 ; CHECK-SD-NEXT:    mov d0, v0.d[1]
1331 ; CHECK-SD-NEXT:    bl exp2
1332 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1333 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1334 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1335 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
1336 ; CHECK-SD-NEXT:    bl exp2
1337 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1338 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1339 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1340 ; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
1341 ; CHECK-SD-NEXT:    add sp, sp, #48
1342 ; CHECK-SD-NEXT:    ret
1343 ;
1344 ; CHECK-GI-LABEL: exp2_v2f64:
1345 ; CHECK-GI:       // %bb.0: // %entry
1346 ; CHECK-GI-NEXT:    sub sp, sp, #32
1347 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
1348 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
1349 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
1350 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
1351 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
1352 ; CHECK-GI-NEXT:    mov d8, v0.d[1]
1353 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
1354 ; CHECK-GI-NEXT:    bl exp2
1355 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1356 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1357 ; CHECK-GI-NEXT:    fmov d0, d8
1358 ; CHECK-GI-NEXT:    bl exp2
1359 ; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1360 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1361 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
1362 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
1363 ; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
1364 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
1365 ; CHECK-GI-NEXT:    add sp, sp, #32
1366 ; CHECK-GI-NEXT:    ret
1367 entry:
1368   %c = call <2 x double> @llvm.exp2.v2f64(<2 x double> %a)
1369   ret <2 x double> %c
1370 }
1371
1372 define <3 x double> @exp2_v3f64(<3 x double> %a) {
1373 ; CHECK-SD-LABEL: exp2_v3f64:
1374 ; CHECK-SD:       // %bb.0: // %entry
1375 ; CHECK-SD-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
1376 ; CHECK-SD-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
1377 ; CHECK-SD-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
1378 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 32
1379 ; CHECK-SD-NEXT:    .cfi_offset w30, -8
1380 ; CHECK-SD-NEXT:    .cfi_offset b8, -16
1381 ; CHECK-SD-NEXT:    .cfi_offset b9, -24
1382 ; CHECK-SD-NEXT:    .cfi_offset b10, -32
1383 ; CHECK-SD-NEXT:    fmov d8, d2
1384 ; CHECK-SD-NEXT:    fmov d9, d1
1385 ; CHECK-SD-NEXT:    bl exp2
1386 ; CHECK-SD-NEXT:    fmov d10, d0
1387 ; CHECK-SD-NEXT:    fmov d0, d9
1388 ; CHECK-SD-NEXT:    bl exp2
1389 ; CHECK-SD-NEXT:    fmov d9, d0
1390 ; CHECK-SD-NEXT:    fmov d0, d8
1391 ; CHECK-SD-NEXT:    bl exp2
1392 ; CHECK-SD-NEXT:    fmov d1, d9
1393 ; CHECK-SD-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
1394 ; CHECK-SD-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
1395 ; CHECK-SD-NEXT:    fmov d2, d0
1396 ; CHECK-SD-NEXT:    fmov d0, d10
1397 ; CHECK-SD-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
1398 ; CHECK-SD-NEXT:    ret
1399 ;
1400 ; CHECK-GI-LABEL: exp2_v3f64:
1401 ; CHECK-GI:       // %bb.0: // %entry
1402 ; CHECK-GI-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
1403 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
1404 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
1405 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
1406 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
1407 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
1408 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
1409 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
1410 ; CHECK-GI-NEXT:    fmov d8, d1
1411 ; CHECK-GI-NEXT:    fmov d9, d2
1412 ; CHECK-GI-NEXT:    bl exp2
1413 ; CHECK-GI-NEXT:    fmov d10, d0
1414 ; CHECK-GI-NEXT:    fmov d0, d8
1415 ; CHECK-GI-NEXT:    bl exp2
1416 ; CHECK-GI-NEXT:    fmov d8, d0
1417 ; CHECK-GI-NEXT:    fmov d0, d9
1418 ; CHECK-GI-NEXT:    bl exp2
1419 ; CHECK-GI-NEXT:    fmov d1, d8
1420 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
1421 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
1422 ; CHECK-GI-NEXT:    fmov d2, d0
1423 ; CHECK-GI-NEXT:    fmov d0, d10
1424 ; CHECK-GI-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
1425 ; CHECK-GI-NEXT:    ret
1426 entry:
1427   %c = call <3 x double> @llvm.exp2.v3f64(<3 x double> %a)
1428   ret <3 x double> %c
1429 }
1430
1431 define <4 x double> @exp2_v4f64(<4 x double> %a) {
1432 ; CHECK-SD-LABEL: exp2_v4f64:
1433 ; CHECK-SD:       // %bb.0: // %entry
1434 ; CHECK-SD-NEXT:    sub sp, sp, #64
1435 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
1436 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
1437 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
1438 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1439 ; CHECK-SD-NEXT:    mov d0, v0.d[1]
1440 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1441 ; CHECK-SD-NEXT:    bl exp2
1442 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1443 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1444 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1445 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
1446 ; CHECK-SD-NEXT:    bl exp2
1447 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1448 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1449 ; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
1450 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1451 ; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
1452 ; CHECK-SD-NEXT:    mov d0, v0.d[1]
1453 ; CHECK-SD-NEXT:    bl exp2
1454 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1455 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1456 ; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
1457 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
1458 ; CHECK-SD-NEXT:    bl exp2
1459 ; CHECK-SD-NEXT:    fmov d1, d0
1460 ; CHECK-SD-NEXT:    ldp q2, q0, [sp] // 32-byte Folded Reload
1461 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
1462 ; CHECK-SD-NEXT:    mov v1.d[1], v2.d[0]
1463 ; CHECK-SD-NEXT:    add sp, sp, #64
1464 ; CHECK-SD-NEXT:    ret
1465 ;
1466 ; CHECK-GI-LABEL: exp2_v4f64:
1467 ; CHECK-GI:       // %bb.0: // %entry
1468 ; CHECK-GI-NEXT:    sub sp, sp, #80
1469 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
1470 ; CHECK-GI-NEXT:    str x30, [sp, #64] // 8-byte Folded Spill
1471 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
1472 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
1473 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
1474 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
1475 ; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
1476 ; CHECK-GI-NEXT:    mov d8, v0.d[1]
1477 ; CHECK-GI-NEXT:    mov d9, v1.d[1]
1478 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
1479 ; CHECK-GI-NEXT:    bl exp2
1480 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1481 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
1482 ; CHECK-GI-NEXT:    fmov d0, d8
1483 ; CHECK-GI-NEXT:    bl exp2
1484 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1485 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1486 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1487 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
1488 ; CHECK-GI-NEXT:    bl exp2
1489 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1490 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1491 ; CHECK-GI-NEXT:    fmov d0, d9
1492 ; CHECK-GI-NEXT:    bl exp2
1493 ; CHECK-GI-NEXT:    ldp q1, q2, [sp, #16] // 32-byte Folded Reload
1494 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1495 ; CHECK-GI-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
1496 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
1497 ; CHECK-GI-NEXT:    mov v2.d[1], v1.d[0]
1498 ; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1499 ; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
1500 ; CHECK-GI-NEXT:    mov v0.16b, v2.16b
1501 ; CHECK-GI-NEXT:    add sp, sp, #80
1502 ; CHECK-GI-NEXT:    ret
1503 entry:
1504   %c = call <4 x double> @llvm.exp2.v4f64(<4 x double> %a)
1505   ret <4 x double> %c
1506 }
1507
1508 define <2 x float> @exp2_v2f32(<2 x float> %a) {
1509 ; CHECK-SD-LABEL: exp2_v2f32:
1510 ; CHECK-SD:       // %bb.0: // %entry
1511 ; CHECK-SD-NEXT:    sub sp, sp, #48
1512 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1513 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
1514 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
1515 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1516 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1517 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
1518 ; CHECK-SD-NEXT:    bl exp2f
1519 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1520 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1521 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1522 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
1523 ; CHECK-SD-NEXT:    bl exp2f
1524 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1525 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1526 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1527 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
1528 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
1529 ; CHECK-SD-NEXT:    add sp, sp, #48
1530 ; CHECK-SD-NEXT:    ret
1531 ;
1532 ; CHECK-GI-LABEL: exp2_v2f32:
1533 ; CHECK-GI:       // %bb.0: // %entry
1534 ; CHECK-GI-NEXT:    sub sp, sp, #32
1535 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
1536 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
1537 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
1538 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
1539 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
1540 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1541 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
1542 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
1543 ; CHECK-GI-NEXT:    bl exp2f
1544 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1545 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1546 ; CHECK-GI-NEXT:    fmov s0, s8
1547 ; CHECK-GI-NEXT:    bl exp2f
1548 ; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1549 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1550 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
1551 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
1552 ; CHECK-GI-NEXT:    mov v1.s[1], v0.s[0]
1553 ; CHECK-GI-NEXT:    fmov d0, d1
1554 ; CHECK-GI-NEXT:    add sp, sp, #32
1555 ; CHECK-GI-NEXT:    ret
1556 entry:
1557   %c = call <2 x float> @llvm.exp2.v2f32(<2 x float> %a)
1558   ret <2 x float> %c
1559 }
1560
1561 define <3 x float> @exp2_v3f32(<3 x float> %a) {
1562 ; CHECK-SD-LABEL: exp2_v3f32:
1563 ; CHECK-SD:       // %bb.0: // %entry
1564 ; CHECK-SD-NEXT:    sub sp, sp, #48
1565 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1566 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
1567 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
1568 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1569 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
1570 ; CHECK-SD-NEXT:    bl exp2f
1571 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1572 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1573 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1574 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
1575 ; CHECK-SD-NEXT:    bl exp2f
1576 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1577 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1578 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
1579 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1580 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1581 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
1582 ; CHECK-SD-NEXT:    bl exp2f
1583 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1584 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1585 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1586 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
1587 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
1588 ; CHECK-SD-NEXT:    add sp, sp, #48
1589 ; CHECK-SD-NEXT:    ret
1590 ;
1591 ; CHECK-GI-LABEL: exp2_v3f32:
1592 ; CHECK-GI:       // %bb.0: // %entry
1593 ; CHECK-GI-NEXT:    sub sp, sp, #64
1594 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #32] // 16-byte Folded Spill
1595 ; CHECK-GI-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
1596 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 64
1597 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
1598 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
1599 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
1600 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
1601 ; CHECK-GI-NEXT:    mov s9, v0.s[2]
1602 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
1603 ; CHECK-GI-NEXT:    bl exp2f
1604 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1605 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1606 ; CHECK-GI-NEXT:    fmov s0, s8
1607 ; CHECK-GI-NEXT:    bl exp2f
1608 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1609 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1610 ; CHECK-GI-NEXT:    fmov s0, s9
1611 ; CHECK-GI-NEXT:    bl exp2f
1612 ; CHECK-GI-NEXT:    ldp q2, q1, [sp] // 32-byte Folded Reload
1613 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1614 ; CHECK-GI-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
1615 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #32] // 16-byte Folded Reload
1616 ; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
1617 ; CHECK-GI-NEXT:    mov v1.s[2], v0.s[0]
1618 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
1619 ; CHECK-GI-NEXT:    add sp, sp, #64
1620 ; CHECK-GI-NEXT:    ret
1621 entry:
1622   %c = call <3 x float> @llvm.exp2.v3f32(<3 x float> %a)
1623   ret <3 x float> %c
1624 }
1625
1626 define <4 x float> @exp2_v4f32(<4 x float> %a) {
1627 ; CHECK-SD-LABEL: exp2_v4f32:
1628 ; CHECK-SD:       // %bb.0: // %entry
1629 ; CHECK-SD-NEXT:    sub sp, sp, #48
1630 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1631 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
1632 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
1633 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1634 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
1635 ; CHECK-SD-NEXT:    bl exp2f
1636 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1637 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1638 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1639 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
1640 ; CHECK-SD-NEXT:    bl exp2f
1641 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1642 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1643 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
1644 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1645 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1646 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
1647 ; CHECK-SD-NEXT:    bl exp2f
1648 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1649 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1650 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
1651 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1652 ; CHECK-SD-NEXT:    mov s0, v0.s[3]
1653 ; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
1654 ; CHECK-SD-NEXT:    bl exp2f
1655 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1656 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1657 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1658 ; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
1659 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
1660 ; CHECK-SD-NEXT:    add sp, sp, #48
1661 ; CHECK-SD-NEXT:    ret
1662 ;
1663 ; CHECK-GI-LABEL: exp2_v4f32:
1664 ; CHECK-GI:       // %bb.0: // %entry
1665 ; CHECK-GI-NEXT:    sub sp, sp, #80
1666 ; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
1667 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
1668 ; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
1669 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
1670 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
1671 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
1672 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
1673 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
1674 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
1675 ; CHECK-GI-NEXT:    mov s9, v0.s[2]
1676 ; CHECK-GI-NEXT:    mov s10, v0.s[3]
1677 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
1678 ; CHECK-GI-NEXT:    bl exp2f
1679 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1680 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
1681 ; CHECK-GI-NEXT:    fmov s0, s8
1682 ; CHECK-GI-NEXT:    bl exp2f
1683 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1684 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1685 ; CHECK-GI-NEXT:    fmov s0, s9
1686 ; CHECK-GI-NEXT:    bl exp2f
1687 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1688 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1689 ; CHECK-GI-NEXT:    fmov s0, s10
1690 ; CHECK-GI-NEXT:    bl exp2f
1691 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #16] // 32-byte Folded Reload
1692 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1693 ; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
1694 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
1695 ; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
1696 ; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
1697 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
1698 ; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
1699 ; CHECK-GI-NEXT:    mov v1.s[3], v0.s[0]
1700 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
1701 ; CHECK-GI-NEXT:    add sp, sp, #80
1702 ; CHECK-GI-NEXT:    ret
1703 entry:
1704   %c = call <4 x float> @llvm.exp2.v4f32(<4 x float> %a)
1705   ret <4 x float> %c
1706 }
1707
1708 define <8 x float> @exp2_v8f32(<8 x float> %a) {
1709 ; CHECK-SD-LABEL: exp2_v8f32:
1710 ; CHECK-SD:       // %bb.0: // %entry
1711 ; CHECK-SD-NEXT:    sub sp, sp, #64
1712 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
1713 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
1714 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
1715 ; CHECK-SD-NEXT:    stp q0, q1, [sp] // 32-byte Folded Spill
1716 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
1717 ; CHECK-SD-NEXT:    bl exp2f
1718 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1719 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
1720 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1721 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
1722 ; CHECK-SD-NEXT:    bl exp2f
1723 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1724 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1725 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
1726 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
1727 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1728 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
1729 ; CHECK-SD-NEXT:    bl exp2f
1730 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1731 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1732 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
1733 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1734 ; CHECK-SD-NEXT:    mov s0, v0.s[3]
1735 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1736 ; CHECK-SD-NEXT:    bl exp2f
1737 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1738 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1739 ; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
1740 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1741 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
1742 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1743 ; CHECK-SD-NEXT:    bl exp2f
1744 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1745 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1746 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1747 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
1748 ; CHECK-SD-NEXT:    bl exp2f
1749 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1750 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1751 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
1752 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1753 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1754 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
1755 ; CHECK-SD-NEXT:    bl exp2f
1756 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1757 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1758 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
1759 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1760 ; CHECK-SD-NEXT:    mov s0, v0.s[3]
1761 ; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
1762 ; CHECK-SD-NEXT:    bl exp2f
1763 ; CHECK-SD-NEXT:    fmov s2, s0
1764 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1765 ; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
1766 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
1767 ; CHECK-SD-NEXT:    mov v1.s[3], v2.s[0]
1768 ; CHECK-SD-NEXT:    add sp, sp, #64
1769 ; CHECK-SD-NEXT:    ret
1770 ;
1771 ; CHECK-GI-LABEL: exp2_v8f32:
1772 ; CHECK-GI:       // %bb.0: // %entry
1773 ; CHECK-GI-NEXT:    sub sp, sp, #176
1774 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #112] // 16-byte Folded Spill
1775 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #128] // 16-byte Folded Spill
1776 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #144] // 16-byte Folded Spill
1777 ; CHECK-GI-NEXT:    str x30, [sp, #160] // 8-byte Folded Spill
1778 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
1779 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
1780 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
1781 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
1782 ; CHECK-GI-NEXT:    .cfi_offset b10, -40
1783 ; CHECK-GI-NEXT:    .cfi_offset b11, -48
1784 ; CHECK-GI-NEXT:    .cfi_offset b12, -56
1785 ; CHECK-GI-NEXT:    .cfi_offset b13, -64
1786 ; CHECK-GI-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1787 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
1788 ; CHECK-GI-NEXT:    mov s9, v0.s[2]
1789 ; CHECK-GI-NEXT:    mov s10, v0.s[3]
1790 ; CHECK-GI-NEXT:    mov s11, v1.s[1]
1791 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
1792 ; CHECK-GI-NEXT:    mov s12, v1.s[2]
1793 ; CHECK-GI-NEXT:    mov s13, v1.s[3]
1794 ; CHECK-GI-NEXT:    bl exp2f
1795 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1796 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
1797 ; CHECK-GI-NEXT:    fmov s0, s8
1798 ; CHECK-GI-NEXT:    bl exp2f
1799 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1800 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
1801 ; CHECK-GI-NEXT:    fmov s0, s9
1802 ; CHECK-GI-NEXT:    bl exp2f
1803 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1804 ; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
1805 ; CHECK-GI-NEXT:    fmov s0, s10
1806 ; CHECK-GI-NEXT:    bl exp2f
1807 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1808 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
1809 ; CHECK-GI-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
1810 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
1811 ; CHECK-GI-NEXT:    bl exp2f
1812 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1813 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
1814 ; CHECK-GI-NEXT:    fmov s0, s11
1815 ; CHECK-GI-NEXT:    bl exp2f
1816 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1817 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1818 ; CHECK-GI-NEXT:    fmov s0, s12
1819 ; CHECK-GI-NEXT:    bl exp2f
1820 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1821 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1822 ; CHECK-GI-NEXT:    fmov s0, s13
1823 ; CHECK-GI-NEXT:    bl exp2f
1824 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #48] // 32-byte Folded Reload
1825 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1826 ; CHECK-GI-NEXT:    ldr x30, [sp, #160] // 8-byte Folded Reload
1827 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #144] // 16-byte Folded Reload
1828 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #128] // 16-byte Folded Reload
1829 ; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
1830 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
1831 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #112] // 16-byte Folded Reload
1832 ; CHECK-GI-NEXT:    mov v3.s[1], v2.s[0]
1833 ; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
1834 ; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
1835 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
1836 ; CHECK-GI-NEXT:    mov v3.s[2], v2.s[0]
1837 ; CHECK-GI-NEXT:    ldr q2, [sp, #80] // 16-byte Folded Reload
1838 ; CHECK-GI-NEXT:    mov v1.s[3], v2.s[0]
1839 ; CHECK-GI-NEXT:    mov v3.s[3], v0.s[0]
1840 ; CHECK-GI-NEXT:    mov v2.16b, v1.16b
1841 ; CHECK-GI-NEXT:    mov v1.16b, v3.16b
1842 ; CHECK-GI-NEXT:    mov v0.16b, v2.16b
1843 ; CHECK-GI-NEXT:    add sp, sp, #176
1844 ; CHECK-GI-NEXT:    ret
1845 entry:
1846   %c = call <8 x float> @llvm.exp2.v8f32(<8 x float> %a)
1847   ret <8 x float> %c
1848 }
1849
1850 define <7 x half> @exp2_v7f16(<7 x half> %a) {
1851 ; CHECK-SD-LABEL: exp2_v7f16:
1852 ; CHECK-SD:       // %bb.0: // %entry
1853 ; CHECK-SD-NEXT:    sub sp, sp, #48
1854 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1855 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
1856 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
1857 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
1858 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1859 ; CHECK-SD-NEXT:    fcvt s0, h1
1860 ; CHECK-SD-NEXT:    bl exp2f
1861 ; CHECK-SD-NEXT:    fcvt h0, s0
1862 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1863 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1864 ; CHECK-SD-NEXT:    fcvt s0, h0
1865 ; CHECK-SD-NEXT:    bl exp2f
1866 ; CHECK-SD-NEXT:    fcvt h0, s0
1867 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1868 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
1869 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1870 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1871 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
1872 ; CHECK-SD-NEXT:    fcvt s0, h0
1873 ; CHECK-SD-NEXT:    bl exp2f
1874 ; CHECK-SD-NEXT:    fcvt h0, s0
1875 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1876 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
1877 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1878 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
1879 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1880 ; CHECK-SD-NEXT:    fcvt s0, h0
1881 ; CHECK-SD-NEXT:    bl exp2f
1882 ; CHECK-SD-NEXT:    fcvt h0, s0
1883 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1884 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
1885 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1886 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
1887 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1888 ; CHECK-SD-NEXT:    fcvt s0, h0
1889 ; CHECK-SD-NEXT:    bl exp2f
1890 ; CHECK-SD-NEXT:    fcvt h0, s0
1891 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1892 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
1893 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1894 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
1895 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1896 ; CHECK-SD-NEXT:    fcvt s0, h0
1897 ; CHECK-SD-NEXT:    bl exp2f
1898 ; CHECK-SD-NEXT:    fcvt h0, s0
1899 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1900 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
1901 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1902 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
1903 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1904 ; CHECK-SD-NEXT:    fcvt s0, h0
1905 ; CHECK-SD-NEXT:    bl exp2f
1906 ; CHECK-SD-NEXT:    fcvt h0, s0
1907 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1908 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
1909 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1910 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
1911 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1912 ; CHECK-SD-NEXT:    fcvt s0, h0
1913 ; CHECK-SD-NEXT:    bl exp2f
1914 ; CHECK-SD-NEXT:    fcvt h1, s0
1915 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1916 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1917 ; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
1918 ; CHECK-SD-NEXT:    add sp, sp, #48
1919 ; CHECK-SD-NEXT:    ret
1920 ;
1921 ; CHECK-GI-LABEL: exp2_v7f16:
1922 ; CHECK-GI:       // %bb.0: // %entry
1923 ; CHECK-GI-NEXT:    sub sp, sp, #160
1924 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #96] // 16-byte Folded Spill
1925 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #112] // 16-byte Folded Spill
1926 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #128] // 16-byte Folded Spill
1927 ; CHECK-GI-NEXT:    str x30, [sp, #144] // 8-byte Folded Spill
1928 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 160
1929 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
1930 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
1931 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
1932 ; CHECK-GI-NEXT:    .cfi_offset b10, -40
1933 ; CHECK-GI-NEXT:    .cfi_offset b11, -48
1934 ; CHECK-GI-NEXT:    .cfi_offset b12, -56
1935 ; CHECK-GI-NEXT:    .cfi_offset b13, -64
1936 ; CHECK-GI-NEXT:    mov h8, v0.h[1]
1937 ; CHECK-GI-NEXT:    mov h9, v0.h[2]
1938 ; CHECK-GI-NEXT:    mov h10, v0.h[3]
1939 ; CHECK-GI-NEXT:    mov h11, v0.h[4]
1940 ; CHECK-GI-NEXT:    mov h12, v0.h[5]
1941 ; CHECK-GI-NEXT:    mov h13, v0.h[6]
1942 ; CHECK-GI-NEXT:    fcvt s0, h0
1943 ; CHECK-GI-NEXT:    bl exp2f
1944 ; CHECK-GI-NEXT:    fcvt s1, h8
1945 ; CHECK-GI-NEXT:    fcvt h0, s0
1946 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
1947 ; CHECK-GI-NEXT:    fmov s0, s1
1948 ; CHECK-GI-NEXT:    bl exp2f
1949 ; CHECK-GI-NEXT:    fcvt s1, h9
1950 ; CHECK-GI-NEXT:    fcvt h0, s0
1951 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
1952 ; CHECK-GI-NEXT:    fmov s0, s1
1953 ; CHECK-GI-NEXT:    bl exp2f
1954 ; CHECK-GI-NEXT:    fcvt s1, h10
1955 ; CHECK-GI-NEXT:    fcvt h0, s0
1956 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
1957 ; CHECK-GI-NEXT:    fmov s0, s1
1958 ; CHECK-GI-NEXT:    bl exp2f
1959 ; CHECK-GI-NEXT:    fcvt s1, h11
1960 ; CHECK-GI-NEXT:    fcvt h0, s0
1961 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
1962 ; CHECK-GI-NEXT:    fmov s0, s1
1963 ; CHECK-GI-NEXT:    bl exp2f
1964 ; CHECK-GI-NEXT:    fcvt s1, h12
1965 ; CHECK-GI-NEXT:    fcvt h0, s0
1966 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1967 ; CHECK-GI-NEXT:    fmov s0, s1
1968 ; CHECK-GI-NEXT:    bl exp2f
1969 ; CHECK-GI-NEXT:    fcvt s1, h13
1970 ; CHECK-GI-NEXT:    fcvt h0, s0
1971 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1972 ; CHECK-GI-NEXT:    fmov s0, s1
1973 ; CHECK-GI-NEXT:    bl exp2f
1974 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #64] // 32-byte Folded Reload
1975 ; CHECK-GI-NEXT:    fcvt h0, s0
1976 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #128] // 16-byte Folded Reload
1977 ; CHECK-GI-NEXT:    ldr x30, [sp, #144] // 8-byte Folded Reload
1978 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #112] // 16-byte Folded Reload
1979 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
1980 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #32] // 32-byte Folded Reload
1981 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #96] // 16-byte Folded Reload
1982 ; CHECK-GI-NEXT:    mov v1.h[2], v3.h[0]
1983 ; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
1984 ; CHECK-GI-NEXT:    ldp q2, q3, [sp] // 32-byte Folded Reload
1985 ; CHECK-GI-NEXT:    mov v1.h[4], v3.h[0]
1986 ; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
1987 ; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
1988 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
1989 ; CHECK-GI-NEXT:    add sp, sp, #160
1990 ; CHECK-GI-NEXT:    ret
1991 entry:
1992   %c = call <7 x half> @llvm.exp2.v7f16(<7 x half> %a)
1993   ret <7 x half> %c
1994 }
1995
1996 define <4 x half> @exp2_v4f16(<4 x half> %a) {
1997 ; CHECK-SD-LABEL: exp2_v4f16:
1998 ; CHECK-SD:       // %bb.0: // %entry
1999 ; CHECK-SD-NEXT:    sub sp, sp, #48
2000 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
2001 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
2002 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
2003 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
2004 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
2005 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2006 ; CHECK-SD-NEXT:    fcvt s0, h1
2007 ; CHECK-SD-NEXT:    bl exp2f
2008 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2009 ; CHECK-SD-NEXT:    fcvt h0, s0
2010 ; CHECK-SD-NEXT:    fcvt s1, h1
2011 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2012 ; CHECK-SD-NEXT:    fmov s0, s1
2013 ; CHECK-SD-NEXT:    bl exp2f
2014 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2015 ; CHECK-SD-NEXT:    fcvt h2, s0
2016 ; CHECK-SD-NEXT:    mov h1, v1.h[2]
2017 ; CHECK-SD-NEXT:    fcvt s0, h1
2018 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2019 ; CHECK-SD-NEXT:    mov v2.h[1], v1.h[0]
2020 ; CHECK-SD-NEXT:    str q2, [sp] // 16-byte Folded Spill
2021 ; CHECK-SD-NEXT:    bl exp2f
2022 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2023 ; CHECK-SD-NEXT:    fcvt h2, s0
2024 ; CHECK-SD-NEXT:    mov h1, v1.h[3]
2025 ; CHECK-SD-NEXT:    fcvt s0, h1
2026 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2027 ; CHECK-SD-NEXT:    mov v1.h[2], v2.h[0]
2028 ; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
2029 ; CHECK-SD-NEXT:    bl exp2f
2030 ; CHECK-SD-NEXT:    fcvt h1, s0
2031 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2032 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
2033 ; CHECK-SD-NEXT:    mov v0.h[3], v1.h[0]
2034 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
2035 ; CHECK-SD-NEXT:    add sp, sp, #48
2036 ; CHECK-SD-NEXT:    ret
2037 ;
2038 ; CHECK-GI-LABEL: exp2_v4f16:
2039 ; CHECK-GI:       // %bb.0: // %entry
2040 ; CHECK-GI-NEXT:    sub sp, sp, #80
2041 ; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
2042 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
2043 ; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
2044 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
2045 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
2046 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
2047 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
2048 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
2049 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
2050 ; CHECK-GI-NEXT:    mov h8, v0.h[1]
2051 ; CHECK-GI-NEXT:    mov h9, v0.h[2]
2052 ; CHECK-GI-NEXT:    mov h10, v0.h[3]
2053 ; CHECK-GI-NEXT:    fcvt s0, h0
2054 ; CHECK-GI-NEXT:    bl exp2f
2055 ; CHECK-GI-NEXT:    fcvt s1, h8
2056 ; CHECK-GI-NEXT:    fcvt h0, s0
2057 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
2058 ; CHECK-GI-NEXT:    fmov s0, s1
2059 ; CHECK-GI-NEXT:    bl exp2f
2060 ; CHECK-GI-NEXT:    fcvt s1, h9
2061 ; CHECK-GI-NEXT:    fcvt h0, s0
2062 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2063 ; CHECK-GI-NEXT:    fmov s0, s1
2064 ; CHECK-GI-NEXT:    bl exp2f
2065 ; CHECK-GI-NEXT:    fcvt s1, h10
2066 ; CHECK-GI-NEXT:    fcvt h0, s0
2067 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
2068 ; CHECK-GI-NEXT:    fmov s0, s1
2069 ; CHECK-GI-NEXT:    bl exp2f
2070 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #16] // 32-byte Folded Reload
2071 ; CHECK-GI-NEXT:    fcvt h0, s0
2072 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
2073 ; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
2074 ; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
2075 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
2076 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
2077 ; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
2078 ; CHECK-GI-NEXT:    mov v1.h[3], v0.h[0]
2079 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
2080 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
2081 ; CHECK-GI-NEXT:    add sp, sp, #80
2082 ; CHECK-GI-NEXT:    ret
2083 entry:
2084   %c = call <4 x half> @llvm.exp2.v4f16(<4 x half> %a)
2085   ret <4 x half> %c
2086 }
2087
2088 define <8 x half> @exp2_v8f16(<8 x half> %a) {
2089 ; CHECK-SD-LABEL: exp2_v8f16:
2090 ; CHECK-SD:       // %bb.0: // %entry
2091 ; CHECK-SD-NEXT:    sub sp, sp, #48
2092 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
2093 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
2094 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
2095 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
2096 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2097 ; CHECK-SD-NEXT:    fcvt s0, h1
2098 ; CHECK-SD-NEXT:    bl exp2f
2099 ; CHECK-SD-NEXT:    fcvt h0, s0
2100 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2101 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2102 ; CHECK-SD-NEXT:    fcvt s0, h0
2103 ; CHECK-SD-NEXT:    bl exp2f
2104 ; CHECK-SD-NEXT:    fcvt h0, s0
2105 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2106 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
2107 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2108 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2109 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
2110 ; CHECK-SD-NEXT:    fcvt s0, h0
2111 ; CHECK-SD-NEXT:    bl exp2f
2112 ; CHECK-SD-NEXT:    fcvt h0, s0
2113 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2114 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
2115 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2116 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
2117 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2118 ; CHECK-SD-NEXT:    fcvt s0, h0
2119 ; CHECK-SD-NEXT:    bl exp2f
2120 ; CHECK-SD-NEXT:    fcvt h0, s0
2121 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2122 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
2123 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2124 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
2125 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2126 ; CHECK-SD-NEXT:    fcvt s0, h0
2127 ; CHECK-SD-NEXT:    bl exp2f
2128 ; CHECK-SD-NEXT:    fcvt h0, s0
2129 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2130 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
2131 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2132 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
2133 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2134 ; CHECK-SD-NEXT:    fcvt s0, h0
2135 ; CHECK-SD-NEXT:    bl exp2f
2136 ; CHECK-SD-NEXT:    fcvt h0, s0
2137 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2138 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
2139 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2140 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
2141 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2142 ; CHECK-SD-NEXT:    fcvt s0, h0
2143 ; CHECK-SD-NEXT:    bl exp2f
2144 ; CHECK-SD-NEXT:    fcvt h0, s0
2145 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2146 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
2147 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2148 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
2149 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2150 ; CHECK-SD-NEXT:    fcvt s0, h0
2151 ; CHECK-SD-NEXT:    bl exp2f
2152 ; CHECK-SD-NEXT:    fcvt h1, s0
2153 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2154 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
2155 ; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
2156 ; CHECK-SD-NEXT:    add sp, sp, #48
2157 ; CHECK-SD-NEXT:    ret
2158 ;
2159 ; CHECK-GI-LABEL: exp2_v8f16:
2160 ; CHECK-GI:       // %bb.0: // %entry
2161 ; CHECK-GI-NEXT:    sub sp, sp, #176
2162 ; CHECK-GI-NEXT:    str d14, [sp, #112] // 8-byte Folded Spill
2163 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #120] // 16-byte Folded Spill
2164 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #136] // 16-byte Folded Spill
2165 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #152] // 16-byte Folded Spill
2166 ; CHECK-GI-NEXT:    str x30, [sp, #168] // 8-byte Folded Spill
2167 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
2168 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
2169 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
2170 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
2171 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
2172 ; CHECK-GI-NEXT:    .cfi_offset b11, -40
2173 ; CHECK-GI-NEXT:    .cfi_offset b12, -48
2174 ; CHECK-GI-NEXT:    .cfi_offset b13, -56
2175 ; CHECK-GI-NEXT:    .cfi_offset b14, -64
2176 ; CHECK-GI-NEXT:    mov h8, v0.h[1]
2177 ; CHECK-GI-NEXT:    mov h9, v0.h[2]
2178 ; CHECK-GI-NEXT:    mov h10, v0.h[3]
2179 ; CHECK-GI-NEXT:    mov h11, v0.h[4]
2180 ; CHECK-GI-NEXT:    mov h12, v0.h[5]
2181 ; CHECK-GI-NEXT:    mov h13, v0.h[6]
2182 ; CHECK-GI-NEXT:    mov h14, v0.h[7]
2183 ; CHECK-GI-NEXT:    fcvt s0, h0
2184 ; CHECK-GI-NEXT:    bl exp2f
2185 ; CHECK-GI-NEXT:    fcvt s1, h8
2186 ; CHECK-GI-NEXT:    fcvt h0, s0
2187 ; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
2188 ; CHECK-GI-NEXT:    fmov s0, s1
2189 ; CHECK-GI-NEXT:    bl exp2f
2190 ; CHECK-GI-NEXT:    fcvt s1, h9
2191 ; CHECK-GI-NEXT:    fcvt h0, s0
2192 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
2193 ; CHECK-GI-NEXT:    fmov s0, s1
2194 ; CHECK-GI-NEXT:    bl exp2f
2195 ; CHECK-GI-NEXT:    fcvt s1, h10
2196 ; CHECK-GI-NEXT:    fcvt h0, s0
2197 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
2198 ; CHECK-GI-NEXT:    fmov s0, s1
2199 ; CHECK-GI-NEXT:    bl exp2f
2200 ; CHECK-GI-NEXT:    fcvt s1, h11
2201 ; CHECK-GI-NEXT:    fcvt h0, s0
2202 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
2203 ; CHECK-GI-NEXT:    fmov s0, s1
2204 ; CHECK-GI-NEXT:    bl exp2f
2205 ; CHECK-GI-NEXT:    fcvt s1, h12
2206 ; CHECK-GI-NEXT:    fcvt h0, s0
2207 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
2208 ; CHECK-GI-NEXT:    fmov s0, s1
2209 ; CHECK-GI-NEXT:    bl exp2f
2210 ; CHECK-GI-NEXT:    fcvt s1, h13
2211 ; CHECK-GI-NEXT:    fcvt h0, s0
2212 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2213 ; CHECK-GI-NEXT:    fmov s0, s1
2214 ; CHECK-GI-NEXT:    bl exp2f
2215 ; CHECK-GI-NEXT:    fcvt s1, h14
2216 ; CHECK-GI-NEXT:    fcvt h0, s0
2217 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
2218 ; CHECK-GI-NEXT:    fmov s0, s1
2219 ; CHECK-GI-NEXT:    bl exp2f
2220 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #80] // 32-byte Folded Reload
2221 ; CHECK-GI-NEXT:    fcvt h0, s0
2222 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #152] // 16-byte Folded Reload
2223 ; CHECK-GI-NEXT:    ldr x30, [sp, #168] // 8-byte Folded Reload
2224 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #136] // 16-byte Folded Reload
2225 ; CHECK-GI-NEXT:    ldr d14, [sp, #112] // 8-byte Folded Reload
2226 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
2227 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #48] // 32-byte Folded Reload
2228 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #120] // 16-byte Folded Reload
2229 ; CHECK-GI-NEXT:    mov v1.h[2], v3.h[0]
2230 ; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
2231 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
2232 ; CHECK-GI-NEXT:    mov v1.h[4], v3.h[0]
2233 ; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
2234 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
2235 ; CHECK-GI-NEXT:    mov v1.h[6], v2.h[0]
2236 ; CHECK-GI-NEXT:    mov v1.h[7], v0.h[0]
2237 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
2238 ; CHECK-GI-NEXT:    add sp, sp, #176
2239 ; CHECK-GI-NEXT:    ret
2240 entry:
2241   %c = call <8 x half> @llvm.exp2.v8f16(<8 x half> %a)
2242   ret <8 x half> %c
2243 }
2244
2245 define <16 x half> @exp2_v16f16(<16 x half> %a) {
2246 ; CHECK-SD-LABEL: exp2_v16f16:
2247 ; CHECK-SD:       // %bb.0: // %entry
2248 ; CHECK-SD-NEXT:    sub sp, sp, #64
2249 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
2250 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
2251 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
2252 ; CHECK-SD-NEXT:    stp q1, q0, [sp] // 32-byte Folded Spill
2253 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
2254 ; CHECK-SD-NEXT:    fcvt s0, h1
2255 ; CHECK-SD-NEXT:    bl exp2f
2256 ; CHECK-SD-NEXT:    fcvt h0, s0
2257 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
2258 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2259 ; CHECK-SD-NEXT:    fcvt s0, h0
2260 ; CHECK-SD-NEXT:    bl exp2f
2261 ; CHECK-SD-NEXT:    fcvt h0, s0
2262 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
2263 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
2264 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
2265 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2266 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
2267 ; CHECK-SD-NEXT:    fcvt s0, h0
2268 ; CHECK-SD-NEXT:    bl exp2f
2269 ; CHECK-SD-NEXT:    fcvt h0, s0
2270 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
2271 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
2272 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2273 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
2274 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
2275 ; CHECK-SD-NEXT:    fcvt s0, h0
2276 ; CHECK-SD-NEXT:    bl exp2f
2277 ; CHECK-SD-NEXT:    fcvt h0, s0
2278 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
2279 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
2280 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2281 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
2282 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
2283 ; CHECK-SD-NEXT:    fcvt s0, h0
2284 ; CHECK-SD-NEXT:    bl exp2f
2285 ; CHECK-SD-NEXT:    fcvt h0, s0
2286 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
2287 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
2288 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2289 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
2290 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
2291 ; CHECK-SD-NEXT:    fcvt s0, h0
2292 ; CHECK-SD-NEXT:    bl exp2f
2293 ; CHECK-SD-NEXT:    fcvt h0, s0
2294 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
2295 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
2296 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2297 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
2298 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
2299 ; CHECK-SD-NEXT:    fcvt s0, h0
2300 ; CHECK-SD-NEXT:    bl exp2f
2301 ; CHECK-SD-NEXT:    fcvt h0, s0
2302 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
2303 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
2304 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2305 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
2306 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
2307 ; CHECK-SD-NEXT:    fcvt s0, h0
2308 ; CHECK-SD-NEXT:    bl exp2f
2309 ; CHECK-SD-NEXT:    fcvt h0, s0
2310 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
2311 ; CHECK-SD-NEXT:    mov v1.h[7], v0.h[0]
2312 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2313 ; CHECK-SD-NEXT:    mov h0, v0.h[1]
2314 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
2315 ; CHECK-SD-NEXT:    fcvt s0, h0
2316 ; CHECK-SD-NEXT:    bl exp2f
2317 ; CHECK-SD-NEXT:    fcvt h0, s0
2318 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2319 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2320 ; CHECK-SD-NEXT:    fcvt s0, h0
2321 ; CHECK-SD-NEXT:    bl exp2f
2322 ; CHECK-SD-NEXT:    fcvt h0, s0
2323 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2324 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
2325 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2326 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2327 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
2328 ; CHECK-SD-NEXT:    fcvt s0, h0
2329 ; CHECK-SD-NEXT:    bl exp2f
2330 ; CHECK-SD-NEXT:    fcvt h0, s0
2331 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2332 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
2333 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2334 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
2335 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2336 ; CHECK-SD-NEXT:    fcvt s0, h0
2337 ; CHECK-SD-NEXT:    bl exp2f
2338 ; CHECK-SD-NEXT:    fcvt h0, s0
2339 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2340 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
2341 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2342 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
2343 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2344 ; CHECK-SD-NEXT:    fcvt s0, h0
2345 ; CHECK-SD-NEXT:    bl exp2f
2346 ; CHECK-SD-NEXT:    fcvt h0, s0
2347 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2348 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
2349 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2350 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
2351 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2352 ; CHECK-SD-NEXT:    fcvt s0, h0
2353 ; CHECK-SD-NEXT:    bl exp2f
2354 ; CHECK-SD-NEXT:    fcvt h0, s0
2355 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2356 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
2357 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2358 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
2359 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2360 ; CHECK-SD-NEXT:    fcvt s0, h0
2361 ; CHECK-SD-NEXT:    bl exp2f
2362 ; CHECK-SD-NEXT:    fcvt h0, s0
2363 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2364 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
2365 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2366 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
2367 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2368 ; CHECK-SD-NEXT:    fcvt s0, h0
2369 ; CHECK-SD-NEXT:    bl exp2f
2370 ; CHECK-SD-NEXT:    fmov s1, s0
2371 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
2372 ; CHECK-SD-NEXT:    fcvt h2, s1
2373 ; CHECK-SD-NEXT:    ldp q1, q0, [sp, #16] // 32-byte Folded Reload
2374 ; CHECK-SD-NEXT:    mov v1.h[7], v2.h[0]
2375 ; CHECK-SD-NEXT:    add sp, sp, #64
2376 ; CHECK-SD-NEXT:    ret
2377 ;
2378 ; CHECK-GI-LABEL: exp2_v16f16:
2379 ; CHECK-GI:       // %bb.0: // %entry
2380 ; CHECK-GI-NEXT:    sub sp, sp, #320
2381 ; CHECK-GI-NEXT:    stp d15, d14, [sp, #240] // 16-byte Folded Spill
2382 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #256] // 16-byte Folded Spill
2383 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #272] // 16-byte Folded Spill
2384 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #288] // 16-byte Folded Spill
2385 ; CHECK-GI-NEXT:    stp x29, x30, [sp, #304] // 16-byte Folded Spill
2386 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 320
2387 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
2388 ; CHECK-GI-NEXT:    .cfi_offset w29, -16
2389 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
2390 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
2391 ; CHECK-GI-NEXT:    .cfi_offset b10, -40
2392 ; CHECK-GI-NEXT:    .cfi_offset b11, -48
2393 ; CHECK-GI-NEXT:    .cfi_offset b12, -56
2394 ; CHECK-GI-NEXT:    .cfi_offset b13, -64
2395 ; CHECK-GI-NEXT:    .cfi_offset b14, -72
2396 ; CHECK-GI-NEXT:    .cfi_offset b15, -80
2397 ; CHECK-GI-NEXT:    mov v2.16b, v1.16b
2398 ; CHECK-GI-NEXT:    str q1, [sp, #80] // 16-byte Folded Spill
2399 ; CHECK-GI-NEXT:    mov h14, v1.h[1]
2400 ; CHECK-GI-NEXT:    mov h1, v1.h[2]
2401 ; CHECK-GI-NEXT:    mov h15, v0.h[1]
2402 ; CHECK-GI-NEXT:    mov h8, v0.h[2]
2403 ; CHECK-GI-NEXT:    mov h9, v0.h[3]
2404 ; CHECK-GI-NEXT:    mov h10, v0.h[4]
2405 ; CHECK-GI-NEXT:    mov h11, v0.h[5]
2406 ; CHECK-GI-NEXT:    mov h12, v0.h[6]
2407 ; CHECK-GI-NEXT:    mov h13, v0.h[7]
2408 ; CHECK-GI-NEXT:    fcvt s0, h0
2409 ; CHECK-GI-NEXT:    str h1, [sp, #16] // 2-byte Folded Spill
2410 ; CHECK-GI-NEXT:    mov h1, v2.h[3]
2411 ; CHECK-GI-NEXT:    str h1, [sp, #32] // 2-byte Folded Spill
2412 ; CHECK-GI-NEXT:    mov h1, v2.h[4]
2413 ; CHECK-GI-NEXT:    str h1, [sp, #48] // 2-byte Folded Spill
2414 ; CHECK-GI-NEXT:    mov h1, v2.h[5]
2415 ; CHECK-GI-NEXT:    str h1, [sp, #64] // 2-byte Folded Spill
2416 ; CHECK-GI-NEXT:    mov h1, v2.h[6]
2417 ; CHECK-GI-NEXT:    str h1, [sp, #96] // 2-byte Folded Spill
2418 ; CHECK-GI-NEXT:    mov h1, v2.h[7]
2419 ; CHECK-GI-NEXT:    str h1, [sp, #160] // 2-byte Folded Spill
2420 ; CHECK-GI-NEXT:    bl exp2f
2421 ; CHECK-GI-NEXT:    fcvt s1, h15
2422 ; CHECK-GI-NEXT:    fcvt h0, s0
2423 ; CHECK-GI-NEXT:    str q0, [sp, #192] // 16-byte Folded Spill
2424 ; CHECK-GI-NEXT:    fmov s0, s1
2425 ; CHECK-GI-NEXT:    bl exp2f
2426 ; CHECK-GI-NEXT:    fcvt s1, h8
2427 ; CHECK-GI-NEXT:    fcvt h0, s0
2428 ; CHECK-GI-NEXT:    str q0, [sp, #128] // 16-byte Folded Spill
2429 ; CHECK-GI-NEXT:    fmov s0, s1
2430 ; CHECK-GI-NEXT:    bl exp2f
2431 ; CHECK-GI-NEXT:    fcvt s1, h9
2432 ; CHECK-GI-NEXT:    fcvt h0, s0
2433 ; CHECK-GI-NEXT:    str q0, [sp, #224] // 16-byte Folded Spill
2434 ; CHECK-GI-NEXT:    fmov s0, s1
2435 ; CHECK-GI-NEXT:    bl exp2f
2436 ; CHECK-GI-NEXT:    fcvt s1, h10
2437 ; CHECK-GI-NEXT:    fcvt h0, s0
2438 ; CHECK-GI-NEXT:    str q0, [sp, #208] // 16-byte Folded Spill
2439 ; CHECK-GI-NEXT:    fmov s0, s1
2440 ; CHECK-GI-NEXT:    bl exp2f
2441 ; CHECK-GI-NEXT:    fcvt s1, h11
2442 ; CHECK-GI-NEXT:    fcvt h0, s0
2443 ; CHECK-GI-NEXT:    str q0, [sp, #176] // 16-byte Folded Spill
2444 ; CHECK-GI-NEXT:    fmov s0, s1
2445 ; CHECK-GI-NEXT:    bl exp2f
2446 ; CHECK-GI-NEXT:    fcvt s1, h12
2447 ; CHECK-GI-NEXT:    fcvt h0, s0
2448 ; CHECK-GI-NEXT:    str q0, [sp, #144] // 16-byte Folded Spill
2449 ; CHECK-GI-NEXT:    fmov s0, s1
2450 ; CHECK-GI-NEXT:    bl exp2f
2451 ; CHECK-GI-NEXT:    fcvt s1, h13
2452 ; CHECK-GI-NEXT:    fcvt h0, s0
2453 ; CHECK-GI-NEXT:    str q0, [sp, #112] // 16-byte Folded Spill
2454 ; CHECK-GI-NEXT:    fmov s0, s1
2455 ; CHECK-GI-NEXT:    bl exp2f
2456 ; CHECK-GI-NEXT:    ldr q1, [sp, #80] // 16-byte Folded Reload
2457 ; CHECK-GI-NEXT:    fcvt h0, s0
2458 ; CHECK-GI-NEXT:    fcvt s1, h1
2459 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
2460 ; CHECK-GI-NEXT:    fmov s0, s1
2461 ; CHECK-GI-NEXT:    bl exp2f
2462 ; CHECK-GI-NEXT:    fcvt s1, h14
2463 ; CHECK-GI-NEXT:    fcvt h0, s0
2464 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
2465 ; CHECK-GI-NEXT:    fmov s0, s1
2466 ; CHECK-GI-NEXT:    bl exp2f
2467 ; CHECK-GI-NEXT:    ldr h1, [sp, #16] // 2-byte Folded Reload
2468 ; CHECK-GI-NEXT:    fcvt h0, s0
2469 ; CHECK-GI-NEXT:    fcvt s1, h1
2470 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2471 ; CHECK-GI-NEXT:    fmov s0, s1
2472 ; CHECK-GI-NEXT:    bl exp2f
2473 ; CHECK-GI-NEXT:    ldr h1, [sp, #32] // 2-byte Folded Reload
2474 ; CHECK-GI-NEXT:    fcvt h0, s0
2475 ; CHECK-GI-NEXT:    fcvt s1, h1
2476 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
2477 ; CHECK-GI-NEXT:    fmov s0, s1
2478 ; CHECK-GI-NEXT:    bl exp2f
2479 ; CHECK-GI-NEXT:    ldr h1, [sp, #48] // 2-byte Folded Reload
2480 ; CHECK-GI-NEXT:    fcvt h0, s0
2481 ; CHECK-GI-NEXT:    fcvt s1, h1
2482 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
2483 ; CHECK-GI-NEXT:    fmov s0, s1
2484 ; CHECK-GI-NEXT:    bl exp2f
2485 ; CHECK-GI-NEXT:    ldr h1, [sp, #64] // 2-byte Folded Reload
2486 ; CHECK-GI-NEXT:    fcvt h0, s0
2487 ; CHECK-GI-NEXT:    fcvt s1, h1
2488 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
2489 ; CHECK-GI-NEXT:    fmov s0, s1
2490 ; CHECK-GI-NEXT:    bl exp2f
2491 ; CHECK-GI-NEXT:    ldr h1, [sp, #96] // 2-byte Folded Reload
2492 ; CHECK-GI-NEXT:    fcvt h0, s0
2493 ; CHECK-GI-NEXT:    fcvt s1, h1
2494 ; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
2495 ; CHECK-GI-NEXT:    fmov s0, s1
2496 ; CHECK-GI-NEXT:    bl exp2f
2497 ; CHECK-GI-NEXT:    ldr h1, [sp, #160] // 2-byte Folded Reload
2498 ; CHECK-GI-NEXT:    fcvt h0, s0
2499 ; CHECK-GI-NEXT:    fcvt s1, h1
2500 ; CHECK-GI-NEXT:    str q0, [sp, #160] // 16-byte Folded Spill
2501 ; CHECK-GI-NEXT:    fmov s0, s1
2502 ; CHECK-GI-NEXT:    bl exp2f
2503 ; CHECK-GI-NEXT:    ldr q3, [sp, #192] // 16-byte Folded Reload
2504 ; CHECK-GI-NEXT:    ldr q2, [sp, #128] // 16-byte Folded Reload
2505 ; CHECK-GI-NEXT:    ldp x29, x30, [sp, #304] // 16-byte Folded Reload
2506 ; CHECK-GI-NEXT:    mov v3.h[1], v2.h[0]
2507 ; CHECK-GI-NEXT:    ldp q1, q2, [sp] // 32-byte Folded Reload
2508 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #288] // 16-byte Folded Reload
2509 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #272] // 16-byte Folded Reload
2510 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
2511 ; CHECK-GI-NEXT:    ldr q2, [sp, #224] // 16-byte Folded Reload
2512 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #256] // 16-byte Folded Reload
2513 ; CHECK-GI-NEXT:    mov v3.h[2], v2.h[0]
2514 ; CHECK-GI-NEXT:    ldr q2, [sp, #32] // 16-byte Folded Reload
2515 ; CHECK-GI-NEXT:    ldp d15, d14, [sp, #240] // 16-byte Folded Reload
2516 ; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
2517 ; CHECK-GI-NEXT:    ldr q2, [sp, #208] // 16-byte Folded Reload
2518 ; CHECK-GI-NEXT:    mov v3.h[3], v2.h[0]
2519 ; CHECK-GI-NEXT:    ldr q2, [sp, #48] // 16-byte Folded Reload
2520 ; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
2521 ; CHECK-GI-NEXT:    ldr q2, [sp, #176] // 16-byte Folded Reload
2522 ; CHECK-GI-NEXT:    mov v3.h[4], v2.h[0]
2523 ; CHECK-GI-NEXT:    ldr q2, [sp, #64] // 16-byte Folded Reload
2524 ; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
2525 ; CHECK-GI-NEXT:    ldr q2, [sp, #144] // 16-byte Folded Reload
2526 ; CHECK-GI-NEXT:    mov v3.h[5], v2.h[0]
2527 ; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
2528 ; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
2529 ; CHECK-GI-NEXT:    fcvt h2, s0
2530 ; CHECK-GI-NEXT:    ldr q0, [sp, #112] // 16-byte Folded Reload
2531 ; CHECK-GI-NEXT:    mov v3.h[6], v0.h[0]
2532 ; CHECK-GI-NEXT:    ldr q0, [sp, #160] // 16-byte Folded Reload
2533 ; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
2534 ; CHECK-GI-NEXT:    ldr q0, [sp, #80] // 16-byte Folded Reload
2535 ; CHECK-GI-NEXT:    mov v3.h[7], v0.h[0]
2536 ; CHECK-GI-NEXT:    mov v1.h[7], v2.h[0]
2537 ; CHECK-GI-NEXT:    mov v0.16b, v3.16b
2538 ; CHECK-GI-NEXT:    add sp, sp, #320
2539 ; CHECK-GI-NEXT:    ret
2540 entry:
2541   %c = call <16 x half> @llvm.exp2.v16f16(<16 x half> %a)
2542   ret <16 x half> %c
2543 }
2544
2545 define double @log_f64(double %a) {
2546 ; CHECK-LABEL: log_f64:
2547 ; CHECK:       // %bb.0: // %entry
2548 ; CHECK-NEXT:    b log
2549 entry:
2550   %c = call double @llvm.log.f64(double %a)
2551   ret double %c
2552 }
2553
2554 define float @log_f32(float %a) {
2555 ; CHECK-LABEL: log_f32:
2556 ; CHECK:       // %bb.0: // %entry
2557 ; CHECK-NEXT:    b logf
2558 entry:
2559   %c = call float @llvm.log.f32(float %a)
2560   ret float %c
2561 }
2562
2563 define half @log_f16(half %a) {
2564 ; CHECK-LABEL: log_f16:
2565 ; CHECK:       // %bb.0: // %entry
2566 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
2567 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
2568 ; CHECK-NEXT:    .cfi_offset w30, -16
2569 ; CHECK-NEXT:    fcvt s0, h0
2570 ; CHECK-NEXT:    bl logf
2571 ; CHECK-NEXT:    fcvt h0, s0
2572 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
2573 ; CHECK-NEXT:    ret
2574 entry:
2575   %c = call half @llvm.log.f16(half %a)
2576   ret half %c
2577 }
2578
2579 define <1 x double> @log_v1f64(<1 x double> %x) {
2580 ; CHECK-LABEL: log_v1f64:
2581 ; CHECK:       // %bb.0:
2582 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
2583 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
2584 ; CHECK-NEXT:    .cfi_offset w30, -16
2585 ; CHECK-NEXT:    bl log
2586 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
2587 ; CHECK-NEXT:    ret
2588   %c = call <1 x double> @llvm.log.v1f64(<1 x double> %x)
2589   ret <1 x double> %c
2590 }
2591
2592 define <2 x double> @log_v2f64(<2 x double> %a) {
2593 ; CHECK-SD-LABEL: log_v2f64:
2594 ; CHECK-SD:       // %bb.0: // %entry
2595 ; CHECK-SD-NEXT:    sub sp, sp, #48
2596 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
2597 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
2598 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
2599 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2600 ; CHECK-SD-NEXT:    mov d0, v0.d[1]
2601 ; CHECK-SD-NEXT:    bl log
2602 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
2603 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2604 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2605 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
2606 ; CHECK-SD-NEXT:    bl log
2607 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2608 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
2609 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
2610 ; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
2611 ; CHECK-SD-NEXT:    add sp, sp, #48
2612 ; CHECK-SD-NEXT:    ret
2613 ;
2614 ; CHECK-GI-LABEL: log_v2f64:
2615 ; CHECK-GI:       // %bb.0: // %entry
2616 ; CHECK-GI-NEXT:    sub sp, sp, #32
2617 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
2618 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
2619 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
2620 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
2621 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
2622 ; CHECK-GI-NEXT:    mov d8, v0.d[1]
2623 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
2624 ; CHECK-GI-NEXT:    bl log
2625 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
2626 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
2627 ; CHECK-GI-NEXT:    fmov d0, d8
2628 ; CHECK-GI-NEXT:    bl log
2629 ; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2630 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
2631 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
2632 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
2633 ; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
2634 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
2635 ; CHECK-GI-NEXT:    add sp, sp, #32
2636 ; CHECK-GI-NEXT:    ret
2637 entry:
2638   %c = call <2 x double> @llvm.log.v2f64(<2 x double> %a)
2639   ret <2 x double> %c
2640 }
2641
2642 define <3 x double> @log_v3f64(<3 x double> %a) {
2643 ; CHECK-SD-LABEL: log_v3f64:
2644 ; CHECK-SD:       // %bb.0: // %entry
2645 ; CHECK-SD-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
2646 ; CHECK-SD-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
2647 ; CHECK-SD-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
2648 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 32
2649 ; CHECK-SD-NEXT:    .cfi_offset w30, -8
2650 ; CHECK-SD-NEXT:    .cfi_offset b8, -16
2651 ; CHECK-SD-NEXT:    .cfi_offset b9, -24
2652 ; CHECK-SD-NEXT:    .cfi_offset b10, -32
2653 ; CHECK-SD-NEXT:    fmov d8, d2
2654 ; CHECK-SD-NEXT:    fmov d9, d1
2655 ; CHECK-SD-NEXT:    bl log
2656 ; CHECK-SD-NEXT:    fmov d10, d0
2657 ; CHECK-SD-NEXT:    fmov d0, d9
2658 ; CHECK-SD-NEXT:    bl log
2659 ; CHECK-SD-NEXT:    fmov d9, d0
2660 ; CHECK-SD-NEXT:    fmov d0, d8
2661 ; CHECK-SD-NEXT:    bl log
2662 ; CHECK-SD-NEXT:    fmov d1, d9
2663 ; CHECK-SD-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
2664 ; CHECK-SD-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
2665 ; CHECK-SD-NEXT:    fmov d2, d0
2666 ; CHECK-SD-NEXT:    fmov d0, d10
2667 ; CHECK-SD-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
2668 ; CHECK-SD-NEXT:    ret
2669 ;
2670 ; CHECK-GI-LABEL: log_v3f64:
2671 ; CHECK-GI:       // %bb.0: // %entry
2672 ; CHECK-GI-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
2673 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
2674 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
2675 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
2676 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
2677 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
2678 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
2679 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
2680 ; CHECK-GI-NEXT:    fmov d8, d1
2681 ; CHECK-GI-NEXT:    fmov d9, d2
2682 ; CHECK-GI-NEXT:    bl log
2683 ; CHECK-GI-NEXT:    fmov d10, d0
2684 ; CHECK-GI-NEXT:    fmov d0, d8
2685 ; CHECK-GI-NEXT:    bl log
2686 ; CHECK-GI-NEXT:    fmov d8, d0
2687 ; CHECK-GI-NEXT:    fmov d0, d9
2688 ; CHECK-GI-NEXT:    bl log
2689 ; CHECK-GI-NEXT:    fmov d1, d8
2690 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
2691 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
2692 ; CHECK-GI-NEXT:    fmov d2, d0
2693 ; CHECK-GI-NEXT:    fmov d0, d10
2694 ; CHECK-GI-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
2695 ; CHECK-GI-NEXT:    ret
2696 entry:
2697   %c = call <3 x double> @llvm.log.v3f64(<3 x double> %a)
2698   ret <3 x double> %c
2699 }
2700
2701 define <4 x double> @log_v4f64(<4 x double> %a) {
2702 ; CHECK-SD-LABEL: log_v4f64:
2703 ; CHECK-SD:       // %bb.0: // %entry
2704 ; CHECK-SD-NEXT:    sub sp, sp, #64
2705 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
2706 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
2707 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
2708 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2709 ; CHECK-SD-NEXT:    mov d0, v0.d[1]
2710 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
2711 ; CHECK-SD-NEXT:    bl log
2712 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
2713 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2714 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2715 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
2716 ; CHECK-SD-NEXT:    bl log
2717 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2718 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
2719 ; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
2720 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2721 ; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
2722 ; CHECK-SD-NEXT:    mov d0, v0.d[1]
2723 ; CHECK-SD-NEXT:    bl log
2724 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
2725 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2726 ; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
2727 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
2728 ; CHECK-SD-NEXT:    bl log
2729 ; CHECK-SD-NEXT:    fmov d1, d0
2730 ; CHECK-SD-NEXT:    ldp q2, q0, [sp] // 32-byte Folded Reload
2731 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
2732 ; CHECK-SD-NEXT:    mov v1.d[1], v2.d[0]
2733 ; CHECK-SD-NEXT:    add sp, sp, #64
2734 ; CHECK-SD-NEXT:    ret
2735 ;
2736 ; CHECK-GI-LABEL: log_v4f64:
2737 ; CHECK-GI:       // %bb.0: // %entry
2738 ; CHECK-GI-NEXT:    sub sp, sp, #80
2739 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
2740 ; CHECK-GI-NEXT:    str x30, [sp, #64] // 8-byte Folded Spill
2741 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
2742 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
2743 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
2744 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
2745 ; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
2746 ; CHECK-GI-NEXT:    mov d8, v0.d[1]
2747 ; CHECK-GI-NEXT:    mov d9, v1.d[1]
2748 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
2749 ; CHECK-GI-NEXT:    bl log
2750 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
2751 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
2752 ; CHECK-GI-NEXT:    fmov d0, d8
2753 ; CHECK-GI-NEXT:    bl log
2754 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
2755 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2756 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2757 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
2758 ; CHECK-GI-NEXT:    bl log
2759 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
2760 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
2761 ; CHECK-GI-NEXT:    fmov d0, d9
2762 ; CHECK-GI-NEXT:    bl log
2763 ; CHECK-GI-NEXT:    ldp q1, q2, [sp, #16] // 32-byte Folded Reload
2764 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
2765 ; CHECK-GI-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
2766 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
2767 ; CHECK-GI-NEXT:    mov v2.d[1], v1.d[0]
2768 ; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2769 ; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
2770 ; CHECK-GI-NEXT:    mov v0.16b, v2.16b
2771 ; CHECK-GI-NEXT:    add sp, sp, #80
2772 ; CHECK-GI-NEXT:    ret
2773 entry:
2774   %c = call <4 x double> @llvm.log.v4f64(<4 x double> %a)
2775   ret <4 x double> %c
2776 }
2777
2778 define <2 x float> @log_v2f32(<2 x float> %a) {
2779 ; CHECK-SD-LABEL: log_v2f32:
2780 ; CHECK-SD:       // %bb.0: // %entry
2781 ; CHECK-SD-NEXT:    sub sp, sp, #48
2782 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
2783 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
2784 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
2785 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
2786 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2787 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
2788 ; CHECK-SD-NEXT:    bl logf
2789 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2790 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2791 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2792 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
2793 ; CHECK-SD-NEXT:    bl logf
2794 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2795 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2796 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
2797 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
2798 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
2799 ; CHECK-SD-NEXT:    add sp, sp, #48
2800 ; CHECK-SD-NEXT:    ret
2801 ;
2802 ; CHECK-GI-LABEL: log_v2f32:
2803 ; CHECK-GI:       // %bb.0: // %entry
2804 ; CHECK-GI-NEXT:    sub sp, sp, #32
2805 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
2806 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
2807 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
2808 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
2809 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
2810 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
2811 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
2812 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
2813 ; CHECK-GI-NEXT:    bl logf
2814 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
2815 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
2816 ; CHECK-GI-NEXT:    fmov s0, s8
2817 ; CHECK-GI-NEXT:    bl logf
2818 ; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2819 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
2820 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
2821 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
2822 ; CHECK-GI-NEXT:    mov v1.s[1], v0.s[0]
2823 ; CHECK-GI-NEXT:    fmov d0, d1
2824 ; CHECK-GI-NEXT:    add sp, sp, #32
2825 ; CHECK-GI-NEXT:    ret
2826 entry:
2827   %c = call <2 x float> @llvm.log.v2f32(<2 x float> %a)
2828   ret <2 x float> %c
2829 }
2830
2831 define <3 x float> @log_v3f32(<3 x float> %a) {
2832 ; CHECK-SD-LABEL: log_v3f32:
2833 ; CHECK-SD:       // %bb.0: // %entry
2834 ; CHECK-SD-NEXT:    sub sp, sp, #48
2835 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
2836 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
2837 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
2838 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2839 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
2840 ; CHECK-SD-NEXT:    bl logf
2841 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2842 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2843 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2844 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
2845 ; CHECK-SD-NEXT:    bl logf
2846 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2847 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2848 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
2849 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2850 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2851 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
2852 ; CHECK-SD-NEXT:    bl logf
2853 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2854 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2855 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
2856 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
2857 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
2858 ; CHECK-SD-NEXT:    add sp, sp, #48
2859 ; CHECK-SD-NEXT:    ret
2860 ;
2861 ; CHECK-GI-LABEL: log_v3f32:
2862 ; CHECK-GI:       // %bb.0: // %entry
2863 ; CHECK-GI-NEXT:    sub sp, sp, #64
2864 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #32] // 16-byte Folded Spill
2865 ; CHECK-GI-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
2866 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 64
2867 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
2868 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
2869 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
2870 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
2871 ; CHECK-GI-NEXT:    mov s9, v0.s[2]
2872 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
2873 ; CHECK-GI-NEXT:    bl logf
2874 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
2875 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2876 ; CHECK-GI-NEXT:    fmov s0, s8
2877 ; CHECK-GI-NEXT:    bl logf
2878 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
2879 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
2880 ; CHECK-GI-NEXT:    fmov s0, s9
2881 ; CHECK-GI-NEXT:    bl logf
2882 ; CHECK-GI-NEXT:    ldp q2, q1, [sp] // 32-byte Folded Reload
2883 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
2884 ; CHECK-GI-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
2885 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #32] // 16-byte Folded Reload
2886 ; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
2887 ; CHECK-GI-NEXT:    mov v1.s[2], v0.s[0]
2888 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
2889 ; CHECK-GI-NEXT:    add sp, sp, #64
2890 ; CHECK-GI-NEXT:    ret
2891 entry:
2892   %c = call <3 x float> @llvm.log.v3f32(<3 x float> %a)
2893   ret <3 x float> %c
2894 }
2895
2896 define <4 x float> @log_v4f32(<4 x float> %a) {
2897 ; CHECK-SD-LABEL: log_v4f32:
2898 ; CHECK-SD:       // %bb.0: // %entry
2899 ; CHECK-SD-NEXT:    sub sp, sp, #48
2900 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
2901 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
2902 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
2903 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2904 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
2905 ; CHECK-SD-NEXT:    bl logf
2906 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2907 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2908 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2909 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
2910 ; CHECK-SD-NEXT:    bl logf
2911 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2912 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2913 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
2914 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2915 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2916 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
2917 ; CHECK-SD-NEXT:    bl logf
2918 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2919 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2920 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
2921 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2922 ; CHECK-SD-NEXT:    mov s0, v0.s[3]
2923 ; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
2924 ; CHECK-SD-NEXT:    bl logf
2925 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2926 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2927 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
2928 ; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
2929 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
2930 ; CHECK-SD-NEXT:    add sp, sp, #48
2931 ; CHECK-SD-NEXT:    ret
2932 ;
2933 ; CHECK-GI-LABEL: log_v4f32:
2934 ; CHECK-GI:       // %bb.0: // %entry
2935 ; CHECK-GI-NEXT:    sub sp, sp, #80
2936 ; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
2937 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
2938 ; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
2939 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
2940 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
2941 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
2942 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
2943 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
2944 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
2945 ; CHECK-GI-NEXT:    mov s9, v0.s[2]
2946 ; CHECK-GI-NEXT:    mov s10, v0.s[3]
2947 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
2948 ; CHECK-GI-NEXT:    bl logf
2949 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
2950 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
2951 ; CHECK-GI-NEXT:    fmov s0, s8
2952 ; CHECK-GI-NEXT:    bl logf
2953 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
2954 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2955 ; CHECK-GI-NEXT:    fmov s0, s9
2956 ; CHECK-GI-NEXT:    bl logf
2957 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
2958 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
2959 ; CHECK-GI-NEXT:    fmov s0, s10
2960 ; CHECK-GI-NEXT:    bl logf
2961 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #16] // 32-byte Folded Reload
2962 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
2963 ; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
2964 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
2965 ; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
2966 ; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
2967 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
2968 ; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
2969 ; CHECK-GI-NEXT:    mov v1.s[3], v0.s[0]
2970 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
2971 ; CHECK-GI-NEXT:    add sp, sp, #80
2972 ; CHECK-GI-NEXT:    ret
2973 entry:
2974   %c = call <4 x float> @llvm.log.v4f32(<4 x float> %a)
2975   ret <4 x float> %c
2976 }
2977
2978 define <8 x float> @log_v8f32(<8 x float> %a) {
2979 ; CHECK-SD-LABEL: log_v8f32:
2980 ; CHECK-SD:       // %bb.0: // %entry
2981 ; CHECK-SD-NEXT:    sub sp, sp, #64
2982 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
2983 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
2984 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
2985 ; CHECK-SD-NEXT:    stp q0, q1, [sp] // 32-byte Folded Spill
2986 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
2987 ; CHECK-SD-NEXT:    bl logf
2988 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2989 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
2990 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2991 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
2992 ; CHECK-SD-NEXT:    bl logf
2993 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
2994 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2995 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
2996 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
2997 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2998 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
2999 ; CHECK-SD-NEXT:    bl logf
3000 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3001 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
3002 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
3003 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3004 ; CHECK-SD-NEXT:    mov s0, v0.s[3]
3005 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3006 ; CHECK-SD-NEXT:    bl logf
3007 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3008 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
3009 ; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
3010 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3011 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
3012 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3013 ; CHECK-SD-NEXT:    bl logf
3014 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
3015 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
3016 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3017 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
3018 ; CHECK-SD-NEXT:    bl logf
3019 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
3020 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
3021 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
3022 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
3023 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3024 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
3025 ; CHECK-SD-NEXT:    bl logf
3026 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
3027 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
3028 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
3029 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3030 ; CHECK-SD-NEXT:    mov s0, v0.s[3]
3031 ; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
3032 ; CHECK-SD-NEXT:    bl logf
3033 ; CHECK-SD-NEXT:    fmov s2, s0
3034 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
3035 ; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
3036 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
3037 ; CHECK-SD-NEXT:    mov v1.s[3], v2.s[0]
3038 ; CHECK-SD-NEXT:    add sp, sp, #64
3039 ; CHECK-SD-NEXT:    ret
3040 ;
3041 ; CHECK-GI-LABEL: log_v8f32:
3042 ; CHECK-GI:       // %bb.0: // %entry
3043 ; CHECK-GI-NEXT:    sub sp, sp, #176
3044 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #112] // 16-byte Folded Spill
3045 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #128] // 16-byte Folded Spill
3046 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #144] // 16-byte Folded Spill
3047 ; CHECK-GI-NEXT:    str x30, [sp, #160] // 8-byte Folded Spill
3048 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
3049 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
3050 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
3051 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
3052 ; CHECK-GI-NEXT:    .cfi_offset b10, -40
3053 ; CHECK-GI-NEXT:    .cfi_offset b11, -48
3054 ; CHECK-GI-NEXT:    .cfi_offset b12, -56
3055 ; CHECK-GI-NEXT:    .cfi_offset b13, -64
3056 ; CHECK-GI-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3057 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
3058 ; CHECK-GI-NEXT:    mov s9, v0.s[2]
3059 ; CHECK-GI-NEXT:    mov s10, v0.s[3]
3060 ; CHECK-GI-NEXT:    mov s11, v1.s[1]
3061 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
3062 ; CHECK-GI-NEXT:    mov s12, v1.s[2]
3063 ; CHECK-GI-NEXT:    mov s13, v1.s[3]
3064 ; CHECK-GI-NEXT:    bl logf
3065 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3066 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
3067 ; CHECK-GI-NEXT:    fmov s0, s8
3068 ; CHECK-GI-NEXT:    bl logf
3069 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3070 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
3071 ; CHECK-GI-NEXT:    fmov s0, s9
3072 ; CHECK-GI-NEXT:    bl logf
3073 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3074 ; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
3075 ; CHECK-GI-NEXT:    fmov s0, s10
3076 ; CHECK-GI-NEXT:    bl logf
3077 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3078 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
3079 ; CHECK-GI-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
3080 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
3081 ; CHECK-GI-NEXT:    bl logf
3082 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3083 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3084 ; CHECK-GI-NEXT:    fmov s0, s11
3085 ; CHECK-GI-NEXT:    bl logf
3086 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3087 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3088 ; CHECK-GI-NEXT:    fmov s0, s12
3089 ; CHECK-GI-NEXT:    bl logf
3090 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3091 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
3092 ; CHECK-GI-NEXT:    fmov s0, s13
3093 ; CHECK-GI-NEXT:    bl logf
3094 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #48] // 32-byte Folded Reload
3095 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3096 ; CHECK-GI-NEXT:    ldr x30, [sp, #160] // 8-byte Folded Reload
3097 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #144] // 16-byte Folded Reload
3098 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #128] // 16-byte Folded Reload
3099 ; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
3100 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
3101 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #112] // 16-byte Folded Reload
3102 ; CHECK-GI-NEXT:    mov v3.s[1], v2.s[0]
3103 ; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
3104 ; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
3105 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
3106 ; CHECK-GI-NEXT:    mov v3.s[2], v2.s[0]
3107 ; CHECK-GI-NEXT:    ldr q2, [sp, #80] // 16-byte Folded Reload
3108 ; CHECK-GI-NEXT:    mov v1.s[3], v2.s[0]
3109 ; CHECK-GI-NEXT:    mov v3.s[3], v0.s[0]
3110 ; CHECK-GI-NEXT:    mov v2.16b, v1.16b
3111 ; CHECK-GI-NEXT:    mov v1.16b, v3.16b
3112 ; CHECK-GI-NEXT:    mov v0.16b, v2.16b
3113 ; CHECK-GI-NEXT:    add sp, sp, #176
3114 ; CHECK-GI-NEXT:    ret
3115 entry:
3116   %c = call <8 x float> @llvm.log.v8f32(<8 x float> %a)
3117   ret <8 x float> %c
3118 }
3119
3120 define <7 x half> @log_v7f16(<7 x half> %a) {
3121 ; CHECK-SD-LABEL: log_v7f16:
3122 ; CHECK-SD:       // %bb.0: // %entry
3123 ; CHECK-SD-NEXT:    sub sp, sp, #48
3124 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
3125 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
3126 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
3127 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
3128 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
3129 ; CHECK-SD-NEXT:    fcvt s0, h1
3130 ; CHECK-SD-NEXT:    bl logf
3131 ; CHECK-SD-NEXT:    fcvt h0, s0
3132 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3133 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3134 ; CHECK-SD-NEXT:    fcvt s0, h0
3135 ; CHECK-SD-NEXT:    bl logf
3136 ; CHECK-SD-NEXT:    fcvt h0, s0
3137 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3138 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
3139 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3140 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3141 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
3142 ; CHECK-SD-NEXT:    fcvt s0, h0
3143 ; CHECK-SD-NEXT:    bl logf
3144 ; CHECK-SD-NEXT:    fcvt h0, s0
3145 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3146 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
3147 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3148 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
3149 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3150 ; CHECK-SD-NEXT:    fcvt s0, h0
3151 ; CHECK-SD-NEXT:    bl logf
3152 ; CHECK-SD-NEXT:    fcvt h0, s0
3153 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3154 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
3155 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3156 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
3157 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3158 ; CHECK-SD-NEXT:    fcvt s0, h0
3159 ; CHECK-SD-NEXT:    bl logf
3160 ; CHECK-SD-NEXT:    fcvt h0, s0
3161 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3162 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
3163 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3164 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
3165 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3166 ; CHECK-SD-NEXT:    fcvt s0, h0
3167 ; CHECK-SD-NEXT:    bl logf
3168 ; CHECK-SD-NEXT:    fcvt h0, s0
3169 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3170 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
3171 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3172 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
3173 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3174 ; CHECK-SD-NEXT:    fcvt s0, h0
3175 ; CHECK-SD-NEXT:    bl logf
3176 ; CHECK-SD-NEXT:    fcvt h0, s0
3177 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3178 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
3179 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3180 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
3181 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3182 ; CHECK-SD-NEXT:    fcvt s0, h0
3183 ; CHECK-SD-NEXT:    bl logf
3184 ; CHECK-SD-NEXT:    fcvt h1, s0
3185 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3186 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
3187 ; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
3188 ; CHECK-SD-NEXT:    add sp, sp, #48
3189 ; CHECK-SD-NEXT:    ret
3190 ;
3191 ; CHECK-GI-LABEL: log_v7f16:
3192 ; CHECK-GI:       // %bb.0: // %entry
3193 ; CHECK-GI-NEXT:    sub sp, sp, #160
3194 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #96] // 16-byte Folded Spill
3195 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #112] // 16-byte Folded Spill
3196 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #128] // 16-byte Folded Spill
3197 ; CHECK-GI-NEXT:    str x30, [sp, #144] // 8-byte Folded Spill
3198 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 160
3199 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
3200 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
3201 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
3202 ; CHECK-GI-NEXT:    .cfi_offset b10, -40
3203 ; CHECK-GI-NEXT:    .cfi_offset b11, -48
3204 ; CHECK-GI-NEXT:    .cfi_offset b12, -56
3205 ; CHECK-GI-NEXT:    .cfi_offset b13, -64
3206 ; CHECK-GI-NEXT:    mov h8, v0.h[1]
3207 ; CHECK-GI-NEXT:    mov h9, v0.h[2]
3208 ; CHECK-GI-NEXT:    mov h10, v0.h[3]
3209 ; CHECK-GI-NEXT:    mov h11, v0.h[4]
3210 ; CHECK-GI-NEXT:    mov h12, v0.h[5]
3211 ; CHECK-GI-NEXT:    mov h13, v0.h[6]
3212 ; CHECK-GI-NEXT:    fcvt s0, h0
3213 ; CHECK-GI-NEXT:    bl logf
3214 ; CHECK-GI-NEXT:    fcvt s1, h8
3215 ; CHECK-GI-NEXT:    fcvt h0, s0
3216 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
3217 ; CHECK-GI-NEXT:    fmov s0, s1
3218 ; CHECK-GI-NEXT:    bl logf
3219 ; CHECK-GI-NEXT:    fcvt s1, h9
3220 ; CHECK-GI-NEXT:    fcvt h0, s0
3221 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
3222 ; CHECK-GI-NEXT:    fmov s0, s1
3223 ; CHECK-GI-NEXT:    bl logf
3224 ; CHECK-GI-NEXT:    fcvt s1, h10
3225 ; CHECK-GI-NEXT:    fcvt h0, s0
3226 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
3227 ; CHECK-GI-NEXT:    fmov s0, s1
3228 ; CHECK-GI-NEXT:    bl logf
3229 ; CHECK-GI-NEXT:    fcvt s1, h11
3230 ; CHECK-GI-NEXT:    fcvt h0, s0
3231 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3232 ; CHECK-GI-NEXT:    fmov s0, s1
3233 ; CHECK-GI-NEXT:    bl logf
3234 ; CHECK-GI-NEXT:    fcvt s1, h12
3235 ; CHECK-GI-NEXT:    fcvt h0, s0
3236 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3237 ; CHECK-GI-NEXT:    fmov s0, s1
3238 ; CHECK-GI-NEXT:    bl logf
3239 ; CHECK-GI-NEXT:    fcvt s1, h13
3240 ; CHECK-GI-NEXT:    fcvt h0, s0
3241 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
3242 ; CHECK-GI-NEXT:    fmov s0, s1
3243 ; CHECK-GI-NEXT:    bl logf
3244 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #64] // 32-byte Folded Reload
3245 ; CHECK-GI-NEXT:    fcvt h0, s0
3246 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #128] // 16-byte Folded Reload
3247 ; CHECK-GI-NEXT:    ldr x30, [sp, #144] // 8-byte Folded Reload
3248 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #112] // 16-byte Folded Reload
3249 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
3250 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #32] // 32-byte Folded Reload
3251 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #96] // 16-byte Folded Reload
3252 ; CHECK-GI-NEXT:    mov v1.h[2], v3.h[0]
3253 ; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
3254 ; CHECK-GI-NEXT:    ldp q2, q3, [sp] // 32-byte Folded Reload
3255 ; CHECK-GI-NEXT:    mov v1.h[4], v3.h[0]
3256 ; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
3257 ; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
3258 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
3259 ; CHECK-GI-NEXT:    add sp, sp, #160
3260 ; CHECK-GI-NEXT:    ret
3261 entry:
3262   %c = call <7 x half> @llvm.log.v7f16(<7 x half> %a)
3263   ret <7 x half> %c
3264 }
3265
3266 define <4 x half> @log_v4f16(<4 x half> %a) {
3267 ; CHECK-SD-LABEL: log_v4f16:
3268 ; CHECK-SD:       // %bb.0: // %entry
3269 ; CHECK-SD-NEXT:    sub sp, sp, #48
3270 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
3271 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
3272 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
3273 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
3274 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
3275 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3276 ; CHECK-SD-NEXT:    fcvt s0, h1
3277 ; CHECK-SD-NEXT:    bl logf
3278 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3279 ; CHECK-SD-NEXT:    fcvt h0, s0
3280 ; CHECK-SD-NEXT:    fcvt s1, h1
3281 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
3282 ; CHECK-SD-NEXT:    fmov s0, s1
3283 ; CHECK-SD-NEXT:    bl logf
3284 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3285 ; CHECK-SD-NEXT:    fcvt h2, s0
3286 ; CHECK-SD-NEXT:    mov h1, v1.h[2]
3287 ; CHECK-SD-NEXT:    fcvt s0, h1
3288 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
3289 ; CHECK-SD-NEXT:    mov v2.h[1], v1.h[0]
3290 ; CHECK-SD-NEXT:    str q2, [sp] // 16-byte Folded Spill
3291 ; CHECK-SD-NEXT:    bl logf
3292 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3293 ; CHECK-SD-NEXT:    fcvt h2, s0
3294 ; CHECK-SD-NEXT:    mov h1, v1.h[3]
3295 ; CHECK-SD-NEXT:    fcvt s0, h1
3296 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
3297 ; CHECK-SD-NEXT:    mov v1.h[2], v2.h[0]
3298 ; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
3299 ; CHECK-SD-NEXT:    bl logf
3300 ; CHECK-SD-NEXT:    fcvt h1, s0
3301 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3302 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
3303 ; CHECK-SD-NEXT:    mov v0.h[3], v1.h[0]
3304 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
3305 ; CHECK-SD-NEXT:    add sp, sp, #48
3306 ; CHECK-SD-NEXT:    ret
3307 ;
3308 ; CHECK-GI-LABEL: log_v4f16:
3309 ; CHECK-GI:       // %bb.0: // %entry
3310 ; CHECK-GI-NEXT:    sub sp, sp, #80
3311 ; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
3312 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
3313 ; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
3314 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
3315 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
3316 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
3317 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
3318 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
3319 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
3320 ; CHECK-GI-NEXT:    mov h8, v0.h[1]
3321 ; CHECK-GI-NEXT:    mov h9, v0.h[2]
3322 ; CHECK-GI-NEXT:    mov h10, v0.h[3]
3323 ; CHECK-GI-NEXT:    fcvt s0, h0
3324 ; CHECK-GI-NEXT:    bl logf
3325 ; CHECK-GI-NEXT:    fcvt s1, h8
3326 ; CHECK-GI-NEXT:    fcvt h0, s0
3327 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3328 ; CHECK-GI-NEXT:    fmov s0, s1
3329 ; CHECK-GI-NEXT:    bl logf
3330 ; CHECK-GI-NEXT:    fcvt s1, h9
3331 ; CHECK-GI-NEXT:    fcvt h0, s0
3332 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3333 ; CHECK-GI-NEXT:    fmov s0, s1
3334 ; CHECK-GI-NEXT:    bl logf
3335 ; CHECK-GI-NEXT:    fcvt s1, h10
3336 ; CHECK-GI-NEXT:    fcvt h0, s0
3337 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
3338 ; CHECK-GI-NEXT:    fmov s0, s1
3339 ; CHECK-GI-NEXT:    bl logf
3340 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #16] // 32-byte Folded Reload
3341 ; CHECK-GI-NEXT:    fcvt h0, s0
3342 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
3343 ; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
3344 ; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
3345 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
3346 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
3347 ; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
3348 ; CHECK-GI-NEXT:    mov v1.h[3], v0.h[0]
3349 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
3350 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
3351 ; CHECK-GI-NEXT:    add sp, sp, #80
3352 ; CHECK-GI-NEXT:    ret
3353 entry:
3354   %c = call <4 x half> @llvm.log.v4f16(<4 x half> %a)
3355   ret <4 x half> %c
3356 }
3357
3358 define <8 x half> @log_v8f16(<8 x half> %a) {
3359 ; CHECK-SD-LABEL: log_v8f16:
3360 ; CHECK-SD:       // %bb.0: // %entry
3361 ; CHECK-SD-NEXT:    sub sp, sp, #48
3362 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
3363 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
3364 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
3365 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
3366 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
3367 ; CHECK-SD-NEXT:    fcvt s0, h1
3368 ; CHECK-SD-NEXT:    bl logf
3369 ; CHECK-SD-NEXT:    fcvt h0, s0
3370 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3371 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3372 ; CHECK-SD-NEXT:    fcvt s0, h0
3373 ; CHECK-SD-NEXT:    bl logf
3374 ; CHECK-SD-NEXT:    fcvt h0, s0
3375 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3376 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
3377 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3378 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3379 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
3380 ; CHECK-SD-NEXT:    fcvt s0, h0
3381 ; CHECK-SD-NEXT:    bl logf
3382 ; CHECK-SD-NEXT:    fcvt h0, s0
3383 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3384 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
3385 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3386 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
3387 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3388 ; CHECK-SD-NEXT:    fcvt s0, h0
3389 ; CHECK-SD-NEXT:    bl logf
3390 ; CHECK-SD-NEXT:    fcvt h0, s0
3391 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3392 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
3393 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3394 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
3395 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3396 ; CHECK-SD-NEXT:    fcvt s0, h0
3397 ; CHECK-SD-NEXT:    bl logf
3398 ; CHECK-SD-NEXT:    fcvt h0, s0
3399 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3400 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
3401 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3402 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
3403 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3404 ; CHECK-SD-NEXT:    fcvt s0, h0
3405 ; CHECK-SD-NEXT:    bl logf
3406 ; CHECK-SD-NEXT:    fcvt h0, s0
3407 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3408 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
3409 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3410 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
3411 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3412 ; CHECK-SD-NEXT:    fcvt s0, h0
3413 ; CHECK-SD-NEXT:    bl logf
3414 ; CHECK-SD-NEXT:    fcvt h0, s0
3415 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3416 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
3417 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3418 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
3419 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3420 ; CHECK-SD-NEXT:    fcvt s0, h0
3421 ; CHECK-SD-NEXT:    bl logf
3422 ; CHECK-SD-NEXT:    fcvt h1, s0
3423 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3424 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
3425 ; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
3426 ; CHECK-SD-NEXT:    add sp, sp, #48
3427 ; CHECK-SD-NEXT:    ret
3428 ;
3429 ; CHECK-GI-LABEL: log_v8f16:
3430 ; CHECK-GI:       // %bb.0: // %entry
3431 ; CHECK-GI-NEXT:    sub sp, sp, #176
3432 ; CHECK-GI-NEXT:    str d14, [sp, #112] // 8-byte Folded Spill
3433 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #120] // 16-byte Folded Spill
3434 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #136] // 16-byte Folded Spill
3435 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #152] // 16-byte Folded Spill
3436 ; CHECK-GI-NEXT:    str x30, [sp, #168] // 8-byte Folded Spill
3437 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
3438 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
3439 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
3440 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
3441 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
3442 ; CHECK-GI-NEXT:    .cfi_offset b11, -40
3443 ; CHECK-GI-NEXT:    .cfi_offset b12, -48
3444 ; CHECK-GI-NEXT:    .cfi_offset b13, -56
3445 ; CHECK-GI-NEXT:    .cfi_offset b14, -64
3446 ; CHECK-GI-NEXT:    mov h8, v0.h[1]
3447 ; CHECK-GI-NEXT:    mov h9, v0.h[2]
3448 ; CHECK-GI-NEXT:    mov h10, v0.h[3]
3449 ; CHECK-GI-NEXT:    mov h11, v0.h[4]
3450 ; CHECK-GI-NEXT:    mov h12, v0.h[5]
3451 ; CHECK-GI-NEXT:    mov h13, v0.h[6]
3452 ; CHECK-GI-NEXT:    mov h14, v0.h[7]
3453 ; CHECK-GI-NEXT:    fcvt s0, h0
3454 ; CHECK-GI-NEXT:    bl logf
3455 ; CHECK-GI-NEXT:    fcvt s1, h8
3456 ; CHECK-GI-NEXT:    fcvt h0, s0
3457 ; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
3458 ; CHECK-GI-NEXT:    fmov s0, s1
3459 ; CHECK-GI-NEXT:    bl logf
3460 ; CHECK-GI-NEXT:    fcvt s1, h9
3461 ; CHECK-GI-NEXT:    fcvt h0, s0
3462 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
3463 ; CHECK-GI-NEXT:    fmov s0, s1
3464 ; CHECK-GI-NEXT:    bl logf
3465 ; CHECK-GI-NEXT:    fcvt s1, h10
3466 ; CHECK-GI-NEXT:    fcvt h0, s0
3467 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
3468 ; CHECK-GI-NEXT:    fmov s0, s1
3469 ; CHECK-GI-NEXT:    bl logf
3470 ; CHECK-GI-NEXT:    fcvt s1, h11
3471 ; CHECK-GI-NEXT:    fcvt h0, s0
3472 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
3473 ; CHECK-GI-NEXT:    fmov s0, s1
3474 ; CHECK-GI-NEXT:    bl logf
3475 ; CHECK-GI-NEXT:    fcvt s1, h12
3476 ; CHECK-GI-NEXT:    fcvt h0, s0
3477 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3478 ; CHECK-GI-NEXT:    fmov s0, s1
3479 ; CHECK-GI-NEXT:    bl logf
3480 ; CHECK-GI-NEXT:    fcvt s1, h13
3481 ; CHECK-GI-NEXT:    fcvt h0, s0
3482 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3483 ; CHECK-GI-NEXT:    fmov s0, s1
3484 ; CHECK-GI-NEXT:    bl logf
3485 ; CHECK-GI-NEXT:    fcvt s1, h14
3486 ; CHECK-GI-NEXT:    fcvt h0, s0
3487 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
3488 ; CHECK-GI-NEXT:    fmov s0, s1
3489 ; CHECK-GI-NEXT:    bl logf
3490 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #80] // 32-byte Folded Reload
3491 ; CHECK-GI-NEXT:    fcvt h0, s0
3492 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #152] // 16-byte Folded Reload
3493 ; CHECK-GI-NEXT:    ldr x30, [sp, #168] // 8-byte Folded Reload
3494 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #136] // 16-byte Folded Reload
3495 ; CHECK-GI-NEXT:    ldr d14, [sp, #112] // 8-byte Folded Reload
3496 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
3497 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #48] // 32-byte Folded Reload
3498 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #120] // 16-byte Folded Reload
3499 ; CHECK-GI-NEXT:    mov v1.h[2], v3.h[0]
3500 ; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
3501 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
3502 ; CHECK-GI-NEXT:    mov v1.h[4], v3.h[0]
3503 ; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
3504 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
3505 ; CHECK-GI-NEXT:    mov v1.h[6], v2.h[0]
3506 ; CHECK-GI-NEXT:    mov v1.h[7], v0.h[0]
3507 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
3508 ; CHECK-GI-NEXT:    add sp, sp, #176
3509 ; CHECK-GI-NEXT:    ret
3510 entry:
3511   %c = call <8 x half> @llvm.log.v8f16(<8 x half> %a)
3512   ret <8 x half> %c
3513 }
3514
3515 define <16 x half> @log_v16f16(<16 x half> %a) {
3516 ; CHECK-SD-LABEL: log_v16f16:
3517 ; CHECK-SD:       // %bb.0: // %entry
3518 ; CHECK-SD-NEXT:    sub sp, sp, #64
3519 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
3520 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
3521 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
3522 ; CHECK-SD-NEXT:    stp q1, q0, [sp] // 32-byte Folded Spill
3523 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
3524 ; CHECK-SD-NEXT:    fcvt s0, h1
3525 ; CHECK-SD-NEXT:    bl logf
3526 ; CHECK-SD-NEXT:    fcvt h0, s0
3527 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3528 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3529 ; CHECK-SD-NEXT:    fcvt s0, h0
3530 ; CHECK-SD-NEXT:    bl logf
3531 ; CHECK-SD-NEXT:    fcvt h0, s0
3532 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3533 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
3534 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3535 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3536 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
3537 ; CHECK-SD-NEXT:    fcvt s0, h0
3538 ; CHECK-SD-NEXT:    bl logf
3539 ; CHECK-SD-NEXT:    fcvt h0, s0
3540 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3541 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
3542 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3543 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
3544 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3545 ; CHECK-SD-NEXT:    fcvt s0, h0
3546 ; CHECK-SD-NEXT:    bl logf
3547 ; CHECK-SD-NEXT:    fcvt h0, s0
3548 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3549 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
3550 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3551 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
3552 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3553 ; CHECK-SD-NEXT:    fcvt s0, h0
3554 ; CHECK-SD-NEXT:    bl logf
3555 ; CHECK-SD-NEXT:    fcvt h0, s0
3556 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3557 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
3558 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3559 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
3560 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3561 ; CHECK-SD-NEXT:    fcvt s0, h0
3562 ; CHECK-SD-NEXT:    bl logf
3563 ; CHECK-SD-NEXT:    fcvt h0, s0
3564 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3565 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
3566 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3567 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
3568 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3569 ; CHECK-SD-NEXT:    fcvt s0, h0
3570 ; CHECK-SD-NEXT:    bl logf
3571 ; CHECK-SD-NEXT:    fcvt h0, s0
3572 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3573 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
3574 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3575 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
3576 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3577 ; CHECK-SD-NEXT:    fcvt s0, h0
3578 ; CHECK-SD-NEXT:    bl logf
3579 ; CHECK-SD-NEXT:    fcvt h0, s0
3580 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3581 ; CHECK-SD-NEXT:    mov v1.h[7], v0.h[0]
3582 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3583 ; CHECK-SD-NEXT:    mov h0, v0.h[1]
3584 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3585 ; CHECK-SD-NEXT:    fcvt s0, h0
3586 ; CHECK-SD-NEXT:    bl logf
3587 ; CHECK-SD-NEXT:    fcvt h0, s0
3588 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3589 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3590 ; CHECK-SD-NEXT:    fcvt s0, h0
3591 ; CHECK-SD-NEXT:    bl logf
3592 ; CHECK-SD-NEXT:    fcvt h0, s0
3593 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3594 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
3595 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3596 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3597 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
3598 ; CHECK-SD-NEXT:    fcvt s0, h0
3599 ; CHECK-SD-NEXT:    bl logf
3600 ; CHECK-SD-NEXT:    fcvt h0, s0
3601 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3602 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
3603 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3604 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
3605 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3606 ; CHECK-SD-NEXT:    fcvt s0, h0
3607 ; CHECK-SD-NEXT:    bl logf
3608 ; CHECK-SD-NEXT:    fcvt h0, s0
3609 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3610 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
3611 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3612 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
3613 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3614 ; CHECK-SD-NEXT:    fcvt s0, h0
3615 ; CHECK-SD-NEXT:    bl logf
3616 ; CHECK-SD-NEXT:    fcvt h0, s0
3617 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3618 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
3619 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3620 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
3621 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3622 ; CHECK-SD-NEXT:    fcvt s0, h0
3623 ; CHECK-SD-NEXT:    bl logf
3624 ; CHECK-SD-NEXT:    fcvt h0, s0
3625 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3626 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
3627 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3628 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
3629 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3630 ; CHECK-SD-NEXT:    fcvt s0, h0
3631 ; CHECK-SD-NEXT:    bl logf
3632 ; CHECK-SD-NEXT:    fcvt h0, s0
3633 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3634 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
3635 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3636 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
3637 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3638 ; CHECK-SD-NEXT:    fcvt s0, h0
3639 ; CHECK-SD-NEXT:    bl logf
3640 ; CHECK-SD-NEXT:    fmov s1, s0
3641 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
3642 ; CHECK-SD-NEXT:    fcvt h2, s1
3643 ; CHECK-SD-NEXT:    ldp q1, q0, [sp, #16] // 32-byte Folded Reload
3644 ; CHECK-SD-NEXT:    mov v1.h[7], v2.h[0]
3645 ; CHECK-SD-NEXT:    add sp, sp, #64
3646 ; CHECK-SD-NEXT:    ret
3647 ;
3648 ; CHECK-GI-LABEL: log_v16f16:
3649 ; CHECK-GI:       // %bb.0: // %entry
3650 ; CHECK-GI-NEXT:    sub sp, sp, #320
3651 ; CHECK-GI-NEXT:    stp d15, d14, [sp, #240] // 16-byte Folded Spill
3652 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #256] // 16-byte Folded Spill
3653 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #272] // 16-byte Folded Spill
3654 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #288] // 16-byte Folded Spill
3655 ; CHECK-GI-NEXT:    stp x29, x30, [sp, #304] // 16-byte Folded Spill
3656 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 320
3657 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
3658 ; CHECK-GI-NEXT:    .cfi_offset w29, -16
3659 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
3660 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
3661 ; CHECK-GI-NEXT:    .cfi_offset b10, -40
3662 ; CHECK-GI-NEXT:    .cfi_offset b11, -48
3663 ; CHECK-GI-NEXT:    .cfi_offset b12, -56
3664 ; CHECK-GI-NEXT:    .cfi_offset b13, -64
3665 ; CHECK-GI-NEXT:    .cfi_offset b14, -72
3666 ; CHECK-GI-NEXT:    .cfi_offset b15, -80
3667 ; CHECK-GI-NEXT:    mov v2.16b, v1.16b
3668 ; CHECK-GI-NEXT:    str q1, [sp, #80] // 16-byte Folded Spill
3669 ; CHECK-GI-NEXT:    mov h14, v1.h[1]
3670 ; CHECK-GI-NEXT:    mov h1, v1.h[2]
3671 ; CHECK-GI-NEXT:    mov h15, v0.h[1]
3672 ; CHECK-GI-NEXT:    mov h8, v0.h[2]
3673 ; CHECK-GI-NEXT:    mov h9, v0.h[3]
3674 ; CHECK-GI-NEXT:    mov h10, v0.h[4]
3675 ; CHECK-GI-NEXT:    mov h11, v0.h[5]
3676 ; CHECK-GI-NEXT:    mov h12, v0.h[6]
3677 ; CHECK-GI-NEXT:    mov h13, v0.h[7]
3678 ; CHECK-GI-NEXT:    fcvt s0, h0
3679 ; CHECK-GI-NEXT:    str h1, [sp, #16] // 2-byte Folded Spill
3680 ; CHECK-GI-NEXT:    mov h1, v2.h[3]
3681 ; CHECK-GI-NEXT:    str h1, [sp, #32] // 2-byte Folded Spill
3682 ; CHECK-GI-NEXT:    mov h1, v2.h[4]
3683 ; CHECK-GI-NEXT:    str h1, [sp, #48] // 2-byte Folded Spill
3684 ; CHECK-GI-NEXT:    mov h1, v2.h[5]
3685 ; CHECK-GI-NEXT:    str h1, [sp, #64] // 2-byte Folded Spill
3686 ; CHECK-GI-NEXT:    mov h1, v2.h[6]
3687 ; CHECK-GI-NEXT:    str h1, [sp, #96] // 2-byte Folded Spill
3688 ; CHECK-GI-NEXT:    mov h1, v2.h[7]
3689 ; CHECK-GI-NEXT:    str h1, [sp, #160] // 2-byte Folded Spill
3690 ; CHECK-GI-NEXT:    bl logf
3691 ; CHECK-GI-NEXT:    fcvt s1, h15
3692 ; CHECK-GI-NEXT:    fcvt h0, s0
3693 ; CHECK-GI-NEXT:    str q0, [sp, #192] // 16-byte Folded Spill
3694 ; CHECK-GI-NEXT:    fmov s0, s1
3695 ; CHECK-GI-NEXT:    bl logf
3696 ; CHECK-GI-NEXT:    fcvt s1, h8
3697 ; CHECK-GI-NEXT:    fcvt h0, s0
3698 ; CHECK-GI-NEXT:    str q0, [sp, #128] // 16-byte Folded Spill
3699 ; CHECK-GI-NEXT:    fmov s0, s1
3700 ; CHECK-GI-NEXT:    bl logf
3701 ; CHECK-GI-NEXT:    fcvt s1, h9
3702 ; CHECK-GI-NEXT:    fcvt h0, s0
3703 ; CHECK-GI-NEXT:    str q0, [sp, #224] // 16-byte Folded Spill
3704 ; CHECK-GI-NEXT:    fmov s0, s1
3705 ; CHECK-GI-NEXT:    bl logf
3706 ; CHECK-GI-NEXT:    fcvt s1, h10
3707 ; CHECK-GI-NEXT:    fcvt h0, s0
3708 ; CHECK-GI-NEXT:    str q0, [sp, #208] // 16-byte Folded Spill
3709 ; CHECK-GI-NEXT:    fmov s0, s1
3710 ; CHECK-GI-NEXT:    bl logf
3711 ; CHECK-GI-NEXT:    fcvt s1, h11
3712 ; CHECK-GI-NEXT:    fcvt h0, s0
3713 ; CHECK-GI-NEXT:    str q0, [sp, #176] // 16-byte Folded Spill
3714 ; CHECK-GI-NEXT:    fmov s0, s1
3715 ; CHECK-GI-NEXT:    bl logf
3716 ; CHECK-GI-NEXT:    fcvt s1, h12
3717 ; CHECK-GI-NEXT:    fcvt h0, s0
3718 ; CHECK-GI-NEXT:    str q0, [sp, #144] // 16-byte Folded Spill
3719 ; CHECK-GI-NEXT:    fmov s0, s1
3720 ; CHECK-GI-NEXT:    bl logf
3721 ; CHECK-GI-NEXT:    fcvt s1, h13
3722 ; CHECK-GI-NEXT:    fcvt h0, s0
3723 ; CHECK-GI-NEXT:    str q0, [sp, #112] // 16-byte Folded Spill
3724 ; CHECK-GI-NEXT:    fmov s0, s1
3725 ; CHECK-GI-NEXT:    bl logf
3726 ; CHECK-GI-NEXT:    ldr q1, [sp, #80] // 16-byte Folded Reload
3727 ; CHECK-GI-NEXT:    fcvt h0, s0
3728 ; CHECK-GI-NEXT:    fcvt s1, h1
3729 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
3730 ; CHECK-GI-NEXT:    fmov s0, s1
3731 ; CHECK-GI-NEXT:    bl logf
3732 ; CHECK-GI-NEXT:    fcvt s1, h14
3733 ; CHECK-GI-NEXT:    fcvt h0, s0
3734 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
3735 ; CHECK-GI-NEXT:    fmov s0, s1
3736 ; CHECK-GI-NEXT:    bl logf
3737 ; CHECK-GI-NEXT:    ldr h1, [sp, #16] // 2-byte Folded Reload
3738 ; CHECK-GI-NEXT:    fcvt h0, s0
3739 ; CHECK-GI-NEXT:    fcvt s1, h1
3740 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3741 ; CHECK-GI-NEXT:    fmov s0, s1
3742 ; CHECK-GI-NEXT:    bl logf
3743 ; CHECK-GI-NEXT:    ldr h1, [sp, #32] // 2-byte Folded Reload
3744 ; CHECK-GI-NEXT:    fcvt h0, s0
3745 ; CHECK-GI-NEXT:    fcvt s1, h1
3746 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3747 ; CHECK-GI-NEXT:    fmov s0, s1
3748 ; CHECK-GI-NEXT:    bl logf
3749 ; CHECK-GI-NEXT:    ldr h1, [sp, #48] // 2-byte Folded Reload
3750 ; CHECK-GI-NEXT:    fcvt h0, s0
3751 ; CHECK-GI-NEXT:    fcvt s1, h1
3752 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
3753 ; CHECK-GI-NEXT:    fmov s0, s1
3754 ; CHECK-GI-NEXT:    bl logf
3755 ; CHECK-GI-NEXT:    ldr h1, [sp, #64] // 2-byte Folded Reload
3756 ; CHECK-GI-NEXT:    fcvt h0, s0
3757 ; CHECK-GI-NEXT:    fcvt s1, h1
3758 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
3759 ; CHECK-GI-NEXT:    fmov s0, s1
3760 ; CHECK-GI-NEXT:    bl logf
3761 ; CHECK-GI-NEXT:    ldr h1, [sp, #96] // 2-byte Folded Reload
3762 ; CHECK-GI-NEXT:    fcvt h0, s0
3763 ; CHECK-GI-NEXT:    fcvt s1, h1
3764 ; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
3765 ; CHECK-GI-NEXT:    fmov s0, s1
3766 ; CHECK-GI-NEXT:    bl logf
3767 ; CHECK-GI-NEXT:    ldr h1, [sp, #160] // 2-byte Folded Reload
3768 ; CHECK-GI-NEXT:    fcvt h0, s0
3769 ; CHECK-GI-NEXT:    fcvt s1, h1
3770 ; CHECK-GI-NEXT:    str q0, [sp, #160] // 16-byte Folded Spill
3771 ; CHECK-GI-NEXT:    fmov s0, s1
3772 ; CHECK-GI-NEXT:    bl logf
3773 ; CHECK-GI-NEXT:    ldr q3, [sp, #192] // 16-byte Folded Reload
3774 ; CHECK-GI-NEXT:    ldr q2, [sp, #128] // 16-byte Folded Reload
3775 ; CHECK-GI-NEXT:    ldp x29, x30, [sp, #304] // 16-byte Folded Reload
3776 ; CHECK-GI-NEXT:    mov v3.h[1], v2.h[0]
3777 ; CHECK-GI-NEXT:    ldp q1, q2, [sp] // 32-byte Folded Reload
3778 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #288] // 16-byte Folded Reload
3779 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #272] // 16-byte Folded Reload
3780 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
3781 ; CHECK-GI-NEXT:    ldr q2, [sp, #224] // 16-byte Folded Reload
3782 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #256] // 16-byte Folded Reload
3783 ; CHECK-GI-NEXT:    mov v3.h[2], v2.h[0]
3784 ; CHECK-GI-NEXT:    ldr q2, [sp, #32] // 16-byte Folded Reload
3785 ; CHECK-GI-NEXT:    ldp d15, d14, [sp, #240] // 16-byte Folded Reload
3786 ; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
3787 ; CHECK-GI-NEXT:    ldr q2, [sp, #208] // 16-byte Folded Reload
3788 ; CHECK-GI-NEXT:    mov v3.h[3], v2.h[0]
3789 ; CHECK-GI-NEXT:    ldr q2, [sp, #48] // 16-byte Folded Reload
3790 ; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
3791 ; CHECK-GI-NEXT:    ldr q2, [sp, #176] // 16-byte Folded Reload
3792 ; CHECK-GI-NEXT:    mov v3.h[4], v2.h[0]
3793 ; CHECK-GI-NEXT:    ldr q2, [sp, #64] // 16-byte Folded Reload
3794 ; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
3795 ; CHECK-GI-NEXT:    ldr q2, [sp, #144] // 16-byte Folded Reload
3796 ; CHECK-GI-NEXT:    mov v3.h[5], v2.h[0]
3797 ; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
3798 ; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
3799 ; CHECK-GI-NEXT:    fcvt h2, s0
3800 ; CHECK-GI-NEXT:    ldr q0, [sp, #112] // 16-byte Folded Reload
3801 ; CHECK-GI-NEXT:    mov v3.h[6], v0.h[0]
3802 ; CHECK-GI-NEXT:    ldr q0, [sp, #160] // 16-byte Folded Reload
3803 ; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
3804 ; CHECK-GI-NEXT:    ldr q0, [sp, #80] // 16-byte Folded Reload
3805 ; CHECK-GI-NEXT:    mov v3.h[7], v0.h[0]
3806 ; CHECK-GI-NEXT:    mov v1.h[7], v2.h[0]
3807 ; CHECK-GI-NEXT:    mov v0.16b, v3.16b
3808 ; CHECK-GI-NEXT:    add sp, sp, #320
3809 ; CHECK-GI-NEXT:    ret
3810 entry:
3811   %c = call <16 x half> @llvm.log.v16f16(<16 x half> %a)
3812   ret <16 x half> %c
3813 }
3814
3815 define double @log2_f64(double %a) {
3816 ; CHECK-LABEL: log2_f64:
3817 ; CHECK:       // %bb.0: // %entry
3818 ; CHECK-NEXT:    b log2
3819 entry:
3820   %c = call double @llvm.log2.f64(double %a)
3821   ret double %c
3822 }
3823
3824 define float @log2_f32(float %a) {
3825 ; CHECK-LABEL: log2_f32:
3826 ; CHECK:       // %bb.0: // %entry
3827 ; CHECK-NEXT:    b log2f
3828 entry:
3829   %c = call float @llvm.log2.f32(float %a)
3830   ret float %c
3831 }
3832
3833 define half @log2_f16(half %a) {
3834 ; CHECK-LABEL: log2_f16:
3835 ; CHECK:       // %bb.0: // %entry
3836 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
3837 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
3838 ; CHECK-NEXT:    .cfi_offset w30, -16
3839 ; CHECK-NEXT:    fcvt s0, h0
3840 ; CHECK-NEXT:    bl log2f
3841 ; CHECK-NEXT:    fcvt h0, s0
3842 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
3843 ; CHECK-NEXT:    ret
3844 entry:
3845   %c = call half @llvm.log2.f16(half %a)
3846   ret half %c
3847 }
3848
3849 define <1 x double> @log2_v1f64(<1 x double> %x) {
3850 ; CHECK-LABEL: log2_v1f64:
3851 ; CHECK:       // %bb.0:
3852 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
3853 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
3854 ; CHECK-NEXT:    .cfi_offset w30, -16
3855 ; CHECK-NEXT:    bl log2
3856 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
3857 ; CHECK-NEXT:    ret
3858   %c = call <1 x double> @llvm.log2.v1f64(<1 x double> %x)
3859   ret <1 x double> %c
3860 }
3861
3862 define <2 x double> @log2_v2f64(<2 x double> %a) {
3863 ; CHECK-SD-LABEL: log2_v2f64:
3864 ; CHECK-SD:       // %bb.0: // %entry
3865 ; CHECK-SD-NEXT:    sub sp, sp, #48
3866 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
3867 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
3868 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
3869 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
3870 ; CHECK-SD-NEXT:    mov d0, v0.d[1]
3871 ; CHECK-SD-NEXT:    bl log2
3872 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
3873 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3874 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3875 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
3876 ; CHECK-SD-NEXT:    bl log2
3877 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3878 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
3879 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
3880 ; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
3881 ; CHECK-SD-NEXT:    add sp, sp, #48
3882 ; CHECK-SD-NEXT:    ret
3883 ;
3884 ; CHECK-GI-LABEL: log2_v2f64:
3885 ; CHECK-GI:       // %bb.0: // %entry
3886 ; CHECK-GI-NEXT:    sub sp, sp, #32
3887 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
3888 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
3889 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
3890 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
3891 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
3892 ; CHECK-GI-NEXT:    mov d8, v0.d[1]
3893 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
3894 ; CHECK-GI-NEXT:    bl log2
3895 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
3896 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
3897 ; CHECK-GI-NEXT:    fmov d0, d8
3898 ; CHECK-GI-NEXT:    bl log2
3899 ; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
3900 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
3901 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
3902 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
3903 ; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
3904 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
3905 ; CHECK-GI-NEXT:    add sp, sp, #32
3906 ; CHECK-GI-NEXT:    ret
3907 entry:
3908   %c = call <2 x double> @llvm.log2.v2f64(<2 x double> %a)
3909   ret <2 x double> %c
3910 }
3911
3912 define <3 x double> @log2_v3f64(<3 x double> %a) {
3913 ; CHECK-SD-LABEL: log2_v3f64:
3914 ; CHECK-SD:       // %bb.0: // %entry
3915 ; CHECK-SD-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
3916 ; CHECK-SD-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
3917 ; CHECK-SD-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
3918 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 32
3919 ; CHECK-SD-NEXT:    .cfi_offset w30, -8
3920 ; CHECK-SD-NEXT:    .cfi_offset b8, -16
3921 ; CHECK-SD-NEXT:    .cfi_offset b9, -24
3922 ; CHECK-SD-NEXT:    .cfi_offset b10, -32
3923 ; CHECK-SD-NEXT:    fmov d8, d2
3924 ; CHECK-SD-NEXT:    fmov d9, d1
3925 ; CHECK-SD-NEXT:    bl log2
3926 ; CHECK-SD-NEXT:    fmov d10, d0
3927 ; CHECK-SD-NEXT:    fmov d0, d9
3928 ; CHECK-SD-NEXT:    bl log2
3929 ; CHECK-SD-NEXT:    fmov d9, d0
3930 ; CHECK-SD-NEXT:    fmov d0, d8
3931 ; CHECK-SD-NEXT:    bl log2
3932 ; CHECK-SD-NEXT:    fmov d1, d9
3933 ; CHECK-SD-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
3934 ; CHECK-SD-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
3935 ; CHECK-SD-NEXT:    fmov d2, d0
3936 ; CHECK-SD-NEXT:    fmov d0, d10
3937 ; CHECK-SD-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
3938 ; CHECK-SD-NEXT:    ret
3939 ;
3940 ; CHECK-GI-LABEL: log2_v3f64:
3941 ; CHECK-GI:       // %bb.0: // %entry
3942 ; CHECK-GI-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
3943 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
3944 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
3945 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
3946 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
3947 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
3948 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
3949 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
3950 ; CHECK-GI-NEXT:    fmov d8, d1
3951 ; CHECK-GI-NEXT:    fmov d9, d2
3952 ; CHECK-GI-NEXT:    bl log2
3953 ; CHECK-GI-NEXT:    fmov d10, d0
3954 ; CHECK-GI-NEXT:    fmov d0, d8
3955 ; CHECK-GI-NEXT:    bl log2
3956 ; CHECK-GI-NEXT:    fmov d8, d0
3957 ; CHECK-GI-NEXT:    fmov d0, d9
3958 ; CHECK-GI-NEXT:    bl log2
3959 ; CHECK-GI-NEXT:    fmov d1, d8
3960 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
3961 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
3962 ; CHECK-GI-NEXT:    fmov d2, d0
3963 ; CHECK-GI-NEXT:    fmov d0, d10
3964 ; CHECK-GI-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
3965 ; CHECK-GI-NEXT:    ret
3966 entry:
3967   %c = call <3 x double> @llvm.log2.v3f64(<3 x double> %a)
3968   ret <3 x double> %c
3969 }
3970
3971 define <4 x double> @log2_v4f64(<4 x double> %a) {
3972 ; CHECK-SD-LABEL: log2_v4f64:
3973 ; CHECK-SD:       // %bb.0: // %entry
3974 ; CHECK-SD-NEXT:    sub sp, sp, #64
3975 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
3976 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
3977 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
3978 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
3979 ; CHECK-SD-NEXT:    mov d0, v0.d[1]
3980 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3981 ; CHECK-SD-NEXT:    bl log2
3982 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
3983 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3984 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3985 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
3986 ; CHECK-SD-NEXT:    bl log2
3987 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3988 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
3989 ; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
3990 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3991 ; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
3992 ; CHECK-SD-NEXT:    mov d0, v0.d[1]
3993 ; CHECK-SD-NEXT:    bl log2
3994 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
3995 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
3996 ; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
3997 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
3998 ; CHECK-SD-NEXT:    bl log2
3999 ; CHECK-SD-NEXT:    fmov d1, d0
4000 ; CHECK-SD-NEXT:    ldp q2, q0, [sp] // 32-byte Folded Reload
4001 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
4002 ; CHECK-SD-NEXT:    mov v1.d[1], v2.d[0]
4003 ; CHECK-SD-NEXT:    add sp, sp, #64
4004 ; CHECK-SD-NEXT:    ret
4005 ;
4006 ; CHECK-GI-LABEL: log2_v4f64:
4007 ; CHECK-GI:       // %bb.0: // %entry
4008 ; CHECK-GI-NEXT:    sub sp, sp, #80
4009 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
4010 ; CHECK-GI-NEXT:    str x30, [sp, #64] // 8-byte Folded Spill
4011 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
4012 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
4013 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
4014 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
4015 ; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
4016 ; CHECK-GI-NEXT:    mov d8, v0.d[1]
4017 ; CHECK-GI-NEXT:    mov d9, v1.d[1]
4018 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
4019 ; CHECK-GI-NEXT:    bl log2
4020 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
4021 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4022 ; CHECK-GI-NEXT:    fmov d0, d8
4023 ; CHECK-GI-NEXT:    bl log2
4024 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
4025 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4026 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4027 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
4028 ; CHECK-GI-NEXT:    bl log2
4029 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
4030 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4031 ; CHECK-GI-NEXT:    fmov d0, d9
4032 ; CHECK-GI-NEXT:    bl log2
4033 ; CHECK-GI-NEXT:    ldp q1, q2, [sp, #16] // 32-byte Folded Reload
4034 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
4035 ; CHECK-GI-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
4036 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
4037 ; CHECK-GI-NEXT:    mov v2.d[1], v1.d[0]
4038 ; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4039 ; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
4040 ; CHECK-GI-NEXT:    mov v0.16b, v2.16b
4041 ; CHECK-GI-NEXT:    add sp, sp, #80
4042 ; CHECK-GI-NEXT:    ret
4043 entry:
4044   %c = call <4 x double> @llvm.log2.v4f64(<4 x double> %a)
4045   ret <4 x double> %c
4046 }
4047
4048 define <2 x float> @log2_v2f32(<2 x float> %a) {
4049 ; CHECK-SD-LABEL: log2_v2f32:
4050 ; CHECK-SD:       // %bb.0: // %entry
4051 ; CHECK-SD-NEXT:    sub sp, sp, #48
4052 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
4053 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
4054 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
4055 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
4056 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4057 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
4058 ; CHECK-SD-NEXT:    bl log2f
4059 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4060 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4061 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4062 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
4063 ; CHECK-SD-NEXT:    bl log2f
4064 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4065 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4066 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
4067 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
4068 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
4069 ; CHECK-SD-NEXT:    add sp, sp, #48
4070 ; CHECK-SD-NEXT:    ret
4071 ;
4072 ; CHECK-GI-LABEL: log2_v2f32:
4073 ; CHECK-GI:       // %bb.0: // %entry
4074 ; CHECK-GI-NEXT:    sub sp, sp, #32
4075 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
4076 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
4077 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
4078 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
4079 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
4080 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
4081 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
4082 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
4083 ; CHECK-GI-NEXT:    bl log2f
4084 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4085 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4086 ; CHECK-GI-NEXT:    fmov s0, s8
4087 ; CHECK-GI-NEXT:    bl log2f
4088 ; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4089 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4090 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
4091 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
4092 ; CHECK-GI-NEXT:    mov v1.s[1], v0.s[0]
4093 ; CHECK-GI-NEXT:    fmov d0, d1
4094 ; CHECK-GI-NEXT:    add sp, sp, #32
4095 ; CHECK-GI-NEXT:    ret
4096 entry:
4097   %c = call <2 x float> @llvm.log2.v2f32(<2 x float> %a)
4098   ret <2 x float> %c
4099 }
4100
4101 define <3 x float> @log2_v3f32(<3 x float> %a) {
4102 ; CHECK-SD-LABEL: log2_v3f32:
4103 ; CHECK-SD:       // %bb.0: // %entry
4104 ; CHECK-SD-NEXT:    sub sp, sp, #48
4105 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
4106 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
4107 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
4108 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4109 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
4110 ; CHECK-SD-NEXT:    bl log2f
4111 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4112 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4113 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4114 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
4115 ; CHECK-SD-NEXT:    bl log2f
4116 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4117 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4118 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
4119 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4120 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4121 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
4122 ; CHECK-SD-NEXT:    bl log2f
4123 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4124 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4125 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
4126 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
4127 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
4128 ; CHECK-SD-NEXT:    add sp, sp, #48
4129 ; CHECK-SD-NEXT:    ret
4130 ;
4131 ; CHECK-GI-LABEL: log2_v3f32:
4132 ; CHECK-GI:       // %bb.0: // %entry
4133 ; CHECK-GI-NEXT:    sub sp, sp, #64
4134 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #32] // 16-byte Folded Spill
4135 ; CHECK-GI-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
4136 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 64
4137 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
4138 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
4139 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
4140 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
4141 ; CHECK-GI-NEXT:    mov s9, v0.s[2]
4142 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
4143 ; CHECK-GI-NEXT:    bl log2f
4144 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4145 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4146 ; CHECK-GI-NEXT:    fmov s0, s8
4147 ; CHECK-GI-NEXT:    bl log2f
4148 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4149 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4150 ; CHECK-GI-NEXT:    fmov s0, s9
4151 ; CHECK-GI-NEXT:    bl log2f
4152 ; CHECK-GI-NEXT:    ldp q2, q1, [sp] // 32-byte Folded Reload
4153 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4154 ; CHECK-GI-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
4155 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #32] // 16-byte Folded Reload
4156 ; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
4157 ; CHECK-GI-NEXT:    mov v1.s[2], v0.s[0]
4158 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
4159 ; CHECK-GI-NEXT:    add sp, sp, #64
4160 ; CHECK-GI-NEXT:    ret
4161 entry:
4162   %c = call <3 x float> @llvm.log2.v3f32(<3 x float> %a)
4163   ret <3 x float> %c
4164 }
4165
4166 define <4 x float> @log2_v4f32(<4 x float> %a) {
4167 ; CHECK-SD-LABEL: log2_v4f32:
4168 ; CHECK-SD:       // %bb.0: // %entry
4169 ; CHECK-SD-NEXT:    sub sp, sp, #48
4170 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
4171 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
4172 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
4173 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4174 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
4175 ; CHECK-SD-NEXT:    bl log2f
4176 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4177 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4178 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4179 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
4180 ; CHECK-SD-NEXT:    bl log2f
4181 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4182 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4183 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
4184 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4185 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4186 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
4187 ; CHECK-SD-NEXT:    bl log2f
4188 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4189 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4190 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
4191 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4192 ; CHECK-SD-NEXT:    mov s0, v0.s[3]
4193 ; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
4194 ; CHECK-SD-NEXT:    bl log2f
4195 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4196 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4197 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
4198 ; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
4199 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
4200 ; CHECK-SD-NEXT:    add sp, sp, #48
4201 ; CHECK-SD-NEXT:    ret
4202 ;
4203 ; CHECK-GI-LABEL: log2_v4f32:
4204 ; CHECK-GI:       // %bb.0: // %entry
4205 ; CHECK-GI-NEXT:    sub sp, sp, #80
4206 ; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
4207 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
4208 ; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
4209 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
4210 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
4211 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
4212 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
4213 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
4214 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
4215 ; CHECK-GI-NEXT:    mov s9, v0.s[2]
4216 ; CHECK-GI-NEXT:    mov s10, v0.s[3]
4217 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
4218 ; CHECK-GI-NEXT:    bl log2f
4219 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4220 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4221 ; CHECK-GI-NEXT:    fmov s0, s8
4222 ; CHECK-GI-NEXT:    bl log2f
4223 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4224 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4225 ; CHECK-GI-NEXT:    fmov s0, s9
4226 ; CHECK-GI-NEXT:    bl log2f
4227 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4228 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4229 ; CHECK-GI-NEXT:    fmov s0, s10
4230 ; CHECK-GI-NEXT:    bl log2f
4231 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #16] // 32-byte Folded Reload
4232 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4233 ; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
4234 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
4235 ; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
4236 ; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
4237 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
4238 ; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
4239 ; CHECK-GI-NEXT:    mov v1.s[3], v0.s[0]
4240 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
4241 ; CHECK-GI-NEXT:    add sp, sp, #80
4242 ; CHECK-GI-NEXT:    ret
4243 entry:
4244   %c = call <4 x float> @llvm.log2.v4f32(<4 x float> %a)
4245   ret <4 x float> %c
4246 }
4247
4248 define <8 x float> @log2_v8f32(<8 x float> %a) {
4249 ; CHECK-SD-LABEL: log2_v8f32:
4250 ; CHECK-SD:       // %bb.0: // %entry
4251 ; CHECK-SD-NEXT:    sub sp, sp, #64
4252 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
4253 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
4254 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
4255 ; CHECK-SD-NEXT:    stp q0, q1, [sp] // 32-byte Folded Spill
4256 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
4257 ; CHECK-SD-NEXT:    bl log2f
4258 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4259 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4260 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4261 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
4262 ; CHECK-SD-NEXT:    bl log2f
4263 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4264 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4265 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
4266 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4267 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4268 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
4269 ; CHECK-SD-NEXT:    bl log2f
4270 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4271 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4272 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
4273 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4274 ; CHECK-SD-NEXT:    mov s0, v0.s[3]
4275 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4276 ; CHECK-SD-NEXT:    bl log2f
4277 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4278 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4279 ; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
4280 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4281 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
4282 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4283 ; CHECK-SD-NEXT:    bl log2f
4284 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4285 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4286 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4287 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
4288 ; CHECK-SD-NEXT:    bl log2f
4289 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4290 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4291 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
4292 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4293 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4294 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
4295 ; CHECK-SD-NEXT:    bl log2f
4296 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4297 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4298 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
4299 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4300 ; CHECK-SD-NEXT:    mov s0, v0.s[3]
4301 ; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
4302 ; CHECK-SD-NEXT:    bl log2f
4303 ; CHECK-SD-NEXT:    fmov s2, s0
4304 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4305 ; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
4306 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
4307 ; CHECK-SD-NEXT:    mov v1.s[3], v2.s[0]
4308 ; CHECK-SD-NEXT:    add sp, sp, #64
4309 ; CHECK-SD-NEXT:    ret
4310 ;
4311 ; CHECK-GI-LABEL: log2_v8f32:
4312 ; CHECK-GI:       // %bb.0: // %entry
4313 ; CHECK-GI-NEXT:    sub sp, sp, #176
4314 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #112] // 16-byte Folded Spill
4315 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #128] // 16-byte Folded Spill
4316 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #144] // 16-byte Folded Spill
4317 ; CHECK-GI-NEXT:    str x30, [sp, #160] // 8-byte Folded Spill
4318 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
4319 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
4320 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
4321 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
4322 ; CHECK-GI-NEXT:    .cfi_offset b10, -40
4323 ; CHECK-GI-NEXT:    .cfi_offset b11, -48
4324 ; CHECK-GI-NEXT:    .cfi_offset b12, -56
4325 ; CHECK-GI-NEXT:    .cfi_offset b13, -64
4326 ; CHECK-GI-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4327 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
4328 ; CHECK-GI-NEXT:    mov s9, v0.s[2]
4329 ; CHECK-GI-NEXT:    mov s10, v0.s[3]
4330 ; CHECK-GI-NEXT:    mov s11, v1.s[1]
4331 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
4332 ; CHECK-GI-NEXT:    mov s12, v1.s[2]
4333 ; CHECK-GI-NEXT:    mov s13, v1.s[3]
4334 ; CHECK-GI-NEXT:    bl log2f
4335 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4336 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
4337 ; CHECK-GI-NEXT:    fmov s0, s8
4338 ; CHECK-GI-NEXT:    bl log2f
4339 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4340 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
4341 ; CHECK-GI-NEXT:    fmov s0, s9
4342 ; CHECK-GI-NEXT:    bl log2f
4343 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4344 ; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
4345 ; CHECK-GI-NEXT:    fmov s0, s10
4346 ; CHECK-GI-NEXT:    bl log2f
4347 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4348 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
4349 ; CHECK-GI-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
4350 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
4351 ; CHECK-GI-NEXT:    bl log2f
4352 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4353 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4354 ; CHECK-GI-NEXT:    fmov s0, s11
4355 ; CHECK-GI-NEXT:    bl log2f
4356 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4357 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4358 ; CHECK-GI-NEXT:    fmov s0, s12
4359 ; CHECK-GI-NEXT:    bl log2f
4360 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4361 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4362 ; CHECK-GI-NEXT:    fmov s0, s13
4363 ; CHECK-GI-NEXT:    bl log2f
4364 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #48] // 32-byte Folded Reload
4365 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4366 ; CHECK-GI-NEXT:    ldr x30, [sp, #160] // 8-byte Folded Reload
4367 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #144] // 16-byte Folded Reload
4368 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #128] // 16-byte Folded Reload
4369 ; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
4370 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
4371 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #112] // 16-byte Folded Reload
4372 ; CHECK-GI-NEXT:    mov v3.s[1], v2.s[0]
4373 ; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
4374 ; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
4375 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
4376 ; CHECK-GI-NEXT:    mov v3.s[2], v2.s[0]
4377 ; CHECK-GI-NEXT:    ldr q2, [sp, #80] // 16-byte Folded Reload
4378 ; CHECK-GI-NEXT:    mov v1.s[3], v2.s[0]
4379 ; CHECK-GI-NEXT:    mov v3.s[3], v0.s[0]
4380 ; CHECK-GI-NEXT:    mov v2.16b, v1.16b
4381 ; CHECK-GI-NEXT:    mov v1.16b, v3.16b
4382 ; CHECK-GI-NEXT:    mov v0.16b, v2.16b
4383 ; CHECK-GI-NEXT:    add sp, sp, #176
4384 ; CHECK-GI-NEXT:    ret
4385 entry:
4386   %c = call <8 x float> @llvm.log2.v8f32(<8 x float> %a)
4387   ret <8 x float> %c
4388 }
4389
4390 define <7 x half> @log2_v7f16(<7 x half> %a) {
4391 ; CHECK-SD-LABEL: log2_v7f16:
4392 ; CHECK-SD:       // %bb.0: // %entry
4393 ; CHECK-SD-NEXT:    sub sp, sp, #48
4394 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
4395 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
4396 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
4397 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
4398 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4399 ; CHECK-SD-NEXT:    fcvt s0, h1
4400 ; CHECK-SD-NEXT:    bl log2f
4401 ; CHECK-SD-NEXT:    fcvt h0, s0
4402 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4403 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4404 ; CHECK-SD-NEXT:    fcvt s0, h0
4405 ; CHECK-SD-NEXT:    bl log2f
4406 ; CHECK-SD-NEXT:    fcvt h0, s0
4407 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4408 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
4409 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4410 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4411 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
4412 ; CHECK-SD-NEXT:    fcvt s0, h0
4413 ; CHECK-SD-NEXT:    bl log2f
4414 ; CHECK-SD-NEXT:    fcvt h0, s0
4415 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4416 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
4417 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4418 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
4419 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4420 ; CHECK-SD-NEXT:    fcvt s0, h0
4421 ; CHECK-SD-NEXT:    bl log2f
4422 ; CHECK-SD-NEXT:    fcvt h0, s0
4423 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4424 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
4425 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4426 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
4427 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4428 ; CHECK-SD-NEXT:    fcvt s0, h0
4429 ; CHECK-SD-NEXT:    bl log2f
4430 ; CHECK-SD-NEXT:    fcvt h0, s0
4431 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4432 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
4433 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4434 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
4435 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4436 ; CHECK-SD-NEXT:    fcvt s0, h0
4437 ; CHECK-SD-NEXT:    bl log2f
4438 ; CHECK-SD-NEXT:    fcvt h0, s0
4439 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4440 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
4441 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4442 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
4443 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4444 ; CHECK-SD-NEXT:    fcvt s0, h0
4445 ; CHECK-SD-NEXT:    bl log2f
4446 ; CHECK-SD-NEXT:    fcvt h0, s0
4447 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4448 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
4449 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4450 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
4451 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4452 ; CHECK-SD-NEXT:    fcvt s0, h0
4453 ; CHECK-SD-NEXT:    bl log2f
4454 ; CHECK-SD-NEXT:    fcvt h1, s0
4455 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4456 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
4457 ; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
4458 ; CHECK-SD-NEXT:    add sp, sp, #48
4459 ; CHECK-SD-NEXT:    ret
4460 ;
4461 ; CHECK-GI-LABEL: log2_v7f16:
4462 ; CHECK-GI:       // %bb.0: // %entry
4463 ; CHECK-GI-NEXT:    sub sp, sp, #160
4464 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #96] // 16-byte Folded Spill
4465 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #112] // 16-byte Folded Spill
4466 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #128] // 16-byte Folded Spill
4467 ; CHECK-GI-NEXT:    str x30, [sp, #144] // 8-byte Folded Spill
4468 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 160
4469 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
4470 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
4471 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
4472 ; CHECK-GI-NEXT:    .cfi_offset b10, -40
4473 ; CHECK-GI-NEXT:    .cfi_offset b11, -48
4474 ; CHECK-GI-NEXT:    .cfi_offset b12, -56
4475 ; CHECK-GI-NEXT:    .cfi_offset b13, -64
4476 ; CHECK-GI-NEXT:    mov h8, v0.h[1]
4477 ; CHECK-GI-NEXT:    mov h9, v0.h[2]
4478 ; CHECK-GI-NEXT:    mov h10, v0.h[3]
4479 ; CHECK-GI-NEXT:    mov h11, v0.h[4]
4480 ; CHECK-GI-NEXT:    mov h12, v0.h[5]
4481 ; CHECK-GI-NEXT:    mov h13, v0.h[6]
4482 ; CHECK-GI-NEXT:    fcvt s0, h0
4483 ; CHECK-GI-NEXT:    bl log2f
4484 ; CHECK-GI-NEXT:    fcvt s1, h8
4485 ; CHECK-GI-NEXT:    fcvt h0, s0
4486 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
4487 ; CHECK-GI-NEXT:    fmov s0, s1
4488 ; CHECK-GI-NEXT:    bl log2f
4489 ; CHECK-GI-NEXT:    fcvt s1, h9
4490 ; CHECK-GI-NEXT:    fcvt h0, s0
4491 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
4492 ; CHECK-GI-NEXT:    fmov s0, s1
4493 ; CHECK-GI-NEXT:    bl log2f
4494 ; CHECK-GI-NEXT:    fcvt s1, h10
4495 ; CHECK-GI-NEXT:    fcvt h0, s0
4496 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
4497 ; CHECK-GI-NEXT:    fmov s0, s1
4498 ; CHECK-GI-NEXT:    bl log2f
4499 ; CHECK-GI-NEXT:    fcvt s1, h11
4500 ; CHECK-GI-NEXT:    fcvt h0, s0
4501 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4502 ; CHECK-GI-NEXT:    fmov s0, s1
4503 ; CHECK-GI-NEXT:    bl log2f
4504 ; CHECK-GI-NEXT:    fcvt s1, h12
4505 ; CHECK-GI-NEXT:    fcvt h0, s0
4506 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4507 ; CHECK-GI-NEXT:    fmov s0, s1
4508 ; CHECK-GI-NEXT:    bl log2f
4509 ; CHECK-GI-NEXT:    fcvt s1, h13
4510 ; CHECK-GI-NEXT:    fcvt h0, s0
4511 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4512 ; CHECK-GI-NEXT:    fmov s0, s1
4513 ; CHECK-GI-NEXT:    bl log2f
4514 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #64] // 32-byte Folded Reload
4515 ; CHECK-GI-NEXT:    fcvt h0, s0
4516 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #128] // 16-byte Folded Reload
4517 ; CHECK-GI-NEXT:    ldr x30, [sp, #144] // 8-byte Folded Reload
4518 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #112] // 16-byte Folded Reload
4519 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
4520 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #32] // 32-byte Folded Reload
4521 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #96] // 16-byte Folded Reload
4522 ; CHECK-GI-NEXT:    mov v1.h[2], v3.h[0]
4523 ; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
4524 ; CHECK-GI-NEXT:    ldp q2, q3, [sp] // 32-byte Folded Reload
4525 ; CHECK-GI-NEXT:    mov v1.h[4], v3.h[0]
4526 ; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
4527 ; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
4528 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
4529 ; CHECK-GI-NEXT:    add sp, sp, #160
4530 ; CHECK-GI-NEXT:    ret
4531 entry:
4532   %c = call <7 x half> @llvm.log2.v7f16(<7 x half> %a)
4533   ret <7 x half> %c
4534 }
4535
4536 define <4 x half> @log2_v4f16(<4 x half> %a) {
4537 ; CHECK-SD-LABEL: log2_v4f16:
4538 ; CHECK-SD:       // %bb.0: // %entry
4539 ; CHECK-SD-NEXT:    sub sp, sp, #48
4540 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
4541 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
4542 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
4543 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
4544 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
4545 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4546 ; CHECK-SD-NEXT:    fcvt s0, h1
4547 ; CHECK-SD-NEXT:    bl log2f
4548 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4549 ; CHECK-SD-NEXT:    fcvt h0, s0
4550 ; CHECK-SD-NEXT:    fcvt s1, h1
4551 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4552 ; CHECK-SD-NEXT:    fmov s0, s1
4553 ; CHECK-SD-NEXT:    bl log2f
4554 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4555 ; CHECK-SD-NEXT:    fcvt h2, s0
4556 ; CHECK-SD-NEXT:    mov h1, v1.h[2]
4557 ; CHECK-SD-NEXT:    fcvt s0, h1
4558 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4559 ; CHECK-SD-NEXT:    mov v2.h[1], v1.h[0]
4560 ; CHECK-SD-NEXT:    str q2, [sp] // 16-byte Folded Spill
4561 ; CHECK-SD-NEXT:    bl log2f
4562 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4563 ; CHECK-SD-NEXT:    fcvt h2, s0
4564 ; CHECK-SD-NEXT:    mov h1, v1.h[3]
4565 ; CHECK-SD-NEXT:    fcvt s0, h1
4566 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4567 ; CHECK-SD-NEXT:    mov v1.h[2], v2.h[0]
4568 ; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
4569 ; CHECK-SD-NEXT:    bl log2f
4570 ; CHECK-SD-NEXT:    fcvt h1, s0
4571 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4572 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
4573 ; CHECK-SD-NEXT:    mov v0.h[3], v1.h[0]
4574 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
4575 ; CHECK-SD-NEXT:    add sp, sp, #48
4576 ; CHECK-SD-NEXT:    ret
4577 ;
4578 ; CHECK-GI-LABEL: log2_v4f16:
4579 ; CHECK-GI:       // %bb.0: // %entry
4580 ; CHECK-GI-NEXT:    sub sp, sp, #80
4581 ; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
4582 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
4583 ; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
4584 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
4585 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
4586 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
4587 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
4588 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
4589 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
4590 ; CHECK-GI-NEXT:    mov h8, v0.h[1]
4591 ; CHECK-GI-NEXT:    mov h9, v0.h[2]
4592 ; CHECK-GI-NEXT:    mov h10, v0.h[3]
4593 ; CHECK-GI-NEXT:    fcvt s0, h0
4594 ; CHECK-GI-NEXT:    bl log2f
4595 ; CHECK-GI-NEXT:    fcvt s1, h8
4596 ; CHECK-GI-NEXT:    fcvt h0, s0
4597 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4598 ; CHECK-GI-NEXT:    fmov s0, s1
4599 ; CHECK-GI-NEXT:    bl log2f
4600 ; CHECK-GI-NEXT:    fcvt s1, h9
4601 ; CHECK-GI-NEXT:    fcvt h0, s0
4602 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4603 ; CHECK-GI-NEXT:    fmov s0, s1
4604 ; CHECK-GI-NEXT:    bl log2f
4605 ; CHECK-GI-NEXT:    fcvt s1, h10
4606 ; CHECK-GI-NEXT:    fcvt h0, s0
4607 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4608 ; CHECK-GI-NEXT:    fmov s0, s1
4609 ; CHECK-GI-NEXT:    bl log2f
4610 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #16] // 32-byte Folded Reload
4611 ; CHECK-GI-NEXT:    fcvt h0, s0
4612 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
4613 ; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
4614 ; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
4615 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
4616 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
4617 ; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
4618 ; CHECK-GI-NEXT:    mov v1.h[3], v0.h[0]
4619 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
4620 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
4621 ; CHECK-GI-NEXT:    add sp, sp, #80
4622 ; CHECK-GI-NEXT:    ret
4623 entry:
4624   %c = call <4 x half> @llvm.log2.v4f16(<4 x half> %a)
4625   ret <4 x half> %c
4626 }
4627
4628 define <8 x half> @log2_v8f16(<8 x half> %a) {
4629 ; CHECK-SD-LABEL: log2_v8f16:
4630 ; CHECK-SD:       // %bb.0: // %entry
4631 ; CHECK-SD-NEXT:    sub sp, sp, #48
4632 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
4633 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
4634 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
4635 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
4636 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4637 ; CHECK-SD-NEXT:    fcvt s0, h1
4638 ; CHECK-SD-NEXT:    bl log2f
4639 ; CHECK-SD-NEXT:    fcvt h0, s0
4640 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4641 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4642 ; CHECK-SD-NEXT:    fcvt s0, h0
4643 ; CHECK-SD-NEXT:    bl log2f
4644 ; CHECK-SD-NEXT:    fcvt h0, s0
4645 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4646 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
4647 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4648 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4649 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
4650 ; CHECK-SD-NEXT:    fcvt s0, h0
4651 ; CHECK-SD-NEXT:    bl log2f
4652 ; CHECK-SD-NEXT:    fcvt h0, s0
4653 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4654 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
4655 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4656 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
4657 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4658 ; CHECK-SD-NEXT:    fcvt s0, h0
4659 ; CHECK-SD-NEXT:    bl log2f
4660 ; CHECK-SD-NEXT:    fcvt h0, s0
4661 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4662 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
4663 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4664 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
4665 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4666 ; CHECK-SD-NEXT:    fcvt s0, h0
4667 ; CHECK-SD-NEXT:    bl log2f
4668 ; CHECK-SD-NEXT:    fcvt h0, s0
4669 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4670 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
4671 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4672 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
4673 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4674 ; CHECK-SD-NEXT:    fcvt s0, h0
4675 ; CHECK-SD-NEXT:    bl log2f
4676 ; CHECK-SD-NEXT:    fcvt h0, s0
4677 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4678 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
4679 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4680 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
4681 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4682 ; CHECK-SD-NEXT:    fcvt s0, h0
4683 ; CHECK-SD-NEXT:    bl log2f
4684 ; CHECK-SD-NEXT:    fcvt h0, s0
4685 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4686 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
4687 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4688 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
4689 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4690 ; CHECK-SD-NEXT:    fcvt s0, h0
4691 ; CHECK-SD-NEXT:    bl log2f
4692 ; CHECK-SD-NEXT:    fcvt h1, s0
4693 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4694 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
4695 ; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
4696 ; CHECK-SD-NEXT:    add sp, sp, #48
4697 ; CHECK-SD-NEXT:    ret
4698 ;
4699 ; CHECK-GI-LABEL: log2_v8f16:
4700 ; CHECK-GI:       // %bb.0: // %entry
4701 ; CHECK-GI-NEXT:    sub sp, sp, #176
4702 ; CHECK-GI-NEXT:    str d14, [sp, #112] // 8-byte Folded Spill
4703 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #120] // 16-byte Folded Spill
4704 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #136] // 16-byte Folded Spill
4705 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #152] // 16-byte Folded Spill
4706 ; CHECK-GI-NEXT:    str x30, [sp, #168] // 8-byte Folded Spill
4707 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
4708 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
4709 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
4710 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
4711 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
4712 ; CHECK-GI-NEXT:    .cfi_offset b11, -40
4713 ; CHECK-GI-NEXT:    .cfi_offset b12, -48
4714 ; CHECK-GI-NEXT:    .cfi_offset b13, -56
4715 ; CHECK-GI-NEXT:    .cfi_offset b14, -64
4716 ; CHECK-GI-NEXT:    mov h8, v0.h[1]
4717 ; CHECK-GI-NEXT:    mov h9, v0.h[2]
4718 ; CHECK-GI-NEXT:    mov h10, v0.h[3]
4719 ; CHECK-GI-NEXT:    mov h11, v0.h[4]
4720 ; CHECK-GI-NEXT:    mov h12, v0.h[5]
4721 ; CHECK-GI-NEXT:    mov h13, v0.h[6]
4722 ; CHECK-GI-NEXT:    mov h14, v0.h[7]
4723 ; CHECK-GI-NEXT:    fcvt s0, h0
4724 ; CHECK-GI-NEXT:    bl log2f
4725 ; CHECK-GI-NEXT:    fcvt s1, h8
4726 ; CHECK-GI-NEXT:    fcvt h0, s0
4727 ; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
4728 ; CHECK-GI-NEXT:    fmov s0, s1
4729 ; CHECK-GI-NEXT:    bl log2f
4730 ; CHECK-GI-NEXT:    fcvt s1, h9
4731 ; CHECK-GI-NEXT:    fcvt h0, s0
4732 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
4733 ; CHECK-GI-NEXT:    fmov s0, s1
4734 ; CHECK-GI-NEXT:    bl log2f
4735 ; CHECK-GI-NEXT:    fcvt s1, h10
4736 ; CHECK-GI-NEXT:    fcvt h0, s0
4737 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
4738 ; CHECK-GI-NEXT:    fmov s0, s1
4739 ; CHECK-GI-NEXT:    bl log2f
4740 ; CHECK-GI-NEXT:    fcvt s1, h11
4741 ; CHECK-GI-NEXT:    fcvt h0, s0
4742 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
4743 ; CHECK-GI-NEXT:    fmov s0, s1
4744 ; CHECK-GI-NEXT:    bl log2f
4745 ; CHECK-GI-NEXT:    fcvt s1, h12
4746 ; CHECK-GI-NEXT:    fcvt h0, s0
4747 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4748 ; CHECK-GI-NEXT:    fmov s0, s1
4749 ; CHECK-GI-NEXT:    bl log2f
4750 ; CHECK-GI-NEXT:    fcvt s1, h13
4751 ; CHECK-GI-NEXT:    fcvt h0, s0
4752 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4753 ; CHECK-GI-NEXT:    fmov s0, s1
4754 ; CHECK-GI-NEXT:    bl log2f
4755 ; CHECK-GI-NEXT:    fcvt s1, h14
4756 ; CHECK-GI-NEXT:    fcvt h0, s0
4757 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4758 ; CHECK-GI-NEXT:    fmov s0, s1
4759 ; CHECK-GI-NEXT:    bl log2f
4760 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #80] // 32-byte Folded Reload
4761 ; CHECK-GI-NEXT:    fcvt h0, s0
4762 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #152] // 16-byte Folded Reload
4763 ; CHECK-GI-NEXT:    ldr x30, [sp, #168] // 8-byte Folded Reload
4764 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #136] // 16-byte Folded Reload
4765 ; CHECK-GI-NEXT:    ldr d14, [sp, #112] // 8-byte Folded Reload
4766 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
4767 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #48] // 32-byte Folded Reload
4768 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #120] // 16-byte Folded Reload
4769 ; CHECK-GI-NEXT:    mov v1.h[2], v3.h[0]
4770 ; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
4771 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
4772 ; CHECK-GI-NEXT:    mov v1.h[4], v3.h[0]
4773 ; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
4774 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
4775 ; CHECK-GI-NEXT:    mov v1.h[6], v2.h[0]
4776 ; CHECK-GI-NEXT:    mov v1.h[7], v0.h[0]
4777 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
4778 ; CHECK-GI-NEXT:    add sp, sp, #176
4779 ; CHECK-GI-NEXT:    ret
4780 entry:
4781   %c = call <8 x half> @llvm.log2.v8f16(<8 x half> %a)
4782   ret <8 x half> %c
4783 }
4784
4785 define <16 x half> @log2_v16f16(<16 x half> %a) {
4786 ; CHECK-SD-LABEL: log2_v16f16:
4787 ; CHECK-SD:       // %bb.0: // %entry
4788 ; CHECK-SD-NEXT:    sub sp, sp, #64
4789 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
4790 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
4791 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
4792 ; CHECK-SD-NEXT:    stp q1, q0, [sp] // 32-byte Folded Spill
4793 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
4794 ; CHECK-SD-NEXT:    fcvt s0, h1
4795 ; CHECK-SD-NEXT:    bl log2f
4796 ; CHECK-SD-NEXT:    fcvt h0, s0
4797 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4798 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4799 ; CHECK-SD-NEXT:    fcvt s0, h0
4800 ; CHECK-SD-NEXT:    bl log2f
4801 ; CHECK-SD-NEXT:    fcvt h0, s0
4802 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4803 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
4804 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4805 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4806 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
4807 ; CHECK-SD-NEXT:    fcvt s0, h0
4808 ; CHECK-SD-NEXT:    bl log2f
4809 ; CHECK-SD-NEXT:    fcvt h0, s0
4810 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4811 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
4812 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4813 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
4814 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4815 ; CHECK-SD-NEXT:    fcvt s0, h0
4816 ; CHECK-SD-NEXT:    bl log2f
4817 ; CHECK-SD-NEXT:    fcvt h0, s0
4818 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4819 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
4820 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4821 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
4822 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4823 ; CHECK-SD-NEXT:    fcvt s0, h0
4824 ; CHECK-SD-NEXT:    bl log2f
4825 ; CHECK-SD-NEXT:    fcvt h0, s0
4826 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4827 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
4828 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4829 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
4830 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4831 ; CHECK-SD-NEXT:    fcvt s0, h0
4832 ; CHECK-SD-NEXT:    bl log2f
4833 ; CHECK-SD-NEXT:    fcvt h0, s0
4834 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4835 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
4836 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4837 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
4838 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4839 ; CHECK-SD-NEXT:    fcvt s0, h0
4840 ; CHECK-SD-NEXT:    bl log2f
4841 ; CHECK-SD-NEXT:    fcvt h0, s0
4842 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4843 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
4844 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4845 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
4846 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4847 ; CHECK-SD-NEXT:    fcvt s0, h0
4848 ; CHECK-SD-NEXT:    bl log2f
4849 ; CHECK-SD-NEXT:    fcvt h0, s0
4850 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4851 ; CHECK-SD-NEXT:    mov v1.h[7], v0.h[0]
4852 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4853 ; CHECK-SD-NEXT:    mov h0, v0.h[1]
4854 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4855 ; CHECK-SD-NEXT:    fcvt s0, h0
4856 ; CHECK-SD-NEXT:    bl log2f
4857 ; CHECK-SD-NEXT:    fcvt h0, s0
4858 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4859 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4860 ; CHECK-SD-NEXT:    fcvt s0, h0
4861 ; CHECK-SD-NEXT:    bl log2f
4862 ; CHECK-SD-NEXT:    fcvt h0, s0
4863 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4864 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
4865 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4866 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4867 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
4868 ; CHECK-SD-NEXT:    fcvt s0, h0
4869 ; CHECK-SD-NEXT:    bl log2f
4870 ; CHECK-SD-NEXT:    fcvt h0, s0
4871 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4872 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
4873 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4874 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
4875 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4876 ; CHECK-SD-NEXT:    fcvt s0, h0
4877 ; CHECK-SD-NEXT:    bl log2f
4878 ; CHECK-SD-NEXT:    fcvt h0, s0
4879 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4880 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
4881 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4882 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
4883 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4884 ; CHECK-SD-NEXT:    fcvt s0, h0
4885 ; CHECK-SD-NEXT:    bl log2f
4886 ; CHECK-SD-NEXT:    fcvt h0, s0
4887 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4888 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
4889 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4890 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
4891 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4892 ; CHECK-SD-NEXT:    fcvt s0, h0
4893 ; CHECK-SD-NEXT:    bl log2f
4894 ; CHECK-SD-NEXT:    fcvt h0, s0
4895 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4896 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
4897 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4898 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
4899 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4900 ; CHECK-SD-NEXT:    fcvt s0, h0
4901 ; CHECK-SD-NEXT:    bl log2f
4902 ; CHECK-SD-NEXT:    fcvt h0, s0
4903 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4904 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
4905 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4906 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
4907 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4908 ; CHECK-SD-NEXT:    fcvt s0, h0
4909 ; CHECK-SD-NEXT:    bl log2f
4910 ; CHECK-SD-NEXT:    fmov s1, s0
4911 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
4912 ; CHECK-SD-NEXT:    fcvt h2, s1
4913 ; CHECK-SD-NEXT:    ldp q1, q0, [sp, #16] // 32-byte Folded Reload
4914 ; CHECK-SD-NEXT:    mov v1.h[7], v2.h[0]
4915 ; CHECK-SD-NEXT:    add sp, sp, #64
4916 ; CHECK-SD-NEXT:    ret
4917 ;
4918 ; CHECK-GI-LABEL: log2_v16f16:
4919 ; CHECK-GI:       // %bb.0: // %entry
4920 ; CHECK-GI-NEXT:    sub sp, sp, #320
4921 ; CHECK-GI-NEXT:    stp d15, d14, [sp, #240] // 16-byte Folded Spill
4922 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #256] // 16-byte Folded Spill
4923 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #272] // 16-byte Folded Spill
4924 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #288] // 16-byte Folded Spill
4925 ; CHECK-GI-NEXT:    stp x29, x30, [sp, #304] // 16-byte Folded Spill
4926 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 320
4927 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
4928 ; CHECK-GI-NEXT:    .cfi_offset w29, -16
4929 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
4930 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
4931 ; CHECK-GI-NEXT:    .cfi_offset b10, -40
4932 ; CHECK-GI-NEXT:    .cfi_offset b11, -48
4933 ; CHECK-GI-NEXT:    .cfi_offset b12, -56
4934 ; CHECK-GI-NEXT:    .cfi_offset b13, -64
4935 ; CHECK-GI-NEXT:    .cfi_offset b14, -72
4936 ; CHECK-GI-NEXT:    .cfi_offset b15, -80
4937 ; CHECK-GI-NEXT:    mov v2.16b, v1.16b
4938 ; CHECK-GI-NEXT:    str q1, [sp, #80] // 16-byte Folded Spill
4939 ; CHECK-GI-NEXT:    mov h14, v1.h[1]
4940 ; CHECK-GI-NEXT:    mov h1, v1.h[2]
4941 ; CHECK-GI-NEXT:    mov h15, v0.h[1]
4942 ; CHECK-GI-NEXT:    mov h8, v0.h[2]
4943 ; CHECK-GI-NEXT:    mov h9, v0.h[3]
4944 ; CHECK-GI-NEXT:    mov h10, v0.h[4]
4945 ; CHECK-GI-NEXT:    mov h11, v0.h[5]
4946 ; CHECK-GI-NEXT:    mov h12, v0.h[6]
4947 ; CHECK-GI-NEXT:    mov h13, v0.h[7]
4948 ; CHECK-GI-NEXT:    fcvt s0, h0
4949 ; CHECK-GI-NEXT:    str h1, [sp, #16] // 2-byte Folded Spill
4950 ; CHECK-GI-NEXT:    mov h1, v2.h[3]
4951 ; CHECK-GI-NEXT:    str h1, [sp, #32] // 2-byte Folded Spill
4952 ; CHECK-GI-NEXT:    mov h1, v2.h[4]
4953 ; CHECK-GI-NEXT:    str h1, [sp, #48] // 2-byte Folded Spill
4954 ; CHECK-GI-NEXT:    mov h1, v2.h[5]
4955 ; CHECK-GI-NEXT:    str h1, [sp, #64] // 2-byte Folded Spill
4956 ; CHECK-GI-NEXT:    mov h1, v2.h[6]
4957 ; CHECK-GI-NEXT:    str h1, [sp, #96] // 2-byte Folded Spill
4958 ; CHECK-GI-NEXT:    mov h1, v2.h[7]
4959 ; CHECK-GI-NEXT:    str h1, [sp, #160] // 2-byte Folded Spill
4960 ; CHECK-GI-NEXT:    bl log2f
4961 ; CHECK-GI-NEXT:    fcvt s1, h15
4962 ; CHECK-GI-NEXT:    fcvt h0, s0
4963 ; CHECK-GI-NEXT:    str q0, [sp, #192] // 16-byte Folded Spill
4964 ; CHECK-GI-NEXT:    fmov s0, s1
4965 ; CHECK-GI-NEXT:    bl log2f
4966 ; CHECK-GI-NEXT:    fcvt s1, h8
4967 ; CHECK-GI-NEXT:    fcvt h0, s0
4968 ; CHECK-GI-NEXT:    str q0, [sp, #128] // 16-byte Folded Spill
4969 ; CHECK-GI-NEXT:    fmov s0, s1
4970 ; CHECK-GI-NEXT:    bl log2f
4971 ; CHECK-GI-NEXT:    fcvt s1, h9
4972 ; CHECK-GI-NEXT:    fcvt h0, s0
4973 ; CHECK-GI-NEXT:    str q0, [sp, #224] // 16-byte Folded Spill
4974 ; CHECK-GI-NEXT:    fmov s0, s1
4975 ; CHECK-GI-NEXT:    bl log2f
4976 ; CHECK-GI-NEXT:    fcvt s1, h10
4977 ; CHECK-GI-NEXT:    fcvt h0, s0
4978 ; CHECK-GI-NEXT:    str q0, [sp, #208] // 16-byte Folded Spill
4979 ; CHECK-GI-NEXT:    fmov s0, s1
4980 ; CHECK-GI-NEXT:    bl log2f
4981 ; CHECK-GI-NEXT:    fcvt s1, h11
4982 ; CHECK-GI-NEXT:    fcvt h0, s0
4983 ; CHECK-GI-NEXT:    str q0, [sp, #176] // 16-byte Folded Spill
4984 ; CHECK-GI-NEXT:    fmov s0, s1
4985 ; CHECK-GI-NEXT:    bl log2f
4986 ; CHECK-GI-NEXT:    fcvt s1, h12
4987 ; CHECK-GI-NEXT:    fcvt h0, s0
4988 ; CHECK-GI-NEXT:    str q0, [sp, #144] // 16-byte Folded Spill
4989 ; CHECK-GI-NEXT:    fmov s0, s1
4990 ; CHECK-GI-NEXT:    bl log2f
4991 ; CHECK-GI-NEXT:    fcvt s1, h13
4992 ; CHECK-GI-NEXT:    fcvt h0, s0
4993 ; CHECK-GI-NEXT:    str q0, [sp, #112] // 16-byte Folded Spill
4994 ; CHECK-GI-NEXT:    fmov s0, s1
4995 ; CHECK-GI-NEXT:    bl log2f
4996 ; CHECK-GI-NEXT:    ldr q1, [sp, #80] // 16-byte Folded Reload
4997 ; CHECK-GI-NEXT:    fcvt h0, s0
4998 ; CHECK-GI-NEXT:    fcvt s1, h1
4999 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
5000 ; CHECK-GI-NEXT:    fmov s0, s1
5001 ; CHECK-GI-NEXT:    bl log2f
5002 ; CHECK-GI-NEXT:    fcvt s1, h14
5003 ; CHECK-GI-NEXT:    fcvt h0, s0
5004 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5005 ; CHECK-GI-NEXT:    fmov s0, s1
5006 ; CHECK-GI-NEXT:    bl log2f
5007 ; CHECK-GI-NEXT:    ldr h1, [sp, #16] // 2-byte Folded Reload
5008 ; CHECK-GI-NEXT:    fcvt h0, s0
5009 ; CHECK-GI-NEXT:    fcvt s1, h1
5010 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5011 ; CHECK-GI-NEXT:    fmov s0, s1
5012 ; CHECK-GI-NEXT:    bl log2f
5013 ; CHECK-GI-NEXT:    ldr h1, [sp, #32] // 2-byte Folded Reload
5014 ; CHECK-GI-NEXT:    fcvt h0, s0
5015 ; CHECK-GI-NEXT:    fcvt s1, h1
5016 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
5017 ; CHECK-GI-NEXT:    fmov s0, s1
5018 ; CHECK-GI-NEXT:    bl log2f
5019 ; CHECK-GI-NEXT:    ldr h1, [sp, #48] // 2-byte Folded Reload
5020 ; CHECK-GI-NEXT:    fcvt h0, s0
5021 ; CHECK-GI-NEXT:    fcvt s1, h1
5022 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
5023 ; CHECK-GI-NEXT:    fmov s0, s1
5024 ; CHECK-GI-NEXT:    bl log2f
5025 ; CHECK-GI-NEXT:    ldr h1, [sp, #64] // 2-byte Folded Reload
5026 ; CHECK-GI-NEXT:    fcvt h0, s0
5027 ; CHECK-GI-NEXT:    fcvt s1, h1
5028 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
5029 ; CHECK-GI-NEXT:    fmov s0, s1
5030 ; CHECK-GI-NEXT:    bl log2f
5031 ; CHECK-GI-NEXT:    ldr h1, [sp, #96] // 2-byte Folded Reload
5032 ; CHECK-GI-NEXT:    fcvt h0, s0
5033 ; CHECK-GI-NEXT:    fcvt s1, h1
5034 ; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
5035 ; CHECK-GI-NEXT:    fmov s0, s1
5036 ; CHECK-GI-NEXT:    bl log2f
5037 ; CHECK-GI-NEXT:    ldr h1, [sp, #160] // 2-byte Folded Reload
5038 ; CHECK-GI-NEXT:    fcvt h0, s0
5039 ; CHECK-GI-NEXT:    fcvt s1, h1
5040 ; CHECK-GI-NEXT:    str q0, [sp, #160] // 16-byte Folded Spill
5041 ; CHECK-GI-NEXT:    fmov s0, s1
5042 ; CHECK-GI-NEXT:    bl log2f
5043 ; CHECK-GI-NEXT:    ldr q3, [sp, #192] // 16-byte Folded Reload
5044 ; CHECK-GI-NEXT:    ldr q2, [sp, #128] // 16-byte Folded Reload
5045 ; CHECK-GI-NEXT:    ldp x29, x30, [sp, #304] // 16-byte Folded Reload
5046 ; CHECK-GI-NEXT:    mov v3.h[1], v2.h[0]
5047 ; CHECK-GI-NEXT:    ldp q1, q2, [sp] // 32-byte Folded Reload
5048 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #288] // 16-byte Folded Reload
5049 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #272] // 16-byte Folded Reload
5050 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
5051 ; CHECK-GI-NEXT:    ldr q2, [sp, #224] // 16-byte Folded Reload
5052 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #256] // 16-byte Folded Reload
5053 ; CHECK-GI-NEXT:    mov v3.h[2], v2.h[0]
5054 ; CHECK-GI-NEXT:    ldr q2, [sp, #32] // 16-byte Folded Reload
5055 ; CHECK-GI-NEXT:    ldp d15, d14, [sp, #240] // 16-byte Folded Reload
5056 ; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
5057 ; CHECK-GI-NEXT:    ldr q2, [sp, #208] // 16-byte Folded Reload
5058 ; CHECK-GI-NEXT:    mov v3.h[3], v2.h[0]
5059 ; CHECK-GI-NEXT:    ldr q2, [sp, #48] // 16-byte Folded Reload
5060 ; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
5061 ; CHECK-GI-NEXT:    ldr q2, [sp, #176] // 16-byte Folded Reload
5062 ; CHECK-GI-NEXT:    mov v3.h[4], v2.h[0]
5063 ; CHECK-GI-NEXT:    ldr q2, [sp, #64] // 16-byte Folded Reload
5064 ; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
5065 ; CHECK-GI-NEXT:    ldr q2, [sp, #144] // 16-byte Folded Reload
5066 ; CHECK-GI-NEXT:    mov v3.h[5], v2.h[0]
5067 ; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
5068 ; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
5069 ; CHECK-GI-NEXT:    fcvt h2, s0
5070 ; CHECK-GI-NEXT:    ldr q0, [sp, #112] // 16-byte Folded Reload
5071 ; CHECK-GI-NEXT:    mov v3.h[6], v0.h[0]
5072 ; CHECK-GI-NEXT:    ldr q0, [sp, #160] // 16-byte Folded Reload
5073 ; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
5074 ; CHECK-GI-NEXT:    ldr q0, [sp, #80] // 16-byte Folded Reload
5075 ; CHECK-GI-NEXT:    mov v3.h[7], v0.h[0]
5076 ; CHECK-GI-NEXT:    mov v1.h[7], v2.h[0]
5077 ; CHECK-GI-NEXT:    mov v0.16b, v3.16b
5078 ; CHECK-GI-NEXT:    add sp, sp, #320
5079 ; CHECK-GI-NEXT:    ret
5080 entry:
5081   %c = call <16 x half> @llvm.log2.v16f16(<16 x half> %a)
5082   ret <16 x half> %c
5083 }
5084
5085 define double @log10_f64(double %a) {
5086 ; CHECK-LABEL: log10_f64:
5087 ; CHECK:       // %bb.0: // %entry
5088 ; CHECK-NEXT:    b log10
5089 entry:
5090   %c = call double @llvm.log10.f64(double %a)
5091   ret double %c
5092 }
5093
5094 define float @log10_f32(float %a) {
5095 ; CHECK-LABEL: log10_f32:
5096 ; CHECK:       // %bb.0: // %entry
5097 ; CHECK-NEXT:    b log10f
5098 entry:
5099   %c = call float @llvm.log10.f32(float %a)
5100   ret float %c
5101 }
5102
5103 define half @log10_f16(half %a) {
5104 ; CHECK-LABEL: log10_f16:
5105 ; CHECK:       // %bb.0: // %entry
5106 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
5107 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
5108 ; CHECK-NEXT:    .cfi_offset w30, -16
5109 ; CHECK-NEXT:    fcvt s0, h0
5110 ; CHECK-NEXT:    bl log10f
5111 ; CHECK-NEXT:    fcvt h0, s0
5112 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
5113 ; CHECK-NEXT:    ret
5114 entry:
5115   %c = call half @llvm.log10.f16(half %a)
5116   ret half %c
5117 }
5118
5119 define <1 x double> @log10_v1f64(<1 x double> %x) {
5120 ; CHECK-LABEL: log10_v1f64:
5121 ; CHECK:       // %bb.0:
5122 ; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
5123 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
5124 ; CHECK-NEXT:    .cfi_offset w30, -16
5125 ; CHECK-NEXT:    bl log10
5126 ; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
5127 ; CHECK-NEXT:    ret
5128   %c = call <1 x double> @llvm.log10.v1f64(<1 x double> %x)
5129   ret <1 x double> %c
5130 }
5131
5132 define <2 x double> @log10_v2f64(<2 x double> %a) {
5133 ; CHECK-SD-LABEL: log10_v2f64:
5134 ; CHECK-SD:       // %bb.0: // %entry
5135 ; CHECK-SD-NEXT:    sub sp, sp, #48
5136 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
5137 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
5138 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
5139 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5140 ; CHECK-SD-NEXT:    mov d0, v0.d[1]
5141 ; CHECK-SD-NEXT:    bl log10
5142 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
5143 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5144 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5145 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
5146 ; CHECK-SD-NEXT:    bl log10
5147 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5148 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
5149 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
5150 ; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
5151 ; CHECK-SD-NEXT:    add sp, sp, #48
5152 ; CHECK-SD-NEXT:    ret
5153 ;
5154 ; CHECK-GI-LABEL: log10_v2f64:
5155 ; CHECK-GI:       // %bb.0: // %entry
5156 ; CHECK-GI-NEXT:    sub sp, sp, #32
5157 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
5158 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
5159 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
5160 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
5161 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
5162 ; CHECK-GI-NEXT:    mov d8, v0.d[1]
5163 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
5164 ; CHECK-GI-NEXT:    bl log10
5165 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
5166 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5167 ; CHECK-GI-NEXT:    fmov d0, d8
5168 ; CHECK-GI-NEXT:    bl log10
5169 ; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5170 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
5171 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
5172 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
5173 ; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
5174 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
5175 ; CHECK-GI-NEXT:    add sp, sp, #32
5176 ; CHECK-GI-NEXT:    ret
5177 entry:
5178   %c = call <2 x double> @llvm.log10.v2f64(<2 x double> %a)
5179   ret <2 x double> %c
5180 }
5181
5182 define <3 x double> @log10_v3f64(<3 x double> %a) {
5183 ; CHECK-SD-LABEL: log10_v3f64:
5184 ; CHECK-SD:       // %bb.0: // %entry
5185 ; CHECK-SD-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
5186 ; CHECK-SD-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
5187 ; CHECK-SD-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
5188 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 32
5189 ; CHECK-SD-NEXT:    .cfi_offset w30, -8
5190 ; CHECK-SD-NEXT:    .cfi_offset b8, -16
5191 ; CHECK-SD-NEXT:    .cfi_offset b9, -24
5192 ; CHECK-SD-NEXT:    .cfi_offset b10, -32
5193 ; CHECK-SD-NEXT:    fmov d8, d2
5194 ; CHECK-SD-NEXT:    fmov d9, d1
5195 ; CHECK-SD-NEXT:    bl log10
5196 ; CHECK-SD-NEXT:    fmov d10, d0
5197 ; CHECK-SD-NEXT:    fmov d0, d9
5198 ; CHECK-SD-NEXT:    bl log10
5199 ; CHECK-SD-NEXT:    fmov d9, d0
5200 ; CHECK-SD-NEXT:    fmov d0, d8
5201 ; CHECK-SD-NEXT:    bl log10
5202 ; CHECK-SD-NEXT:    fmov d1, d9
5203 ; CHECK-SD-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
5204 ; CHECK-SD-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
5205 ; CHECK-SD-NEXT:    fmov d2, d0
5206 ; CHECK-SD-NEXT:    fmov d0, d10
5207 ; CHECK-SD-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
5208 ; CHECK-SD-NEXT:    ret
5209 ;
5210 ; CHECK-GI-LABEL: log10_v3f64:
5211 ; CHECK-GI:       // %bb.0: // %entry
5212 ; CHECK-GI-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
5213 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
5214 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
5215 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
5216 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
5217 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
5218 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
5219 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
5220 ; CHECK-GI-NEXT:    fmov d8, d1
5221 ; CHECK-GI-NEXT:    fmov d9, d2
5222 ; CHECK-GI-NEXT:    bl log10
5223 ; CHECK-GI-NEXT:    fmov d10, d0
5224 ; CHECK-GI-NEXT:    fmov d0, d8
5225 ; CHECK-GI-NEXT:    bl log10
5226 ; CHECK-GI-NEXT:    fmov d8, d0
5227 ; CHECK-GI-NEXT:    fmov d0, d9
5228 ; CHECK-GI-NEXT:    bl log10
5229 ; CHECK-GI-NEXT:    fmov d1, d8
5230 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
5231 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
5232 ; CHECK-GI-NEXT:    fmov d2, d0
5233 ; CHECK-GI-NEXT:    fmov d0, d10
5234 ; CHECK-GI-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
5235 ; CHECK-GI-NEXT:    ret
5236 entry:
5237   %c = call <3 x double> @llvm.log10.v3f64(<3 x double> %a)
5238   ret <3 x double> %c
5239 }
5240
5241 define <4 x double> @log10_v4f64(<4 x double> %a) {
5242 ; CHECK-SD-LABEL: log10_v4f64:
5243 ; CHECK-SD:       // %bb.0: // %entry
5244 ; CHECK-SD-NEXT:    sub sp, sp, #64
5245 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
5246 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
5247 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
5248 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5249 ; CHECK-SD-NEXT:    mov d0, v0.d[1]
5250 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
5251 ; CHECK-SD-NEXT:    bl log10
5252 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
5253 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5254 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5255 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
5256 ; CHECK-SD-NEXT:    bl log10
5257 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5258 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
5259 ; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
5260 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5261 ; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
5262 ; CHECK-SD-NEXT:    mov d0, v0.d[1]
5263 ; CHECK-SD-NEXT:    bl log10
5264 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
5265 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5266 ; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
5267 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
5268 ; CHECK-SD-NEXT:    bl log10
5269 ; CHECK-SD-NEXT:    fmov d1, d0
5270 ; CHECK-SD-NEXT:    ldp q2, q0, [sp] // 32-byte Folded Reload
5271 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
5272 ; CHECK-SD-NEXT:    mov v1.d[1], v2.d[0]
5273 ; CHECK-SD-NEXT:    add sp, sp, #64
5274 ; CHECK-SD-NEXT:    ret
5275 ;
5276 ; CHECK-GI-LABEL: log10_v4f64:
5277 ; CHECK-GI:       // %bb.0: // %entry
5278 ; CHECK-GI-NEXT:    sub sp, sp, #80
5279 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
5280 ; CHECK-GI-NEXT:    str x30, [sp, #64] // 8-byte Folded Spill
5281 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
5282 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
5283 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
5284 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
5285 ; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
5286 ; CHECK-GI-NEXT:    mov d8, v0.d[1]
5287 ; CHECK-GI-NEXT:    mov d9, v1.d[1]
5288 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
5289 ; CHECK-GI-NEXT:    bl log10
5290 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
5291 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
5292 ; CHECK-GI-NEXT:    fmov d0, d8
5293 ; CHECK-GI-NEXT:    bl log10
5294 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
5295 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5296 ; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5297 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
5298 ; CHECK-GI-NEXT:    bl log10
5299 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
5300 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5301 ; CHECK-GI-NEXT:    fmov d0, d9
5302 ; CHECK-GI-NEXT:    bl log10
5303 ; CHECK-GI-NEXT:    ldp q1, q2, [sp, #16] // 32-byte Folded Reload
5304 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
5305 ; CHECK-GI-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
5306 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
5307 ; CHECK-GI-NEXT:    mov v2.d[1], v1.d[0]
5308 ; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5309 ; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
5310 ; CHECK-GI-NEXT:    mov v0.16b, v2.16b
5311 ; CHECK-GI-NEXT:    add sp, sp, #80
5312 ; CHECK-GI-NEXT:    ret
5313 entry:
5314   %c = call <4 x double> @llvm.log10.v4f64(<4 x double> %a)
5315   ret <4 x double> %c
5316 }
5317
5318 define <2 x float> @log10_v2f32(<2 x float> %a) {
5319 ; CHECK-SD-LABEL: log10_v2f32:
5320 ; CHECK-SD:       // %bb.0: // %entry
5321 ; CHECK-SD-NEXT:    sub sp, sp, #48
5322 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
5323 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
5324 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
5325 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
5326 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5327 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
5328 ; CHECK-SD-NEXT:    bl log10f
5329 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5330 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5331 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5332 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
5333 ; CHECK-SD-NEXT:    bl log10f
5334 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5335 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5336 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
5337 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
5338 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
5339 ; CHECK-SD-NEXT:    add sp, sp, #48
5340 ; CHECK-SD-NEXT:    ret
5341 ;
5342 ; CHECK-GI-LABEL: log10_v2f32:
5343 ; CHECK-GI:       // %bb.0: // %entry
5344 ; CHECK-GI-NEXT:    sub sp, sp, #32
5345 ; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
5346 ; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
5347 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
5348 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
5349 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
5350 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
5351 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
5352 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
5353 ; CHECK-GI-NEXT:    bl log10f
5354 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5355 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5356 ; CHECK-GI-NEXT:    fmov s0, s8
5357 ; CHECK-GI-NEXT:    bl log10f
5358 ; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5359 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5360 ; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
5361 ; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
5362 ; CHECK-GI-NEXT:    mov v1.s[1], v0.s[0]
5363 ; CHECK-GI-NEXT:    fmov d0, d1
5364 ; CHECK-GI-NEXT:    add sp, sp, #32
5365 ; CHECK-GI-NEXT:    ret
5366 entry:
5367   %c = call <2 x float> @llvm.log10.v2f32(<2 x float> %a)
5368   ret <2 x float> %c
5369 }
5370
5371 define <3 x float> @log10_v3f32(<3 x float> %a) {
5372 ; CHECK-SD-LABEL: log10_v3f32:
5373 ; CHECK-SD:       // %bb.0: // %entry
5374 ; CHECK-SD-NEXT:    sub sp, sp, #48
5375 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
5376 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
5377 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
5378 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5379 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
5380 ; CHECK-SD-NEXT:    bl log10f
5381 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5382 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5383 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5384 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
5385 ; CHECK-SD-NEXT:    bl log10f
5386 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5387 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5388 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
5389 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5390 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5391 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
5392 ; CHECK-SD-NEXT:    bl log10f
5393 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5394 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5395 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
5396 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
5397 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
5398 ; CHECK-SD-NEXT:    add sp, sp, #48
5399 ; CHECK-SD-NEXT:    ret
5400 ;
5401 ; CHECK-GI-LABEL: log10_v3f32:
5402 ; CHECK-GI:       // %bb.0: // %entry
5403 ; CHECK-GI-NEXT:    sub sp, sp, #64
5404 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #32] // 16-byte Folded Spill
5405 ; CHECK-GI-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
5406 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 64
5407 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
5408 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
5409 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
5410 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
5411 ; CHECK-GI-NEXT:    mov s9, v0.s[2]
5412 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
5413 ; CHECK-GI-NEXT:    bl log10f
5414 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5415 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5416 ; CHECK-GI-NEXT:    fmov s0, s8
5417 ; CHECK-GI-NEXT:    bl log10f
5418 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5419 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5420 ; CHECK-GI-NEXT:    fmov s0, s9
5421 ; CHECK-GI-NEXT:    bl log10f
5422 ; CHECK-GI-NEXT:    ldp q2, q1, [sp] // 32-byte Folded Reload
5423 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5424 ; CHECK-GI-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
5425 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #32] // 16-byte Folded Reload
5426 ; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
5427 ; CHECK-GI-NEXT:    mov v1.s[2], v0.s[0]
5428 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
5429 ; CHECK-GI-NEXT:    add sp, sp, #64
5430 ; CHECK-GI-NEXT:    ret
5431 entry:
5432   %c = call <3 x float> @llvm.log10.v3f32(<3 x float> %a)
5433   ret <3 x float> %c
5434 }
5435
5436 define <4 x float> @log10_v4f32(<4 x float> %a) {
5437 ; CHECK-SD-LABEL: log10_v4f32:
5438 ; CHECK-SD:       // %bb.0: // %entry
5439 ; CHECK-SD-NEXT:    sub sp, sp, #48
5440 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
5441 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
5442 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
5443 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5444 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
5445 ; CHECK-SD-NEXT:    bl log10f
5446 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5447 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5448 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5449 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
5450 ; CHECK-SD-NEXT:    bl log10f
5451 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5452 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5453 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
5454 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5455 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5456 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
5457 ; CHECK-SD-NEXT:    bl log10f
5458 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5459 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5460 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
5461 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5462 ; CHECK-SD-NEXT:    mov s0, v0.s[3]
5463 ; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
5464 ; CHECK-SD-NEXT:    bl log10f
5465 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5466 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5467 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
5468 ; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
5469 ; CHECK-SD-NEXT:    mov v0.16b, v1.16b
5470 ; CHECK-SD-NEXT:    add sp, sp, #48
5471 ; CHECK-SD-NEXT:    ret
5472 ;
5473 ; CHECK-GI-LABEL: log10_v4f32:
5474 ; CHECK-GI:       // %bb.0: // %entry
5475 ; CHECK-GI-NEXT:    sub sp, sp, #80
5476 ; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
5477 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
5478 ; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
5479 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
5480 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
5481 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
5482 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
5483 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
5484 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
5485 ; CHECK-GI-NEXT:    mov s9, v0.s[2]
5486 ; CHECK-GI-NEXT:    mov s10, v0.s[3]
5487 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
5488 ; CHECK-GI-NEXT:    bl log10f
5489 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5490 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
5491 ; CHECK-GI-NEXT:    fmov s0, s8
5492 ; CHECK-GI-NEXT:    bl log10f
5493 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5494 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5495 ; CHECK-GI-NEXT:    fmov s0, s9
5496 ; CHECK-GI-NEXT:    bl log10f
5497 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5498 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5499 ; CHECK-GI-NEXT:    fmov s0, s10
5500 ; CHECK-GI-NEXT:    bl log10f
5501 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #16] // 32-byte Folded Reload
5502 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5503 ; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
5504 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
5505 ; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
5506 ; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
5507 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
5508 ; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
5509 ; CHECK-GI-NEXT:    mov v1.s[3], v0.s[0]
5510 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
5511 ; CHECK-GI-NEXT:    add sp, sp, #80
5512 ; CHECK-GI-NEXT:    ret
5513 entry:
5514   %c = call <4 x float> @llvm.log10.v4f32(<4 x float> %a)
5515   ret <4 x float> %c
5516 }
5517
5518 define <8 x float> @log10_v8f32(<8 x float> %a) {
5519 ; CHECK-SD-LABEL: log10_v8f32:
5520 ; CHECK-SD:       // %bb.0: // %entry
5521 ; CHECK-SD-NEXT:    sub sp, sp, #64
5522 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
5523 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
5524 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
5525 ; CHECK-SD-NEXT:    stp q0, q1, [sp] // 32-byte Folded Spill
5526 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
5527 ; CHECK-SD-NEXT:    bl log10f
5528 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5529 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
5530 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5531 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
5532 ; CHECK-SD-NEXT:    bl log10f
5533 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
5534 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5535 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
5536 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
5537 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5538 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
5539 ; CHECK-SD-NEXT:    bl log10f
5540 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
5541 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5542 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
5543 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5544 ; CHECK-SD-NEXT:    mov s0, v0.s[3]
5545 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
5546 ; CHECK-SD-NEXT:    bl log10f
5547 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
5548 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5549 ; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
5550 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5551 ; CHECK-SD-NEXT:    mov s0, v0.s[1]
5552 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
5553 ; CHECK-SD-NEXT:    bl log10f
5554 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5555 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5556 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5557 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
5558 ; CHECK-SD-NEXT:    bl log10f
5559 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5560 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5561 ; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
5562 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5563 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5564 ; CHECK-SD-NEXT:    mov s0, v0.s[2]
5565 ; CHECK-SD-NEXT:    bl log10f
5566 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5567 ; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5568 ; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
5569 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5570 ; CHECK-SD-NEXT:    mov s0, v0.s[3]
5571 ; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
5572 ; CHECK-SD-NEXT:    bl log10f
5573 ; CHECK-SD-NEXT:    fmov s2, s0
5574 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5575 ; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
5576 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
5577 ; CHECK-SD-NEXT:    mov v1.s[3], v2.s[0]
5578 ; CHECK-SD-NEXT:    add sp, sp, #64
5579 ; CHECK-SD-NEXT:    ret
5580 ;
5581 ; CHECK-GI-LABEL: log10_v8f32:
5582 ; CHECK-GI:       // %bb.0: // %entry
5583 ; CHECK-GI-NEXT:    sub sp, sp, #176
5584 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #112] // 16-byte Folded Spill
5585 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #128] // 16-byte Folded Spill
5586 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #144] // 16-byte Folded Spill
5587 ; CHECK-GI-NEXT:    str x30, [sp, #160] // 8-byte Folded Spill
5588 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
5589 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
5590 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
5591 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
5592 ; CHECK-GI-NEXT:    .cfi_offset b10, -40
5593 ; CHECK-GI-NEXT:    .cfi_offset b11, -48
5594 ; CHECK-GI-NEXT:    .cfi_offset b12, -56
5595 ; CHECK-GI-NEXT:    .cfi_offset b13, -64
5596 ; CHECK-GI-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
5597 ; CHECK-GI-NEXT:    mov s8, v0.s[1]
5598 ; CHECK-GI-NEXT:    mov s9, v0.s[2]
5599 ; CHECK-GI-NEXT:    mov s10, v0.s[3]
5600 ; CHECK-GI-NEXT:    mov s11, v1.s[1]
5601 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
5602 ; CHECK-GI-NEXT:    mov s12, v1.s[2]
5603 ; CHECK-GI-NEXT:    mov s13, v1.s[3]
5604 ; CHECK-GI-NEXT:    bl log10f
5605 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5606 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
5607 ; CHECK-GI-NEXT:    fmov s0, s8
5608 ; CHECK-GI-NEXT:    bl log10f
5609 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5610 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
5611 ; CHECK-GI-NEXT:    fmov s0, s9
5612 ; CHECK-GI-NEXT:    bl log10f
5613 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5614 ; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
5615 ; CHECK-GI-NEXT:    fmov s0, s10
5616 ; CHECK-GI-NEXT:    bl log10f
5617 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5618 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
5619 ; CHECK-GI-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
5620 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
5621 ; CHECK-GI-NEXT:    bl log10f
5622 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5623 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
5624 ; CHECK-GI-NEXT:    fmov s0, s11
5625 ; CHECK-GI-NEXT:    bl log10f
5626 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5627 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5628 ; CHECK-GI-NEXT:    fmov s0, s12
5629 ; CHECK-GI-NEXT:    bl log10f
5630 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5631 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5632 ; CHECK-GI-NEXT:    fmov s0, s13
5633 ; CHECK-GI-NEXT:    bl log10f
5634 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #48] // 32-byte Folded Reload
5635 ; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5636 ; CHECK-GI-NEXT:    ldr x30, [sp, #160] // 8-byte Folded Reload
5637 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #144] // 16-byte Folded Reload
5638 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #128] // 16-byte Folded Reload
5639 ; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
5640 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
5641 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #112] // 16-byte Folded Reload
5642 ; CHECK-GI-NEXT:    mov v3.s[1], v2.s[0]
5643 ; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
5644 ; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
5645 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
5646 ; CHECK-GI-NEXT:    mov v3.s[2], v2.s[0]
5647 ; CHECK-GI-NEXT:    ldr q2, [sp, #80] // 16-byte Folded Reload
5648 ; CHECK-GI-NEXT:    mov v1.s[3], v2.s[0]
5649 ; CHECK-GI-NEXT:    mov v3.s[3], v0.s[0]
5650 ; CHECK-GI-NEXT:    mov v2.16b, v1.16b
5651 ; CHECK-GI-NEXT:    mov v1.16b, v3.16b
5652 ; CHECK-GI-NEXT:    mov v0.16b, v2.16b
5653 ; CHECK-GI-NEXT:    add sp, sp, #176
5654 ; CHECK-GI-NEXT:    ret
5655 entry:
5656   %c = call <8 x float> @llvm.log10.v8f32(<8 x float> %a)
5657   ret <8 x float> %c
5658 }
5659
5660 define <7 x half> @log10_v7f16(<7 x half> %a) {
5661 ; CHECK-SD-LABEL: log10_v7f16:
5662 ; CHECK-SD:       // %bb.0: // %entry
5663 ; CHECK-SD-NEXT:    sub sp, sp, #48
5664 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
5665 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
5666 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
5667 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
5668 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5669 ; CHECK-SD-NEXT:    fcvt s0, h1
5670 ; CHECK-SD-NEXT:    bl log10f
5671 ; CHECK-SD-NEXT:    fcvt h0, s0
5672 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5673 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5674 ; CHECK-SD-NEXT:    fcvt s0, h0
5675 ; CHECK-SD-NEXT:    bl log10f
5676 ; CHECK-SD-NEXT:    fcvt h0, s0
5677 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5678 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
5679 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5680 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5681 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
5682 ; CHECK-SD-NEXT:    fcvt s0, h0
5683 ; CHECK-SD-NEXT:    bl log10f
5684 ; CHECK-SD-NEXT:    fcvt h0, s0
5685 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5686 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
5687 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5688 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
5689 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5690 ; CHECK-SD-NEXT:    fcvt s0, h0
5691 ; CHECK-SD-NEXT:    bl log10f
5692 ; CHECK-SD-NEXT:    fcvt h0, s0
5693 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5694 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
5695 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5696 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
5697 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5698 ; CHECK-SD-NEXT:    fcvt s0, h0
5699 ; CHECK-SD-NEXT:    bl log10f
5700 ; CHECK-SD-NEXT:    fcvt h0, s0
5701 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5702 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
5703 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5704 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
5705 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5706 ; CHECK-SD-NEXT:    fcvt s0, h0
5707 ; CHECK-SD-NEXT:    bl log10f
5708 ; CHECK-SD-NEXT:    fcvt h0, s0
5709 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5710 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
5711 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5712 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
5713 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5714 ; CHECK-SD-NEXT:    fcvt s0, h0
5715 ; CHECK-SD-NEXT:    bl log10f
5716 ; CHECK-SD-NEXT:    fcvt h0, s0
5717 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5718 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
5719 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5720 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
5721 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5722 ; CHECK-SD-NEXT:    fcvt s0, h0
5723 ; CHECK-SD-NEXT:    bl log10f
5724 ; CHECK-SD-NEXT:    fcvt h1, s0
5725 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5726 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
5727 ; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
5728 ; CHECK-SD-NEXT:    add sp, sp, #48
5729 ; CHECK-SD-NEXT:    ret
5730 ;
5731 ; CHECK-GI-LABEL: log10_v7f16:
5732 ; CHECK-GI:       // %bb.0: // %entry
5733 ; CHECK-GI-NEXT:    sub sp, sp, #160
5734 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #96] // 16-byte Folded Spill
5735 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #112] // 16-byte Folded Spill
5736 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #128] // 16-byte Folded Spill
5737 ; CHECK-GI-NEXT:    str x30, [sp, #144] // 8-byte Folded Spill
5738 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 160
5739 ; CHECK-GI-NEXT:    .cfi_offset w30, -16
5740 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
5741 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
5742 ; CHECK-GI-NEXT:    .cfi_offset b10, -40
5743 ; CHECK-GI-NEXT:    .cfi_offset b11, -48
5744 ; CHECK-GI-NEXT:    .cfi_offset b12, -56
5745 ; CHECK-GI-NEXT:    .cfi_offset b13, -64
5746 ; CHECK-GI-NEXT:    mov h8, v0.h[1]
5747 ; CHECK-GI-NEXT:    mov h9, v0.h[2]
5748 ; CHECK-GI-NEXT:    mov h10, v0.h[3]
5749 ; CHECK-GI-NEXT:    mov h11, v0.h[4]
5750 ; CHECK-GI-NEXT:    mov h12, v0.h[5]
5751 ; CHECK-GI-NEXT:    mov h13, v0.h[6]
5752 ; CHECK-GI-NEXT:    fcvt s0, h0
5753 ; CHECK-GI-NEXT:    bl log10f
5754 ; CHECK-GI-NEXT:    fcvt s1, h8
5755 ; CHECK-GI-NEXT:    fcvt h0, s0
5756 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
5757 ; CHECK-GI-NEXT:    fmov s0, s1
5758 ; CHECK-GI-NEXT:    bl log10f
5759 ; CHECK-GI-NEXT:    fcvt s1, h9
5760 ; CHECK-GI-NEXT:    fcvt h0, s0
5761 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
5762 ; CHECK-GI-NEXT:    fmov s0, s1
5763 ; CHECK-GI-NEXT:    bl log10f
5764 ; CHECK-GI-NEXT:    fcvt s1, h10
5765 ; CHECK-GI-NEXT:    fcvt h0, s0
5766 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
5767 ; CHECK-GI-NEXT:    fmov s0, s1
5768 ; CHECK-GI-NEXT:    bl log10f
5769 ; CHECK-GI-NEXT:    fcvt s1, h11
5770 ; CHECK-GI-NEXT:    fcvt h0, s0
5771 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
5772 ; CHECK-GI-NEXT:    fmov s0, s1
5773 ; CHECK-GI-NEXT:    bl log10f
5774 ; CHECK-GI-NEXT:    fcvt s1, h12
5775 ; CHECK-GI-NEXT:    fcvt h0, s0
5776 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5777 ; CHECK-GI-NEXT:    fmov s0, s1
5778 ; CHECK-GI-NEXT:    bl log10f
5779 ; CHECK-GI-NEXT:    fcvt s1, h13
5780 ; CHECK-GI-NEXT:    fcvt h0, s0
5781 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5782 ; CHECK-GI-NEXT:    fmov s0, s1
5783 ; CHECK-GI-NEXT:    bl log10f
5784 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #64] // 32-byte Folded Reload
5785 ; CHECK-GI-NEXT:    fcvt h0, s0
5786 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #128] // 16-byte Folded Reload
5787 ; CHECK-GI-NEXT:    ldr x30, [sp, #144] // 8-byte Folded Reload
5788 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #112] // 16-byte Folded Reload
5789 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
5790 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #32] // 32-byte Folded Reload
5791 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #96] // 16-byte Folded Reload
5792 ; CHECK-GI-NEXT:    mov v1.h[2], v3.h[0]
5793 ; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
5794 ; CHECK-GI-NEXT:    ldp q2, q3, [sp] // 32-byte Folded Reload
5795 ; CHECK-GI-NEXT:    mov v1.h[4], v3.h[0]
5796 ; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
5797 ; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
5798 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
5799 ; CHECK-GI-NEXT:    add sp, sp, #160
5800 ; CHECK-GI-NEXT:    ret
5801 entry:
5802   %c = call <7 x half> @llvm.log10.v7f16(<7 x half> %a)
5803   ret <7 x half> %c
5804 }
5805
5806 define <4 x half> @log10_v4f16(<4 x half> %a) {
5807 ; CHECK-SD-LABEL: log10_v4f16:
5808 ; CHECK-SD:       // %bb.0: // %entry
5809 ; CHECK-SD-NEXT:    sub sp, sp, #48
5810 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
5811 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
5812 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
5813 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
5814 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
5815 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5816 ; CHECK-SD-NEXT:    fcvt s0, h1
5817 ; CHECK-SD-NEXT:    bl log10f
5818 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5819 ; CHECK-SD-NEXT:    fcvt h0, s0
5820 ; CHECK-SD-NEXT:    fcvt s1, h1
5821 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5822 ; CHECK-SD-NEXT:    fmov s0, s1
5823 ; CHECK-SD-NEXT:    bl log10f
5824 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5825 ; CHECK-SD-NEXT:    fcvt h2, s0
5826 ; CHECK-SD-NEXT:    mov h1, v1.h[2]
5827 ; CHECK-SD-NEXT:    fcvt s0, h1
5828 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5829 ; CHECK-SD-NEXT:    mov v2.h[1], v1.h[0]
5830 ; CHECK-SD-NEXT:    str q2, [sp] // 16-byte Folded Spill
5831 ; CHECK-SD-NEXT:    bl log10f
5832 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5833 ; CHECK-SD-NEXT:    fcvt h2, s0
5834 ; CHECK-SD-NEXT:    mov h1, v1.h[3]
5835 ; CHECK-SD-NEXT:    fcvt s0, h1
5836 ; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5837 ; CHECK-SD-NEXT:    mov v1.h[2], v2.h[0]
5838 ; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
5839 ; CHECK-SD-NEXT:    bl log10f
5840 ; CHECK-SD-NEXT:    fcvt h1, s0
5841 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5842 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
5843 ; CHECK-SD-NEXT:    mov v0.h[3], v1.h[0]
5844 ; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
5845 ; CHECK-SD-NEXT:    add sp, sp, #48
5846 ; CHECK-SD-NEXT:    ret
5847 ;
5848 ; CHECK-GI-LABEL: log10_v4f16:
5849 ; CHECK-GI:       // %bb.0: // %entry
5850 ; CHECK-GI-NEXT:    sub sp, sp, #80
5851 ; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
5852 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
5853 ; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
5854 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
5855 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
5856 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
5857 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
5858 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
5859 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
5860 ; CHECK-GI-NEXT:    mov h8, v0.h[1]
5861 ; CHECK-GI-NEXT:    mov h9, v0.h[2]
5862 ; CHECK-GI-NEXT:    mov h10, v0.h[3]
5863 ; CHECK-GI-NEXT:    fcvt s0, h0
5864 ; CHECK-GI-NEXT:    bl log10f
5865 ; CHECK-GI-NEXT:    fcvt s1, h8
5866 ; CHECK-GI-NEXT:    fcvt h0, s0
5867 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
5868 ; CHECK-GI-NEXT:    fmov s0, s1
5869 ; CHECK-GI-NEXT:    bl log10f
5870 ; CHECK-GI-NEXT:    fcvt s1, h9
5871 ; CHECK-GI-NEXT:    fcvt h0, s0
5872 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5873 ; CHECK-GI-NEXT:    fmov s0, s1
5874 ; CHECK-GI-NEXT:    bl log10f
5875 ; CHECK-GI-NEXT:    fcvt s1, h10
5876 ; CHECK-GI-NEXT:    fcvt h0, s0
5877 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5878 ; CHECK-GI-NEXT:    fmov s0, s1
5879 ; CHECK-GI-NEXT:    bl log10f
5880 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #16] // 32-byte Folded Reload
5881 ; CHECK-GI-NEXT:    fcvt h0, s0
5882 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
5883 ; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
5884 ; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
5885 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
5886 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
5887 ; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
5888 ; CHECK-GI-NEXT:    mov v1.h[3], v0.h[0]
5889 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
5890 ; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
5891 ; CHECK-GI-NEXT:    add sp, sp, #80
5892 ; CHECK-GI-NEXT:    ret
5893 entry:
5894   %c = call <4 x half> @llvm.log10.v4f16(<4 x half> %a)
5895   ret <4 x half> %c
5896 }
5897
5898 define <8 x half> @log10_v8f16(<8 x half> %a) {
5899 ; CHECK-SD-LABEL: log10_v8f16:
5900 ; CHECK-SD:       // %bb.0: // %entry
5901 ; CHECK-SD-NEXT:    sub sp, sp, #48
5902 ; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
5903 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
5904 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
5905 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
5906 ; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5907 ; CHECK-SD-NEXT:    fcvt s0, h1
5908 ; CHECK-SD-NEXT:    bl log10f
5909 ; CHECK-SD-NEXT:    fcvt h0, s0
5910 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5911 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5912 ; CHECK-SD-NEXT:    fcvt s0, h0
5913 ; CHECK-SD-NEXT:    bl log10f
5914 ; CHECK-SD-NEXT:    fcvt h0, s0
5915 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5916 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
5917 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5918 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5919 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
5920 ; CHECK-SD-NEXT:    fcvt s0, h0
5921 ; CHECK-SD-NEXT:    bl log10f
5922 ; CHECK-SD-NEXT:    fcvt h0, s0
5923 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5924 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
5925 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5926 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
5927 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5928 ; CHECK-SD-NEXT:    fcvt s0, h0
5929 ; CHECK-SD-NEXT:    bl log10f
5930 ; CHECK-SD-NEXT:    fcvt h0, s0
5931 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5932 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
5933 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5934 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
5935 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5936 ; CHECK-SD-NEXT:    fcvt s0, h0
5937 ; CHECK-SD-NEXT:    bl log10f
5938 ; CHECK-SD-NEXT:    fcvt h0, s0
5939 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5940 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
5941 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5942 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
5943 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5944 ; CHECK-SD-NEXT:    fcvt s0, h0
5945 ; CHECK-SD-NEXT:    bl log10f
5946 ; CHECK-SD-NEXT:    fcvt h0, s0
5947 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5948 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
5949 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5950 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
5951 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5952 ; CHECK-SD-NEXT:    fcvt s0, h0
5953 ; CHECK-SD-NEXT:    bl log10f
5954 ; CHECK-SD-NEXT:    fcvt h0, s0
5955 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5956 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
5957 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5958 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
5959 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5960 ; CHECK-SD-NEXT:    fcvt s0, h0
5961 ; CHECK-SD-NEXT:    bl log10f
5962 ; CHECK-SD-NEXT:    fcvt h1, s0
5963 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5964 ; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
5965 ; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
5966 ; CHECK-SD-NEXT:    add sp, sp, #48
5967 ; CHECK-SD-NEXT:    ret
5968 ;
5969 ; CHECK-GI-LABEL: log10_v8f16:
5970 ; CHECK-GI:       // %bb.0: // %entry
5971 ; CHECK-GI-NEXT:    sub sp, sp, #176
5972 ; CHECK-GI-NEXT:    str d14, [sp, #112] // 8-byte Folded Spill
5973 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #120] // 16-byte Folded Spill
5974 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #136] // 16-byte Folded Spill
5975 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #152] // 16-byte Folded Spill
5976 ; CHECK-GI-NEXT:    str x30, [sp, #168] // 8-byte Folded Spill
5977 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
5978 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
5979 ; CHECK-GI-NEXT:    .cfi_offset b8, -16
5980 ; CHECK-GI-NEXT:    .cfi_offset b9, -24
5981 ; CHECK-GI-NEXT:    .cfi_offset b10, -32
5982 ; CHECK-GI-NEXT:    .cfi_offset b11, -40
5983 ; CHECK-GI-NEXT:    .cfi_offset b12, -48
5984 ; CHECK-GI-NEXT:    .cfi_offset b13, -56
5985 ; CHECK-GI-NEXT:    .cfi_offset b14, -64
5986 ; CHECK-GI-NEXT:    mov h8, v0.h[1]
5987 ; CHECK-GI-NEXT:    mov h9, v0.h[2]
5988 ; CHECK-GI-NEXT:    mov h10, v0.h[3]
5989 ; CHECK-GI-NEXT:    mov h11, v0.h[4]
5990 ; CHECK-GI-NEXT:    mov h12, v0.h[5]
5991 ; CHECK-GI-NEXT:    mov h13, v0.h[6]
5992 ; CHECK-GI-NEXT:    mov h14, v0.h[7]
5993 ; CHECK-GI-NEXT:    fcvt s0, h0
5994 ; CHECK-GI-NEXT:    bl log10f
5995 ; CHECK-GI-NEXT:    fcvt s1, h8
5996 ; CHECK-GI-NEXT:    fcvt h0, s0
5997 ; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
5998 ; CHECK-GI-NEXT:    fmov s0, s1
5999 ; CHECK-GI-NEXT:    bl log10f
6000 ; CHECK-GI-NEXT:    fcvt s1, h9
6001 ; CHECK-GI-NEXT:    fcvt h0, s0
6002 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
6003 ; CHECK-GI-NEXT:    fmov s0, s1
6004 ; CHECK-GI-NEXT:    bl log10f
6005 ; CHECK-GI-NEXT:    fcvt s1, h10
6006 ; CHECK-GI-NEXT:    fcvt h0, s0
6007 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
6008 ; CHECK-GI-NEXT:    fmov s0, s1
6009 ; CHECK-GI-NEXT:    bl log10f
6010 ; CHECK-GI-NEXT:    fcvt s1, h11
6011 ; CHECK-GI-NEXT:    fcvt h0, s0
6012 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
6013 ; CHECK-GI-NEXT:    fmov s0, s1
6014 ; CHECK-GI-NEXT:    bl log10f
6015 ; CHECK-GI-NEXT:    fcvt s1, h12
6016 ; CHECK-GI-NEXT:    fcvt h0, s0
6017 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
6018 ; CHECK-GI-NEXT:    fmov s0, s1
6019 ; CHECK-GI-NEXT:    bl log10f
6020 ; CHECK-GI-NEXT:    fcvt s1, h13
6021 ; CHECK-GI-NEXT:    fcvt h0, s0
6022 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
6023 ; CHECK-GI-NEXT:    fmov s0, s1
6024 ; CHECK-GI-NEXT:    bl log10f
6025 ; CHECK-GI-NEXT:    fcvt s1, h14
6026 ; CHECK-GI-NEXT:    fcvt h0, s0
6027 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
6028 ; CHECK-GI-NEXT:    fmov s0, s1
6029 ; CHECK-GI-NEXT:    bl log10f
6030 ; CHECK-GI-NEXT:    ldp q2, q1, [sp, #80] // 32-byte Folded Reload
6031 ; CHECK-GI-NEXT:    fcvt h0, s0
6032 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #152] // 16-byte Folded Reload
6033 ; CHECK-GI-NEXT:    ldr x30, [sp, #168] // 8-byte Folded Reload
6034 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #136] // 16-byte Folded Reload
6035 ; CHECK-GI-NEXT:    ldr d14, [sp, #112] // 8-byte Folded Reload
6036 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
6037 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #48] // 32-byte Folded Reload
6038 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #120] // 16-byte Folded Reload
6039 ; CHECK-GI-NEXT:    mov v1.h[2], v3.h[0]
6040 ; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
6041 ; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
6042 ; CHECK-GI-NEXT:    mov v1.h[4], v3.h[0]
6043 ; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
6044 ; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
6045 ; CHECK-GI-NEXT:    mov v1.h[6], v2.h[0]
6046 ; CHECK-GI-NEXT:    mov v1.h[7], v0.h[0]
6047 ; CHECK-GI-NEXT:    mov v0.16b, v1.16b
6048 ; CHECK-GI-NEXT:    add sp, sp, #176
6049 ; CHECK-GI-NEXT:    ret
6050 entry:
6051   %c = call <8 x half> @llvm.log10.v8f16(<8 x half> %a)
6052   ret <8 x half> %c
6053 }
6054
6055 define <16 x half> @log10_v16f16(<16 x half> %a) {
6056 ; CHECK-SD-LABEL: log10_v16f16:
6057 ; CHECK-SD:       // %bb.0: // %entry
6058 ; CHECK-SD-NEXT:    sub sp, sp, #64
6059 ; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
6060 ; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
6061 ; CHECK-SD-NEXT:    .cfi_offset w30, -16
6062 ; CHECK-SD-NEXT:    stp q1, q0, [sp] // 32-byte Folded Spill
6063 ; CHECK-SD-NEXT:    mov h1, v0.h[1]
6064 ; CHECK-SD-NEXT:    fcvt s0, h1
6065 ; CHECK-SD-NEXT:    bl log10f
6066 ; CHECK-SD-NEXT:    fcvt h0, s0
6067 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
6068 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
6069 ; CHECK-SD-NEXT:    fcvt s0, h0
6070 ; CHECK-SD-NEXT:    bl log10f
6071 ; CHECK-SD-NEXT:    fcvt h0, s0
6072 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
6073 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
6074 ; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
6075 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
6076 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
6077 ; CHECK-SD-NEXT:    fcvt s0, h0
6078 ; CHECK-SD-NEXT:    bl log10f
6079 ; CHECK-SD-NEXT:    fcvt h0, s0
6080 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
6081 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
6082 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
6083 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
6084 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
6085 ; CHECK-SD-NEXT:    fcvt s0, h0
6086 ; CHECK-SD-NEXT:    bl log10f
6087 ; CHECK-SD-NEXT:    fcvt h0, s0
6088 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
6089 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
6090 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
6091 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
6092 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
6093 ; CHECK-SD-NEXT:    fcvt s0, h0
6094 ; CHECK-SD-NEXT:    bl log10f
6095 ; CHECK-SD-NEXT:    fcvt h0, s0
6096 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
6097 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
6098 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
6099 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
6100 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
6101 ; CHECK-SD-NEXT:    fcvt s0, h0
6102 ; CHECK-SD-NEXT:    bl log10f
6103 ; CHECK-SD-NEXT:    fcvt h0, s0
6104 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
6105 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
6106 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
6107 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
6108 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
6109 ; CHECK-SD-NEXT:    fcvt s0, h0
6110 ; CHECK-SD-NEXT:    bl log10f
6111 ; CHECK-SD-NEXT:    fcvt h0, s0
6112 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
6113 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
6114 ; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
6115 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
6116 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
6117 ; CHECK-SD-NEXT:    fcvt s0, h0
6118 ; CHECK-SD-NEXT:    bl log10f
6119 ; CHECK-SD-NEXT:    fcvt h0, s0
6120 ; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
6121 ; CHECK-SD-NEXT:    mov v1.h[7], v0.h[0]
6122 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6123 ; CHECK-SD-NEXT:    mov h0, v0.h[1]
6124 ; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
6125 ; CHECK-SD-NEXT:    fcvt s0, h0
6126 ; CHECK-SD-NEXT:    bl log10f
6127 ; CHECK-SD-NEXT:    fcvt h0, s0
6128 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
6129 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6130 ; CHECK-SD-NEXT:    fcvt s0, h0
6131 ; CHECK-SD-NEXT:    bl log10f
6132 ; CHECK-SD-NEXT:    fcvt h0, s0
6133 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6134 ; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
6135 ; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
6136 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6137 ; CHECK-SD-NEXT:    mov h0, v0.h[2]
6138 ; CHECK-SD-NEXT:    fcvt s0, h0
6139 ; CHECK-SD-NEXT:    bl log10f
6140 ; CHECK-SD-NEXT:    fcvt h0, s0
6141 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6142 ; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
6143 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6144 ; CHECK-SD-NEXT:    mov h0, v0.h[3]
6145 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
6146 ; CHECK-SD-NEXT:    fcvt s0, h0
6147 ; CHECK-SD-NEXT:    bl log10f
6148 ; CHECK-SD-NEXT:    fcvt h0, s0
6149 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6150 ; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
6151 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6152 ; CHECK-SD-NEXT:    mov h0, v0.h[4]
6153 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
6154 ; CHECK-SD-NEXT:    fcvt s0, h0
6155 ; CHECK-SD-NEXT:    bl log10f
6156 ; CHECK-SD-NEXT:    fcvt h0, s0
6157 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6158 ; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
6159 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6160 ; CHECK-SD-NEXT:    mov h0, v0.h[5]
6161 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
6162 ; CHECK-SD-NEXT:    fcvt s0, h0
6163 ; CHECK-SD-NEXT:    bl log10f
6164 ; CHECK-SD-NEXT:    fcvt h0, s0
6165 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6166 ; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
6167 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6168 ; CHECK-SD-NEXT:    mov h0, v0.h[6]
6169 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
6170 ; CHECK-SD-NEXT:    fcvt s0, h0
6171 ; CHECK-SD-NEXT:    bl log10f
6172 ; CHECK-SD-NEXT:    fcvt h0, s0
6173 ; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6174 ; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
6175 ; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6176 ; CHECK-SD-NEXT:    mov h0, v0.h[7]
6177 ; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
6178 ; CHECK-SD-NEXT:    fcvt s0, h0
6179 ; CHECK-SD-NEXT:    bl log10f
6180 ; CHECK-SD-NEXT:    fmov s1, s0
6181 ; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
6182 ; CHECK-SD-NEXT:    fcvt h2, s1
6183 ; CHECK-SD-NEXT:    ldp q1, q0, [sp, #16] // 32-byte Folded Reload
6184 ; CHECK-SD-NEXT:    mov v1.h[7], v2.h[0]
6185 ; CHECK-SD-NEXT:    add sp, sp, #64
6186 ; CHECK-SD-NEXT:    ret
6187 ;
6188 ; CHECK-GI-LABEL: log10_v16f16:
6189 ; CHECK-GI:       // %bb.0: // %entry
6190 ; CHECK-GI-NEXT:    sub sp, sp, #320
6191 ; CHECK-GI-NEXT:    stp d15, d14, [sp, #240] // 16-byte Folded Spill
6192 ; CHECK-GI-NEXT:    stp d13, d12, [sp, #256] // 16-byte Folded Spill
6193 ; CHECK-GI-NEXT:    stp d11, d10, [sp, #272] // 16-byte Folded Spill
6194 ; CHECK-GI-NEXT:    stp d9, d8, [sp, #288] // 16-byte Folded Spill
6195 ; CHECK-GI-NEXT:    stp x29, x30, [sp, #304] // 16-byte Folded Spill
6196 ; CHECK-GI-NEXT:    .cfi_def_cfa_offset 320
6197 ; CHECK-GI-NEXT:    .cfi_offset w30, -8
6198 ; CHECK-GI-NEXT:    .cfi_offset w29, -16
6199 ; CHECK-GI-NEXT:    .cfi_offset b8, -24
6200 ; CHECK-GI-NEXT:    .cfi_offset b9, -32
6201 ; CHECK-GI-NEXT:    .cfi_offset b10, -40
6202 ; CHECK-GI-NEXT:    .cfi_offset b11, -48
6203 ; CHECK-GI-NEXT:    .cfi_offset b12, -56
6204 ; CHECK-GI-NEXT:    .cfi_offset b13, -64
6205 ; CHECK-GI-NEXT:    .cfi_offset b14, -72
6206 ; CHECK-GI-NEXT:    .cfi_offset b15, -80
6207 ; CHECK-GI-NEXT:    mov v2.16b, v1.16b
6208 ; CHECK-GI-NEXT:    str q1, [sp, #80] // 16-byte Folded Spill
6209 ; CHECK-GI-NEXT:    mov h14, v1.h[1]
6210 ; CHECK-GI-NEXT:    mov h1, v1.h[2]
6211 ; CHECK-GI-NEXT:    mov h15, v0.h[1]
6212 ; CHECK-GI-NEXT:    mov h8, v0.h[2]
6213 ; CHECK-GI-NEXT:    mov h9, v0.h[3]
6214 ; CHECK-GI-NEXT:    mov h10, v0.h[4]
6215 ; CHECK-GI-NEXT:    mov h11, v0.h[5]
6216 ; CHECK-GI-NEXT:    mov h12, v0.h[6]
6217 ; CHECK-GI-NEXT:    mov h13, v0.h[7]
6218 ; CHECK-GI-NEXT:    fcvt s0, h0
6219 ; CHECK-GI-NEXT:    str h1, [sp, #16] // 2-byte Folded Spill
6220 ; CHECK-GI-NEXT:    mov h1, v2.h[3]
6221 ; CHECK-GI-NEXT:    str h1, [sp, #32] // 2-byte Folded Spill
6222 ; CHECK-GI-NEXT:    mov h1, v2.h[4]
6223 ; CHECK-GI-NEXT:    str h1, [sp, #48] // 2-byte Folded Spill
6224 ; CHECK-GI-NEXT:    mov h1, v2.h[5]
6225 ; CHECK-GI-NEXT:    str h1, [sp, #64] // 2-byte Folded Spill
6226 ; CHECK-GI-NEXT:    mov h1, v2.h[6]
6227 ; CHECK-GI-NEXT:    str h1, [sp, #96] // 2-byte Folded Spill
6228 ; CHECK-GI-NEXT:    mov h1, v2.h[7]
6229 ; CHECK-GI-NEXT:    str h1, [sp, #160] // 2-byte Folded Spill
6230 ; CHECK-GI-NEXT:    bl log10f
6231 ; CHECK-GI-NEXT:    fcvt s1, h15
6232 ; CHECK-GI-NEXT:    fcvt h0, s0
6233 ; CHECK-GI-NEXT:    str q0, [sp, #192] // 16-byte Folded Spill
6234 ; CHECK-GI-NEXT:    fmov s0, s1
6235 ; CHECK-GI-NEXT:    bl log10f
6236 ; CHECK-GI-NEXT:    fcvt s1, h8
6237 ; CHECK-GI-NEXT:    fcvt h0, s0
6238 ; CHECK-GI-NEXT:    str q0, [sp, #128] // 16-byte Folded Spill
6239 ; CHECK-GI-NEXT:    fmov s0, s1
6240 ; CHECK-GI-NEXT:    bl log10f
6241 ; CHECK-GI-NEXT:    fcvt s1, h9
6242 ; CHECK-GI-NEXT:    fcvt h0, s0
6243 ; CHECK-GI-NEXT:    str q0, [sp, #224] // 16-byte Folded Spill
6244 ; CHECK-GI-NEXT:    fmov s0, s1
6245 ; CHECK-GI-NEXT:    bl log10f
6246 ; CHECK-GI-NEXT:    fcvt s1, h10
6247 ; CHECK-GI-NEXT:    fcvt h0, s0
6248 ; CHECK-GI-NEXT:    str q0, [sp, #208] // 16-byte Folded Spill
6249 ; CHECK-GI-NEXT:    fmov s0, s1
6250 ; CHECK-GI-NEXT:    bl log10f
6251 ; CHECK-GI-NEXT:    fcvt s1, h11
6252 ; CHECK-GI-NEXT:    fcvt h0, s0
6253 ; CHECK-GI-NEXT:    str q0, [sp, #176] // 16-byte Folded Spill
6254 ; CHECK-GI-NEXT:    fmov s0, s1
6255 ; CHECK-GI-NEXT:    bl log10f
6256 ; CHECK-GI-NEXT:    fcvt s1, h12
6257 ; CHECK-GI-NEXT:    fcvt h0, s0
6258 ; CHECK-GI-NEXT:    str q0, [sp, #144] // 16-byte Folded Spill
6259 ; CHECK-GI-NEXT:    fmov s0, s1
6260 ; CHECK-GI-NEXT:    bl log10f
6261 ; CHECK-GI-NEXT:    fcvt s1, h13
6262 ; CHECK-GI-NEXT:    fcvt h0, s0
6263 ; CHECK-GI-NEXT:    str q0, [sp, #112] // 16-byte Folded Spill
6264 ; CHECK-GI-NEXT:    fmov s0, s1
6265 ; CHECK-GI-NEXT:    bl log10f
6266 ; CHECK-GI-NEXT:    ldr q1, [sp, #80] // 16-byte Folded Reload
6267 ; CHECK-GI-NEXT:    fcvt h0, s0
6268 ; CHECK-GI-NEXT:    fcvt s1, h1
6269 ; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
6270 ; CHECK-GI-NEXT:    fmov s0, s1
6271 ; CHECK-GI-NEXT:    bl log10f
6272 ; CHECK-GI-NEXT:    fcvt s1, h14
6273 ; CHECK-GI-NEXT:    fcvt h0, s0
6274 ; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
6275 ; CHECK-GI-NEXT:    fmov s0, s1
6276 ; CHECK-GI-NEXT:    bl log10f
6277 ; CHECK-GI-NEXT:    ldr h1, [sp, #16] // 2-byte Folded Reload
6278 ; CHECK-GI-NEXT:    fcvt h0, s0
6279 ; CHECK-GI-NEXT:    fcvt s1, h1
6280 ; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
6281 ; CHECK-GI-NEXT:    fmov s0, s1
6282 ; CHECK-GI-NEXT:    bl log10f
6283 ; CHECK-GI-NEXT:    ldr h1, [sp, #32] // 2-byte Folded Reload
6284 ; CHECK-GI-NEXT:    fcvt h0, s0
6285 ; CHECK-GI-NEXT:    fcvt s1, h1
6286 ; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
6287 ; CHECK-GI-NEXT:    fmov s0, s1
6288 ; CHECK-GI-NEXT:    bl log10f
6289 ; CHECK-GI-NEXT:    ldr h1, [sp, #48] // 2-byte Folded Reload
6290 ; CHECK-GI-NEXT:    fcvt h0, s0
6291 ; CHECK-GI-NEXT:    fcvt s1, h1
6292 ; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
6293 ; CHECK-GI-NEXT:    fmov s0, s1
6294 ; CHECK-GI-NEXT:    bl log10f
6295 ; CHECK-GI-NEXT:    ldr h1, [sp, #64] // 2-byte Folded Reload
6296 ; CHECK-GI-NEXT:    fcvt h0, s0
6297 ; CHECK-GI-NEXT:    fcvt s1, h1
6298 ; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
6299 ; CHECK-GI-NEXT:    fmov s0, s1
6300 ; CHECK-GI-NEXT:    bl log10f
6301 ; CHECK-GI-NEXT:    ldr h1, [sp, #96] // 2-byte Folded Reload
6302 ; CHECK-GI-NEXT:    fcvt h0, s0
6303 ; CHECK-GI-NEXT:    fcvt s1, h1
6304 ; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
6305 ; CHECK-GI-NEXT:    fmov s0, s1
6306 ; CHECK-GI-NEXT:    bl log10f
6307 ; CHECK-GI-NEXT:    ldr h1, [sp, #160] // 2-byte Folded Reload
6308 ; CHECK-GI-NEXT:    fcvt h0, s0
6309 ; CHECK-GI-NEXT:    fcvt s1, h1
6310 ; CHECK-GI-NEXT:    str q0, [sp, #160] // 16-byte Folded Spill
6311 ; CHECK-GI-NEXT:    fmov s0, s1
6312 ; CHECK-GI-NEXT:    bl log10f
6313 ; CHECK-GI-NEXT:    ldr q3, [sp, #192] // 16-byte Folded Reload
6314 ; CHECK-GI-NEXT:    ldr q2, [sp, #128] // 16-byte Folded Reload
6315 ; CHECK-GI-NEXT:    ldp x29, x30, [sp, #304] // 16-byte Folded Reload
6316 ; CHECK-GI-NEXT:    mov v3.h[1], v2.h[0]
6317 ; CHECK-GI-NEXT:    ldp q1, q2, [sp] // 32-byte Folded Reload
6318 ; CHECK-GI-NEXT:    ldp d9, d8, [sp, #288] // 16-byte Folded Reload
6319 ; CHECK-GI-NEXT:    ldp d11, d10, [sp, #272] // 16-byte Folded Reload
6320 ; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
6321 ; CHECK-GI-NEXT:    ldr q2, [sp, #224] // 16-byte Folded Reload
6322 ; CHECK-GI-NEXT:    ldp d13, d12, [sp, #256] // 16-byte Folded Reload
6323 ; CHECK-GI-NEXT:    mov v3.h[2], v2.h[0]
6324 ; CHECK-GI-NEXT:    ldr q2, [sp, #32] // 16-byte Folded Reload
6325 ; CHECK-GI-NEXT:    ldp d15, d14, [sp, #240] // 16-byte Folded Reload
6326 ; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
6327 ; CHECK-GI-NEXT:    ldr q2, [sp, #208] // 16-byte Folded Reload
6328 ; CHECK-GI-NEXT:    mov v3.h[3], v2.h[0]
6329 ; CHECK-GI-NEXT:    ldr q2, [sp, #48] // 16-byte Folded Reload
6330 ; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
6331 ; CHECK-GI-NEXT:    ldr q2, [sp, #176] // 16-byte Folded Reload
6332 ; CHECK-GI-NEXT:    mov v3.h[4], v2.h[0]
6333 ; CHECK-GI-NEXT:    ldr q2, [sp, #64] // 16-byte Folded Reload
6334 ; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
6335 ; CHECK-GI-NEXT:    ldr q2, [sp, #144] // 16-byte Folded Reload
6336 ; CHECK-GI-NEXT:    mov v3.h[5], v2.h[0]
6337 ; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
6338 ; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
6339 ; CHECK-GI-NEXT:    fcvt h2, s0
6340 ; CHECK-GI-NEXT:    ldr q0, [sp, #112] // 16-byte Folded Reload
6341 ; CHECK-GI-NEXT:    mov v3.h[6], v0.h[0]
6342 ; CHECK-GI-NEXT:    ldr q0, [sp, #160] // 16-byte Folded Reload
6343 ; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
6344 ; CHECK-GI-NEXT:    ldr q0, [sp, #80] // 16-byte Folded Reload
6345 ; CHECK-GI-NEXT:    mov v3.h[7], v0.h[0]
6346 ; CHECK-GI-NEXT:    mov v1.h[7], v2.h[0]
6347 ; CHECK-GI-NEXT:    mov v0.16b, v3.16b
6348 ; CHECK-GI-NEXT:    add sp, sp, #320
6349 ; CHECK-GI-NEXT:    ret
6350 entry:
6351   %c = call <16 x half> @llvm.log10.v16f16(<16 x half> %a)
6352   ret <16 x half> %c
6353 }
6354
6355 declare <16 x half> @llvm.exp.v16f16(<16 x half>)
6356 declare <16 x half> @llvm.exp2.v16f16(<16 x half>)
6357 declare <16 x half> @llvm.log.v16f16(<16 x half>)
6358 declare <16 x half> @llvm.log10.v16f16(<16 x half>)
6359 declare <16 x half> @llvm.log2.v16f16(<16 x half>)
6360 declare <2 x double> @llvm.exp.v2f64(<2 x double>)
6361 declare <2 x double> @llvm.exp2.v2f64(<2 x double>)
6362 declare <2 x double> @llvm.log.v2f64(<2 x double>)
6363 declare <2 x double> @llvm.log10.v2f64(<2 x double>)
6364 declare <2 x double> @llvm.log2.v2f64(<2 x double>)
6365 declare <2 x float> @llvm.exp.v2f32(<2 x float>)
6366 declare <2 x float> @llvm.exp2.v2f32(<2 x float>)
6367 declare <2 x float> @llvm.log.v2f32(<2 x float>)
6368 declare <2 x float> @llvm.log10.v2f32(<2 x float>)
6369 declare <2 x float> @llvm.log2.v2f32(<2 x float>)
6370 declare <3 x double> @llvm.exp.v3f64(<3 x double>)
6371 declare <3 x double> @llvm.exp2.v3f64(<3 x double>)
6372 declare <3 x double> @llvm.log.v3f64(<3 x double>)
6373 declare <3 x double> @llvm.log10.v3f64(<3 x double>)
6374 declare <3 x double> @llvm.log2.v3f64(<3 x double>)
6375 declare <3 x float> @llvm.exp.v3f32(<3 x float>)
6376 declare <3 x float> @llvm.exp2.v3f32(<3 x float>)
6377 declare <3 x float> @llvm.log.v3f32(<3 x float>)
6378 declare <3 x float> @llvm.log10.v3f32(<3 x float>)
6379 declare <3 x float> @llvm.log2.v3f32(<3 x float>)
6380 declare <4 x double> @llvm.exp.v4f64(<4 x double>)
6381 declare <4 x double> @llvm.exp2.v4f64(<4 x double>)
6382 declare <4 x double> @llvm.log.v4f64(<4 x double>)
6383 declare <4 x double> @llvm.log10.v4f64(<4 x double>)
6384 declare <4 x double> @llvm.log2.v4f64(<4 x double>)
6385 declare <4 x float> @llvm.exp.v4f32(<4 x float>)
6386 declare <4 x float> @llvm.exp2.v4f32(<4 x float>)
6387 declare <4 x float> @llvm.log.v4f32(<4 x float>)
6388 declare <4 x float> @llvm.log10.v4f32(<4 x float>)
6389 declare <4 x float> @llvm.log2.v4f32(<4 x float>)
6390 declare <4 x half> @llvm.exp.v4f16(<4 x half>)
6391 declare <4 x half> @llvm.exp2.v4f16(<4 x half>)
6392 declare <4 x half> @llvm.log.v4f16(<4 x half>)
6393 declare <4 x half> @llvm.log10.v4f16(<4 x half>)
6394 declare <4 x half> @llvm.log2.v4f16(<4 x half>)
6395 declare <7 x half> @llvm.exp.v7f16(<7 x half>)
6396 declare <7 x half> @llvm.exp2.v7f16(<7 x half>)
6397 declare <7 x half> @llvm.log.v7f16(<7 x half>)
6398 declare <7 x half> @llvm.log10.v7f16(<7 x half>)
6399 declare <7 x half> @llvm.log2.v7f16(<7 x half>)
6400 declare <8 x float> @llvm.exp.v8f32(<8 x float>)
6401 declare <8 x float> @llvm.exp2.v8f32(<8 x float>)
6402 declare <8 x float> @llvm.log.v8f32(<8 x float>)
6403 declare <8 x float> @llvm.log10.v8f32(<8 x float>)
6404 declare <8 x float> @llvm.log2.v8f32(<8 x float>)
6405 declare <8 x half> @llvm.exp.v8f16(<8 x half>)
6406 declare <8 x half> @llvm.exp2.v8f16(<8 x half>)
6407 declare <8 x half> @llvm.log.v8f16(<8 x half>)
6408 declare <8 x half> @llvm.log10.v8f16(<8 x half>)
6409 declare <8 x half> @llvm.log2.v8f16(<8 x half>)
6410 declare double @llvm.exp.f64(double)
6411 declare double @llvm.exp2.f64(double)
6412 declare double @llvm.log.f64(double)
6413 declare double @llvm.log10.f64(double)
6414 declare double @llvm.log2.f64(double)
6415 declare float @llvm.exp.f32(float)
6416 declare float @llvm.exp2.f32(float)
6417 declare float @llvm.log.f32(float)
6418 declare float @llvm.log10.f32(float)
6419 declare float @llvm.log2.f32(float)
6420 declare half @llvm.exp.f16(half)
6421 declare half @llvm.exp2.f16(half)
6422 declare half @llvm.log.f16(half)
6423 declare half @llvm.log10.f16(half)
6424 declare half @llvm.log2.f16(half)