9122c5235e
This is based on other targets like PPC/AArch64 and some experiments. This PR will only enable bidirectional scheduling and tracking register pressure. Disclaimer: I haven't tested it on many cores, maybe we should make some options being features. I believe downstreams must have tried this before, so feedbacks are welcome.
2421 lines
120 KiB
LLVM
2421 lines
120 KiB
LLVM
; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 3
|
|
; RUN: llc < %s -mtriple=riscv64 -mattr=+m,+v,+xsfvcp \
|
|
; RUN: -riscv-use-rematerializable-movimm=false | FileCheck %s --check-prefix=NOREMAT
|
|
; RUN: llc < %s -mtriple=riscv64 -mattr=+m,+v,+xsfvcp \
|
|
; RUN: --riscv-use-rematerializable-movimm=true | FileCheck %s --check-prefix=REMAT
|
|
|
|
define void @test(ptr %0, ptr %1, i64 %2) {
|
|
; NOREMAT-LABEL: test:
|
|
; NOREMAT: # %bb.0:
|
|
; NOREMAT-NEXT: addi sp, sp, -752
|
|
; NOREMAT-NEXT: .cfi_def_cfa_offset 752
|
|
; NOREMAT-NEXT: sd ra, 744(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sd s0, 736(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sd s1, 728(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sd s2, 720(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sd s3, 712(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sd s4, 704(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sd s5, 696(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sd s6, 688(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sd s7, 680(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sd s8, 672(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sd s9, 664(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sd s10, 656(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sd s11, 648(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: .cfi_offset ra, -8
|
|
; NOREMAT-NEXT: .cfi_offset s0, -16
|
|
; NOREMAT-NEXT: .cfi_offset s1, -24
|
|
; NOREMAT-NEXT: .cfi_offset s2, -32
|
|
; NOREMAT-NEXT: .cfi_offset s3, -40
|
|
; NOREMAT-NEXT: .cfi_offset s4, -48
|
|
; NOREMAT-NEXT: .cfi_offset s5, -56
|
|
; NOREMAT-NEXT: .cfi_offset s6, -64
|
|
; NOREMAT-NEXT: .cfi_offset s7, -72
|
|
; NOREMAT-NEXT: .cfi_offset s8, -80
|
|
; NOREMAT-NEXT: .cfi_offset s9, -88
|
|
; NOREMAT-NEXT: .cfi_offset s10, -96
|
|
; NOREMAT-NEXT: .cfi_offset s11, -104
|
|
; NOREMAT-NEXT: csrr a2, vlenb
|
|
; NOREMAT-NEXT: slli a2, a2, 1
|
|
; NOREMAT-NEXT: sub sp, sp, a2
|
|
; NOREMAT-NEXT: .cfi_escape 0x0f, 0x0e, 0x72, 0x00, 0x11, 0xf0, 0x05, 0x22, 0x11, 0x02, 0x92, 0xa2, 0x38, 0x00, 0x1e, 0x22 # sp + 752 + 2 * vlenb
|
|
; NOREMAT-NEXT: mv a7, a0
|
|
; NOREMAT-NEXT: li a0, 32
|
|
; NOREMAT-NEXT: addi a5, a7, 512
|
|
; NOREMAT-NEXT: addi a4, a7, 1024
|
|
; NOREMAT-NEXT: addi a6, a7, 1536
|
|
; NOREMAT-NEXT: li t4, 1
|
|
; NOREMAT-NEXT: li a2, 5
|
|
; NOREMAT-NEXT: li t1, 3
|
|
; NOREMAT-NEXT: li t0, 7
|
|
; NOREMAT-NEXT: lui t5, 1
|
|
; NOREMAT-NEXT: li s4, 9
|
|
; NOREMAT-NEXT: li s6, 11
|
|
; NOREMAT-NEXT: li s9, 13
|
|
; NOREMAT-NEXT: li ra, 15
|
|
; NOREMAT-NEXT: lui t2, 2
|
|
; NOREMAT-NEXT: lui s1, 3
|
|
; NOREMAT-NEXT: lui t3, 4
|
|
; NOREMAT-NEXT: lui s0, 5
|
|
; NOREMAT-NEXT: lui s3, 6
|
|
; NOREMAT-NEXT: lui s7, 7
|
|
; NOREMAT-NEXT: vsetvli zero, a0, e32, m2, ta, ma
|
|
; NOREMAT-NEXT: slli t4, t4, 11
|
|
; NOREMAT-NEXT: sd t4, 512(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: slli a3, a2, 9
|
|
; NOREMAT-NEXT: sd a3, 504(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: slli t6, t1, 10
|
|
; NOREMAT-NEXT: slli s2, t0, 9
|
|
; NOREMAT-NEXT: add a0, a7, t5
|
|
; NOREMAT-NEXT: lui s11, 1
|
|
; NOREMAT-NEXT: slli s4, s4, 9
|
|
; NOREMAT-NEXT: slli s5, a2, 10
|
|
; NOREMAT-NEXT: slli s6, s6, 9
|
|
; NOREMAT-NEXT: slli s8, t1, 11
|
|
; NOREMAT-NEXT: vle32.v v8, (a5)
|
|
; NOREMAT-NEXT: slli s9, s9, 9
|
|
; NOREMAT-NEXT: li t5, 13
|
|
; NOREMAT-NEXT: vle32.v v10, (a4)
|
|
; NOREMAT-NEXT: vle32.v v2, (a4)
|
|
; NOREMAT-NEXT: slli s10, t0, 10
|
|
; NOREMAT-NEXT: vle32.v v0, (a6)
|
|
; NOREMAT-NEXT: vle32.v v12, (a6)
|
|
; NOREMAT-NEXT: slli ra, ra, 9
|
|
; NOREMAT-NEXT: vle32.v v4, (a0)
|
|
; NOREMAT-NEXT: vle32.v v20, (a0)
|
|
; NOREMAT-NEXT: add a4, a7, t2
|
|
; NOREMAT-NEXT: vle32.v v6, (a4)
|
|
; NOREMAT-NEXT: vle32.v v30, (a4)
|
|
; NOREMAT-NEXT: add a4, a7, s1
|
|
; NOREMAT-NEXT: vle32.v v28, (a4)
|
|
; NOREMAT-NEXT: vle32.v v26, (a4)
|
|
; NOREMAT-NEXT: add a4, a7, t3
|
|
; NOREMAT-NEXT: vle32.v v24, (a4)
|
|
; NOREMAT-NEXT: vle32.v v22, (a4)
|
|
; NOREMAT-NEXT: add a4, a7, s0
|
|
; NOREMAT-NEXT: vle32.v v14, (a7)
|
|
; NOREMAT-NEXT: vle32.v v18, (a4)
|
|
; NOREMAT-NEXT: vle32.v v16, (a4)
|
|
; NOREMAT-NEXT: add a4, a7, s3
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v14, v8
|
|
; NOREMAT-NEXT: vle32.v v14, (a4)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v8, v10
|
|
; NOREMAT-NEXT: vle32.v v8, (a4)
|
|
; NOREMAT-NEXT: addi a0, sp, 640
|
|
; NOREMAT-NEXT: vs2r.v v8, (a0) # Unknown-size Folded Spill
|
|
; NOREMAT-NEXT: add a4, a7, t4
|
|
; NOREMAT-NEXT: vle32.v v10, (a4)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v2, v0
|
|
; NOREMAT-NEXT: vle32.v v2, (a4)
|
|
; NOREMAT-NEXT: add a4, a7, a3
|
|
; NOREMAT-NEXT: vle32.v v0, (a4)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v12, v10
|
|
; NOREMAT-NEXT: vle32.v v10, (a4)
|
|
; NOREMAT-NEXT: add a4, a7, t6
|
|
; NOREMAT-NEXT: vle32.v v12, (a4)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v2, v0
|
|
; NOREMAT-NEXT: vle32.v v2, (a4)
|
|
; NOREMAT-NEXT: add a4, a7, s2
|
|
; NOREMAT-NEXT: vle32.v v8, (a4)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v10, v12
|
|
; NOREMAT-NEXT: vle32.v v12, (a4)
|
|
; NOREMAT-NEXT: add a4, a7, s7
|
|
; NOREMAT-NEXT: vle32.v v0, (a4)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v2, v8
|
|
; NOREMAT-NEXT: vle32.v v10, (a4)
|
|
; NOREMAT-NEXT: add a4, a7, s4
|
|
; NOREMAT-NEXT: vle32.v v8, (a4)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v12, v4
|
|
; NOREMAT-NEXT: vle32.v v12, (a4)
|
|
; NOREMAT-NEXT: add a4, a7, s5
|
|
; NOREMAT-NEXT: vle32.v v4, (a4)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v20, v8
|
|
; NOREMAT-NEXT: vle32.v v8, (a4)
|
|
; NOREMAT-NEXT: add a4, a7, s6
|
|
; NOREMAT-NEXT: vle32.v v20, (a4)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v12, v4
|
|
; NOREMAT-NEXT: vle32.v v12, (a4)
|
|
; NOREMAT-NEXT: add a4, a7, s8
|
|
; NOREMAT-NEXT: vle32.v v4, (a4)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v8, v20
|
|
; NOREMAT-NEXT: vle32.v v8, (a4)
|
|
; NOREMAT-NEXT: add a4, a7, s9
|
|
; NOREMAT-NEXT: vle32.v v20, (a4)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v12, v4
|
|
; NOREMAT-NEXT: vle32.v v12, (a4)
|
|
; NOREMAT-NEXT: add a4, a7, s10
|
|
; NOREMAT-NEXT: vle32.v v4, (a4)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v8, v20
|
|
; NOREMAT-NEXT: vle32.v v8, (a4)
|
|
; NOREMAT-NEXT: add a4, a7, ra
|
|
; NOREMAT-NEXT: vle32.v v2, (a4)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v12, v4
|
|
; NOREMAT-NEXT: lui t4, 8
|
|
; NOREMAT-NEXT: add a5, a7, t4
|
|
; NOREMAT-NEXT: vle32.v v20, (a5)
|
|
; NOREMAT-NEXT: vle32.v v12, (a4)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v8, v2
|
|
; NOREMAT-NEXT: li a4, 17
|
|
; NOREMAT-NEXT: slli a4, a4, 9
|
|
; NOREMAT-NEXT: li s1, 17
|
|
; NOREMAT-NEXT: sd a4, 624(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a4, a7, a4
|
|
; NOREMAT-NEXT: vle32.v v8, (a4)
|
|
; NOREMAT-NEXT: vle32.v v4, (a4)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v12, v6
|
|
; NOREMAT-NEXT: li a5, 9
|
|
; NOREMAT-NEXT: slli a4, a5, 10
|
|
; NOREMAT-NEXT: sd a4, 616(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a4, a7, a4
|
|
; NOREMAT-NEXT: vle32.v v12, (a4)
|
|
; NOREMAT-NEXT: vle32.v v6, (a4)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v30, v8
|
|
; NOREMAT-NEXT: li a4, 19
|
|
; NOREMAT-NEXT: slli a4, a4, 9
|
|
; NOREMAT-NEXT: li t2, 19
|
|
; NOREMAT-NEXT: sd a4, 608(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a4, a7, a4
|
|
; NOREMAT-NEXT: vle32.v v8, (a4)
|
|
; NOREMAT-NEXT: vle32.v v30, (a4)
|
|
; NOREMAT-NEXT: slli a3, a2, 11
|
|
; NOREMAT-NEXT: sd a3, 600(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v4, v12
|
|
; NOREMAT-NEXT: add a3, a7, a3
|
|
; NOREMAT-NEXT: vle32.v v12, (a3)
|
|
; NOREMAT-NEXT: vle32.v v4, (a3)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v6, v8
|
|
; NOREMAT-NEXT: li s7, 21
|
|
; NOREMAT-NEXT: slli a3, s7, 9
|
|
; NOREMAT-NEXT: sd a3, 592(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a3, a7, a3
|
|
; NOREMAT-NEXT: vle32.v v8, (a3)
|
|
; NOREMAT-NEXT: vle32.v v6, (a3)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v30, v12
|
|
; NOREMAT-NEXT: li a6, 11
|
|
; NOREMAT-NEXT: slli a3, a6, 10
|
|
; NOREMAT-NEXT: sd a3, 584(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a3, a7, a3
|
|
; NOREMAT-NEXT: vle32.v v12, (a3)
|
|
; NOREMAT-NEXT: vle32.v v30, (a3)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v4, v8
|
|
; NOREMAT-NEXT: li s3, 23
|
|
; NOREMAT-NEXT: slli a3, s3, 9
|
|
; NOREMAT-NEXT: sd a3, 576(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a3, a7, a3
|
|
; NOREMAT-NEXT: vle32.v v8, (a3)
|
|
; NOREMAT-NEXT: vle32.v v4, (a3)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v6, v12
|
|
; NOREMAT-NEXT: li s0, 25
|
|
; NOREMAT-NEXT: slli a3, s0, 9
|
|
; NOREMAT-NEXT: sd a3, 568(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a3, a7, a3
|
|
; NOREMAT-NEXT: vle32.v v12, (a3)
|
|
; NOREMAT-NEXT: vle32.v v6, (a3)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v30, v8
|
|
; NOREMAT-NEXT: slli a3, t5, 10
|
|
; NOREMAT-NEXT: sd a3, 560(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a3, a7, a3
|
|
; NOREMAT-NEXT: vle32.v v8, (a3)
|
|
; NOREMAT-NEXT: vle32.v v30, (a3)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v4, v28
|
|
; NOREMAT-NEXT: li t3, 27
|
|
; NOREMAT-NEXT: slli a3, t3, 9
|
|
; NOREMAT-NEXT: sd a3, 552(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a3, a7, a3
|
|
; NOREMAT-NEXT: vle32.v v28, (a3)
|
|
; NOREMAT-NEXT: vle32.v v4, (a3)
|
|
; NOREMAT-NEXT: slli a2, t0, 11
|
|
; NOREMAT-NEXT: sd a2, 544(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v26, v12
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v12, (a2)
|
|
; NOREMAT-NEXT: vle32.v v26, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v6, v8
|
|
; NOREMAT-NEXT: li t0, 29
|
|
; NOREMAT-NEXT: slli a2, t0, 9
|
|
; NOREMAT-NEXT: sd a2, 536(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v8, (a2)
|
|
; NOREMAT-NEXT: vle32.v v6, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v30, v28
|
|
; NOREMAT-NEXT: li a3, 15
|
|
; NOREMAT-NEXT: slli a2, a3, 10
|
|
; NOREMAT-NEXT: sd a2, 528(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v28, (a2)
|
|
; NOREMAT-NEXT: vle32.v v30, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v4, v12
|
|
; NOREMAT-NEXT: li t1, 31
|
|
; NOREMAT-NEXT: slli a2, t1, 9
|
|
; NOREMAT-NEXT: sd a2, 520(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v12, (a2)
|
|
; NOREMAT-NEXT: vle32.v v4, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v26, v8
|
|
; NOREMAT-NEXT: lui a4, 4
|
|
; NOREMAT-NEXT: addiw a0, a4, 512
|
|
; NOREMAT-NEXT: sd a0, 496(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a0, a7, a0
|
|
; NOREMAT-NEXT: vle32.v v8, (a0)
|
|
; NOREMAT-NEXT: vle32.v v26, (a0)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v6, v28
|
|
; NOREMAT-NEXT: slli a2, s1, 10
|
|
; NOREMAT-NEXT: sd a2, 488(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v28, (a2)
|
|
; NOREMAT-NEXT: vle32.v v6, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v30, v12
|
|
; NOREMAT-NEXT: addiw a2, a4, 1536
|
|
; NOREMAT-NEXT: sd a2, 480(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v12, (a2)
|
|
; NOREMAT-NEXT: vle32.v v30, (a2)
|
|
; NOREMAT-NEXT: slli a2, a5, 11
|
|
; NOREMAT-NEXT: sd a2, 472(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v4, v24
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v24, (a2)
|
|
; NOREMAT-NEXT: vle32.v v4, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v22, v8
|
|
; NOREMAT-NEXT: lui a5, 5
|
|
; NOREMAT-NEXT: addiw a2, a5, -1536
|
|
; NOREMAT-NEXT: sd a2, 464(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v8, (a2)
|
|
; NOREMAT-NEXT: vle32.v v22, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v26, v28
|
|
; NOREMAT-NEXT: slli a2, t2, 10
|
|
; NOREMAT-NEXT: sd a2, 456(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: li t2, 19
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v26, (a2)
|
|
; NOREMAT-NEXT: vle32.v v28, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v6, v12
|
|
; NOREMAT-NEXT: addiw a2, a5, -512
|
|
; NOREMAT-NEXT: sd a2, 448(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v12, (a2)
|
|
; NOREMAT-NEXT: vle32.v v6, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v30, v24
|
|
; NOREMAT-NEXT: addiw a2, a5, 512
|
|
; NOREMAT-NEXT: sd a2, 440(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v24, (a2)
|
|
; NOREMAT-NEXT: vle32.v v30, (a2)
|
|
; NOREMAT-NEXT: slli a2, s7, 10
|
|
; NOREMAT-NEXT: sd a2, 432(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v4, v8
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v8, (a2)
|
|
; NOREMAT-NEXT: vle32.v v4, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v22, v26
|
|
; NOREMAT-NEXT: addiw a2, a5, 1536
|
|
; NOREMAT-NEXT: sd a2, 424(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v22, (a2)
|
|
; NOREMAT-NEXT: vle32.v v26, (a2)
|
|
; NOREMAT-NEXT: slli a2, a6, 11
|
|
; NOREMAT-NEXT: sd a2, 416(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v28, v12
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v12, (a2)
|
|
; NOREMAT-NEXT: vle32.v v28, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v6, v18
|
|
; NOREMAT-NEXT: lui a6, 6
|
|
; NOREMAT-NEXT: addiw a2, a6, -1536
|
|
; NOREMAT-NEXT: sd a2, 408(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v18, (a2)
|
|
; NOREMAT-NEXT: vle32.v v6, (a2)
|
|
; NOREMAT-NEXT: slli a2, s3, 10
|
|
; NOREMAT-NEXT: sd a2, 400(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v16, v24
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v16, (a2)
|
|
; NOREMAT-NEXT: vle32.v v24, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v30, v8
|
|
; NOREMAT-NEXT: addiw a2, a6, -512
|
|
; NOREMAT-NEXT: sd a2, 392(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v8, (a2)
|
|
; NOREMAT-NEXT: vle32.v v30, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v4, v22
|
|
; NOREMAT-NEXT: addiw a2, a6, 512
|
|
; NOREMAT-NEXT: sd a2, 384(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v22, (a2)
|
|
; NOREMAT-NEXT: vle32.v v4, (a2)
|
|
; NOREMAT-NEXT: slli a2, s0, 10
|
|
; NOREMAT-NEXT: sd a2, 376(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v26, v12
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v26, (a2)
|
|
; NOREMAT-NEXT: vle32.v v2, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v28, v18
|
|
; NOREMAT-NEXT: addiw a2, a6, 1536
|
|
; NOREMAT-NEXT: sd a2, 368(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v18, (a2)
|
|
; NOREMAT-NEXT: vle32.v v28, (a2)
|
|
; NOREMAT-NEXT: slli a2, t5, 11
|
|
; NOREMAT-NEXT: sd a2, 360(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v6, v16
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v16, (a2)
|
|
; NOREMAT-NEXT: vle32.v v6, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v24, v8
|
|
; NOREMAT-NEXT: lui s0, 7
|
|
; NOREMAT-NEXT: addiw a2, s0, -1536
|
|
; NOREMAT-NEXT: sd a2, 352(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v8, (a2)
|
|
; NOREMAT-NEXT: vle32.v v24, (a2)
|
|
; NOREMAT-NEXT: slli a2, t3, 10
|
|
; NOREMAT-NEXT: sd a2, 344(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v30, v14
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v14, (a2)
|
|
; NOREMAT-NEXT: vle32.v v30, (a2)
|
|
; NOREMAT-NEXT: addi a0, sp, 640
|
|
; NOREMAT-NEXT: vl2r.v v12, (a0) # Unknown-size Folded Reload
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v12, v22
|
|
; NOREMAT-NEXT: addiw a2, s0, -512
|
|
; NOREMAT-NEXT: sd a2, 336(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v22, (a2)
|
|
; NOREMAT-NEXT: vle32.v v12, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v4, v26
|
|
; NOREMAT-NEXT: addiw a2, s0, 512
|
|
; NOREMAT-NEXT: sd a2, 328(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: lui t3, 7
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v26, (a2)
|
|
; NOREMAT-NEXT: vle32.v v4, (a2)
|
|
; NOREMAT-NEXT: slli a2, t0, 10
|
|
; NOREMAT-NEXT: sd a2, 320(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v2, v18
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v18, (a2)
|
|
; NOREMAT-NEXT: vle32.v v2, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v28, v16
|
|
; NOREMAT-NEXT: addiw a2, t3, 1536
|
|
; NOREMAT-NEXT: sd a2, 312(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v16, (a2)
|
|
; NOREMAT-NEXT: vle32.v v28, (a2)
|
|
; NOREMAT-NEXT: slli a2, a3, 11
|
|
; NOREMAT-NEXT: sd a2, 304(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v6, v8
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v8, (a2)
|
|
; NOREMAT-NEXT: vle32.v v6, (a2)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v24, v14
|
|
; NOREMAT-NEXT: addiw a2, t4, -1536
|
|
; NOREMAT-NEXT: sd a2, 296(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v14, (a2)
|
|
; NOREMAT-NEXT: vle32.v v24, (a2)
|
|
; NOREMAT-NEXT: slli a2, t1, 10
|
|
; NOREMAT-NEXT: sd a2, 288(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v30, v22
|
|
; NOREMAT-NEXT: add a2, a7, a2
|
|
; NOREMAT-NEXT: vle32.v v22, (a2)
|
|
; NOREMAT-NEXT: vle32.v v30, (a2)
|
|
; NOREMAT-NEXT: addiw a0, t4, -512
|
|
; NOREMAT-NEXT: sd a0, 280(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a0, a7, a0
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v12, v0
|
|
; NOREMAT-NEXT: vle32.v v12, (a0)
|
|
; NOREMAT-NEXT: vle32.v v0, (a0)
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v10, v26
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v4, v18
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v2, v16
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v28, v8
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v6, v14
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v24, v22
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v30, v12
|
|
; NOREMAT-NEXT: sf.vc.vv 3, 0, v0, v20
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: addi a0, a1, 1024
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: add s11, a1, s11
|
|
; NOREMAT-NEXT: sd s11, 272(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: lui a0, 2
|
|
; NOREMAT-NEXT: add a0, a1, a0
|
|
; NOREMAT-NEXT: sd a0, 264(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: lui a0, 3
|
|
; NOREMAT-NEXT: add a0, a1, a0
|
|
; NOREMAT-NEXT: sd a0, 256(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a4, a1, a4
|
|
; NOREMAT-NEXT: sd a4, 248(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a5, a1, a5
|
|
; NOREMAT-NEXT: sd a5, 240(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a6, a1, a6
|
|
; NOREMAT-NEXT: sd a6, 232(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add t3, a1, t3
|
|
; NOREMAT-NEXT: sd t3, 224(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a0, a1, t4
|
|
; NOREMAT-NEXT: sd a0, 216(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: addiw a0, t4, 512
|
|
; NOREMAT-NEXT: sd a0, 192(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: addiw a0, t4, 1024
|
|
; NOREMAT-NEXT: sd a0, 176(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: addiw a0, t4, 1536
|
|
; NOREMAT-NEXT: sd a0, 160(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: slli s1, s1, 11
|
|
; NOREMAT-NEXT: sd s1, 128(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: lui a0, 9
|
|
; NOREMAT-NEXT: addiw a2, a0, -1536
|
|
; NOREMAT-NEXT: sd a2, 88(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: addiw a2, a0, -1024
|
|
; NOREMAT-NEXT: sd a2, 72(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: addiw a2, a0, -512
|
|
; NOREMAT-NEXT: sd a2, 40(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add a2, a1, a0
|
|
; NOREMAT-NEXT: sd a2, 208(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: addiw s11, a0, 512
|
|
; NOREMAT-NEXT: addiw s7, a0, 1024
|
|
; NOREMAT-NEXT: addiw s3, a0, 1536
|
|
; NOREMAT-NEXT: slli s1, t2, 11
|
|
; NOREMAT-NEXT: lui a0, 10
|
|
; NOREMAT-NEXT: addiw t2, a0, -1536
|
|
; NOREMAT-NEXT: addiw a7, a0, -1024
|
|
; NOREMAT-NEXT: addiw a4, a0, -512
|
|
; NOREMAT-NEXT: add a2, a1, a0
|
|
; NOREMAT-NEXT: sd a2, 200(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: addiw a0, a0, 512
|
|
; NOREMAT-NEXT: ld a2, 512(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add a2, a1, a2
|
|
; NOREMAT-NEXT: ld a3, 504(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add a3, a1, a3
|
|
; NOREMAT-NEXT: add a5, a1, t6
|
|
; NOREMAT-NEXT: add a6, a1, s2
|
|
; NOREMAT-NEXT: add t0, a1, s4
|
|
; NOREMAT-NEXT: add t1, a1, s5
|
|
; NOREMAT-NEXT: add t3, a1, s6
|
|
; NOREMAT-NEXT: add t4, a1, s8
|
|
; NOREMAT-NEXT: add t5, a1, s9
|
|
; NOREMAT-NEXT: add t6, a1, s10
|
|
; NOREMAT-NEXT: add s0, a1, ra
|
|
; NOREMAT-NEXT: ld s2, 624(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add s2, a1, s2
|
|
; NOREMAT-NEXT: ld s4, 616(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add s4, a1, s4
|
|
; NOREMAT-NEXT: ld s5, 608(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add s5, a1, s5
|
|
; NOREMAT-NEXT: ld s6, 600(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add s6, a1, s6
|
|
; NOREMAT-NEXT: ld s8, 592(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add s8, a1, s8
|
|
; NOREMAT-NEXT: ld s9, 584(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add s9, a1, s9
|
|
; NOREMAT-NEXT: ld s10, 576(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add s10, a1, s10
|
|
; NOREMAT-NEXT: ld ra, 568(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 16(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 560(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 24(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 552(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 32(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 544(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 48(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 536(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 56(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 528(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 64(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 520(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 80(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 496(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 96(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 488(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 104(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 480(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 112(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 472(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 120(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 464(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 136(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 456(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 144(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 448(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 152(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 440(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 168(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 432(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 184(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 424(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 424(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 416(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 432(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 408(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 440(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 400(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 448(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 392(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 456(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 384(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 464(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 376(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 472(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 368(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 480(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 360(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 488(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 352(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 496(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 344(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 504(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 336(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 512(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 328(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 520(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 320(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 528(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 312(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 536(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 304(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 544(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 296(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 552(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 288(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 560(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 280(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 568(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 192(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 576(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 176(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 584(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 160(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 592(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 128(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 600(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 88(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 608(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 72(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 616(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: ld ra, 40(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: add ra, a1, ra
|
|
; NOREMAT-NEXT: sd ra, 624(sp) # 8-byte Folded Spill
|
|
; NOREMAT-NEXT: add ra, a1, s11
|
|
; NOREMAT-NEXT: add s11, a1, s7
|
|
; NOREMAT-NEXT: add s7, a1, s3
|
|
; NOREMAT-NEXT: add s3, a1, s1
|
|
; NOREMAT-NEXT: add s1, a1, t2
|
|
; NOREMAT-NEXT: add t2, a1, a7
|
|
; NOREMAT-NEXT: add a7, a1, a4
|
|
; NOREMAT-NEXT: add a4, a1, a0
|
|
; NOREMAT-NEXT: addi a0, a1, 1536
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (a2)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (a3)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (a5)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (a6)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 272(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (t0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (t1)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (t3)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (t4)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (t5)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (t6)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (s0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 264(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (s2)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (s4)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (s5)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (s6)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (s8)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (s9)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (s10)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 256(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 16(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 24(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 32(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 48(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 56(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 64(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 80(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 248(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 96(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 104(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 112(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 120(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 136(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 144(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 152(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 240(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 168(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 184(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 424(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 432(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 440(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 448(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 456(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 232(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 464(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 472(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 480(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 488(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 496(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 504(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 512(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 224(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 520(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 528(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 536(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 544(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 552(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 560(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 568(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 216(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 576(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 584(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 592(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 600(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 608(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 616(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 624(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 208(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (ra)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (s11)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (s7)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (s3)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (s1)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (t2)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (a7)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: ld a0, 200(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: vse32.v v8, (a0)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: vse32.v v8, (a4)
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; NOREMAT-NEXT: csrr a0, vlenb
|
|
; NOREMAT-NEXT: slli a0, a0, 1
|
|
; NOREMAT-NEXT: add sp, sp, a0
|
|
; NOREMAT-NEXT: .cfi_def_cfa sp, 752
|
|
; NOREMAT-NEXT: ld ra, 744(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: ld s0, 736(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: ld s1, 728(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: ld s2, 720(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: ld s3, 712(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: ld s4, 704(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: ld s5, 696(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: ld s6, 688(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: ld s7, 680(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: ld s8, 672(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: ld s9, 664(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: ld s10, 656(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: ld s11, 648(sp) # 8-byte Folded Reload
|
|
; NOREMAT-NEXT: .cfi_restore ra
|
|
; NOREMAT-NEXT: .cfi_restore s0
|
|
; NOREMAT-NEXT: .cfi_restore s1
|
|
; NOREMAT-NEXT: .cfi_restore s2
|
|
; NOREMAT-NEXT: .cfi_restore s3
|
|
; NOREMAT-NEXT: .cfi_restore s4
|
|
; NOREMAT-NEXT: .cfi_restore s5
|
|
; NOREMAT-NEXT: .cfi_restore s6
|
|
; NOREMAT-NEXT: .cfi_restore s7
|
|
; NOREMAT-NEXT: .cfi_restore s8
|
|
; NOREMAT-NEXT: .cfi_restore s9
|
|
; NOREMAT-NEXT: .cfi_restore s10
|
|
; NOREMAT-NEXT: .cfi_restore s11
|
|
; NOREMAT-NEXT: addi sp, sp, 752
|
|
; NOREMAT-NEXT: .cfi_def_cfa_offset 0
|
|
; NOREMAT-NEXT: ret
|
|
;
|
|
; REMAT-LABEL: test:
|
|
; REMAT: # %bb.0:
|
|
; REMAT-NEXT: addi sp, sp, -544
|
|
; REMAT-NEXT: .cfi_def_cfa_offset 544
|
|
; REMAT-NEXT: sd ra, 536(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: sd s0, 528(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: sd s1, 520(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: sd s2, 512(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: sd s3, 504(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: sd s4, 496(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: sd s5, 488(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: sd s6, 480(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: sd s7, 472(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: sd s8, 464(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: sd s9, 456(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: sd s10, 448(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: sd s11, 440(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: .cfi_offset ra, -8
|
|
; REMAT-NEXT: .cfi_offset s0, -16
|
|
; REMAT-NEXT: .cfi_offset s1, -24
|
|
; REMAT-NEXT: .cfi_offset s2, -32
|
|
; REMAT-NEXT: .cfi_offset s3, -40
|
|
; REMAT-NEXT: .cfi_offset s4, -48
|
|
; REMAT-NEXT: .cfi_offset s5, -56
|
|
; REMAT-NEXT: .cfi_offset s6, -64
|
|
; REMAT-NEXT: .cfi_offset s7, -72
|
|
; REMAT-NEXT: .cfi_offset s8, -80
|
|
; REMAT-NEXT: .cfi_offset s9, -88
|
|
; REMAT-NEXT: .cfi_offset s10, -96
|
|
; REMAT-NEXT: .cfi_offset s11, -104
|
|
; REMAT-NEXT: csrr a2, vlenb
|
|
; REMAT-NEXT: li a3, 18
|
|
; REMAT-NEXT: mul a2, a2, a3
|
|
; REMAT-NEXT: sub sp, sp, a2
|
|
; REMAT-NEXT: .cfi_escape 0x0f, 0x0e, 0x72, 0x00, 0x11, 0xa0, 0x04, 0x22, 0x11, 0x12, 0x92, 0xa2, 0x38, 0x00, 0x1e, 0x22 # sp + 544 + 18 * vlenb
|
|
; REMAT-NEXT: li a4, 32
|
|
; REMAT-NEXT: addi a5, a0, 512
|
|
; REMAT-NEXT: addi a3, a0, 1024
|
|
; REMAT-NEXT: addi a2, a0, 1536
|
|
; REMAT-NEXT: li a6, 1
|
|
; REMAT-NEXT: slli a6, a6, 11
|
|
; REMAT-NEXT: li a7, 5
|
|
; REMAT-NEXT: slli a7, a7, 9
|
|
; REMAT-NEXT: li t0, 3
|
|
; REMAT-NEXT: slli t0, t0, 10
|
|
; REMAT-NEXT: li t1, 7
|
|
; REMAT-NEXT: slli t1, t1, 9
|
|
; REMAT-NEXT: lui t2, 1
|
|
; REMAT-NEXT: li t3, 9
|
|
; REMAT-NEXT: slli t3, t3, 9
|
|
; REMAT-NEXT: li t4, 5
|
|
; REMAT-NEXT: slli t4, t4, 10
|
|
; REMAT-NEXT: li t5, 11
|
|
; REMAT-NEXT: slli t5, t5, 9
|
|
; REMAT-NEXT: li t6, 3
|
|
; REMAT-NEXT: slli t6, t6, 11
|
|
; REMAT-NEXT: li s0, 13
|
|
; REMAT-NEXT: slli s0, s0, 9
|
|
; REMAT-NEXT: li s1, 7
|
|
; REMAT-NEXT: slli s1, s1, 10
|
|
; REMAT-NEXT: li s2, 15
|
|
; REMAT-NEXT: slli s2, s2, 9
|
|
; REMAT-NEXT: lui s3, 2
|
|
; REMAT-NEXT: li s4, 17
|
|
; REMAT-NEXT: slli s4, s4, 9
|
|
; REMAT-NEXT: li s5, 9
|
|
; REMAT-NEXT: slli s5, s5, 10
|
|
; REMAT-NEXT: li s6, 19
|
|
; REMAT-NEXT: slli s6, s6, 9
|
|
; REMAT-NEXT: li s7, 5
|
|
; REMAT-NEXT: slli s7, s7, 11
|
|
; REMAT-NEXT: li s8, 21
|
|
; REMAT-NEXT: slli s8, s8, 9
|
|
; REMAT-NEXT: li s9, 11
|
|
; REMAT-NEXT: slli s9, s9, 10
|
|
; REMAT-NEXT: li s10, 23
|
|
; REMAT-NEXT: slli s10, s10, 9
|
|
; REMAT-NEXT: lui s11, 3
|
|
; REMAT-NEXT: li ra, 25
|
|
; REMAT-NEXT: slli ra, ra, 9
|
|
; REMAT-NEXT: vsetvli zero, a4, e32, m2, ta, ma
|
|
; REMAT-NEXT: vle32.v v8, (a5)
|
|
; REMAT-NEXT: li a4, 13
|
|
; REMAT-NEXT: slli a4, a4, 10
|
|
; REMAT-NEXT: vle32.v v10, (a3)
|
|
; REMAT-NEXT: vle32.v v12, (a3)
|
|
; REMAT-NEXT: li a3, 27
|
|
; REMAT-NEXT: slli a3, a3, 9
|
|
; REMAT-NEXT: vle32.v v14, (a2)
|
|
; REMAT-NEXT: vle32.v v16, (a2)
|
|
; REMAT-NEXT: add a2, a0, a6
|
|
; REMAT-NEXT: vle32.v v18, (a2)
|
|
; REMAT-NEXT: vle32.v v20, (a2)
|
|
; REMAT-NEXT: add a2, a0, a7
|
|
; REMAT-NEXT: vle32.v v22, (a2)
|
|
; REMAT-NEXT: vle32.v v24, (a2)
|
|
; REMAT-NEXT: add a2, a0, t0
|
|
; REMAT-NEXT: vle32.v v26, (a2)
|
|
; REMAT-NEXT: vle32.v v28, (a2)
|
|
; REMAT-NEXT: add a2, a0, t1
|
|
; REMAT-NEXT: vle32.v v30, (a2)
|
|
; REMAT-NEXT: vle32.v v6, (a2)
|
|
; REMAT-NEXT: csrr a2, vlenb
|
|
; REMAT-NEXT: slli a2, a2, 4
|
|
; REMAT-NEXT: add a2, sp, a2
|
|
; REMAT-NEXT: addi a2, a2, 432
|
|
; REMAT-NEXT: vs2r.v v6, (a2) # Unknown-size Folded Spill
|
|
; REMAT-NEXT: add a2, a0, t2
|
|
; REMAT-NEXT: vle32.v v4, (a0)
|
|
; REMAT-NEXT: vle32.v v2, (a2)
|
|
; REMAT-NEXT: vle32.v v6, (a2)
|
|
; REMAT-NEXT: csrr a2, vlenb
|
|
; REMAT-NEXT: li a5, 14
|
|
; REMAT-NEXT: mul a2, a2, a5
|
|
; REMAT-NEXT: add a2, sp, a2
|
|
; REMAT-NEXT: addi a2, a2, 432
|
|
; REMAT-NEXT: vs2r.v v6, (a2) # Unknown-size Folded Spill
|
|
; REMAT-NEXT: add a2, a0, t3
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v4, v8
|
|
; REMAT-NEXT: vle32.v v4, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v8, v10
|
|
; REMAT-NEXT: vle32.v v6, (a2)
|
|
; REMAT-NEXT: add a2, a0, t4
|
|
; REMAT-NEXT: vle32.v v10, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v12, v14
|
|
; REMAT-NEXT: vle32.v v0, (a2)
|
|
; REMAT-NEXT: add a2, a0, t5
|
|
; REMAT-NEXT: vle32.v v14, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v16, v18
|
|
; REMAT-NEXT: vle32.v v8, (a2)
|
|
; REMAT-NEXT: csrr a2, vlenb
|
|
; REMAT-NEXT: li a5, 12
|
|
; REMAT-NEXT: mul a2, a2, a5
|
|
; REMAT-NEXT: add a2, sp, a2
|
|
; REMAT-NEXT: addi a2, a2, 432
|
|
; REMAT-NEXT: vs2r.v v8, (a2) # Unknown-size Folded Spill
|
|
; REMAT-NEXT: add a2, a0, t6
|
|
; REMAT-NEXT: vle32.v v18, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v20, v22
|
|
; REMAT-NEXT: vle32.v v20, (a2)
|
|
; REMAT-NEXT: add a2, a0, s0
|
|
; REMAT-NEXT: vle32.v v22, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v24, v26
|
|
; REMAT-NEXT: vle32.v v24, (a2)
|
|
; REMAT-NEXT: add a2, a0, s1
|
|
; REMAT-NEXT: vle32.v v26, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v28, v30
|
|
; REMAT-NEXT: vle32.v v28, (a2)
|
|
; REMAT-NEXT: add a2, a0, s2
|
|
; REMAT-NEXT: vle32.v v8, (a2)
|
|
; REMAT-NEXT: csrr a5, vlenb
|
|
; REMAT-NEXT: slli a5, a5, 4
|
|
; REMAT-NEXT: add a5, sp, a5
|
|
; REMAT-NEXT: addi a5, a5, 432
|
|
; REMAT-NEXT: vl2r.v v12, (a5) # Unknown-size Folded Reload
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v12, v2
|
|
; REMAT-NEXT: vle32.v v2, (a2)
|
|
; REMAT-NEXT: add a2, a0, s3
|
|
; REMAT-NEXT: vle32.v v12, (a2)
|
|
; REMAT-NEXT: csrr a5, vlenb
|
|
; REMAT-NEXT: li a6, 14
|
|
; REMAT-NEXT: mul a5, a5, a6
|
|
; REMAT-NEXT: add a5, sp, a5
|
|
; REMAT-NEXT: addi a5, a5, 432
|
|
; REMAT-NEXT: vl2r.v v16, (a5) # Unknown-size Folded Reload
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v16, v4
|
|
; REMAT-NEXT: vle32.v v30, (a2)
|
|
; REMAT-NEXT: add a2, a0, s4
|
|
; REMAT-NEXT: vle32.v v16, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v6, v10
|
|
; REMAT-NEXT: vle32.v v6, (a2)
|
|
; REMAT-NEXT: add a2, a0, s5
|
|
; REMAT-NEXT: vle32.v v10, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v0, v14
|
|
; REMAT-NEXT: vle32.v v4, (a2)
|
|
; REMAT-NEXT: add a2, a0, s6
|
|
; REMAT-NEXT: vle32.v v14, (a2)
|
|
; REMAT-NEXT: csrr a5, vlenb
|
|
; REMAT-NEXT: li a6, 12
|
|
; REMAT-NEXT: mul a5, a5, a6
|
|
; REMAT-NEXT: add a5, sp, a5
|
|
; REMAT-NEXT: addi a5, a5, 432
|
|
; REMAT-NEXT: vl2r.v v0, (a5) # Unknown-size Folded Reload
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v0, v18
|
|
; REMAT-NEXT: vle32.v v0, (a2)
|
|
; REMAT-NEXT: add a2, a0, s7
|
|
; REMAT-NEXT: vle32.v v18, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v20, v22
|
|
; REMAT-NEXT: vle32.v v22, (a2)
|
|
; REMAT-NEXT: add a2, a0, s8
|
|
; REMAT-NEXT: vle32.v v20, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v24, v26
|
|
; REMAT-NEXT: vle32.v v26, (a2)
|
|
; REMAT-NEXT: add a2, a0, s9
|
|
; REMAT-NEXT: vle32.v v24, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v28, v8
|
|
; REMAT-NEXT: vle32.v v28, (a2)
|
|
; REMAT-NEXT: add a2, a0, s10
|
|
; REMAT-NEXT: vle32.v v8, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v2, v12
|
|
; REMAT-NEXT: vle32.v v12, (a2)
|
|
; REMAT-NEXT: csrr a2, vlenb
|
|
; REMAT-NEXT: slli a2, a2, 3
|
|
; REMAT-NEXT: add a2, sp, a2
|
|
; REMAT-NEXT: addi a2, a2, 432
|
|
; REMAT-NEXT: vs2r.v v12, (a2) # Unknown-size Folded Spill
|
|
; REMAT-NEXT: add a2, a0, s11
|
|
; REMAT-NEXT: vle32.v v12, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v30, v16
|
|
; REMAT-NEXT: vle32.v v16, (a2)
|
|
; REMAT-NEXT: add a2, a0, ra
|
|
; REMAT-NEXT: vle32.v v2, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v6, v10
|
|
; REMAT-NEXT: vle32.v v10, (a2)
|
|
; REMAT-NEXT: csrr a2, vlenb
|
|
; REMAT-NEXT: slli a2, a2, 1
|
|
; REMAT-NEXT: add a2, sp, a2
|
|
; REMAT-NEXT: addi a2, a2, 432
|
|
; REMAT-NEXT: vs2r.v v10, (a2) # Unknown-size Folded Spill
|
|
; REMAT-NEXT: add a2, a0, a4
|
|
; REMAT-NEXT: vle32.v v10, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v4, v14
|
|
; REMAT-NEXT: vle32.v v14, (a2)
|
|
; REMAT-NEXT: csrr a2, vlenb
|
|
; REMAT-NEXT: slli a2, a2, 2
|
|
; REMAT-NEXT: add a2, sp, a2
|
|
; REMAT-NEXT: addi a2, a2, 432
|
|
; REMAT-NEXT: vs2r.v v14, (a2) # Unknown-size Folded Spill
|
|
; REMAT-NEXT: add a2, a0, a3
|
|
; REMAT-NEXT: vle32.v v14, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v0, v18
|
|
; REMAT-NEXT: vle32.v v18, (a2)
|
|
; REMAT-NEXT: csrr a2, vlenb
|
|
; REMAT-NEXT: slli a2, a2, 4
|
|
; REMAT-NEXT: add a2, sp, a2
|
|
; REMAT-NEXT: addi a2, a2, 432
|
|
; REMAT-NEXT: vs2r.v v18, (a2) # Unknown-size Folded Spill
|
|
; REMAT-NEXT: li a5, 7
|
|
; REMAT-NEXT: slli a5, a5, 11
|
|
; REMAT-NEXT: add a2, a0, a5
|
|
; REMAT-NEXT: vle32.v v18, (a2)
|
|
; REMAT-NEXT: addi a3, sp, 432
|
|
; REMAT-NEXT: vs2r.v v18, (a3) # Unknown-size Folded Spill
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v22, v20
|
|
; REMAT-NEXT: vle32.v v18, (a2)
|
|
; REMAT-NEXT: csrr a2, vlenb
|
|
; REMAT-NEXT: li a3, 14
|
|
; REMAT-NEXT: mul a2, a2, a3
|
|
; REMAT-NEXT: add a2, sp, a2
|
|
; REMAT-NEXT: addi a2, a2, 432
|
|
; REMAT-NEXT: vs2r.v v18, (a2) # Unknown-size Folded Spill
|
|
; REMAT-NEXT: li a2, 29
|
|
; REMAT-NEXT: slli a2, a2, 9
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v18, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v26, v24
|
|
; REMAT-NEXT: vle32.v v20, (a2)
|
|
; REMAT-NEXT: csrr a2, vlenb
|
|
; REMAT-NEXT: li a3, 12
|
|
; REMAT-NEXT: mul a2, a2, a3
|
|
; REMAT-NEXT: add a2, sp, a2
|
|
; REMAT-NEXT: addi a2, a2, 432
|
|
; REMAT-NEXT: vs2r.v v20, (a2) # Unknown-size Folded Spill
|
|
; REMAT-NEXT: li a2, 15
|
|
; REMAT-NEXT: slli a2, a2, 10
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v30, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v28, v8
|
|
; REMAT-NEXT: vle32.v v8, (a2)
|
|
; REMAT-NEXT: csrr a2, vlenb
|
|
; REMAT-NEXT: li a3, 10
|
|
; REMAT-NEXT: mul a2, a2, a3
|
|
; REMAT-NEXT: add a2, sp, a2
|
|
; REMAT-NEXT: addi a2, a2, 432
|
|
; REMAT-NEXT: vs2r.v v8, (a2) # Unknown-size Folded Spill
|
|
; REMAT-NEXT: li a2, 31
|
|
; REMAT-NEXT: slli a2, a2, 9
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v6, (a2)
|
|
; REMAT-NEXT: csrr a3, vlenb
|
|
; REMAT-NEXT: slli a3, a3, 3
|
|
; REMAT-NEXT: add a3, sp, a3
|
|
; REMAT-NEXT: addi a3, a3, 432
|
|
; REMAT-NEXT: vl2r.v v8, (a3) # Unknown-size Folded Reload
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v8, v12
|
|
; REMAT-NEXT: vle32.v v8, (a2)
|
|
; REMAT-NEXT: csrr a2, vlenb
|
|
; REMAT-NEXT: slli a2, a2, 3
|
|
; REMAT-NEXT: add a2, sp, a2
|
|
; REMAT-NEXT: addi a2, a2, 432
|
|
; REMAT-NEXT: vs2r.v v8, (a2) # Unknown-size Folded Spill
|
|
; REMAT-NEXT: lui a2, 4
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v4, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v16, v2
|
|
; REMAT-NEXT: vle32.v v8, (a2)
|
|
; REMAT-NEXT: csrr a2, vlenb
|
|
; REMAT-NEXT: li a3, 6
|
|
; REMAT-NEXT: mul a2, a2, a3
|
|
; REMAT-NEXT: add a2, sp, a2
|
|
; REMAT-NEXT: addi a2, a2, 432
|
|
; REMAT-NEXT: vs2r.v v8, (a2) # Unknown-size Folded Spill
|
|
; REMAT-NEXT: lui a2, 4
|
|
; REMAT-NEXT: addiw a2, a2, 512
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v2, (a2)
|
|
; REMAT-NEXT: csrr a3, vlenb
|
|
; REMAT-NEXT: slli a3, a3, 1
|
|
; REMAT-NEXT: add a3, sp, a3
|
|
; REMAT-NEXT: addi a3, a3, 432
|
|
; REMAT-NEXT: vl2r.v v8, (a3) # Unknown-size Folded Reload
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v8, v10
|
|
; REMAT-NEXT: vle32.v v20, (a2)
|
|
; REMAT-NEXT: li a2, 17
|
|
; REMAT-NEXT: slli a2, a2, 10
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v0, (a2)
|
|
; REMAT-NEXT: csrr a3, vlenb
|
|
; REMAT-NEXT: slli a3, a3, 2
|
|
; REMAT-NEXT: add a3, sp, a3
|
|
; REMAT-NEXT: addi a3, a3, 432
|
|
; REMAT-NEXT: vl2r.v v8, (a3) # Unknown-size Folded Reload
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v8, v14
|
|
; REMAT-NEXT: vle32.v v22, (a2)
|
|
; REMAT-NEXT: lui a2, 4
|
|
; REMAT-NEXT: addiw a2, a2, 1536
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v24, (a2)
|
|
; REMAT-NEXT: csrr a3, vlenb
|
|
; REMAT-NEXT: slli a3, a3, 4
|
|
; REMAT-NEXT: add a3, sp, a3
|
|
; REMAT-NEXT: addi a3, a3, 432
|
|
; REMAT-NEXT: vl2r.v v8, (a3) # Unknown-size Folded Reload
|
|
; REMAT-NEXT: addi a3, sp, 432
|
|
; REMAT-NEXT: vl2r.v v10, (a3) # Unknown-size Folded Reload
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v8, v10
|
|
; REMAT-NEXT: vle32.v v8, (a2)
|
|
; REMAT-NEXT: li a2, 9
|
|
; REMAT-NEXT: slli a2, a2, 11
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v26, (a2)
|
|
; REMAT-NEXT: csrr a3, vlenb
|
|
; REMAT-NEXT: li a4, 14
|
|
; REMAT-NEXT: mul a3, a3, a4
|
|
; REMAT-NEXT: add a3, sp, a3
|
|
; REMAT-NEXT: addi a3, a3, 432
|
|
; REMAT-NEXT: vl2r.v v10, (a3) # Unknown-size Folded Reload
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v10, v18
|
|
; REMAT-NEXT: vle32.v v10, (a2)
|
|
; REMAT-NEXT: lui a2, 5
|
|
; REMAT-NEXT: addiw a2, a2, -1536
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v28, (a2)
|
|
; REMAT-NEXT: csrr a3, vlenb
|
|
; REMAT-NEXT: li a4, 12
|
|
; REMAT-NEXT: mul a3, a3, a4
|
|
; REMAT-NEXT: add a3, sp, a3
|
|
; REMAT-NEXT: addi a3, a3, 432
|
|
; REMAT-NEXT: vl2r.v v12, (a3) # Unknown-size Folded Reload
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v12, v30
|
|
; REMAT-NEXT: vle32.v v12, (a2)
|
|
; REMAT-NEXT: li a2, 19
|
|
; REMAT-NEXT: slli a2, a2, 10
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v30, (a2)
|
|
; REMAT-NEXT: csrr a3, vlenb
|
|
; REMAT-NEXT: li a4, 10
|
|
; REMAT-NEXT: mul a3, a3, a4
|
|
; REMAT-NEXT: add a3, sp, a3
|
|
; REMAT-NEXT: addi a3, a3, 432
|
|
; REMAT-NEXT: vl2r.v v14, (a3) # Unknown-size Folded Reload
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v14, v6
|
|
; REMAT-NEXT: vle32.v v14, (a2)
|
|
; REMAT-NEXT: lui a2, 5
|
|
; REMAT-NEXT: addiw a2, a2, -512
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v6, (a2)
|
|
; REMAT-NEXT: csrr a3, vlenb
|
|
; REMAT-NEXT: slli a3, a3, 3
|
|
; REMAT-NEXT: add a3, sp, a3
|
|
; REMAT-NEXT: addi a3, a3, 432
|
|
; REMAT-NEXT: vl2r.v v16, (a3) # Unknown-size Folded Reload
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v16, v4
|
|
; REMAT-NEXT: vle32.v v16, (a2)
|
|
; REMAT-NEXT: lui a2, 5
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v4, (a2)
|
|
; REMAT-NEXT: csrr a3, vlenb
|
|
; REMAT-NEXT: li a4, 6
|
|
; REMAT-NEXT: mul a3, a3, a4
|
|
; REMAT-NEXT: add a3, sp, a3
|
|
; REMAT-NEXT: addi a3, a3, 432
|
|
; REMAT-NEXT: vl2r.v v18, (a3) # Unknown-size Folded Reload
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v18, v2
|
|
; REMAT-NEXT: vle32.v v18, (a2)
|
|
; REMAT-NEXT: lui a2, 5
|
|
; REMAT-NEXT: addiw a2, a2, 512
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v2, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v20, v0
|
|
; REMAT-NEXT: vle32.v v20, (a2)
|
|
; REMAT-NEXT: li s7, 21
|
|
; REMAT-NEXT: slli s7, s7, 10
|
|
; REMAT-NEXT: add a2, a0, s7
|
|
; REMAT-NEXT: vle32.v v0, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v22, v24
|
|
; REMAT-NEXT: vle32.v v22, (a2)
|
|
; REMAT-NEXT: lui s4, 5
|
|
; REMAT-NEXT: addiw s4, s4, 1536
|
|
; REMAT-NEXT: add a2, a0, s4
|
|
; REMAT-NEXT: vle32.v v24, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v8, v26
|
|
; REMAT-NEXT: vle32.v v8, (a2)
|
|
; REMAT-NEXT: li a2, 11
|
|
; REMAT-NEXT: slli a2, a2, 11
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v26, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v10, v28
|
|
; REMAT-NEXT: vle32.v v10, (a2)
|
|
; REMAT-NEXT: lui s3, 6
|
|
; REMAT-NEXT: addiw s3, s3, -1536
|
|
; REMAT-NEXT: add a2, a0, s3
|
|
; REMAT-NEXT: vle32.v v28, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v12, v30
|
|
; REMAT-NEXT: vle32.v v12, (a2)
|
|
; REMAT-NEXT: li s2, 23
|
|
; REMAT-NEXT: slli s2, s2, 10
|
|
; REMAT-NEXT: add a2, a0, s2
|
|
; REMAT-NEXT: vle32.v v30, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v14, v6
|
|
; REMAT-NEXT: vle32.v v14, (a2)
|
|
; REMAT-NEXT: lui a2, 6
|
|
; REMAT-NEXT: addiw a2, a2, -512
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v6, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v16, v4
|
|
; REMAT-NEXT: vle32.v v16, (a2)
|
|
; REMAT-NEXT: lui a2, 6
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: lui s1, 6
|
|
; REMAT-NEXT: vle32.v v4, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v18, v2
|
|
; REMAT-NEXT: vle32.v v18, (a2)
|
|
; REMAT-NEXT: lui s0, 6
|
|
; REMAT-NEXT: addiw s0, s0, 512
|
|
; REMAT-NEXT: add a2, a0, s0
|
|
; REMAT-NEXT: vle32.v v2, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v20, v0
|
|
; REMAT-NEXT: vle32.v v20, (a2)
|
|
; REMAT-NEXT: li a2, 25
|
|
; REMAT-NEXT: slli a2, a2, 10
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v0, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v22, v24
|
|
; REMAT-NEXT: vle32.v v22, (a2)
|
|
; REMAT-NEXT: lui t6, 6
|
|
; REMAT-NEXT: addiw t6, t6, 1536
|
|
; REMAT-NEXT: add a2, a0, t6
|
|
; REMAT-NEXT: vle32.v v24, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v8, v26
|
|
; REMAT-NEXT: vle32.v v8, (a2)
|
|
; REMAT-NEXT: li t5, 13
|
|
; REMAT-NEXT: slli t5, t5, 11
|
|
; REMAT-NEXT: add a2, a0, t5
|
|
; REMAT-NEXT: vle32.v v26, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v10, v28
|
|
; REMAT-NEXT: vle32.v v10, (a2)
|
|
; REMAT-NEXT: lui a2, 7
|
|
; REMAT-NEXT: addiw a2, a2, -1536
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v28, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v12, v30
|
|
; REMAT-NEXT: vle32.v v12, (a2)
|
|
; REMAT-NEXT: li t4, 27
|
|
; REMAT-NEXT: slli t4, t4, 10
|
|
; REMAT-NEXT: add a2, a0, t4
|
|
; REMAT-NEXT: vle32.v v30, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v14, v6
|
|
; REMAT-NEXT: vle32.v v14, (a2)
|
|
; REMAT-NEXT: lui a2, 7
|
|
; REMAT-NEXT: addiw a2, a2, -512
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: vle32.v v6, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v16, v4
|
|
; REMAT-NEXT: vle32.v v16, (a2)
|
|
; REMAT-NEXT: lui a2, 7
|
|
; REMAT-NEXT: add a2, a0, a2
|
|
; REMAT-NEXT: lui t3, 7
|
|
; REMAT-NEXT: vle32.v v4, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v18, v2
|
|
; REMAT-NEXT: vle32.v v18, (a2)
|
|
; REMAT-NEXT: lui t2, 7
|
|
; REMAT-NEXT: addiw t2, t2, 512
|
|
; REMAT-NEXT: add a2, a0, t2
|
|
; REMAT-NEXT: vle32.v v2, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v20, v0
|
|
; REMAT-NEXT: vle32.v v20, (a2)
|
|
; REMAT-NEXT: li t1, 29
|
|
; REMAT-NEXT: slli t1, t1, 10
|
|
; REMAT-NEXT: add a2, a0, t1
|
|
; REMAT-NEXT: vle32.v v0, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v22, v24
|
|
; REMAT-NEXT: vle32.v v22, (a2)
|
|
; REMAT-NEXT: lui t0, 7
|
|
; REMAT-NEXT: addiw t0, t0, 1536
|
|
; REMAT-NEXT: add a2, a0, t0
|
|
; REMAT-NEXT: vle32.v v24, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v8, v26
|
|
; REMAT-NEXT: vle32.v v8, (a2)
|
|
; REMAT-NEXT: li a7, 15
|
|
; REMAT-NEXT: slli a7, a7, 11
|
|
; REMAT-NEXT: add a2, a0, a7
|
|
; REMAT-NEXT: vle32.v v26, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v10, v28
|
|
; REMAT-NEXT: vle32.v v10, (a2)
|
|
; REMAT-NEXT: lui a6, 8
|
|
; REMAT-NEXT: addiw a6, a6, -1536
|
|
; REMAT-NEXT: add a2, a0, a6
|
|
; REMAT-NEXT: vle32.v v28, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v12, v30
|
|
; REMAT-NEXT: vle32.v v12, (a2)
|
|
; REMAT-NEXT: li a4, 31
|
|
; REMAT-NEXT: slli a4, a4, 10
|
|
; REMAT-NEXT: add a2, a0, a4
|
|
; REMAT-NEXT: vle32.v v30, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v14, v6
|
|
; REMAT-NEXT: vle32.v v14, (a2)
|
|
; REMAT-NEXT: lui a3, 8
|
|
; REMAT-NEXT: addiw a3, a3, -512
|
|
; REMAT-NEXT: add a2, a0, a3
|
|
; REMAT-NEXT: vle32.v v6, (a2)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v16, v4
|
|
; REMAT-NEXT: vle32.v v16, (a2)
|
|
; REMAT-NEXT: lui a2, 8
|
|
; REMAT-NEXT: add a0, a0, a2
|
|
; REMAT-NEXT: vle32.v v4, (a0)
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v18, v2
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v20, v0
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v22, v24
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v8, v26
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v10, v28
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v12, v30
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v14, v6
|
|
; REMAT-NEXT: sf.vc.vv 3, 0, v16, v4
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: addi a0, a1, 1024
|
|
; REMAT-NEXT: vse32.v v8, (a0)
|
|
; REMAT-NEXT: li a0, 1
|
|
; REMAT-NEXT: slli a0, a0, 11
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 416(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 5
|
|
; REMAT-NEXT: slli a0, a0, 9
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 408(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 3
|
|
; REMAT-NEXT: slli a0, a0, 10
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 400(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 7
|
|
; REMAT-NEXT: slli a0, a0, 9
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 392(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: lui a0, 1
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 384(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 9
|
|
; REMAT-NEXT: slli a0, a0, 9
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 376(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 5
|
|
; REMAT-NEXT: slli a0, a0, 10
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 368(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 11
|
|
; REMAT-NEXT: slli a0, a0, 9
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 360(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 3
|
|
; REMAT-NEXT: slli a0, a0, 11
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 352(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 13
|
|
; REMAT-NEXT: slli a0, a0, 9
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 344(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 7
|
|
; REMAT-NEXT: slli a0, a0, 10
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 336(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 15
|
|
; REMAT-NEXT: slli a0, a0, 9
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 328(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: lui a0, 2
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 320(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 17
|
|
; REMAT-NEXT: slli a0, a0, 9
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 312(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add s5, a1, s5
|
|
; REMAT-NEXT: sd s5, 304(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add s6, a1, s6
|
|
; REMAT-NEXT: sd s6, 296(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 5
|
|
; REMAT-NEXT: slli a0, a0, 11
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 288(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add s8, a1, s8
|
|
; REMAT-NEXT: sd s8, 280(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add s9, a1, s9
|
|
; REMAT-NEXT: sd s9, 272(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add s10, a1, s10
|
|
; REMAT-NEXT: sd s10, 264(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add s11, a1, s11
|
|
; REMAT-NEXT: sd s11, 256(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add ra, a1, ra
|
|
; REMAT-NEXT: sd ra, 248(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 13
|
|
; REMAT-NEXT: slli a0, a0, 10
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 240(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 27
|
|
; REMAT-NEXT: slli a0, a0, 9
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 232(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add a5, a1, a5
|
|
; REMAT-NEXT: sd a5, 224(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 29
|
|
; REMAT-NEXT: slli a0, a0, 9
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 216(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 15
|
|
; REMAT-NEXT: slli a0, a0, 10
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 208(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 31
|
|
; REMAT-NEXT: slli a0, a0, 9
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 200(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: lui a0, 4
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 192(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: lui a0, 4
|
|
; REMAT-NEXT: addiw a0, a0, 512
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 184(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 17
|
|
; REMAT-NEXT: slli a0, a0, 10
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 176(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: lui a0, 4
|
|
; REMAT-NEXT: addiw a0, a0, 1536
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 168(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 9
|
|
; REMAT-NEXT: slli a0, a0, 11
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 160(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: lui a0, 5
|
|
; REMAT-NEXT: addiw a0, a0, -1536
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 152(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 19
|
|
; REMAT-NEXT: slli a0, a0, 10
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 144(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: lui a0, 5
|
|
; REMAT-NEXT: addiw a0, a0, -512
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 136(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: lui a0, 5
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 128(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: lui a0, 5
|
|
; REMAT-NEXT: addiw a0, a0, 512
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 120(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add s7, a1, s7
|
|
; REMAT-NEXT: sd s7, 112(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add s4, a1, s4
|
|
; REMAT-NEXT: sd s4, 104(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 11
|
|
; REMAT-NEXT: slli a0, a0, 11
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 96(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add s3, a1, s3
|
|
; REMAT-NEXT: sd s3, 88(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add s2, a1, s2
|
|
; REMAT-NEXT: sd s2, 80(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: lui a0, 6
|
|
; REMAT-NEXT: addiw a0, a0, -512
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 72(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add s1, a1, s1
|
|
; REMAT-NEXT: sd s1, 64(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add s0, a1, s0
|
|
; REMAT-NEXT: sd s0, 56(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: li a0, 25
|
|
; REMAT-NEXT: slli a0, a0, 10
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 48(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add t6, a1, t6
|
|
; REMAT-NEXT: sd t6, 40(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add t5, a1, t5
|
|
; REMAT-NEXT: sd t5, 32(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: lui a0, 7
|
|
; REMAT-NEXT: addiw a0, a0, -1536
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: sd a0, 24(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: add t4, a1, t4
|
|
; REMAT-NEXT: sd t4, 16(sp) # 8-byte Folded Spill
|
|
; REMAT-NEXT: lui ra, 7
|
|
; REMAT-NEXT: addiw ra, ra, -512
|
|
; REMAT-NEXT: add ra, a1, ra
|
|
; REMAT-NEXT: add s11, a1, t3
|
|
; REMAT-NEXT: add s10, a1, t2
|
|
; REMAT-NEXT: add s9, a1, t1
|
|
; REMAT-NEXT: add s8, a1, t0
|
|
; REMAT-NEXT: add s7, a1, a7
|
|
; REMAT-NEXT: add s6, a1, a6
|
|
; REMAT-NEXT: add s5, a1, a4
|
|
; REMAT-NEXT: add s4, a1, a3
|
|
; REMAT-NEXT: add s3, a1, a2
|
|
; REMAT-NEXT: lui s2, 8
|
|
; REMAT-NEXT: addiw s2, s2, 512
|
|
; REMAT-NEXT: add s2, a1, s2
|
|
; REMAT-NEXT: lui s1, 8
|
|
; REMAT-NEXT: addiw s1, s1, 1024
|
|
; REMAT-NEXT: add s1, a1, s1
|
|
; REMAT-NEXT: lui s0, 8
|
|
; REMAT-NEXT: addiw s0, s0, 1536
|
|
; REMAT-NEXT: add s0, a1, s0
|
|
; REMAT-NEXT: li t6, 17
|
|
; REMAT-NEXT: slli t6, t6, 11
|
|
; REMAT-NEXT: add t6, a1, t6
|
|
; REMAT-NEXT: lui t5, 9
|
|
; REMAT-NEXT: addiw t5, t5, -1536
|
|
; REMAT-NEXT: add t5, a1, t5
|
|
; REMAT-NEXT: lui t4, 9
|
|
; REMAT-NEXT: addiw t4, t4, -1024
|
|
; REMAT-NEXT: add t4, a1, t4
|
|
; REMAT-NEXT: lui t3, 9
|
|
; REMAT-NEXT: addiw t3, t3, -512
|
|
; REMAT-NEXT: add t3, a1, t3
|
|
; REMAT-NEXT: lui t2, 9
|
|
; REMAT-NEXT: add t2, a1, t2
|
|
; REMAT-NEXT: lui t1, 9
|
|
; REMAT-NEXT: addiw t1, t1, 512
|
|
; REMAT-NEXT: add t1, a1, t1
|
|
; REMAT-NEXT: lui t0, 9
|
|
; REMAT-NEXT: addiw t0, t0, 1024
|
|
; REMAT-NEXT: add t0, a1, t0
|
|
; REMAT-NEXT: lui a7, 9
|
|
; REMAT-NEXT: addiw a7, a7, 1536
|
|
; REMAT-NEXT: add a7, a1, a7
|
|
; REMAT-NEXT: li a6, 19
|
|
; REMAT-NEXT: slli a6, a6, 11
|
|
; REMAT-NEXT: add a6, a1, a6
|
|
; REMAT-NEXT: lui a5, 10
|
|
; REMAT-NEXT: addiw a5, a5, -1536
|
|
; REMAT-NEXT: add a5, a1, a5
|
|
; REMAT-NEXT: lui a4, 10
|
|
; REMAT-NEXT: addiw a4, a4, -1024
|
|
; REMAT-NEXT: add a4, a1, a4
|
|
; REMAT-NEXT: lui a3, 10
|
|
; REMAT-NEXT: addiw a3, a3, -512
|
|
; REMAT-NEXT: add a3, a1, a3
|
|
; REMAT-NEXT: lui a2, 10
|
|
; REMAT-NEXT: add a2, a1, a2
|
|
; REMAT-NEXT: lui a0, 10
|
|
; REMAT-NEXT: addiw a0, a0, 512
|
|
; REMAT-NEXT: add a0, a1, a0
|
|
; REMAT-NEXT: addi a1, a1, 1536
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 416(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 408(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 400(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 392(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 384(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 376(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 368(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 360(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 352(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 344(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 336(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 328(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 320(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 312(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 304(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 296(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 288(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 280(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 272(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 264(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 256(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 248(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 240(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 232(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 224(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 216(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 208(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 200(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 192(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 184(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 176(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 168(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 160(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 152(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 144(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 136(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 128(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 120(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 112(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 104(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 96(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 88(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 80(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 72(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 64(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 56(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 48(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 40(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 32(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 24(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: ld a1, 16(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: vse32.v v8, (a1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (ra)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (s11)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (s10)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (s9)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (s8)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (s7)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (s6)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (s5)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (s4)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (s3)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (s2)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (s1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (s0)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (t6)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (t5)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (t4)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (t3)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (t2)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (t1)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (t0)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (a7)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (a6)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (a5)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (a4)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (a3)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (a2)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: vse32.v v8, (a0)
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: sf.vc.v.i 2, 0, v8, 0
|
|
; REMAT-NEXT: csrr a0, vlenb
|
|
; REMAT-NEXT: li a1, 18
|
|
; REMAT-NEXT: mul a0, a0, a1
|
|
; REMAT-NEXT: add sp, sp, a0
|
|
; REMAT-NEXT: .cfi_def_cfa sp, 544
|
|
; REMAT-NEXT: ld ra, 536(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: ld s0, 528(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: ld s1, 520(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: ld s2, 512(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: ld s3, 504(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: ld s4, 496(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: ld s5, 488(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: ld s6, 480(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: ld s7, 472(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: ld s8, 464(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: ld s9, 456(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: ld s10, 448(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: ld s11, 440(sp) # 8-byte Folded Reload
|
|
; REMAT-NEXT: .cfi_restore ra
|
|
; REMAT-NEXT: .cfi_restore s0
|
|
; REMAT-NEXT: .cfi_restore s1
|
|
; REMAT-NEXT: .cfi_restore s2
|
|
; REMAT-NEXT: .cfi_restore s3
|
|
; REMAT-NEXT: .cfi_restore s4
|
|
; REMAT-NEXT: .cfi_restore s5
|
|
; REMAT-NEXT: .cfi_restore s6
|
|
; REMAT-NEXT: .cfi_restore s7
|
|
; REMAT-NEXT: .cfi_restore s8
|
|
; REMAT-NEXT: .cfi_restore s9
|
|
; REMAT-NEXT: .cfi_restore s10
|
|
; REMAT-NEXT: .cfi_restore s11
|
|
; REMAT-NEXT: addi sp, sp, 544
|
|
; REMAT-NEXT: .cfi_def_cfa_offset 0
|
|
; REMAT-NEXT: ret
|
|
%4 = tail call i64 @llvm.riscv.vsetvli.i64(i64 32, i64 2, i64 1)
|
|
%5 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %0, i64 %4)
|
|
%6 = getelementptr inbounds i32, ptr %0, i64 128
|
|
%7 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %6, i64 %4)
|
|
%8 = getelementptr inbounds i32, ptr %0, i64 256
|
|
%9 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %8, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %5, <vscale x 4 x i32> %7, i64 %4)
|
|
%10 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %8, i64 %4)
|
|
%11 = getelementptr inbounds i32, ptr %0, i64 384
|
|
%12 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %11, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %7, <vscale x 4 x i32> %9, i64 %4)
|
|
%13 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %11, i64 %4)
|
|
%14 = getelementptr inbounds i32, ptr %0, i64 512
|
|
%15 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %14, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %10, <vscale x 4 x i32> %12, i64 %4)
|
|
%16 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %14, i64 %4)
|
|
%17 = getelementptr inbounds i32, ptr %0, i64 640
|
|
%18 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %17, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %13, <vscale x 4 x i32> %15, i64 %4)
|
|
%19 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %17, i64 %4)
|
|
%20 = getelementptr inbounds i32, ptr %0, i64 768
|
|
%21 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %20, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %16, <vscale x 4 x i32> %18, i64 %4)
|
|
%22 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %20, i64 %4)
|
|
%23 = getelementptr inbounds i32, ptr %0, i64 896
|
|
%24 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %23, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %19, <vscale x 4 x i32> %21, i64 %4)
|
|
%25 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %23, i64 %4)
|
|
%26 = getelementptr inbounds i32, ptr %0, i64 1024
|
|
%27 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %26, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %22, <vscale x 4 x i32> %24, i64 %4)
|
|
%28 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %26, i64 %4)
|
|
%29 = getelementptr inbounds i32, ptr %0, i64 1152
|
|
%30 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %29, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %25, <vscale x 4 x i32> %27, i64 %4)
|
|
%31 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %29, i64 %4)
|
|
%32 = getelementptr inbounds i32, ptr %0, i64 1280
|
|
%33 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %32, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %28, <vscale x 4 x i32> %30, i64 %4)
|
|
%34 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %32, i64 %4)
|
|
%35 = getelementptr inbounds i32, ptr %0, i64 1408
|
|
%36 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %35, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %31, <vscale x 4 x i32> %33, i64 %4)
|
|
%37 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %35, i64 %4)
|
|
%38 = getelementptr inbounds i32, ptr %0, i64 1536
|
|
%39 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %38, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %34, <vscale x 4 x i32> %36, i64 %4)
|
|
%40 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %38, i64 %4)
|
|
%41 = getelementptr inbounds i32, ptr %0, i64 1664
|
|
%42 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %41, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %37, <vscale x 4 x i32> %39, i64 %4)
|
|
%43 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %41, i64 %4)
|
|
%44 = getelementptr inbounds i32, ptr %0, i64 1792
|
|
%45 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %44, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %40, <vscale x 4 x i32> %42, i64 %4)
|
|
%46 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %44, i64 %4)
|
|
%47 = getelementptr inbounds i32, ptr %0, i64 1920
|
|
%48 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %47, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %43, <vscale x 4 x i32> %45, i64 %4)
|
|
%49 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %47, i64 %4)
|
|
%50 = getelementptr inbounds i32, ptr %0, i64 2048
|
|
%51 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %50, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %46, <vscale x 4 x i32> %48, i64 %4)
|
|
%52 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %50, i64 %4)
|
|
%53 = getelementptr inbounds i32, ptr %0, i64 2176
|
|
%54 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %53, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %49, <vscale x 4 x i32> %51, i64 %4)
|
|
%55 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %53, i64 %4)
|
|
%56 = getelementptr inbounds i32, ptr %0, i64 2304
|
|
%57 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %56, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %52, <vscale x 4 x i32> %54, i64 %4)
|
|
%58 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %56, i64 %4)
|
|
%59 = getelementptr inbounds i32, ptr %0, i64 2432
|
|
%60 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %59, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %55, <vscale x 4 x i32> %57, i64 %4)
|
|
%61 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %59, i64 %4)
|
|
%62 = getelementptr inbounds i32, ptr %0, i64 2560
|
|
%63 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %62, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %58, <vscale x 4 x i32> %60, i64 %4)
|
|
%64 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %62, i64 %4)
|
|
%65 = getelementptr inbounds i32, ptr %0, i64 2688
|
|
%66 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %65, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %61, <vscale x 4 x i32> %63, i64 %4)
|
|
%67 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %65, i64 %4)
|
|
%68 = getelementptr inbounds i32, ptr %0, i64 2816
|
|
%69 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %68, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %64, <vscale x 4 x i32> %66, i64 %4)
|
|
%70 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %68, i64 %4)
|
|
%71 = getelementptr inbounds i32, ptr %0, i64 2944
|
|
%72 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %71, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %67, <vscale x 4 x i32> %69, i64 %4)
|
|
%73 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %71, i64 %4)
|
|
%74 = getelementptr inbounds i32, ptr %0, i64 3072
|
|
%75 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %74, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %70, <vscale x 4 x i32> %72, i64 %4)
|
|
%76 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %74, i64 %4)
|
|
%77 = getelementptr inbounds i32, ptr %0, i64 3200
|
|
%78 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %77, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %73, <vscale x 4 x i32> %75, i64 %4)
|
|
%79 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %77, i64 %4)
|
|
%80 = getelementptr inbounds i32, ptr %0, i64 3328
|
|
%81 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %80, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %76, <vscale x 4 x i32> %78, i64 %4)
|
|
%82 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %80, i64 %4)
|
|
%83 = getelementptr inbounds i32, ptr %0, i64 3456
|
|
%84 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %83, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %79, <vscale x 4 x i32> %81, i64 %4)
|
|
%85 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %83, i64 %4)
|
|
%86 = getelementptr inbounds i32, ptr %0, i64 3584
|
|
%87 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %86, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %82, <vscale x 4 x i32> %84, i64 %4)
|
|
%88 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %86, i64 %4)
|
|
%89 = getelementptr inbounds i32, ptr %0, i64 3712
|
|
%90 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %89, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %85, <vscale x 4 x i32> %87, i64 %4)
|
|
%91 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %89, i64 %4)
|
|
%92 = getelementptr inbounds i32, ptr %0, i64 3840
|
|
%93 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %92, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %88, <vscale x 4 x i32> %90, i64 %4)
|
|
%94 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %92, i64 %4)
|
|
%95 = getelementptr inbounds i32, ptr %0, i64 3968
|
|
%96 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %95, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %91, <vscale x 4 x i32> %93, i64 %4)
|
|
%97 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %95, i64 %4)
|
|
%98 = getelementptr inbounds i32, ptr %0, i64 4096
|
|
%99 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %98, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %94, <vscale x 4 x i32> %96, i64 %4)
|
|
%100 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %98, i64 %4)
|
|
%101 = getelementptr inbounds i32, ptr %0, i64 4224
|
|
%102 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %101, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %97, <vscale x 4 x i32> %99, i64 %4)
|
|
%103 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %101, i64 %4)
|
|
%104 = getelementptr inbounds i32, ptr %0, i64 4352
|
|
%105 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %104, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %100, <vscale x 4 x i32> %102, i64 %4)
|
|
%106 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %104, i64 %4)
|
|
%107 = getelementptr inbounds i32, ptr %0, i64 4480
|
|
%108 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %107, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %103, <vscale x 4 x i32> %105, i64 %4)
|
|
%109 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %107, i64 %4)
|
|
%110 = getelementptr inbounds i32, ptr %0, i64 4608
|
|
%111 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %110, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %106, <vscale x 4 x i32> %108, i64 %4)
|
|
%112 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %110, i64 %4)
|
|
%113 = getelementptr inbounds i32, ptr %0, i64 4736
|
|
%114 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %113, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %109, <vscale x 4 x i32> %111, i64 %4)
|
|
%115 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %113, i64 %4)
|
|
%116 = getelementptr inbounds i32, ptr %0, i64 4864
|
|
%117 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %116, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %112, <vscale x 4 x i32> %114, i64 %4)
|
|
%118 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %116, i64 %4)
|
|
%119 = getelementptr inbounds i32, ptr %0, i64 4992
|
|
%120 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %119, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %115, <vscale x 4 x i32> %117, i64 %4)
|
|
%121 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %119, i64 %4)
|
|
%122 = getelementptr inbounds i32, ptr %0, i64 5120
|
|
%123 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %122, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %118, <vscale x 4 x i32> %120, i64 %4)
|
|
%124 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %122, i64 %4)
|
|
%125 = getelementptr inbounds i32, ptr %0, i64 5248
|
|
%126 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %125, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %121, <vscale x 4 x i32> %123, i64 %4)
|
|
%127 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %125, i64 %4)
|
|
%128 = getelementptr inbounds i32, ptr %0, i64 5376
|
|
%129 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %128, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %124, <vscale x 4 x i32> %126, i64 %4)
|
|
%130 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %128, i64 %4)
|
|
%131 = getelementptr inbounds i32, ptr %0, i64 5504
|
|
%132 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %131, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %127, <vscale x 4 x i32> %129, i64 %4)
|
|
%133 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %131, i64 %4)
|
|
%134 = getelementptr inbounds i32, ptr %0, i64 5632
|
|
%135 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %134, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %130, <vscale x 4 x i32> %132, i64 %4)
|
|
%136 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %134, i64 %4)
|
|
%137 = getelementptr inbounds i32, ptr %0, i64 5760
|
|
%138 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %137, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %133, <vscale x 4 x i32> %135, i64 %4)
|
|
%139 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %137, i64 %4)
|
|
%140 = getelementptr inbounds i32, ptr %0, i64 5888
|
|
%141 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %140, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %136, <vscale x 4 x i32> %138, i64 %4)
|
|
%142 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %140, i64 %4)
|
|
%143 = getelementptr inbounds i32, ptr %0, i64 6016
|
|
%144 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %143, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %139, <vscale x 4 x i32> %141, i64 %4)
|
|
%145 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %143, i64 %4)
|
|
%146 = getelementptr inbounds i32, ptr %0, i64 6144
|
|
%147 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %146, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %142, <vscale x 4 x i32> %144, i64 %4)
|
|
%148 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %146, i64 %4)
|
|
%149 = getelementptr inbounds i32, ptr %0, i64 6272
|
|
%150 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %149, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %145, <vscale x 4 x i32> %147, i64 %4)
|
|
%151 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %149, i64 %4)
|
|
%152 = getelementptr inbounds i32, ptr %0, i64 6400
|
|
%153 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %152, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %148, <vscale x 4 x i32> %150, i64 %4)
|
|
%154 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %152, i64 %4)
|
|
%155 = getelementptr inbounds i32, ptr %0, i64 6528
|
|
%156 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %155, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %151, <vscale x 4 x i32> %153, i64 %4)
|
|
%157 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %155, i64 %4)
|
|
%158 = getelementptr inbounds i32, ptr %0, i64 6656
|
|
%159 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %158, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %154, <vscale x 4 x i32> %156, i64 %4)
|
|
%160 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %158, i64 %4)
|
|
%161 = getelementptr inbounds i32, ptr %0, i64 6784
|
|
%162 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %161, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %157, <vscale x 4 x i32> %159, i64 %4)
|
|
%163 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %161, i64 %4)
|
|
%164 = getelementptr inbounds i32, ptr %0, i64 6912
|
|
%165 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %164, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %160, <vscale x 4 x i32> %162, i64 %4)
|
|
%166 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %164, i64 %4)
|
|
%167 = getelementptr inbounds i32, ptr %0, i64 7040
|
|
%168 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %167, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %163, <vscale x 4 x i32> %165, i64 %4)
|
|
%169 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %167, i64 %4)
|
|
%170 = getelementptr inbounds i32, ptr %0, i64 7168
|
|
%171 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %170, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %166, <vscale x 4 x i32> %168, i64 %4)
|
|
%172 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %170, i64 %4)
|
|
%173 = getelementptr inbounds i32, ptr %0, i64 7296
|
|
%174 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %173, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %169, <vscale x 4 x i32> %171, i64 %4)
|
|
%175 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %173, i64 %4)
|
|
%176 = getelementptr inbounds i32, ptr %0, i64 7424
|
|
%177 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %176, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %172, <vscale x 4 x i32> %174, i64 %4)
|
|
%178 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %176, i64 %4)
|
|
%179 = getelementptr inbounds i32, ptr %0, i64 7552
|
|
%180 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %179, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %175, <vscale x 4 x i32> %177, i64 %4)
|
|
%181 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %179, i64 %4)
|
|
%182 = getelementptr inbounds i32, ptr %0, i64 7680
|
|
%183 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %182, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %178, <vscale x 4 x i32> %180, i64 %4)
|
|
%184 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %182, i64 %4)
|
|
%185 = getelementptr inbounds i32, ptr %0, i64 7808
|
|
%186 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %185, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %181, <vscale x 4 x i32> %183, i64 %4)
|
|
%187 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %185, i64 %4)
|
|
%188 = getelementptr inbounds i32, ptr %0, i64 7936
|
|
%189 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %188, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %184, <vscale x 4 x i32> %186, i64 %4)
|
|
%190 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %188, i64 %4)
|
|
%191 = getelementptr inbounds i32, ptr %0, i64 8064
|
|
%192 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %191, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %187, <vscale x 4 x i32> %189, i64 %4)
|
|
%193 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %191, i64 %4)
|
|
%194 = getelementptr inbounds i32, ptr %0, i64 8192
|
|
%195 = tail call <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32> poison, ptr %194, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %190, <vscale x 4 x i32> %192, i64 %4)
|
|
tail call void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64 3, i64 0, <vscale x 4 x i32> %193, <vscale x 4 x i32> %195, i64 %4)
|
|
%196 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
%197 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
%198 = getelementptr inbounds i32, ptr %1, i64 256
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %196, ptr %198, i64 %4)
|
|
%199 = getelementptr inbounds i32, ptr %1, i64 384
|
|
%200 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %197, ptr %199, i64 %4)
|
|
%201 = getelementptr inbounds i32, ptr %1, i64 512
|
|
%202 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %200, ptr %201, i64 %4)
|
|
%203 = getelementptr inbounds i32, ptr %1, i64 640
|
|
%204 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %202, ptr %203, i64 %4)
|
|
%205 = getelementptr inbounds i32, ptr %1, i64 768
|
|
%206 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %204, ptr %205, i64 %4)
|
|
%207 = getelementptr inbounds i32, ptr %1, i64 896
|
|
%208 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %206, ptr %207, i64 %4)
|
|
%209 = getelementptr inbounds i32, ptr %1, i64 1024
|
|
%210 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %208, ptr %209, i64 %4)
|
|
%211 = getelementptr inbounds i32, ptr %1, i64 1152
|
|
%212 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %210, ptr %211, i64 %4)
|
|
%213 = getelementptr inbounds i32, ptr %1, i64 1280
|
|
%214 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %212, ptr %213, i64 %4)
|
|
%215 = getelementptr inbounds i32, ptr %1, i64 1408
|
|
%216 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %214, ptr %215, i64 %4)
|
|
%217 = getelementptr inbounds i32, ptr %1, i64 1536
|
|
%218 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %216, ptr %217, i64 %4)
|
|
%219 = getelementptr inbounds i32, ptr %1, i64 1664
|
|
%220 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %218, ptr %219, i64 %4)
|
|
%221 = getelementptr inbounds i32, ptr %1, i64 1792
|
|
%222 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %220, ptr %221, i64 %4)
|
|
%223 = getelementptr inbounds i32, ptr %1, i64 1920
|
|
%224 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %222, ptr %223, i64 %4)
|
|
%225 = getelementptr inbounds i32, ptr %1, i64 2048
|
|
%226 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %224, ptr %225, i64 %4)
|
|
%227 = getelementptr inbounds i32, ptr %1, i64 2176
|
|
%228 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %226, ptr %227, i64 %4)
|
|
%229 = getelementptr inbounds i32, ptr %1, i64 2304
|
|
%230 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %228, ptr %229, i64 %4)
|
|
%231 = getelementptr inbounds i32, ptr %1, i64 2432
|
|
%232 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %230, ptr %231, i64 %4)
|
|
%233 = getelementptr inbounds i32, ptr %1, i64 2560
|
|
%234 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %232, ptr %233, i64 %4)
|
|
%235 = getelementptr inbounds i32, ptr %1, i64 2688
|
|
%236 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %234, ptr %235, i64 %4)
|
|
%237 = getelementptr inbounds i32, ptr %1, i64 2816
|
|
%238 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %236, ptr %237, i64 %4)
|
|
%239 = getelementptr inbounds i32, ptr %1, i64 2944
|
|
%240 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %238, ptr %239, i64 %4)
|
|
%241 = getelementptr inbounds i32, ptr %1, i64 3072
|
|
%242 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %240, ptr %241, i64 %4)
|
|
%243 = getelementptr inbounds i32, ptr %1, i64 3200
|
|
%244 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %242, ptr %243, i64 %4)
|
|
%245 = getelementptr inbounds i32, ptr %1, i64 3328
|
|
%246 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %244, ptr %245, i64 %4)
|
|
%247 = getelementptr inbounds i32, ptr %1, i64 3456
|
|
%248 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %246, ptr %247, i64 %4)
|
|
%249 = getelementptr inbounds i32, ptr %1, i64 3584
|
|
%250 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %248, ptr %249, i64 %4)
|
|
%251 = getelementptr inbounds i32, ptr %1, i64 3712
|
|
%252 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %250, ptr %251, i64 %4)
|
|
%253 = getelementptr inbounds i32, ptr %1, i64 3840
|
|
%254 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %252, ptr %253, i64 %4)
|
|
%255 = getelementptr inbounds i32, ptr %1, i64 3968
|
|
%256 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %254, ptr %255, i64 %4)
|
|
%257 = getelementptr inbounds i32, ptr %1, i64 4096
|
|
%258 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %256, ptr %257, i64 %4)
|
|
%259 = getelementptr inbounds i32, ptr %1, i64 4224
|
|
%260 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %258, ptr %259, i64 %4)
|
|
%261 = getelementptr inbounds i32, ptr %1, i64 4352
|
|
%262 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %260, ptr %261, i64 %4)
|
|
%263 = getelementptr inbounds i32, ptr %1, i64 4480
|
|
%264 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %262, ptr %263, i64 %4)
|
|
%265 = getelementptr inbounds i32, ptr %1, i64 4608
|
|
%266 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %264, ptr %265, i64 %4)
|
|
%267 = getelementptr inbounds i32, ptr %1, i64 4736
|
|
%268 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %266, ptr %267, i64 %4)
|
|
%269 = getelementptr inbounds i32, ptr %1, i64 4864
|
|
%270 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %268, ptr %269, i64 %4)
|
|
%271 = getelementptr inbounds i32, ptr %1, i64 4992
|
|
%272 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %270, ptr %271, i64 %4)
|
|
%273 = getelementptr inbounds i32, ptr %1, i64 5120
|
|
%274 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %272, ptr %273, i64 %4)
|
|
%275 = getelementptr inbounds i32, ptr %1, i64 5248
|
|
%276 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %274, ptr %275, i64 %4)
|
|
%277 = getelementptr inbounds i32, ptr %1, i64 5376
|
|
%278 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %276, ptr %277, i64 %4)
|
|
%279 = getelementptr inbounds i32, ptr %1, i64 5504
|
|
%280 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %278, ptr %279, i64 %4)
|
|
%281 = getelementptr inbounds i32, ptr %1, i64 5632
|
|
%282 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %280, ptr %281, i64 %4)
|
|
%283 = getelementptr inbounds i32, ptr %1, i64 5760
|
|
%284 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %282, ptr %283, i64 %4)
|
|
%285 = getelementptr inbounds i32, ptr %1, i64 5888
|
|
%286 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %284, ptr %285, i64 %4)
|
|
%287 = getelementptr inbounds i32, ptr %1, i64 6016
|
|
%288 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %286, ptr %287, i64 %4)
|
|
%289 = getelementptr inbounds i32, ptr %1, i64 6144
|
|
%290 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %288, ptr %289, i64 %4)
|
|
%291 = getelementptr inbounds i32, ptr %1, i64 6272
|
|
%292 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %290, ptr %291, i64 %4)
|
|
%293 = getelementptr inbounds i32, ptr %1, i64 6400
|
|
%294 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %292, ptr %293, i64 %4)
|
|
%295 = getelementptr inbounds i32, ptr %1, i64 6528
|
|
%296 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %294, ptr %295, i64 %4)
|
|
%297 = getelementptr inbounds i32, ptr %1, i64 6656
|
|
%298 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %296, ptr %297, i64 %4)
|
|
%299 = getelementptr inbounds i32, ptr %1, i64 6784
|
|
%300 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %298, ptr %299, i64 %4)
|
|
%301 = getelementptr inbounds i32, ptr %1, i64 6912
|
|
%302 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %300, ptr %301, i64 %4)
|
|
%303 = getelementptr inbounds i32, ptr %1, i64 7040
|
|
%304 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %302, ptr %303, i64 %4)
|
|
%305 = getelementptr inbounds i32, ptr %1, i64 7168
|
|
%306 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %304, ptr %305, i64 %4)
|
|
%307 = getelementptr inbounds i32, ptr %1, i64 7296
|
|
%308 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %306, ptr %307, i64 %4)
|
|
%309 = getelementptr inbounds i32, ptr %1, i64 7424
|
|
%310 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %308, ptr %309, i64 %4)
|
|
%311 = getelementptr inbounds i32, ptr %1, i64 7552
|
|
%312 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %310, ptr %311, i64 %4)
|
|
%313 = getelementptr inbounds i32, ptr %1, i64 7680
|
|
%314 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %312, ptr %313, i64 %4)
|
|
%315 = getelementptr inbounds i32, ptr %1, i64 7808
|
|
%316 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %314, ptr %315, i64 %4)
|
|
%317 = getelementptr inbounds i32, ptr %1, i64 7936
|
|
%318 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %316, ptr %317, i64 %4)
|
|
%319 = getelementptr inbounds i32, ptr %1, i64 8064
|
|
%320 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %318, ptr %319, i64 %4)
|
|
%321 = getelementptr inbounds i32, ptr %1, i64 8192
|
|
%322 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %320, ptr %321, i64 %4)
|
|
%323 = getelementptr inbounds i32, ptr %1, i64 8320
|
|
%324 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %322, ptr %323, i64 %4)
|
|
%325 = getelementptr inbounds i32, ptr %1, i64 8448
|
|
%326 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %324, ptr %325, i64 %4)
|
|
%327 = getelementptr inbounds i32, ptr %1, i64 8576
|
|
%328 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %326, ptr %327, i64 %4)
|
|
%329 = getelementptr inbounds i32, ptr %1, i64 8704
|
|
%330 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %328, ptr %329, i64 %4)
|
|
%331 = getelementptr inbounds i32, ptr %1, i64 8832
|
|
%332 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %330, ptr %331, i64 %4)
|
|
%333 = getelementptr inbounds i32, ptr %1, i64 8960
|
|
%334 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %332, ptr %333, i64 %4)
|
|
%335 = getelementptr inbounds i32, ptr %1, i64 9088
|
|
%336 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %334, ptr %335, i64 %4)
|
|
%337 = getelementptr inbounds i32, ptr %1, i64 9216
|
|
%338 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %336, ptr %337, i64 %4)
|
|
%339 = getelementptr inbounds i32, ptr %1, i64 9344
|
|
%340 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %338, ptr %339, i64 %4)
|
|
%341 = getelementptr inbounds i32, ptr %1, i64 9472
|
|
%342 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %340, ptr %341, i64 %4)
|
|
%343 = getelementptr inbounds i32, ptr %1, i64 9600
|
|
%344 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %342, ptr %343, i64 %4)
|
|
%345 = getelementptr inbounds i32, ptr %1, i64 9728
|
|
%346 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %344, ptr %345, i64 %4)
|
|
%347 = getelementptr inbounds i32, ptr %1, i64 9856
|
|
%348 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %346, ptr %347, i64 %4)
|
|
%349 = getelementptr inbounds i32, ptr %1, i64 9984
|
|
%350 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %348, ptr %349, i64 %4)
|
|
%351 = getelementptr inbounds i32, ptr %1, i64 10112
|
|
%352 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %350, ptr %351, i64 %4)
|
|
%353 = getelementptr inbounds i32, ptr %1, i64 10240
|
|
%354 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %352, ptr %353, i64 %4)
|
|
%355 = getelementptr inbounds i32, ptr %1, i64 10368
|
|
%356 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
tail call void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32> %354, ptr %355, i64 %4)
|
|
%357 = tail call <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64 2, i64 0, i64 0, i64 %4)
|
|
ret void
|
|
}
|
|
|
|
declare i64 @llvm.riscv.vsetvli.i64(i64, i64, i64)
|
|
declare <vscale x 4 x i32> @llvm.riscv.vle.nxv4i32.i64(<vscale x 4 x i32>, ptr, i64)
|
|
declare void @llvm.riscv.sf.vc.vv.se.i64.nxv4i32.nxv4i32.i64(i64, i64, <vscale x 4 x i32>, <vscale x 4 x i32>, i64)
|
|
declare <vscale x 4 x i32> @llvm.riscv.sf.vc.v.i.se.nxv4i32.i64.i64.i64(i64, i64, i64, i64)
|
|
declare void @llvm.riscv.vse.nxv4i32.i64(<vscale x 4 x i32>, ptr, i64)
|