test/CodeGen/R600/load.ll

   1 ; RUN: llc < %s -march=r600 -mcpu=redwood | FileCheck --check-prefix=R600 --check-prefix=FUNC %s
   2 ; RUN: llc < %s -march=r600 -mcpu=cayman | FileCheck --check-prefix=R600 --check-prefix=FUNC %s
   3 ; RUN: llc < %s -march=amdgcn -mcpu=SI -verify-machineinstrs | FileCheck --check-prefix=SI --check-prefix=FUNC %s
   4 ; RUN: llc < %s -march=amdgcn -mcpu=tonga -verify-machineinstrs | FileCheck --check-prefix=SI --check-prefix=FUNC %s
   5
   6 ;===------------------------------------------------------------------------===;
   7 ; GLOBAL ADDRESS SPACE
   8 ;===------------------------------------------------------------------------===;
   9
  10 ; Load an i8 value from the global address space.
  11 ; FUNC-LABEL: {{^}}load_i8:
  12 ; R600: VTX_READ_8 T{{[0-9]+\.X, T[0-9]+\.X}}
  13
  14 ; SI: buffer_load_ubyte v{{[0-9]+}},
  15 define void @load_i8(i32 addrspace(1)* %out, i8 addrspace(1)* %in) {
  16   %1 = load i8, i8 addrspace(1)* %in
  17   %2 = zext i8 %1 to i32
  18   store i32 %2, i32 addrspace(1)* %out
  19   ret void
  20 }
  21
  22 ; FUNC-LABEL: {{^}}load_i8_sext:
  23 ; R600: VTX_READ_8 [[DST:T[0-9]\.[XYZW]]], [[DST]]
  24 ; R600: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST]], 0.0, literal
  25 ; R600: 8
  26 ; SI: buffer_load_sbyte
  27 define void @load_i8_sext(i32 addrspace(1)* %out, i8 addrspace(1)* %in) {
  28 entry:
  29   %0 = load i8, i8 addrspace(1)* %in
  30   %1 = sext i8 %0 to i32
  31   store i32 %1, i32 addrspace(1)* %out
  32   ret void
  33 }
  34
  35 ; FUNC-LABEL: {{^}}load_v2i8:
  36 ; R600: VTX_READ_8
  37 ; R600: VTX_READ_8
  38 ; SI: buffer_load_ubyte
  39 ; SI: buffer_load_ubyte
  40 define void @load_v2i8(<2 x i32> addrspace(1)* %out, <2 x i8> addrspace(1)* %in) {
  41 entry:
  42   %0 = load <2 x i8>, <2 x i8> addrspace(1)* %in
  43   %1 = zext <2 x i8> %0 to <2 x i32>
  44   store <2 x i32> %1, <2 x i32> addrspace(1)* %out
  45   ret void
  46 }
  47
  48 ; FUNC-LABEL: {{^}}load_v2i8_sext:
  49 ; R600-DAG: VTX_READ_8 [[DST_X:T[0-9]\.[XYZW]]], [[DST_X]]
  50 ; R600-DAG: VTX_READ_8 [[DST_Y:T[0-9]\.[XYZW]]], [[DST_Y]]
  51 ; R600-DAG: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST_X]], 0.0, literal
  52 ; R600-DAG: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST_Y]], 0.0, literal
  53 ; R600-DAG: 8
  54 ; R600-DAG: 8
  55
  56 ; SI: buffer_load_sbyte
  57 ; SI: buffer_load_sbyte
  58 define void @load_v2i8_sext(<2 x i32> addrspace(1)* %out, <2 x i8> addrspace(1)* %in) {
  59 entry:
  60   %0 = load <2 x i8>, <2 x i8> addrspace(1)* %in
  61   %1 = sext <2 x i8> %0 to <2 x i32>
  62   store <2 x i32> %1, <2 x i32> addrspace(1)* %out
  63   ret void
  64 }
  65
  66 ; FUNC-LABEL: {{^}}load_v4i8:
  67 ; R600: VTX_READ_8
  68 ; R600: VTX_READ_8
  69 ; R600: VTX_READ_8
  70 ; R600: VTX_READ_8
  71 ; SI: buffer_load_ubyte
  72 ; SI: buffer_load_ubyte
  73 ; SI: buffer_load_ubyte
  74 ; SI: buffer_load_ubyte
  75 define void @load_v4i8(<4 x i32> addrspace(1)* %out, <4 x i8> addrspace(1)* %in) {
  76 entry:
  77   %0 = load <4 x i8>, <4 x i8> addrspace(1)* %in
  78   %1 = zext <4 x i8> %0 to <4 x i32>
  79   store <4 x i32> %1, <4 x i32> addrspace(1)* %out
  80   ret void
  81 }
  82
  83 ; FUNC-LABEL: {{^}}load_v4i8_sext:
  84 ; R600-DAG: VTX_READ_8 [[DST_X:T[0-9]\.[XYZW]]], [[DST_X]]
  85 ; R600-DAG: VTX_READ_8 [[DST_Y:T[0-9]\.[XYZW]]], [[DST_Y]]
  86 ; R600-DAG: VTX_READ_8 [[DST_Z:T[0-9]\.[XYZW]]], [[DST_Z]]
  87 ; R600-DAG: VTX_READ_8 [[DST_W:T[0-9]\.[XYZW]]], [[DST_W]]
  88 ; R600-DAG: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST_X]], 0.0, literal
  89 ; R600-DAG: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST_Y]], 0.0, literal
  90 ; R600-DAG: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST_Z]], 0.0, literal
  91 ; R600-DAG: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST_W]], 0.0, literal
  92 ; R600-DAG: 8
  93 ; R600-DAG: 8
  94 ; R600-DAG: 8
  95 ; R600-DAG: 8
  96 ; SI: buffer_load_sbyte
  97 ; SI: buffer_load_sbyte
  98 ; SI: buffer_load_sbyte
  99 ; SI: buffer_load_sbyte
 100 define void @load_v4i8_sext(<4 x i32> addrspace(1)* %out, <4 x i8> addrspace(1)* %in) {
 101 entry:
 102   %0 = load <4 x i8>, <4 x i8> addrspace(1)* %in
 103   %1 = sext <4 x i8> %0 to <4 x i32>
 104   store <4 x i32> %1, <4 x i32> addrspace(1)* %out
 105   ret void
 106 }
 107
 108 ; Load an i16 value from the global address space.
 109 ; FUNC-LABEL: {{^}}load_i16:
 110 ; R600: VTX_READ_16 T{{[0-9]+\.X, T[0-9]+\.X}}
 111 ; SI: buffer_load_ushort
 112 define void @load_i16(i32 addrspace(1)* %out, i16 addrspace(1)* %in) {
 113 entry:
 114   %0 = load i16 , i16    addrspace(1)* %in
 115   %1 = zext i16 %0 to i32
 116   store i32 %1, i32 addrspace(1)* %out
 117   ret void
 118 }
 119
 120 ; FUNC-LABEL: {{^}}load_i16_sext:
 121 ; R600: VTX_READ_16 [[DST:T[0-9]\.[XYZW]]], [[DST]]
 122 ; R600: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST]], 0.0, literal
 123 ; R600: 16
 124 ; SI: buffer_load_sshort
 125 define void @load_i16_sext(i32 addrspace(1)* %out, i16 addrspace(1)* %in) {
 126 entry:
 127   %0 = load i16, i16 addrspace(1)* %in
 128   %1 = sext i16 %0 to i32
 129   store i32 %1, i32 addrspace(1)* %out
 130   ret void
 131 }
 132
 133 ; FUNC-LABEL: {{^}}load_v2i16:
 134 ; R600: VTX_READ_16
 135 ; R600: VTX_READ_16
 136 ; SI: buffer_load_ushort
 137 ; SI: buffer_load_ushort
 138 define void @load_v2i16(<2 x i32> addrspace(1)* %out, <2 x i16> addrspace(1)* %in) {
 139 entry:
 140   %0 = load <2 x i16>, <2 x i16> addrspace(1)* %in
 141   %1 = zext <2 x i16> %0 to <2 x i32>
 142   store <2 x i32> %1, <2 x i32> addrspace(1)* %out
 143   ret void
 144 }
 145
 146 ; FUNC-LABEL: {{^}}load_v2i16_sext:
 147 ; R600-DAG: VTX_READ_16 [[DST_X:T[0-9]\.[XYZW]]], [[DST_X]]
 148 ; R600-DAG: VTX_READ_16 [[DST_Y:T[0-9]\.[XYZW]]], [[DST_Y]]
 149 ; R600-DAG: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST_X]], 0.0, literal
 150 ; R600-DAG: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST_Y]], 0.0, literal
 151 ; R600-DAG: 16
 152 ; R600-DAG: 16
 153 ; SI: buffer_load_sshort
 154 ; SI: buffer_load_sshort
 155 define void @load_v2i16_sext(<2 x i32> addrspace(1)* %out, <2 x i16> addrspace(1)* %in) {
 156 entry:
 157   %0 = load <2 x i16>, <2 x i16> addrspace(1)* %in
 158   %1 = sext <2 x i16> %0 to <2 x i32>
 159   store <2 x i32> %1, <2 x i32> addrspace(1)* %out
 160   ret void
 161 }
 162
 163 ; FUNC-LABEL: {{^}}load_v4i16:
 164 ; R600: VTX_READ_16
 165 ; R600: VTX_READ_16
 166 ; R600: VTX_READ_16
 167 ; R600: VTX_READ_16
 168 ; SI: buffer_load_ushort
 169 ; SI: buffer_load_ushort
 170 ; SI: buffer_load_ushort
 171 ; SI: buffer_load_ushort
 172 define void @load_v4i16(<4 x i32> addrspace(1)* %out, <4 x i16> addrspace(1)* %in) {
 173 entry:
 174   %0 = load <4 x i16>, <4 x i16> addrspace(1)* %in
 175   %1 = zext <4 x i16> %0 to <4 x i32>
 176   store <4 x i32> %1, <4 x i32> addrspace(1)* %out
 177   ret void
 178 }
 179
 180 ; FUNC-LABEL: {{^}}load_v4i16_sext:
 181 ; R600-DAG: VTX_READ_16 [[DST_X:T[0-9]\.[XYZW]]], [[DST_X]]
 182 ; R600-DAG: VTX_READ_16 [[DST_Y:T[0-9]\.[XYZW]]], [[DST_Y]]
 183 ; R600-DAG: VTX_READ_16 [[DST_Z:T[0-9]\.[XYZW]]], [[DST_Z]]
 184 ; R600-DAG: VTX_READ_16 [[DST_W:T[0-9]\.[XYZW]]], [[DST_W]]
 185 ; R600-DAG: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST_X]], 0.0, literal
 186 ; R600-DAG: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST_Y]], 0.0, literal
 187 ; R600-DAG: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST_Z]], 0.0, literal
 188 ; R600-DAG: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST_W]], 0.0, literal
 189 ; R600-DAG: 16
 190 ; R600-DAG: 16
 191 ; R600-DAG: 16
 192 ; R600-DAG: 16
 193 ; SI: buffer_load_sshort
 194 ; SI: buffer_load_sshort
 195 ; SI: buffer_load_sshort
 196 ; SI: buffer_load_sshort
 197 define void @load_v4i16_sext(<4 x i32> addrspace(1)* %out, <4 x i16> addrspace(1)* %in) {
 198 entry:
 199   %0 = load <4 x i16>, <4 x i16> addrspace(1)* %in
 200   %1 = sext <4 x i16> %0 to <4 x i32>
 201   store <4 x i32> %1, <4 x i32> addrspace(1)* %out
 202   ret void
 203 }
 204
 205 ; load an i32 value from the global address space.
 206 ; FUNC-LABEL: {{^}}load_i32:
 207 ; R600: VTX_READ_32 T{{[0-9]+}}.X, T{{[0-9]+}}.X, 0
 208
 209 ; SI: buffer_load_dword v{{[0-9]+}}
 210 define void @load_i32(i32 addrspace(1)* %out, i32 addrspace(1)* %in) {
 211 entry:
 212   %0 = load i32, i32 addrspace(1)* %in
 213   store i32 %0, i32 addrspace(1)* %out
 214   ret void
 215 }
 216
 217 ; load a f32 value from the global address space.
 218 ; FUNC-LABEL: {{^}}load_f32:
 219 ; R600: VTX_READ_32 T{{[0-9]+}}.X, T{{[0-9]+}}.X, 0
 220
 221 ; SI: buffer_load_dword v{{[0-9]+}}
 222 define void @load_f32(float addrspace(1)* %out, float addrspace(1)* %in) {
 223 entry:
 224   %0 = load float, float addrspace(1)* %in
 225   store float %0, float addrspace(1)* %out
 226   ret void
 227 }
 228
 229 ; load a v2f32 value from the global address space
 230 ; FUNC-LABEL: {{^}}load_v2f32:
 231 ; R600: MEM_RAT
 232 ; R600: VTX_READ_64
 233 ; SI: buffer_load_dwordx2
 234 define void @load_v2f32(<2 x float> addrspace(1)* %out, <2 x float> addrspace(1)* %in) {
 235 entry:
 236   %0 = load <2 x float>, <2 x float> addrspace(1)* %in
 237   store <2 x float> %0, <2 x float> addrspace(1)* %out
 238   ret void
 239 }
 240
 241 ; FUNC-LABEL: {{^}}load_i64:
 242 ; R600: VTX_READ_64
 243 ; SI: buffer_load_dwordx2
 244 define void @load_i64(i64 addrspace(1)* %out, i64 addrspace(1)* %in) {
 245 entry:
 246   %0 = load i64, i64 addrspace(1)* %in
 247   store i64 %0, i64 addrspace(1)* %out
 248   ret void
 249 }
 250
 251 ; FUNC-LABEL: {{^}}load_i64_sext:
 252 ; R600: MEM_RAT
 253 ; R600: MEM_RAT
 254 ; R600: ASHR {{[* ]*}}T{{[0-9]\.[XYZW]}}, T{{[0-9]\.[XYZW]}},  literal.x
 255 ; R600: 31
 256 ; SI: buffer_load_dword
 257
 258 define void @load_i64_sext(i64 addrspace(1)* %out, i32 addrspace(1)* %in) {
 259 entry:
 260   %0 = load i32, i32 addrspace(1)* %in
 261   %1 = sext i32 %0 to i64
 262   store i64 %1, i64 addrspace(1)* %out
 263   ret void
 264 }
 265
 266 ; FUNC-LABEL: {{^}}load_i64_zext:
 267 ; R600: MEM_RAT
 268 ; R600: MEM_RAT
 269 define void @load_i64_zext(i64 addrspace(1)* %out, i32 addrspace(1)* %in) {
 270 entry:
 271   %0 = load i32, i32 addrspace(1)* %in
 272   %1 = zext i32 %0 to i64
 273   store i64 %1, i64 addrspace(1)* %out
 274   ret void
 275 }
 276
 277 ; FUNC-LABEL: {{^}}load_v8i32:
 278 ; R600: VTX_READ_128
 279 ; R600: VTX_READ_128
 280 ; XXX: We should be using DWORDX4 instructions on SI.
 281 ; SI: buffer_load_dword
 282 ; SI: buffer_load_dword
 283 ; SI: buffer_load_dword
 284 ; SI: buffer_load_dword
 285 ; SI: buffer_load_dword
 286 ; SI: buffer_load_dword
 287 ; SI: buffer_load_dword
 288 ; SI: buffer_load_dword
 289 define void @load_v8i32(<8 x i32> addrspace(1)* %out, <8 x i32> addrspace(1)* %in) {
 290 entry:
 291   %0 = load <8 x i32>, <8 x i32> addrspace(1)* %in
 292   store <8 x i32> %0, <8 x i32> addrspace(1)* %out
 293   ret void
 294 }
 295
 296 ; FUNC-LABEL: {{^}}load_v16i32:
 297 ; R600: VTX_READ_128
 298 ; R600: VTX_READ_128
 299 ; R600: VTX_READ_128
 300 ; R600: VTX_READ_128
 301 ; XXX: We should be using DWORDX4 instructions on SI.
 302 ; SI: buffer_load_dword
 303 ; SI: buffer_load_dword
 304 ; SI: buffer_load_dword
 305 ; SI: buffer_load_dword
 306 ; SI: buffer_load_dword
 307 ; SI: buffer_load_dword
 308 ; SI: buffer_load_dword
 309 ; SI: buffer_load_dword
 310 ; SI: buffer_load_dword
 311 ; SI: buffer_load_dword
 312 ; SI: buffer_load_dword
 313 ; SI: buffer_load_dword
 314 ; SI: buffer_load_dword
 315 ; SI: buffer_load_dword
 316 ; SI: buffer_load_dword
 317 ; SI: buffer_load_dword
 318 define void @load_v16i32(<16 x i32> addrspace(1)* %out, <16 x i32> addrspace(1)* %in) {
 319 entry:
 320   %0 = load <16 x i32>, <16 x i32> addrspace(1)* %in
 321   store <16 x i32> %0, <16 x i32> addrspace(1)* %out
 322   ret void
 323 }
 324
 325 ;===------------------------------------------------------------------------===;
 326 ; CONSTANT ADDRESS SPACE
 327 ;===------------------------------------------------------------------------===;
 328
 329 ; Load a sign-extended i8 value
 330 ; FUNC-LABEL: {{^}}load_const_i8_sext:
 331 ; R600: VTX_READ_8 [[DST:T[0-9]\.[XYZW]]], [[DST]]
 332 ; R600: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST]], 0.0, literal
 333 ; R600: 8
 334 ; SI: buffer_load_sbyte v{{[0-9]+}},
 335 define void @load_const_i8_sext(i32 addrspace(1)* %out, i8 addrspace(2)* %in) {
 336 entry:
 337   %0 = load i8, i8 addrspace(2)* %in
 338   %1 = sext i8 %0 to i32
 339   store i32 %1, i32 addrspace(1)* %out
 340   ret void
 341 }
 342
 343 ; Load an aligned i8 value
 344 ; FUNC-LABEL: {{^}}load_const_i8_aligned:
 345 ; R600: VTX_READ_8 T{{[0-9]+\.X, T[0-9]+\.X}}
 346 ; SI: buffer_load_ubyte v{{[0-9]+}},
 347 define void @load_const_i8_aligned(i32 addrspace(1)* %out, i8 addrspace(2)* %in) {
 348 entry:
 349   %0 = load i8, i8 addrspace(2)* %in
 350   %1 = zext i8 %0 to i32
 351   store i32 %1, i32 addrspace(1)* %out
 352   ret void
 353 }
 354
 355 ; Load an un-aligned i8 value
 356 ; FUNC-LABEL: {{^}}load_const_i8_unaligned:
 357 ; R600: VTX_READ_8 T{{[0-9]+\.X, T[0-9]+\.X}}
 358 ; SI: buffer_load_ubyte v{{[0-9]+}},
 359 define void @load_const_i8_unaligned(i32 addrspace(1)* %out, i8 addrspace(2)* %in) {
 360 entry:
 361   %0 = getelementptr i8, i8 addrspace(2)* %in, i32 1
 362   %1 = load i8, i8 addrspace(2)* %0
 363   %2 = zext i8 %1 to i32
 364   store i32 %2, i32 addrspace(1)* %out
 365   ret void
 366 }
 367
 368 ; Load a sign-extended i16 value
 369 ; FUNC-LABEL: {{^}}load_const_i16_sext:
 370 ; R600: VTX_READ_16 [[DST:T[0-9]\.[XYZW]]], [[DST]]
 371 ; R600: BFE_INT {{[* ]*}}T{{[0-9].[XYZW]}}, [[DST]], 0.0, literal
 372 ; R600: 16
 373 ; SI: buffer_load_sshort
 374 define void @load_const_i16_sext(i32 addrspace(1)* %out, i16 addrspace(2)* %in) {
 375 entry:
 376   %0 = load i16, i16 addrspace(2)* %in
 377   %1 = sext i16 %0 to i32
 378   store i32 %1, i32 addrspace(1)* %out
 379   ret void
 380 }
 381
 382 ; Load an aligned i16 value
 383 ; FUNC-LABEL: {{^}}load_const_i16_aligned:
 384 ; R600: VTX_READ_16 T{{[0-9]+\.X, T[0-9]+\.X}}
 385 ; SI: buffer_load_ushort
 386 define void @load_const_i16_aligned(i32 addrspace(1)* %out, i16 addrspace(2)* %in) {
 387 entry:
 388   %0 = load i16, i16 addrspace(2)* %in
 389   %1 = zext i16 %0 to i32
 390   store i32 %1, i32 addrspace(1)* %out
 391   ret void
 392 }
 393
 394 ; Load an un-aligned i16 value
 395 ; FUNC-LABEL: {{^}}load_const_i16_unaligned:
 396 ; R600: VTX_READ_16 T{{[0-9]+\.X, T[0-9]+\.X}}
 397 ; SI: buffer_load_ushort
 398 define void @load_const_i16_unaligned(i32 addrspace(1)* %out, i16 addrspace(2)* %in) {
 399 entry:
 400   %0 = getelementptr i16, i16 addrspace(2)* %in, i32 1
 401   %1 = load i16, i16 addrspace(2)* %0
 402   %2 = zext i16 %1 to i32
 403   store i32 %2, i32 addrspace(1)* %out
 404   ret void
 405 }
 406
 407 ; Load an i32 value from the constant address space.
 408 ; FUNC-LABEL: {{^}}load_const_addrspace_i32:
 409 ; R600: VTX_READ_32 T{{[0-9]+}}.X, T{{[0-9]+}}.X, 0
 410
 411 ; SI: s_load_dword s{{[0-9]+}}
 412 define void @load_const_addrspace_i32(i32 addrspace(1)* %out, i32 addrspace(2)* %in) {
 413 entry:
 414   %0 = load i32, i32 addrspace(2)* %in
 415   store i32 %0, i32 addrspace(1)* %out
 416   ret void
 417 }
 418
 419 ; Load a f32 value from the constant address space.
 420 ; FUNC-LABEL: {{^}}load_const_addrspace_f32:
 421 ; R600: VTX_READ_32 T{{[0-9]+}}.X, T{{[0-9]+}}.X, 0
 422
 423 ; SI: s_load_dword s{{[0-9]+}}
 424 define void @load_const_addrspace_f32(float addrspace(1)* %out, float addrspace(2)* %in) {
 425   %1 = load float, float addrspace(2)* %in
 426   store float %1, float addrspace(1)* %out
 427   ret void
 428 }
 429
 430 ;===------------------------------------------------------------------------===;
 431 ; LOCAL ADDRESS SPACE
 432 ;===------------------------------------------------------------------------===;
 433
 434 ; Load an i8 value from the local address space.
 435 ; FUNC-LABEL: {{^}}load_i8_local:
 436 ; R600: LDS_UBYTE_READ_RET
 437 ; SI-NOT: s_wqm_b64
 438 ; SI: s_mov_b32 m0
 439 ; SI: ds_read_u8
 440 define void @load_i8_local(i32 addrspace(1)* %out, i8 addrspace(3)* %in) {
 441   %1 = load i8, i8 addrspace(3)* %in
 442   %2 = zext i8 %1 to i32
 443   store i32 %2, i32 addrspace(1)* %out
 444   ret void
 445 }
 446
 447 ; FUNC-LABEL: {{^}}load_i8_sext_local:
 448 ; R600: LDS_UBYTE_READ_RET
 449 ; R600: BFE_INT
 450 ; SI-NOT: s_wqm_b64
 451 ; SI: s_mov_b32 m0
 452 ; SI: ds_read_i8
 453 define void @load_i8_sext_local(i32 addrspace(1)* %out, i8 addrspace(3)* %in) {
 454 entry:
 455   %0 = load i8, i8 addrspace(3)* %in
 456   %1 = sext i8 %0 to i32
 457   store i32 %1, i32 addrspace(1)* %out
 458   ret void
 459 }
 460
 461 ; FUNC-LABEL: {{^}}load_v2i8_local:
 462 ; R600: LDS_UBYTE_READ_RET
 463 ; R600: LDS_UBYTE_READ_RET
 464 ; SI-NOT: s_wqm_b64
 465 ; SI: s_mov_b32 m0
 466 ; SI: ds_read_u8
 467 ; SI: ds_read_u8
 468 define void @load_v2i8_local(<2 x i32> addrspace(1)* %out, <2 x i8> addrspace(3)* %in) {
 469 entry:
 470   %0 = load <2 x i8>, <2 x i8> addrspace(3)* %in
 471   %1 = zext <2 x i8> %0 to <2 x i32>
 472   store <2 x i32> %1, <2 x i32> addrspace(1)* %out
 473   ret void
 474 }
 475
 476 ; FUNC-LABEL: {{^}}load_v2i8_sext_local:
 477 ; R600-DAG: LDS_UBYTE_READ_RET
 478 ; R600-DAG: LDS_UBYTE_READ_RET
 479 ; R600-DAG: BFE_INT
 480 ; R600-DAG: BFE_INT
 481 ; SI-NOT: s_wqm_b64
 482 ; SI: s_mov_b32 m0
 483 ; SI: ds_read_i8
 484 ; SI: ds_read_i8
 485 define void @load_v2i8_sext_local(<2 x i32> addrspace(1)* %out, <2 x i8> addrspace(3)* %in) {
 486 entry:
 487   %0 = load <2 x i8>, <2 x i8> addrspace(3)* %in
 488   %1 = sext <2 x i8> %0 to <2 x i32>
 489   store <2 x i32> %1, <2 x i32> addrspace(1)* %out
 490   ret void
 491 }
 492
 493 ; FUNC-LABEL: {{^}}load_v4i8_local:
 494 ; R600: LDS_UBYTE_READ_RET
 495 ; R600: LDS_UBYTE_READ_RET
 496 ; R600: LDS_UBYTE_READ_RET
 497 ; R600: LDS_UBYTE_READ_RET
 498 ; SI-NOT: s_wqm_b64
 499 ; SI: s_mov_b32 m0
 500 ; SI: ds_read_u8
 501 ; SI: ds_read_u8
 502 ; SI: ds_read_u8
 503 ; SI: ds_read_u8
 504 define void @load_v4i8_local(<4 x i32> addrspace(1)* %out, <4 x i8> addrspace(3)* %in) {
 505 entry:
 506   %0 = load <4 x i8>, <4 x i8> addrspace(3)* %in
 507   %1 = zext <4 x i8> %0 to <4 x i32>
 508   store <4 x i32> %1, <4 x i32> addrspace(1)* %out
 509   ret void
 510 }
 511
 512 ; FUNC-LABEL: {{^}}load_v4i8_sext_local:
 513 ; R600-DAG: LDS_UBYTE_READ_RET
 514 ; R600-DAG: LDS_UBYTE_READ_RET
 515 ; R600-DAG: LDS_UBYTE_READ_RET
 516 ; R600-DAG: LDS_UBYTE_READ_RET
 517 ; R600-DAG: BFE_INT
 518 ; R600-DAG: BFE_INT
 519 ; R600-DAG: BFE_INT
 520 ; R600-DAG: BFE_INT
 521 ; SI-NOT: s_wqm_b64
 522 ; SI: s_mov_b32 m0
 523 ; SI: ds_read_i8
 524 ; SI: ds_read_i8
 525 ; SI: ds_read_i8
 526 ; SI: ds_read_i8
 527 define void @load_v4i8_sext_local(<4 x i32> addrspace(1)* %out, <4 x i8> addrspace(3)* %in) {
 528 entry:
 529   %0 = load <4 x i8>, <4 x i8> addrspace(3)* %in
 530   %1 = sext <4 x i8> %0 to <4 x i32>
 531   store <4 x i32> %1, <4 x i32> addrspace(1)* %out
 532   ret void
 533 }
 534
 535 ; Load an i16 value from the local address space.
 536 ; FUNC-LABEL: {{^}}load_i16_local:
 537 ; R600: LDS_USHORT_READ_RET
 538 ; SI-NOT: s_wqm_b64
 539 ; SI: s_mov_b32 m0
 540 ; SI: ds_read_u16
 541 define void @load_i16_local(i32 addrspace(1)* %out, i16 addrspace(3)* %in) {
 542 entry:
 543   %0 = load i16 , i16    addrspace(3)* %in
 544   %1 = zext i16 %0 to i32
 545   store i32 %1, i32 addrspace(1)* %out
 546   ret void
 547 }
 548
 549 ; FUNC-LABEL: {{^}}load_i16_sext_local:
 550 ; R600: LDS_USHORT_READ_RET
 551 ; R600: BFE_INT
 552 ; SI-NOT: s_wqm_b64
 553 ; SI: s_mov_b32 m0
 554 ; SI: ds_read_i16
 555 define void @load_i16_sext_local(i32 addrspace(1)* %out, i16 addrspace(3)* %in) {
 556 entry:
 557   %0 = load i16, i16 addrspace(3)* %in
 558   %1 = sext i16 %0 to i32
 559   store i32 %1, i32 addrspace(1)* %out
 560   ret void
 561 }
 562
 563 ; FUNC-LABEL: {{^}}load_v2i16_local:
 564 ; R600: LDS_USHORT_READ_RET
 565 ; R600: LDS_USHORT_READ_RET
 566 ; SI-NOT: s_wqm_b64
 567 ; SI: s_mov_b32 m0
 568 ; SI: ds_read_u16
 569 ; SI: ds_read_u16
 570 define void @load_v2i16_local(<2 x i32> addrspace(1)* %out, <2 x i16> addrspace(3)* %in) {
 571 entry:
 572   %0 = load <2 x i16>, <2 x i16> addrspace(3)* %in
 573   %1 = zext <2 x i16> %0 to <2 x i32>
 574   store <2 x i32> %1, <2 x i32> addrspace(1)* %out
 575   ret void
 576 }
 577
 578 ; FUNC-LABEL: {{^}}load_v2i16_sext_local:
 579 ; R600-DAG: LDS_USHORT_READ_RET
 580 ; R600-DAG: LDS_USHORT_READ_RET
 581 ; R600-DAG: BFE_INT
 582 ; R600-DAG: BFE_INT
 583 ; SI-NOT: s_wqm_b64
 584 ; SI: s_mov_b32 m0
 585 ; SI: ds_read_i16
 586 ; SI: ds_read_i16
 587 define void @load_v2i16_sext_local(<2 x i32> addrspace(1)* %out, <2 x i16> addrspace(3)* %in) {
 588 entry:
 589   %0 = load <2 x i16>, <2 x i16> addrspace(3)* %in
 590   %1 = sext <2 x i16> %0 to <2 x i32>
 591   store <2 x i32> %1, <2 x i32> addrspace(1)* %out
 592   ret void
 593 }
 594
 595 ; FUNC-LABEL: {{^}}load_v4i16_local:
 596 ; R600: LDS_USHORT_READ_RET
 597 ; R600: LDS_USHORT_READ_RET
 598 ; R600: LDS_USHORT_READ_RET
 599 ; R600: LDS_USHORT_READ_RET
 600 ; SI-NOT: s_wqm_b64
 601 ; SI: s_mov_b32 m0
 602 ; SI: ds_read_u16
 603 ; SI: ds_read_u16
 604 ; SI: ds_read_u16
 605 ; SI: ds_read_u16
 606 define void @load_v4i16_local(<4 x i32> addrspace(1)* %out, <4 x i16> addrspace(3)* %in) {
 607 entry:
 608   %0 = load <4 x i16>, <4 x i16> addrspace(3)* %in
 609   %1 = zext <4 x i16> %0 to <4 x i32>
 610   store <4 x i32> %1, <4 x i32> addrspace(1)* %out
 611   ret void
 612 }
 613
 614 ; FUNC-LABEL: {{^}}load_v4i16_sext_local:
 615 ; R600-DAG: LDS_USHORT_READ_RET
 616 ; R600-DAG: LDS_USHORT_READ_RET
 617 ; R600-DAG: LDS_USHORT_READ_RET
 618 ; R600-DAG: LDS_USHORT_READ_RET
 619 ; R600-DAG: BFE_INT
 620 ; R600-DAG: BFE_INT
 621 ; R600-DAG: BFE_INT
 622 ; R600-DAG: BFE_INT
 623 ; SI-NOT: s_wqm_b64
 624 ; SI: s_mov_b32 m0
 625 ; SI: ds_read_i16
 626 ; SI: ds_read_i16
 627 ; SI: ds_read_i16
 628 ; SI: ds_read_i16
 629 define void @load_v4i16_sext_local(<4 x i32> addrspace(1)* %out, <4 x i16> addrspace(3)* %in) {
 630 entry:
 631   %0 = load <4 x i16>, <4 x i16> addrspace(3)* %in
 632   %1 = sext <4 x i16> %0 to <4 x i32>
 633   store <4 x i32> %1, <4 x i32> addrspace(1)* %out
 634   ret void
 635 }
 636
 637 ; load an i32 value from the local address space.
 638 ; FUNC-LABEL: {{^}}load_i32_local:
 639 ; R600: LDS_READ_RET
 640 ; SI-NOT: s_wqm_b64
 641 ; SI: s_mov_b32 m0
 642 ; SI: ds_read_b32
 643 define void @load_i32_local(i32 addrspace(1)* %out, i32 addrspace(3)* %in) {
 644 entry:
 645   %0 = load i32, i32 addrspace(3)* %in
 646   store i32 %0, i32 addrspace(1)* %out
 647   ret void
 648 }
 649
 650 ; load a f32 value from the local address space.
 651 ; FUNC-LABEL: {{^}}load_f32_local:
 652 ; R600: LDS_READ_RET
 653 ; SI: s_mov_b32 m0
 654 ; SI: ds_read_b32
 655 define void @load_f32_local(float addrspace(1)* %out, float addrspace(3)* %in) {
 656 entry:
 657   %0 = load float, float addrspace(3)* %in
 658   store float %0, float addrspace(1)* %out
 659   ret void
 660 }
 661
 662 ; load a v2f32 value from the local address space
 663 ; FUNC-LABEL: {{^}}load_v2f32_local:
 664 ; R600: LDS_READ_RET
 665 ; R600: LDS_READ_RET
 666 ; SI: s_mov_b32 m0
 667 ; SI: ds_read_b64
 668 define void @load_v2f32_local(<2 x float> addrspace(1)* %out, <2 x float> addrspace(3)* %in) {
 669 entry:
 670   %0 = load <2 x float>, <2 x float> addrspace(3)* %in
 671   store <2 x float> %0, <2 x float> addrspace(1)* %out
 672   ret void
 673 }
 674
 675 ; Test loading a i32 and v2i32 value from the same base pointer.
 676 ; FUNC-LABEL: {{^}}load_i32_v2i32_local:
 677 ; R600: LDS_READ_RET
 678 ; R600: LDS_READ_RET
 679 ; R600: LDS_READ_RET
 680 ; SI-DAG: ds_read_b32
 681 ; SI-DAG: ds_read2_b32
 682 define void @load_i32_v2i32_local(<2 x i32> addrspace(1)* %out, i32 addrspace(3)* %in) {
 683   %scalar = load i32, i32 addrspace(3)* %in
 684   %tmp0 = bitcast i32 addrspace(3)* %in to <2 x i32> addrspace(3)*
 685   %vec_ptr = getelementptr <2 x i32>, <2 x i32> addrspace(3)* %tmp0, i32 2
 686   %vec0 = load <2 x i32>, <2 x i32> addrspace(3)* %vec_ptr, align 4
 687   %vec1 = insertelement <2 x i32> <i32 0, i32 0>, i32 %scalar, i32 0
 688   %vec = add <2 x i32> %vec0, %vec1
 689   store <2 x i32> %vec, <2 x i32> addrspace(1)* %out
 690   ret void
 691 }
 692
 693
 694 @lds = addrspace(3) global [512 x i32] undef, align 4
 695
 696 ; On SI we need to make sure that the base offset is a register and not
 697 ; an immediate.
 698 ; FUNC-LABEL: {{^}}load_i32_local_const_ptr:
 699 ; SI: v_mov_b32_e32 v[[ZERO:[0-9]+]], 0
 700 ; SI: ds_read_b32 v0, v[[ZERO]] offset:4
 701 ; R600: LDS_READ_RET
 702 define void @load_i32_local_const_ptr(i32 addrspace(1)* %out, i32 addrspace(3)* %in) {
 703 entry:
 704   %tmp0 = getelementptr [512 x i32], [512 x i32] addrspace(3)* @lds, i32 0, i32 1
 705   %tmp1 = load i32, i32 addrspace(3)* %tmp0
 706   %tmp2 = getelementptr i32, i32 addrspace(1)* %out, i32 1
 707   store i32 %tmp1, i32 addrspace(1)* %tmp2
 708   ret void
 709 }