test/CodeGen/AMDGPU/load-global-i16.ll

   1 ; RUN:  llc -amdgpu-scalarize-global-loads=false  -march=amdgcn -verify-machineinstrs < %s | FileCheck -check-prefixes=GCN,GCN-NOHSA,GCN-NOHSA-SI,FUNC %s
   2 ; RUN:  llc -amdgpu-scalarize-global-loads=false  -mtriple=amdgcn--amdhsa -mcpu=kaveri -verify-machineinstrs < %s | FileCheck -check-prefixes=GCN,GCN-HSA,FUNC %s
   3 ; RUN:  llc -amdgpu-scalarize-global-loads=false  -march=amdgcn -mcpu=tonga -mattr=-flat-for-global -verify-machineinstrs < %s | FileCheck -check-prefixes=GCN,GCN-NOHSA,GCN-NOHSA-VI,FUNC %s
   4 ; RUN:  llc -amdgpu-scalarize-global-loads=false  -march=r600 -mcpu=redwood -verify-machineinstrs < %s | FileCheck -check-prefix=EG -check-prefix=EGCM -check-prefix=FUNC %s
   5 ; RUN:  llc -amdgpu-scalarize-global-loads=false  -march=r600 -mcpu=cayman -verify-machineinstrs < %s | FileCheck -check-prefix=CM -check-prefix=EGCM -check-prefix=FUNC %s
   6
   7 ; FIXME: r600 is broken because the bigger testcases spill and it's not implemented
   8
   9 ; FUNC-LABEL: {{^}}global_load_i16:
  10 ; GCN-NOHSA: buffer_load_ushort v{{[0-9]+}}
  11 ; GCN-HSA: flat_load_ushort
  12
  13 ; EGCM: VTX_READ_16 T{{[0-9]+}}.X, T{{[0-9]+}}.X, 0, #1
  14 define amdgpu_kernel void @global_load_i16(i16 addrspace(1)* %out, i16 addrspace(1)* %in) {
  15 entry:
  16   %ld = load i16, i16 addrspace(1)* %in
  17   store i16 %ld, i16 addrspace(1)* %out
  18   ret void
  19 }
  20
  21 ; FUNC-LABEL: {{^}}global_load_v2i16:
  22 ; GCN-NOHSA: buffer_load_dword v
  23 ; GCN-HSA: flat_load_dword v
  24
  25 ; EGCM: VTX_READ_32 T{{[0-9]+}}.X, T{{[0-9]+}}.X, 0, #1
  26 define amdgpu_kernel void @global_load_v2i16(<2 x i16> addrspace(1)* %out, <2 x i16> addrspace(1)* %in) {
  27 entry:
  28   %ld = load <2 x i16>, <2 x i16> addrspace(1)* %in
  29   store <2 x i16> %ld, <2 x i16> addrspace(1)* %out
  30   ret void
  31 }
  32
  33 ; FUNC-LABEL: {{^}}global_load_v3i16:
  34 ; GCN-NOHSA: buffer_load_dwordx2 v
  35 ; GCN-HSA: flat_load_dwordx2 v
  36
  37 ; EGCM-DAG: VTX_READ_32 T{{[0-9]+}}.X, T{{[0-9]+}}.X, 0, #1
  38 ; EGCM-DAG: VTX_READ_16 T{{[0-9]+}}.X, T{{[0-9]+}}.X, 4, #1
  39 define amdgpu_kernel void @global_load_v3i16(<3 x i16> addrspace(1)* %out, <3 x i16> addrspace(1)* %in) {
  40 entry:
  41   %ld = load <3 x i16>, <3 x i16> addrspace(1)* %in
  42   store <3 x i16> %ld, <3 x i16> addrspace(1)* %out
  43   ret void
  44 }
  45
  46 ; FUNC-LABEL: {{^}}global_load_v4i16:
  47 ; GCN-NOHSA: buffer_load_dwordx2
  48 ; GCN-HSA: flat_load_dwordx2
  49
  50 ; EGCM: VTX_READ_64 T{{[0-9]+}}.XY, T{{[0-9]+}}.X, 0, #1
  51 define amdgpu_kernel void @global_load_v4i16(<4 x i16> addrspace(1)* %out, <4 x i16> addrspace(1)* %in) {
  52 entry:
  53   %ld = load <4 x i16>, <4 x i16> addrspace(1)* %in
  54   store <4 x i16> %ld, <4 x i16> addrspace(1)* %out
  55   ret void
  56 }
  57
  58 ; FUNC-LABEL: {{^}}global_load_v8i16:
  59 ; GCN-NOHSA: buffer_load_dwordx4
  60 ; GCN-HSA: flat_load_dwordx4
  61
  62 ; EGCM: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 0, #1
  63 define amdgpu_kernel void @global_load_v8i16(<8 x i16> addrspace(1)* %out, <8 x i16> addrspace(1)* %in) {
  64 entry:
  65   %ld = load <8 x i16>, <8 x i16> addrspace(1)* %in
  66   store <8 x i16> %ld, <8 x i16> addrspace(1)* %out
  67   ret void
  68 }
  69
  70 ; FUNC-LABEL: {{^}}global_load_v16i16:
  71 ; GCN-NOHSA: buffer_load_dwordx4
  72 ; GCN-NOHSA: buffer_load_dwordx4
  73
  74 ; GCN-HSA: flat_load_dwordx4
  75 ; GCN-HSA: flat_load_dwordx4
  76
  77 ; EGCM-DAG: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 0, #1
  78 ; EGCM-DAG: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 16, #1
  79 define amdgpu_kernel void @global_load_v16i16(<16 x i16> addrspace(1)* %out, <16 x i16> addrspace(1)* %in) {
  80 entry:
  81   %ld = load <16 x i16>, <16 x i16> addrspace(1)* %in
  82   store <16 x i16> %ld, <16 x i16> addrspace(1)* %out
  83   ret void
  84 }
  85
  86 ; FUNC-LABEL: {{^}}global_zextload_i16_to_i32:
  87 ; GCN-NOHSA: buffer_load_ushort
  88 ; GCN-NOHSA: buffer_store_dword
  89
  90 ; GCN-HSA: flat_load_ushort
  91 ; GCN-HSA: flat_store_dword
  92
  93 ; EGCM: VTX_READ_16 T{{[0-9]+}}.X, T{{[0-9]+}}.X, 0, #1
  94 define amdgpu_kernel void @global_zextload_i16_to_i32(i32 addrspace(1)* %out, i16 addrspace(1)* %in) #0 {
  95   %a = load i16, i16 addrspace(1)* %in
  96   %ext = zext i16 %a to i32
  97   store i32 %ext, i32 addrspace(1)* %out
  98   ret void
  99 }
 100
 101 ; FUNC-LABEL: {{^}}global_sextload_i16_to_i32:
 102 ; GCN-NOHSA: buffer_load_sshort
 103 ; GCN-NOHSA: buffer_store_dword
 104
 105 ; GCN-HSA: flat_load_sshort
 106 ; GCN-HSA: flat_store_dword
 107
 108 ; EGCM: VTX_READ_16 [[DST:T[0-9]\.[XYZW]]], T{{[0-9]+}}.X, 0, #1
 109 ; EGCM: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST]], 0.0, literal
 110 ; EGCM: 16
 111 define amdgpu_kernel void @global_sextload_i16_to_i32(i32 addrspace(1)* %out, i16 addrspace(1)* %in) #0 {
 112   %a = load i16, i16 addrspace(1)* %in
 113   %ext = sext i16 %a to i32
 114   store i32 %ext, i32 addrspace(1)* %out
 115   ret void
 116 }
 117
 118 ; FUNC-LABEL: {{^}}global_zextload_v1i16_to_v1i32:
 119 ; GCN-NOHSA: buffer_load_ushort
 120 ; GCN-HSA: flat_load_ushort
 121
 122 ; EGCM: VTX_READ_16 T{{[0-9]+}}.X, T{{[0-9]+}}.X, 0, #1
 123 define amdgpu_kernel void @global_zextload_v1i16_to_v1i32(<1 x i32> addrspace(1)* %out, <1 x i16> addrspace(1)* %in) #0 {
 124   %load = load <1 x i16>, <1 x i16> addrspace(1)* %in
 125   %ext = zext <1 x i16> %load to <1 x i32>
 126   store <1 x i32> %ext, <1 x i32> addrspace(1)* %out
 127   ret void
 128 }
 129
 130 ; FUNC-LABEL: {{^}}global_sextload_v1i16_to_v1i32:
 131 ; GCN-NOHSA: buffer_load_sshort
 132 ; GCN-HSA: flat_load_sshort
 133
 134 ; EGCM: VTX_READ_16 [[DST:T[0-9]\.[XYZW]]], T{{[0-9]+}}.X, 0, #1
 135 ; EGCM: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST]], 0.0, literal
 136 ; EGCM: 16
 137 define amdgpu_kernel void @global_sextload_v1i16_to_v1i32(<1 x i32> addrspace(1)* %out, <1 x i16> addrspace(1)* %in) #0 {
 138   %load = load <1 x i16>, <1 x i16> addrspace(1)* %in
 139   %ext = sext <1 x i16> %load to <1 x i32>
 140   store <1 x i32> %ext, <1 x i32> addrspace(1)* %out
 141   ret void
 142 }
 143
 144 ; FUNC-LABEL: {{^}}global_zextload_v2i16_to_v2i32:
 145 ; GCN-NOHSA: buffer_load_dword
 146 ; GCN-HSA: flat_load_dword
 147
 148 ; EGCM: VTX_READ_32 [[DST:T[0-9]\.[XYZW]]], [[DST]], 0, #1
 149 ; EGCM: BFE_UINT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST]], literal
 150 ; EGCM: 16
 151 define amdgpu_kernel void @global_zextload_v2i16_to_v2i32(<2 x i32> addrspace(1)* %out, <2 x i16> addrspace(1)* %in) #0 {
 152   %load = load <2 x i16>, <2 x i16> addrspace(1)* %in
 153   %ext = zext <2 x i16> %load to <2 x i32>
 154   store <2 x i32> %ext, <2 x i32> addrspace(1)* %out
 155   ret void
 156 }
 157
 158 ; FUNC-LABEL: {{^}}global_sextload_v2i16_to_v2i32:
 159 ; GCN-NOHSA: buffer_load_dword
 160
 161 ; GCN-HSA: flat_load_dword
 162
 163 ; EG: MEM_RAT_CACHELESS STORE_RAW [[ST:T[0-9]]].XY, {{T[0-9]\.[XYZW]}},
 164 ; CM: MEM_RAT_CACHELESS STORE_DWORD [[ST:T[0-9]]], {{T[0-9]\.[XYZW]}}
 165 ; EGCM: VTX_READ_32 [[DST:T[0-9].[XYZW]]], [[DST]], 0, #1
 166 ; TODO: This should use ASHR instead of LSHR + BFE
 167 ; EGCM-DAG: BFE_INT {{[* ]*}}[[ST]].X, [[DST]], 0.0, literal
 168 ; EGCM-DAG: BFE_INT {{[* ]*}}[[ST]].Y, {{PV.[XYZW]}}, 0.0, literal
 169 ; EGCM-DAG: 16
 170 ; EGCM-DAG: 16
 171 define amdgpu_kernel void @global_sextload_v2i16_to_v2i32(<2 x i32> addrspace(1)* %out, <2 x i16> addrspace(1)* %in) #0 {
 172   %load = load <2 x i16>, <2 x i16> addrspace(1)* %in
 173   %ext = sext <2 x i16> %load to <2 x i32>
 174   store <2 x i32> %ext, <2 x i32> addrspace(1)* %out
 175   ret void
 176 }
 177
 178 ; FUNC-LABEL: {{^}}global_zextload_v3i16_to_v3i32:
 179 ; GCN-NOHSA: buffer_load_dwordx2
 180 ; GCN-HSA: flat_load_dwordx2
 181
 182 ; CM: MEM_RAT_CACHELESS STORE_DWORD [[ST_LO:T[0-9]]], {{T[0-9]\.[XYZW]}}
 183 ; CM: MEM_RAT_CACHELESS STORE_DWORD [[ST_HI:T[0-9]]].X, {{T[0-9]\.[XYZW]}}
 184 ; EG: MEM_RAT_CACHELESS STORE_RAW [[ST_HI:T[0-9]]].X, {{T[0-9]\.[XYZW]}},
 185 ; EG: MEM_RAT_CACHELESS STORE_RAW [[ST_LO:T[0-9]]].XY, {{T[0-9]\.[XYZW]}},
 186 ; EGCM-DAG: VTX_READ_32 [[DST_LO:T[0-9]\.[XYZW]]], {{T[0-9]\.[XYZW]}}, 0, #1
 187 ; EGCM-DAG: VTX_READ_16 [[DST_HI:T[0-9]\.[XYZW]]], {{T[0-9]\.[XYZW]}}, 4, #1
 188 ; TODO: This should use DST, but for some there are redundant MOVs
 189 ; EGCM: LSHR {{[* ]*}}[[ST_LO]].Y, {{T[0-9]\.[XYZW]}}, literal
 190 ; EGCM: 16
 191 define amdgpu_kernel void @global_zextload_v3i16_to_v3i32(<3 x i32> addrspace(1)* %out, <3 x i16> addrspace(1)* %in) {
 192 entry:
 193   %ld = load <3 x i16>, <3 x i16> addrspace(1)* %in
 194   %ext = zext <3 x i16> %ld to <3 x i32>
 195   store <3 x i32> %ext, <3 x i32> addrspace(1)* %out
 196   ret void
 197 }
 198
 199 ; FUNC-LABEL: {{^}}global_sextload_v3i16_to_v3i32:
 200 ; GCN-NOHSA: buffer_load_dwordx2
 201 ; GCN-HSA: flat_load_dwordx2
 202
 203 ; CM: MEM_RAT_CACHELESS STORE_DWORD [[ST_LO:T[0-9]]], {{T[0-9]\.[XYZW]}}
 204 ; CM: MEM_RAT_CACHELESS STORE_DWORD [[ST_HI:T[0-9]]].X, {{T[0-9]\.[XYZW]}}
 205 ; EG: MEM_RAT_CACHELESS STORE_RAW [[ST_HI:T[0-9]]].X, {{T[0-9]\.[XYZW]}},
 206 ; EG: MEM_RAT_CACHELESS STORE_RAW [[ST_LO:T[0-9]]].XY, {{T[0-9]\.[XYZW]}},
 207 ; EGCM-DAG: VTX_READ_32 [[DST_LO:T[0-9]\.[XYZW]]], {{T[0-9].[XYZW]}}, 0, #1
 208 ; EGCM-DAG: VTX_READ_16 [[DST_HI:T[0-9]\.[XYZW]]], {{T[0-9].[XYZW]}}, 4, #1
 209 ; TODO: This should use DST, but for some there are redundant MOVs
 210 ; EGCM-DAG: ASHR {{[* ]*}}[[ST_LO]].Y, {{T[0-9]\.[XYZW]}}, literal
 211 ; EGCM-DAG: BFE_INT {{[* ]*}}[[ST_LO]].X, {{T[0-9]\.[XYZW]}}, 0.0, literal
 212 ; EGCM-DAG: BFE_INT {{[* ]*}}[[ST_HI]].X, [[DST_HI]], 0.0, literal
 213 ; EGCM-DAG: 16
 214 ; EGCM-DAG: 16
 215 define amdgpu_kernel void @global_sextload_v3i16_to_v3i32(<3 x i32> addrspace(1)* %out, <3 x i16> addrspace(1)* %in) {
 216 entry:
 217   %ld = load <3 x i16>, <3 x i16> addrspace(1)* %in
 218   %ext = sext <3 x i16> %ld to <3 x i32>
 219   store <3 x i32> %ext, <3 x i32> addrspace(1)* %out
 220   ret void
 221 }
 222
 223 ; FUNC-LABEL: {{^}}global_zextload_v4i16_to_v4i32:
 224 ; GCN-NOHSA: buffer_load_dwordx2
 225
 226 ; GCN-HSA: flat_load_dwordx2
 227
 228 ; CM: MEM_RAT_CACHELESS STORE_DWORD [[ST:T[0-9]]], {{T[0-9]\.[XYZW]}}
 229 ; EG: MEM_RAT_CACHELESS STORE_RAW [[ST:T[0-9]]].XYZW, {{T[0-9]\.[XYZW]}},
 230 ; EGCM: VTX_READ_64 [[DST:T[0-9]]].XY, {{T[0-9].[XYZW]}}, 0, #1
 231 ; TODO: This should use DST, but for some there are redundant MOVs
 232 ; EGCM-DAG: BFE_UINT {{[* ]*}}[[ST]].Y, {{.*}}, literal
 233 ; EGCM-DAG: 16
 234 ; EGCM-DAG: BFE_UINT {{[* ]*}}[[ST]].W, {{.*}}, literal
 235 ; EGCM-DAG: AND_INT {{[* ]*}}[[ST]].X, {{.*}}, literal
 236 ; EGCM-DAG: AND_INT {{[* ]*}}[[ST]].Z, {{.*}}, literal
 237 ; EGCM-DAG: 16
 238 define amdgpu_kernel void @global_zextload_v4i16_to_v4i32(<4 x i32> addrspace(1)* %out, <4 x i16> addrspace(1)* %in) #0 {
 239   %load = load <4 x i16>, <4 x i16> addrspace(1)* %in
 240   %ext = zext <4 x i16> %load to <4 x i32>
 241   store <4 x i32> %ext, <4 x i32> addrspace(1)* %out
 242   ret void
 243 }
 244
 245 ; FUNC-LABEL: {{^}}global_sextload_v4i16_to_v4i32:
 246 ; GCN-NOHSA: buffer_load_dwordx2
 247
 248 ; GCN-HSA: flat_load_dwordx2
 249
 250 ; CM: MEM_RAT_CACHELESS STORE_DWORD [[ST:T[0-9]]], {{T[0-9]\.[XYZW]}}
 251 ; EG: MEM_RAT_CACHELESS STORE_RAW [[ST:T[0-9]]].XYZW, {{T[0-9]\.[XYZW]}},
 252 ; EGCM: VTX_READ_64 [[DST:T[0-9]]].XY, {{T[0-9].[XYZW]}}, 0, #1
 253 ; TODO: We should use ASHR instead of LSHR + BFE
 254 ; TODO: This should use DST, but for some there are redundant MOVs
 255 ; EGCM-DAG: BFE_INT {{[* ]*}}[[ST]].X, {{.*}}, 0.0, literal
 256 ; EGCM-DAG: BFE_INT {{[* ]*}}[[ST]].Y, {{.*}}, 0.0, literal
 257 ; EGCM-DAG: BFE_INT {{[* ]*}}[[ST]].Z, {{.*}}, 0.0, literal
 258 ; EGCM-DAG: BFE_INT {{[* ]*}}[[ST]].W, {{.*}}, 0.0, literal
 259 ; EGCM-DAG: 16
 260 ; EGCM-DAG: 16
 261 ; EGCM-DAG: 16
 262 ; EGCM-DAG: 16
 263 define amdgpu_kernel void @global_sextload_v4i16_to_v4i32(<4 x i32> addrspace(1)* %out, <4 x i16> addrspace(1)* %in) #0 {
 264   %load = load <4 x i16>, <4 x i16> addrspace(1)* %in
 265   %ext = sext <4 x i16> %load to <4 x i32>
 266   store <4 x i32> %ext, <4 x i32> addrspace(1)* %out
 267   ret void
 268 }
 269
 270 ; FUNC-LABEL: {{^}}global_zextload_v8i16_to_v8i32:
 271 ; GCN-NOHSA: buffer_load_dwordx4
 272 ; GCN-HSA: flat_load_dwordx4
 273
 274 ; CM-DAG: MEM_RAT_CACHELESS STORE_DWORD [[ST_LO:T[0-9]]], {{T[0-9]\.[XYZW]}}
 275 ; CM-DAG: MEM_RAT_CACHELESS STORE_DWORD [[ST_HI:T[0-9]]], {{T[0-9]\.[XYZW]}}
 276 ; EG-DAG: MEM_RAT_CACHELESS STORE_RAW [[ST_LO:T[0-9]]].XYZW, {{T[0-9]\.[XYZW]}},
 277 ; EG-DAG: MEM_RAT_CACHELESS STORE_RAW [[ST_HI:T[0-9]]].XYZW, {{T[0-9]\.[XYZW]}},
 278 ; EGCM: CF_END
 279 ; EGCM: VTX_READ_128 [[DST:T[0-9]]].XYZW, {{T[0-9].[XYZW]}}, 0, #1
 280 ; TODO: These should use LSHR instead of BFE_UINT
 281 ; EGCM-DAG: BFE_UINT {{[* ]*}}[[ST_LO]].Y, {{.*}}, literal
 282 ; EGCM-DAG: BFE_UINT {{[* ]*}}[[ST_LO]].W, {{.*}}, literal
 283 ; EGCM-DAG: BFE_UINT {{[* ]*}}[[ST_HI]].Y, {{.*}}, literal
 284 ; EGCM-DAG: BFE_UINT {{[* ]*}}[[ST_HI]].W, {{.*}}, literal
 285 ; EGCM-DAG: AND_INT {{[* ]*}}[[ST_LO]].X, {{.*}}, literal
 286 ; EGCM-DAG: AND_INT {{[* ]*}}[[ST_LO]].Z, {{.*}}, literal
 287 ; EGCM-DAG: AND_INT {{[* ]*}}[[ST_HI]].X, {{.*}}, literal
 288 ; EGCM-DAG: AND_INT {{[* ]*}}[[ST_HI]].Z, {{.*}}, literal
 289 ; EGCM-DAG: 65535
 290 ; EGCM-DAG: 65535
 291 ; EGCM-DAG: 65535
 292 ; EGCM-DAG: 65535
 293 ; EGCM-DAG: 16
 294 ; EGCM-DAG: 16
 295 ; EGCM-DAG: 16
 296 ; EGCM-DAG: 16
 297 define amdgpu_kernel void @global_zextload_v8i16_to_v8i32(<8 x i32> addrspace(1)* %out, <8 x i16> addrspace(1)* %in) #0 {
 298   %load = load <8 x i16>, <8 x i16> addrspace(1)* %in
 299   %ext = zext <8 x i16> %load to <8 x i32>
 300   store <8 x i32> %ext, <8 x i32> addrspace(1)* %out
 301   ret void
 302 }
 303
 304 ; FUNC-LABEL: {{^}}global_sextload_v8i16_to_v8i32:
 305 ; GCN-NOHSA: buffer_load_dwordx4
 306 ; GCN-HSA: flat_load_dwordx4
 307
 308 ; CM-DAG: MEM_RAT_CACHELESS STORE_DWORD [[ST_LO:T[0-9]]], {{T[0-9]\.[XYZW]}}
 309 ; CM-DAG: MEM_RAT_CACHELESS STORE_DWORD [[ST_HI:T[0-9]]], {{T[0-9]\.[XYZW]}}
 310 ; EG-DAG: MEM_RAT_CACHELESS STORE_RAW [[ST_LO:T[0-9]]].XYZW, {{T[0-9]\.[XYZW]}},
 311 ; EG-DAG: MEM_RAT_CACHELESS STORE_RAW [[ST_HI:T[0-9]]].XYZW, {{T[0-9]\.[XYZW]}},
 312 ; EGCM: CF_END
 313 ; EGCM: VTX_READ_128 [[DST:T[0-9]]].XYZW, {{T[0-9].[XYZW]}}, 0, #1
 314 ; TODO: These should use ASHR instead of LSHR + BFE_INT
 315 ; EGCM-DAG: BFE_INT {{[* ]*}}[[ST_LO]].Y, {{.*}}, 0.0, literal
 316 ; EGCM-DAG: BFE_INT {{[* ]*}}[[ST_LO]].W, {{.*}}, 0.0, literal
 317 ; EGCM-DAG: BFE_INT {{[* ]*}}[[ST_HI]].Y, {{.*}}, 0.0, literal
 318 ; EGCM-DAG: BFE_INT {{[* ]*}}[[ST_HI]].W, {{.*}}, 0.0, literal
 319 ; EGCM-DAG: BFE_INT {{[* ]*}}[[ST_LO]].X, {{.*}}, 0.0, literal
 320 ; EGCM-DAG: BFE_INT {{[* ]*}}[[ST_LO]].Z, {{.*}}, 0.0, literal
 321 ; EGCM-DAG: BFE_INT {{[* ]*}}[[ST_HI]].X, {{.*}}, 0.0, literal
 322 ; EGCM-DAG: BFE_INT {{[* ]*}}[[ST_HI]].Z, {{.*}}, 0.0, literal
 323 ; EGCM-DAG: 16
 324 ; EGCM-DAG: 16
 325 ; EGCM-DAG: 16
 326 ; EGCM-DAG: 16
 327 ; EGCM-DAG: 16
 328 ; EGCM-DAG: 16
 329 ; EGCM-DAG: 16
 330 ; EGCM-DAG: 16
 331 define amdgpu_kernel void @global_sextload_v8i16_to_v8i32(<8 x i32> addrspace(1)* %out, <8 x i16> addrspace(1)* %in) #0 {
 332   %load = load <8 x i16>, <8 x i16> addrspace(1)* %in
 333   %ext = sext <8 x i16> %load to <8 x i32>
 334   store <8 x i32> %ext, <8 x i32> addrspace(1)* %out
 335   ret void
 336 }
 337
 338 ; FUNC-LABEL: {{^}}global_zextload_v16i16_to_v16i32:
 339 ; GCN-NOHSA: buffer_load_dwordx4
 340 ; GCN-NOHSA: buffer_load_dwordx4
 341
 342 ; GCN-HSA: flat_load_dwordx4
 343 ; GCN-HSA: flat_load_dwordx4
 344
 345 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 0, #1
 346 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 16, #1
 347 define amdgpu_kernel void @global_zextload_v16i16_to_v16i32(<16 x i32> addrspace(1)* %out, <16 x i16> addrspace(1)* %in) #0 {
 348   %load = load <16 x i16>, <16 x i16> addrspace(1)* %in
 349   %ext = zext <16 x i16> %load to <16 x i32>
 350   store <16 x i32> %ext, <16 x i32> addrspace(1)* %out
 351   ret void
 352 }
 353
 354 ; FUNC-LABEL: {{^}}global_sextload_v16i16_to_v16i32:
 355
 356 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 0, #1
 357 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 16, #1
 358 define amdgpu_kernel void @global_sextload_v16i16_to_v16i32(<16 x i32> addrspace(1)* %out, <16 x i16> addrspace(1)* %in) #0 {
 359   %load = load <16 x i16>, <16 x i16> addrspace(1)* %in
 360   %ext = sext <16 x i16> %load to <16 x i32>
 361   store <16 x i32> %ext, <16 x i32> addrspace(1)* %out
 362   ret void
 363 }
 364
 365 ; FUNC-LABEL: {{^}}global_zextload_v32i16_to_v32i32:
 366 ; GCN-NOHSA: buffer_load_dwordx4
 367 ; GCN-NOHSA: buffer_load_dwordx4
 368 ; GCN-NOHSA: buffer_load_dwordx4
 369 ; GCN-NOHSA: buffer_load_dwordx4
 370
 371 ; GCN-HSA: flat_load_dwordx4
 372 ; GCN-HSA: flat_load_dwordx4
 373 ; GCN-HSA: flat_load_dwordx4
 374 ; GCN-HSA: flat_load_dwordx4
 375
 376 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 0, #1
 377 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 16, #1
 378 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 32, #1
 379 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 48, #1
 380 define amdgpu_kernel void @global_zextload_v32i16_to_v32i32(<32 x i32> addrspace(1)* %out, <32 x i16> addrspace(1)* %in) #0 {
 381   %load = load <32 x i16>, <32 x i16> addrspace(1)* %in
 382   %ext = zext <32 x i16> %load to <32 x i32>
 383   store <32 x i32> %ext, <32 x i32> addrspace(1)* %out
 384   ret void
 385 }
 386
 387 ; FUNC-LABEL: {{^}}global_sextload_v32i16_to_v32i32:
 388 ; GCN-NOHSA: buffer_load_dwordx4
 389 ; GCN-NOHSA: buffer_load_dwordx4
 390 ; GCN-NOHSA: buffer_load_dwordx4
 391 ; GCN-NOHSA: buffer_load_dwordx4
 392
 393 ; GCN-HSA: flat_load_dwordx4
 394 ; GCN-HSA: flat_load_dwordx4
 395 ; GCN-HSA: flat_load_dwordx4
 396 ; GCN-HSA: flat_load_dwordx4
 397
 398 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 0, #1
 399 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 16, #1
 400 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 32, #1
 401 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 48, #1
 402 define amdgpu_kernel void @global_sextload_v32i16_to_v32i32(<32 x i32> addrspace(1)* %out, <32 x i16> addrspace(1)* %in) #0 {
 403   %load = load <32 x i16>, <32 x i16> addrspace(1)* %in
 404   %ext = sext <32 x i16> %load to <32 x i32>
 405   store <32 x i32> %ext, <32 x i32> addrspace(1)* %out
 406   ret void
 407 }
 408
 409 ; FUNC-LABEL: {{^}}global_zextload_v64i16_to_v64i32:
 410 ; GCN-NOHSA: buffer_load_dwordx4
 411 ; GCN-NOHSA: buffer_load_dwordx4
 412 ; GCN-NOHSA: buffer_load_dwordx4
 413 ; GCN-NOHSA: buffer_load_dwordx4
 414 ; GCN-NOHSA: buffer_load_dwordx4
 415 ; GCN-NOHSA: buffer_load_dwordx4
 416 ; GCN-NOHSA: buffer_load_dwordx4
 417 ; GCN-NOHSA: buffer_load_dwordx4
 418
 419 ; GCN-HSA: flat_load_dwordx4
 420 ; GCN-HSA: flat_load_dwordx4
 421 ; GCN-HSA: flat_load_dwordx4
 422 ; GCN-HSA: flat_load_dwordx4
 423 ; GCN-HSA: flat_load_dwordx4
 424 ; GCN-HSA: flat_load_dwordx4
 425 ; GCN-HSA: flat_load_dwordx4
 426 ; GCN-HSA: flat_load_dwordx4
 427
 428 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 0, #1
 429 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 16, #1
 430 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 32, #1
 431 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 48, #1
 432 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 64, #1
 433 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 80, #1
 434 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 96, #1
 435 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 112, #1
 436 define amdgpu_kernel void @global_zextload_v64i16_to_v64i32(<64 x i32> addrspace(1)* %out, <64 x i16> addrspace(1)* %in) #0 {
 437   %load = load <64 x i16>, <64 x i16> addrspace(1)* %in
 438   %ext = zext <64 x i16> %load to <64 x i32>
 439   store <64 x i32> %ext, <64 x i32> addrspace(1)* %out
 440   ret void
 441 }
 442
 443 ; FUNC-LABEL: {{^}}global_sextload_v64i16_to_v64i32:
 444
 445 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 0, #1
 446 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 16, #1
 447 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 32, #1
 448 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 48, #1
 449 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 64, #1
 450 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 80, #1
 451 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 96, #1
 452 ; EGCM-DAG: VTX_READ_128 {{T[0-9]+\.XYZW}}, {{T[0-9]+.[XYZW]}}, 112, #1
 453 define amdgpu_kernel void @global_sextload_v64i16_to_v64i32(<64 x i32> addrspace(1)* %out, <64 x i16> addrspace(1)* %in) #0 {
 454   %load = load <64 x i16>, <64 x i16> addrspace(1)* %in
 455   %ext = sext <64 x i16> %load to <64 x i32>
 456   store <64 x i32> %ext, <64 x i32> addrspace(1)* %out
 457   ret void
 458 }
 459
 460 ; FUNC-LABEL: {{^}}global_zextload_i16_to_i64:
 461 ; GCN-NOHSA-DAG: buffer_load_ushort v[[LO:[0-9]+]],
 462 ; GCN-HSA-DAG: flat_load_ushort v[[LO:[0-9]+]],
 463 ; GCN-DAG: v_mov_b32_e32 v[[HI:[0-9]+]], 0{{$}}
 464
 465 ; GCN-NOHSA: buffer_store_dwordx2 v{{\[}}[[LO]]:[[HI]]]
 466 ; GCN-HSA: flat_store_dwordx2 v{{\[[0-9]+:[0-9]+\]}}, v{{\[}}[[LO]]:[[HI]]{{\]}}
 467
 468 ; EGCM: VTX_READ_16 T{{[0-9]+}}.X, T{{[0-9]+}}.X, 0, #1
 469 ; EGCM: MOV {{.*}}, 0.0
 470 define amdgpu_kernel void @global_zextload_i16_to_i64(i64 addrspace(1)* %out, i16 addrspace(1)* %in) #0 {
 471   %a = load i16, i16 addrspace(1)* %in
 472   %ext = zext i16 %a to i64
 473   store i64 %ext, i64 addrspace(1)* %out
 474   ret void
 475 }
 476
 477 ; FUNC-LABEL: {{^}}global_sextload_i16_to_i64:
 478 ; FIXME: Need to optimize this sequence to avoid extra bfe:
 479 ;  t28: i32,ch = load<LD2[%in(addrspace=1)], anyext from i16> t12, t27, undef:i64
 480 ;          t31: i64 = any_extend t28
 481 ;        t33: i64 = sign_extend_inreg t31, ValueType:ch:i16
 482
 483 ; GCN-NOHSA-SI-DAG: buffer_load_sshort v[[LO:[0-9]+]],
 484 ; GCN-HSA-DAG: flat_load_sshort v[[LO:[0-9]+]],
 485 ; GCN-NOHSA-VI-DAG: buffer_load_ushort v[[ULO:[0-9]+]],
 486 ; GCN-NOHSA-VI-DAG: v_bfe_i32 v[[LO:[0-9]+]], v[[ULO]], 0, 16
 487 ; GCN-DAG: v_ashrrev_i32_e32 v[[HI:[0-9]+]], 31, v[[LO]]
 488
 489 ; GCN-NOHSA: buffer_store_dwordx2 v{{\[}}[[LO]]:[[HI]]]
 490 ; GCN-HSA: flat_store_dwordx2 v{{\[[0-9]+:[0-9]+\]}}, v{{\[}}[[LO]]:[[HI]]{{\]}}
 491
 492 ; EGCM: VTX_READ_16 T{{[0-9]+}}.X, T{{[0-9]+}}.X, 0, #1
 493 ; EGCM: ASHR {{\**}} {{T[0-9]\.[XYZW]}}, {{.*}}, literal
 494 ; TODO: These could be expanded earlier using ASHR 15
 495 ; EGCM: 31
 496 define amdgpu_kernel void @global_sextload_i16_to_i64(i64 addrspace(1)* %out, i16 addrspace(1)* %in) #0 {
 497   %a = load i16, i16 addrspace(1)* %in
 498   %ext = sext i16 %a to i64
 499   store i64 %ext, i64 addrspace(1)* %out
 500   ret void
 501 }
 502
 503 ; FUNC-LABEL: {{^}}global_zextload_v1i16_to_v1i64:
 504
 505 ; EGCM: VTX_READ_16 T{{[0-9]+}}.X, T{{[0-9]+}}.X, 0, #1
 506 ; EGCM: MOV {{.*}}, 0.0
 507 define amdgpu_kernel void @global_zextload_v1i16_to_v1i64(<1 x i64> addrspace(1)* %out, <1 x i16> addrspace(1)* %in) #0 {
 508   %load = load <1 x i16>, <1 x i16> addrspace(1)* %in
 509   %ext = zext <1 x i16> %load to <1 x i64>
 510   store <1 x i64> %ext, <1 x i64> addrspace(1)* %out
 511   ret void
 512 }
 513
 514 ; FUNC-LABEL: {{^}}global_sextload_v1i16_to_v1i64:
 515
 516 ; EGCM: VTX_READ_16 T{{[0-9]+}}.X, T{{[0-9]+}}.X, 0, #1
 517 ; EGCM: ASHR {{\**}} {{T[0-9]\.[XYZW]}}, {{.*}}, literal
 518 ; TODO: These could be expanded earlier using ASHR 15
 519 ; EGCM: 31
 520 define amdgpu_kernel void @global_sextload_v1i16_to_v1i64(<1 x i64> addrspace(1)* %out, <1 x i16> addrspace(1)* %in) #0 {
 521   %load = load <1 x i16>, <1 x i16> addrspace(1)* %in
 522   %ext = sext <1 x i16> %load to <1 x i64>
 523   store <1 x i64> %ext, <1 x i64> addrspace(1)* %out
 524   ret void
 525 }
 526
 527 ; FUNC-LABEL: {{^}}global_zextload_v2i16_to_v2i64:
 528 define amdgpu_kernel void @global_zextload_v2i16_to_v2i64(<2 x i64> addrspace(1)* %out, <2 x i16> addrspace(1)* %in) #0 {
 529   %load = load <2 x i16>, <2 x i16> addrspace(1)* %in
 530   %ext = zext <2 x i16> %load to <2 x i64>
 531   store <2 x i64> %ext, <2 x i64> addrspace(1)* %out
 532   ret void
 533 }
 534
 535 ; FUNC-LABEL: {{^}}global_sextload_v2i16_to_v2i64:
 536
 537 ; EGCM: VTX_READ_32 T{{[0-9]+}}.X, T{{[0-9]+}}.X, 0, #1
 538 define amdgpu_kernel void @global_sextload_v2i16_to_v2i64(<2 x i64> addrspace(1)* %out, <2 x i16> addrspace(1)* %in) #0 {
 539   %load = load <2 x i16>, <2 x i16> addrspace(1)* %in
 540   %ext = sext <2 x i16> %load to <2 x i64>
 541   store <2 x i64> %ext, <2 x i64> addrspace(1)* %out
 542   ret void
 543 }
 544
 545 ; FUNC-LABEL: {{^}}global_zextload_v4i16_to_v4i64:
 546
 547 ; EGCM: VTX_READ_64 T{{[0-9]+}}.XY, T{{[0-9]+}}.X, 0, #1
 548 define amdgpu_kernel void @global_zextload_v4i16_to_v4i64(<4 x i64> addrspace(1)* %out, <4 x i16> addrspace(1)* %in) #0 {
 549   %load = load <4 x i16>, <4 x i16> addrspace(1)* %in
 550   %ext = zext <4 x i16> %load to <4 x i64>
 551   store <4 x i64> %ext, <4 x i64> addrspace(1)* %out
 552   ret void
 553 }
 554
 555 ; FUNC-LABEL: {{^}}global_sextload_v4i16_to_v4i64:
 556
 557 ; EGCM: VTX_READ_64 T{{[0-9]+}}.XY, T{{[0-9]+}}.X, 0, #1
 558 define amdgpu_kernel void @global_sextload_v4i16_to_v4i64(<4 x i64> addrspace(1)* %out, <4 x i16> addrspace(1)* %in) #0 {
 559   %load = load <4 x i16>, <4 x i16> addrspace(1)* %in
 560   %ext = sext <4 x i16> %load to <4 x i64>
 561   store <4 x i64> %ext, <4 x i64> addrspace(1)* %out
 562   ret void
 563 }
 564
 565 ; FUNC-LABEL: {{^}}global_zextload_v8i16_to_v8i64:
 566
 567 ; EGCM: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 0, #1
 568 define amdgpu_kernel void @global_zextload_v8i16_to_v8i64(<8 x i64> addrspace(1)* %out, <8 x i16> addrspace(1)* %in) #0 {
 569   %load = load <8 x i16>, <8 x i16> addrspace(1)* %in
 570   %ext = zext <8 x i16> %load to <8 x i64>
 571   store <8 x i64> %ext, <8 x i64> addrspace(1)* %out
 572   ret void
 573 }
 574
 575 ; FUNC-LABEL: {{^}}global_sextload_v8i16_to_v8i64:
 576
 577 ; EGCM: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 0, #1
 578 define amdgpu_kernel void @global_sextload_v8i16_to_v8i64(<8 x i64> addrspace(1)* %out, <8 x i16> addrspace(1)* %in) #0 {
 579   %load = load <8 x i16>, <8 x i16> addrspace(1)* %in
 580   %ext = sext <8 x i16> %load to <8 x i64>
 581   store <8 x i64> %ext, <8 x i64> addrspace(1)* %out
 582   ret void
 583 }
 584
 585 ; FUNC-LABEL: {{^}}global_zextload_v16i16_to_v16i64:
 586
 587 ; EGCM-DAG: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 0, #1
 588 ; EGCM-DAG: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 16, #1
 589 define amdgpu_kernel void @global_zextload_v16i16_to_v16i64(<16 x i64> addrspace(1)* %out, <16 x i16> addrspace(1)* %in) #0 {
 590   %load = load <16 x i16>, <16 x i16> addrspace(1)* %in
 591   %ext = zext <16 x i16> %load to <16 x i64>
 592   store <16 x i64> %ext, <16 x i64> addrspace(1)* %out
 593   ret void
 594 }
 595
 596 ; FUNC-LABEL: {{^}}global_sextload_v16i16_to_v16i64:
 597
 598 ; EGCM-DAG: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 0, #1
 599 ; EGCM-DAG: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 16, #1
 600 define amdgpu_kernel void @global_sextload_v16i16_to_v16i64(<16 x i64> addrspace(1)* %out, <16 x i16> addrspace(1)* %in) #0 {
 601   %load = load <16 x i16>, <16 x i16> addrspace(1)* %in
 602   %ext = sext <16 x i16> %load to <16 x i64>
 603   store <16 x i64> %ext, <16 x i64> addrspace(1)* %out
 604   ret void
 605 }
 606
 607 ; FUNC-LABEL: {{^}}global_zextload_v32i16_to_v32i64:
 608
 609 ; EGCM-DAG: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 0, #1
 610 ; EGCM-DAG: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 16, #1
 611 ; EGCM-DAG: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 32, #1
 612 ; EGCM-DAG: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 48, #1
 613 define amdgpu_kernel void @global_zextload_v32i16_to_v32i64(<32 x i64> addrspace(1)* %out, <32 x i16> addrspace(1)* %in) #0 {
 614   %load = load <32 x i16>, <32 x i16> addrspace(1)* %in
 615   %ext = zext <32 x i16> %load to <32 x i64>
 616   store <32 x i64> %ext, <32 x i64> addrspace(1)* %out
 617   ret void
 618 }
 619
 620 ; FUNC-LABEL: {{^}}global_sextload_v32i16_to_v32i64:
 621
 622 ; EGCM-DAG: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 0, #1
 623 ; EGCM-DAG: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 16, #1
 624 ; EGCM-DAG: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 32, #1
 625 ; EGCM-DAG: VTX_READ_128 T{{[0-9]+}}.XYZW, T{{[0-9]+}}.X, 48, #1
 626 define amdgpu_kernel void @global_sextload_v32i16_to_v32i64(<32 x i64> addrspace(1)* %out, <32 x i16> addrspace(1)* %in) #0 {
 627   %load = load <32 x i16>, <32 x i16> addrspace(1)* %in
 628   %ext = sext <32 x i16> %load to <32 x i64>
 629   store <32 x i64> %ext, <32 x i64> addrspace(1)* %out
 630   ret void
 631 }
 632
 633 ; ; XFUNC-LABEL: {{^}}global_zextload_v64i16_to_v64i64:
 634 ; define amdgpu_kernel void @global_zextload_v64i16_to_v64i64(<64 x i64> addrspace(1)* %out, <64 x i16> addrspace(1)* %in) #0 {
 635 ;   %load = load <64 x i16>, <64 x i16> addrspace(1)* %in
 636 ;   %ext = zext <64 x i16> %load to <64 x i64>
 637 ;   store <64 x i64> %ext, <64 x i64> addrspace(1)* %out
 638 ;   ret void
 639 ; }
 640
 641 ; ; XFUNC-LABEL: {{^}}global_sextload_v64i16_to_v64i64:
 642 ; define amdgpu_kernel void @global_sextload_v64i16_to_v64i64(<64 x i64> addrspace(1)* %out, <64 x i16> addrspace(1)* %in) #0 {
 643 ;   %load = load <64 x i16>, <64 x i16> addrspace(1)* %in
 644 ;   %ext = sext <64 x i16> %load to <64 x i64>
 645 ;   store <64 x i64> %ext, <64 x i64> addrspace(1)* %out
 646 ;   ret void
 647 ; }
 648
 649 attributes #0 = { nounwind }