llvm/test/CodeGen/AArch64/sve-intrinsics-gather-loads-vector-base-imm-offset.ll

   1 ; RUN: llc -mtriple=aarch64-linux-gnu -mattr=+sve < %s | FileCheck %s
   2
   3 ;
   4 ; LD1B, LD1W, LD1H, LD1D: vector base + immediate offset (index)
   5 ;   e.g. ld1h { z0.s }, p0/z, [z0.s, #16]
   6 ;
   7
   8 ; LD1B
   9 define <vscale x 4 x i32> @gld1b_s_imm_offset(<vscale x 4 x i1> %pg, <vscale x 4 x i32> %base) {
  10 ; CHECK-LABEL: gld1b_s_imm_offset:
  11 ; CHECK: ld1b { z0.s }, p0/z, [z0.s, #16]
  12 ; CHECK-NEXT: ret
  13   %load = call <vscale x 4 x i8> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv4i8.nxv4i32(<vscale x 4 x i1> %pg,
  14                                                                                            <vscale x 4 x i32> %base,
  15                                                                                            i64 16)
  16   %res = zext <vscale x 4 x i8> %load to <vscale x 4 x i32>
  17   ret <vscale x 4 x i32> %res
  18 }
  19
  20 define <vscale x 2 x i64> @gld1b_d_imm_offset(<vscale x 2 x i1> %pg, <vscale x 2 x i64> %base) {
  21 ; CHECK-LABEL: gld1b_d_imm_offset:
  22 ; CHECK: ld1b { z0.d }, p0/z, [z0.d, #16]
  23 ; CHECK-NEXT: ret
  24   %load = call <vscale x 2 x i8> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i8.nxv2i64(<vscale x 2 x i1> %pg,
  25                                                                                            <vscale x 2 x i64> %base,
  26                                                                                            i64 16)
  27   %res = zext <vscale x 2 x i8> %load to <vscale x 2 x i64>
  28   ret <vscale x 2 x i64> %res
  29 }
  30
  31 ; LD1H
  32 define <vscale x 4 x i32> @gld1h_s_imm_offset(<vscale x 4 x i1> %pg, <vscale x 4 x i32> %base) {
  33 ; CHECK-LABEL: gld1h_s_imm_offset:
  34 ; CHECK: ld1h { z0.s }, p0/z, [z0.s, #16]
  35 ; CHECK-NEXT: ret
  36   %load = call <vscale x 4 x i16> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv4i16.nxv4i32(<vscale x 4 x i1> %pg,
  37                                                                                              <vscale x 4 x i32> %base,
  38                                                                                              i64 16)
  39   %res = zext <vscale x 4 x i16> %load to <vscale x 4 x i32>
  40   ret <vscale x 4 x i32> %res
  41 }
  42
  43 define <vscale x 2 x i64> @gld1h_d_imm_offset(<vscale x 2 x i1> %pg, <vscale x 2 x i64> %base) {
  44 ; CHECK-LABEL: gld1h_d_imm_offset:
  45 ; CHECK: ld1h { z0.d }, p0/z, [z0.d, #16]
  46 ; CHECK-NEXT: ret
  47   %load = call <vscale x 2 x i16> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i16.nxv2i64(<vscale x 2 x i1> %pg,
  48                                                                                              <vscale x 2 x i64> %base,
  49                                                                                              i64 16)
  50   %res = zext <vscale x 2 x i16> %load to <vscale x 2 x i64>
  51   ret <vscale x 2 x i64> %res
  52 }
  53
  54 ; LD1W
  55 define <vscale x 4 x i32> @gld1w_s_imm_offset(<vscale x 4 x i1> %pg, <vscale x 4 x i32> %base) {
  56 ; CHECK-LABEL: gld1w_s_imm_offset:
  57 ; CHECK: ld1w { z0.s }, p0/z, [z0.s, #16]
  58 ; CHECK-NEXT: ret
  59   %load = call <vscale x 4 x i32> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv4i32.nxv4i32(<vscale x 4 x i1> %pg,
  60                                                                                              <vscale x 4 x i32> %base,
  61                                                                                              i64 16)
  62   ret <vscale x 4 x i32> %load
  63 }
  64
  65 define <vscale x 2 x i64> @gld1w_d_imm_offset(<vscale x 2 x i1> %pg, <vscale x 2 x i64> %base) {
  66 ; CHECK-LABEL: gld1w_d_imm_offset:
  67 ; CHECK: ld1w { z0.d }, p0/z, [z0.d, #16]
  68 ; CHECK-NEXT: ret
  69   %load = call <vscale x 2 x i32> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i32.nxv2i64(<vscale x 2 x i1> %pg,
  70                                                                                              <vscale x 2 x i64> %base,
  71                                                                                              i64 16)
  72   %res = zext <vscale x 2 x i32> %load to <vscale x 2 x i64>
  73   ret <vscale x 2 x i64> %res
  74 }
  75
  76 define <vscale x 4 x float> @gld1w_s_imm_offset_float(<vscale x 4 x i1> %pg, <vscale x 4 x i32> %base) {
  77 ; CHECK-LABEL: gld1w_s_imm_offset_float:
  78 ; CHECK: ld1w { z0.s }, p0/z, [z0.s, #16]
  79 ; CHECK-NEXT: ret
  80   %load = call <vscale x 4 x float> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv4f32.nxv4i32(<vscale x 4 x i1> %pg,
  81                                                                                                <vscale x 4 x i32> %base,
  82                                                                                                i64 16)
  83   ret <vscale x 4 x float> %load
  84 }
  85
  86 ; LD1D
  87 define <vscale x 2 x i64> @gld1d_d_imm_offset(<vscale x 2 x i1> %pg, <vscale x 2 x i64> %base) {
  88 ; CHECK-LABEL: gld1d_d_imm_offset:
  89 ; CHECK: ld1d { z0.d }, p0/z, [z0.d, #16]
  90 ; CHECK-NEXT: ret
  91   %load = call <vscale x 2 x i64> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i64.nxv2i64(<vscale x 2 x i1> %pg,
  92                                                                                              <vscale x 2 x i64> %base,
  93                                                                                              i64 16)
  94   ret <vscale x 2 x i64> %load
  95 }
  96
  97 define <vscale x 2 x double> @gld1d_d_imm_offset_double(<vscale x 2 x i1> %pg, <vscale x 2 x i64> %base) {
  98 ; CHECK-LABEL: gld1d_d_imm_offset_double:
  99 ; CHECK: ld1d { z0.d }, p0/z, [z0.d, #16]
 100 ; CHECK-NEXT: ret
 101   %load = call <vscale x 2 x double> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2f64.nxv2i64(<vscale x 2 x i1> %pg,
 102                                                                                                 <vscale x 2 x i64> %base,
 103                                                                                                 i64 16)
 104   ret <vscale x 2 x double> %load
 105 }
 106
 107 ;
 108 ; LD1SB, LD1SW, LD1SH: vector base + immediate offset (index)
 109 ;   e.g. ld1sh { z0.s }, p0/z, [z0.s, #16]
 110 ;
 111
 112 ; LD1SB
 113 define <vscale x 4 x i32> @gld1sb_s_imm_offset(<vscale x 4 x i1> %pg, <vscale x 4 x i32> %base) {
 114 ; CHECK-LABEL: gld1sb_s_imm_offset:
 115 ; CHECK: ld1sb { z0.s }, p0/z, [z0.s, #16]
 116 ; CHECK-NEXT: ret
 117   %load = call <vscale x 4 x i8> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv4i8.nxv4i32(<vscale x 4 x i1> %pg,
 118                                                                                            <vscale x 4 x i32> %base,
 119                                                                                            i64 16)
 120   %res = sext <vscale x 4 x i8> %load to <vscale x 4 x i32>
 121   ret <vscale x 4 x i32> %res
 122 }
 123
 124 define <vscale x 2 x i64> @gld1sb_d_imm_offset(<vscale x 2 x i1> %pg, <vscale x 2 x i64> %base) {
 125 ; CHECK-LABEL: gld1sb_d_imm_offset:
 126 ; CHECK: ld1sb { z0.d }, p0/z, [z0.d, #16]
 127 ; CHECK-NEXT: ret
 128   %load = call <vscale x 2 x i8> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i8.nxv2i64(<vscale x 2 x i1> %pg,
 129                                                                                            <vscale x 2 x i64> %base,
 130                                                                                            i64 16)
 131   %res = sext <vscale x 2 x i8> %load to <vscale x 2 x i64>
 132   ret <vscale x 2 x i64> %res
 133 }
 134
 135 ; LD1SH
 136 define <vscale x 4 x i32> @gld1sh_s_imm_offset(<vscale x 4 x i1> %pg, <vscale x 4 x i32> %base) {
 137 ; CHECK-LABEL: gld1sh_s_imm_offset:
 138 ; CHECK: ld1sh { z0.s }, p0/z, [z0.s, #16]
 139 ; CHECK-NEXT: ret
 140   %load = call <vscale x 4 x i16> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv4i16.nxv4i32(<vscale x 4 x i1> %pg,
 141                                                                                              <vscale x 4 x i32> %base,
 142                                                                                              i64 16)
 143   %res = sext <vscale x 4 x i16> %load to <vscale x 4 x i32>
 144   ret <vscale x 4 x i32> %res
 145 }
 146
 147 define <vscale x 2 x i64> @gld1sh_d_imm_offset(<vscale x 2 x i1> %pg, <vscale x 2 x i64> %base) {
 148 ; CHECK-LABEL: gld1sh_d_imm_offset:
 149 ; CHECK: ld1sh { z0.d }, p0/z, [z0.d, #16]
 150 ; CHECK-NEXT: ret
 151   %load = call <vscale x 2 x i16> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i16.nxv2i64(<vscale x 2 x i1> %pg,
 152                                                                                              <vscale x 2 x i64> %base,
 153                                                                                              i64 16)
 154   %res = sext <vscale x 2 x i16> %load to <vscale x 2 x i64>
 155   ret <vscale x 2 x i64> %res
 156 }
 157
 158 ; LD1SW
 159 define <vscale x 2 x i64> @gld1sw_d_imm_offset(<vscale x 2 x i1> %pg, <vscale x 2 x i64> %base) {
 160 ; CHECK-LABEL: gld1sw_d_imm_offset:
 161 ; CHECK: ld1sw { z0.d }, p0/z, [z0.d, #16]
 162 ; CHECK-NEXT: ret
 163   %load = call <vscale x 2 x i32> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i32.nxv2i64(<vscale x 2 x i1> %pg,
 164                                                                                              <vscale x 2 x i64> %base,
 165                                                                                              i64 16)
 166   %res = sext <vscale x 2 x i32> %load to <vscale x 2 x i64>
 167   ret <vscale x 2 x i64> %res
 168 }
 169
 170 ;
 171 ; LD1B, LD1W, LD1H, LD1D: vector base + out of range immediate offset
 172 ;   e.g. ld1b { z0.d }, p0/z, [x0, z0.d]
 173 ;
 174
 175 ; LD1B
 176 define <vscale x 4 x i32> @gld1b_s_imm_offset_out_of_range(<vscale x 4 x i1> %pg, <vscale x 4 x i32> %base) {
 177 ; CHECK-LABEL: gld1b_s_imm_offset_out_of_range:
 178 ; CHECK: mov    w8, #32
 179 ; CHECK-NEXT: ld1b { z0.s }, p0/z, [x8, z0.s, uxtw]
 180 ; CHECK-NEXT: ret
 181   %load = call <vscale x 4 x i8> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv4i8.nxv4i32(<vscale x 4 x i1> %pg,
 182                                                                                            <vscale x 4 x i32> %base,
 183                                                                                            i64 32)
 184   %res = zext <vscale x 4 x i8> %load to <vscale x 4 x i32>
 185   ret <vscale x 4 x i32> %res
 186 }
 187
 188 define <vscale x 2 x i64> @gld1b_d_imm_offset_out_of_range(<vscale x 2 x i1> %pg, <vscale x 2 x i64> %base) {
 189 ; CHECK-LABEL: gld1b_d_imm_offset_out_of_range:
 190 ; CHECK: mov    w8, #32
 191 ; CHECK-NEXT: ld1b { z0.d }, p0/z, [x8, z0.d]
 192 ; CHECK-NEXT: ret
 193   %load = call <vscale x 2 x i8> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i8.nxv2i64(<vscale x 2 x i1> %pg,
 194                                                                                            <vscale x 2 x i64> %base,
 195                                                                                            i64 32)
 196   %res = zext <vscale x 2 x i8> %load to <vscale x 2 x i64>
 197   ret <vscale x 2 x i64> %res
 198 }
 199
 200 ; LD1H
 201 define <vscale x 4 x i32> @gld1h_s_imm_offset_out_of_range(<vscale x 4 x i1> %pg, <vscale x 4 x i32> %base) {
 202 ; CHECK-LABEL: gld1h_s_imm_offset_out_of_range:
 203 ; CHECK: mov    w8, #63
 204 ; CHECK-NEXT: ld1h { z0.s }, p0/z, [x8, z0.s, uxtw]
 205 ; CHECK-NEXT: ret
 206   %load = call <vscale x 4 x i16> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv4i16.nxv4i32(<vscale x 4 x i1> %pg,
 207                                                                                              <vscale x 4 x i32> %base,
 208                                                                                              i64 63)
 209   %res = zext <vscale x 4 x i16> %load to <vscale x 4 x i32>
 210   ret <vscale x 4 x i32> %res
 211 }
 212
 213 define <vscale x 2 x i64> @gld1h_d_imm_offset_out_of_range(<vscale x 2 x i1> %pg, <vscale x 2 x i64> %base) {
 214 ; CHECK-LABEL: gld1h_d_imm_offset_out_of_range:
 215 ; CHECK: mov    w8, #63
 216 ; CHECK-NEXT: ld1h { z0.d }, p0/z, [x8, z0.d]
 217 ; CHECK-NEXT: ret
 218   %load = call <vscale x 2 x i16> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i16.nxv2i64(<vscale x 2 x i1> %pg,
 219                                                                                              <vscale x 2 x i64> %base,
 220                                                                                              i64 63)
 221   %res = zext <vscale x 2 x i16> %load to <vscale x 2 x i64>
 222   ret <vscale x 2 x i64> %res
 223 }
 224
 225 ; LD1W
 226 define <vscale x 4 x i32> @gld1w_s_imm_offset_out_of_range(<vscale x 4 x i1> %pg, <vscale x 4 x i32> %base) {
 227 ; CHECK-LABEL: gld1w_s_imm_offset_out_of_range:
 228 ; CHECK: mov    w8, #125
 229 ; CHECK-NEXT: ld1w { z0.s }, p0/z, [x8, z0.s, uxtw]
 230 ; CHECK-NEXT: ret
 231   %load = call <vscale x 4 x i32> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv4i32.nxv4i32(<vscale x 4 x i1> %pg,
 232                                                                                              <vscale x 4 x i32> %base,
 233                                                                                              i64 125)
 234   ret <vscale x 4 x i32> %load
 235 }
 236
 237 define <vscale x 2 x i64> @gld1w_d_imm_offset_out_of_range(<vscale x 2 x i1> %pg, <vscale x 2 x i64> %base) {
 238 ; CHECK-LABEL: gld1w_d_imm_offset_out_of_range:
 239 ; CHECK: mov    w8, #125
 240 ; CHECK-NEXT: ld1w { z0.d }, p0/z, [x8, z0.d]
 241 ; CHECK-NEXT: ret
 242   %load = call <vscale x 2 x i32> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i32.nxv2i64(<vscale x 2 x i1> %pg,
 243                                                                                              <vscale x 2 x i64> %base,
 244                                                                                              i64 125)
 245   %res = zext <vscale x 2 x i32> %load to <vscale x 2 x i64>
 246   ret <vscale x 2 x i64> %res
 247 }
 248
 249 define <vscale x 4 x float> @gld1w_s_imm_offset_out_of_range_float(<vscale x 4 x i1> %pg, <vscale x 4 x i32> %base) {
 250 ; CHECK-LABEL: gld1w_s_imm_offset_out_of_range_float:
 251 ; CHECK: mov    w8, #125
 252 ; CHECK-NEXT: ld1w { z0.s }, p0/z, [x8, z0.s, uxtw]
 253 ; CHECK-NEXT: ret
 254   %load = call <vscale x 4 x float> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv4f32.nxv4i32(<vscale x 4 x i1> %pg,
 255                                                                                                <vscale x 4 x i32> %base,
 256                                                                                                i64 125)
 257   ret <vscale x 4 x float> %load
 258 }
 259
 260 ; LD1D
 261 define <vscale x 2 x i64> @gld1d_d_imm_offset_out_of_range(<vscale x 2 x i1> %pg, <vscale x 2 x i64> %base) {
 262 ; CHECK-LABEL: gld1d_d_imm_offset_out_of_range:
 263 ; CHECK: mov    w8, #249
 264 ; CHECK-NEXT: ld1d { z0.d }, p0/z, [x8, z0.d]
 265 ; CHECK-NEXT: ret
 266   %load = call <vscale x 2 x i64> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i64.nxv2i64(<vscale x 2 x i1> %pg,
 267                                                                                              <vscale x 2 x i64> %base,
 268                                                                                              i64 249)
 269   ret <vscale x 2 x i64> %load
 270 }
 271
 272 define <vscale x 2 x double> @gld1d_d_imm_offset_out_of_range_double(<vscale x 2 x i1> %pg, <vscale x 2 x i64> %base) {
 273 ; CHECK-LABEL: gld1d_d_imm_offset_out_of_range_double:
 274 ; CHECK: mov    w8, #249
 275 ; CHECK-NEXT: ld1d { z0.d }, p0/z, [x8, z0.d]
 276 ; CHECK-NEXT: ret
 277   %load = call <vscale x 2 x double> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2f64.nxv2i64(<vscale x 2 x i1> %pg,
 278                                                                                                 <vscale x 2 x i64> %base,
 279                                                                                                 i64 249)
 280   ret <vscale x 2 x double> %load
 281 }
 282
 283 ;
 284 ; LD1SB, LD1SW, LD1SH: vector base + out of range immediate offset
 285 ;     e.g. ld1sb { z0.s }, p0/z, [x8, z0.s, uxtw]
 286 ;
 287
 288 ; LD1SB
 289 define <vscale x 4 x i32> @gld1sb_s_imm_offset_out_of_range(<vscale x 4 x i1> %pg, <vscale x 4 x i32> %base) {
 290 ; CHECK-LABEL: gld1sb_s_imm_offset_out_of_range:
 291 ; CHECK: mov    w8, #32
 292 ; CHECK-NEXT: ld1sb { z0.s }, p0/z, [x8, z0.s, uxtw]
 293 ; CHECK-NEXT: ret
 294   %load = call <vscale x 4 x i8> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv4i8.nxv4i32(<vscale x 4 x i1> %pg,
 295                                                                                            <vscale x 4 x i32> %base,
 296                                                                                            i64 32)
 297   %res = sext <vscale x 4 x i8> %load to <vscale x 4 x i32>
 298   ret <vscale x 4 x i32> %res
 299 }
 300
 301 define <vscale x 2 x i64> @gld1sb_d_imm_offset_out_of_range(<vscale x 2 x i1> %pg, <vscale x 2 x i64> %base) {
 302 ; CHECK-LABEL: gld1sb_d_imm_offset_out_of_range:
 303 ; CHECK: mov    w8, #32
 304 ; CHECK-NEXT: ld1sb { z0.d }, p0/z, [x8, z0.d]
 305 ; CHECK-NEXT: ret
 306   %load = call <vscale x 2 x i8> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i8.nxv2i64(<vscale x 2 x i1> %pg,
 307                                                                                            <vscale x 2 x i64> %base,
 308                                                                                            i64 32)
 309   %res = sext <vscale x 2 x i8> %load to <vscale x 2 x i64>
 310   ret <vscale x 2 x i64> %res
 311 }
 312
 313 ; LD1SH
 314 define <vscale x 4 x i32> @gld1sh_s_imm_offset_out_of_range(<vscale x 4 x i1> %pg, <vscale x 4 x i32> %base) {
 315 ; CHECK-LABEL: gld1sh_s_imm_offset_out_of_range:
 316 ; CHECK: mov    w8, #63
 317 ; CHECK-NEXT: ld1sh { z0.s }, p0/z, [x8, z0.s, uxtw]
 318 ; CHECK-NEXT: ret
 319   %load = call <vscale x 4 x i16> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv4i16.nxv4i32(<vscale x 4 x i1> %pg,
 320                                                                                              <vscale x 4 x i32> %base,
 321                                                                                              i64 63)
 322   %res = sext <vscale x 4 x i16> %load to <vscale x 4 x i32>
 323   ret <vscale x 4 x i32> %res
 324 }
 325
 326 define <vscale x 2 x i64> @gld1sh_d_imm_offset_out_of_range(<vscale x 2 x i1> %pg, <vscale x 2 x i64> %base) {
 327 ; CHECK-LABEL: gld1sh_d_imm_offset_out_of_range:
 328 ; CHECK: mov    w8, #63
 329 ; CHECK-NEXT: ld1sh { z0.d }, p0/z, [x8, z0.d]
 330 ; CHECK-NEXT: ret
 331   %load = call <vscale x 2 x i16> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i16.nxv2i64(<vscale x 2 x i1> %pg,
 332                                                                                              <vscale x 2 x i64> %base,
 333                                                                                              i64 63)
 334   %res = sext <vscale x 2 x i16> %load to <vscale x 2 x i64>
 335   ret <vscale x 2 x i64> %res
 336 }
 337
 338 ; LD1SW
 339 define <vscale x 2 x i64> @gld1sw_d_imm_offset_out_of_range(<vscale x 2 x i1> %pg, <vscale x 2 x i64> %base) {
 340 ; CHECK-LABEL: gld1sw_d_imm_offset_out_of_range:
 341 ; CHECK: mov    w8, #125
 342 ; CHECK-NEXT: ld1sw { z0.d }, p0/z, [x8, z0.d]
 343 ; CHECK-NEXT: ret
 344   %load = call <vscale x 2 x i32> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i32.nxv2i64(<vscale x 2 x i1> %pg,
 345                                                                                              <vscale x 2 x i64> %base,
 346                                                                                              i64 125)
 347   %res = sext <vscale x 2 x i32> %load to <vscale x 2 x i64>
 348   ret <vscale x 2 x i64> %res
 349 }
 350
 351 ; LD1B/LD1SB
 352 declare <vscale x 4 x i8> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv4i8.nxv4i32(<vscale x 4 x i1>, <vscale x 4 x i32>, i64)
 353 declare <vscale x 2 x i8> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i8.nxv2i64(<vscale x 2 x i1>, <vscale x 2 x i64>, i64)
 354
 355 ; LD1H/LD1SH
 356 declare <vscale x 4 x i16> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv4i16.nxv4i32(<vscale x 4 x i1>, <vscale x 4 x i32>, i64)
 357 declare <vscale x 2 x i16> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i16.nxv2i64(<vscale x 2 x i1>, <vscale x 2 x i64>, i64)
 358
 359 ; LD1W/LD1SW
 360 declare <vscale x 4 x i32> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv4i32.nxv4i32(<vscale x 4 x i1>, <vscale x 4 x i32>, i64)
 361 declare <vscale x 2 x i32> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i32.nxv2i64(<vscale x 2 x i1>, <vscale x 2 x i64>, i64)
 362
 363 declare <vscale x 4 x float> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv4f32.nxv4i32(<vscale x 4 x i1>, <vscale x 4 x i32>, i64)
 364
 365 ; LD1D
 366 declare <vscale x 2 x i64> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2i64.nxv2i64(<vscale x 2 x i1>, <vscale x 2 x i64>, i64)
 367
 368 declare <vscale x 2 x double> @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv2f64.nxv2i64(<vscale x 2 x i1>, <vscale x 2 x i64>, i64)