5496267025
fixes https://github.com/llvm/llvm-project/issues/177838 - Replaced assert(TargetTypeSize == SourceTypeSize) with a conditional: when sizes differ, compute a BitcastType with the target's element type but sized to match the source's total bitwidth - Instead of unconditionally returning after bitcast, only return early if BitcastType == TargetType (same-size case), otherwise fall through to the shuffle logic - Updated the final assert to use AssignValue->getType() since that may now be the intermediate type rather than SourceType
97 lines
6.4 KiB
LLVM
97 lines
6.4 KiB
LLVM
; RUN: llc -verify-machineinstrs -O0 -mtriple=spirv-unknown-vulkan-compute %s -o - | FileCheck %s --match-full-lines
|
|
; RUN: %if spirv-tools %{ llc -O0 -mtriple=spirv-unknown-vulkan %s -o - -filetype=obj | spirv-val %}
|
|
|
|
; CHECK-DAG: %[[#float:]] = OpTypeFloat 32
|
|
; CHECK-DAG: %[[#uint:]] = OpTypeInt 32 0
|
|
; CHECK-DAG: %[[#v2_uint:]] = OpTypeVector %[[#uint]] 2
|
|
; CHECK-DAG: %[[#double:]] = OpTypeFloat 64
|
|
; CHECK-DAG: %[[#v2_double:]] = OpTypeVector %[[#double]] 2
|
|
; CHECK-DAG: %[[#v4_float:]] = OpTypeVector %[[#float]] 4
|
|
; CHECK-DAG: %[[#v4_uint:]] = OpTypeVector %[[#uint]] 4
|
|
; CHECK-DAG: %[[#ulong:]] = OpTypeInt 64 0
|
|
; CHECK-DAG: %[[#v2_ulong:]] = OpTypeVector %[[#ulong]] 2
|
|
; CHECK-DAG: %[[#v3_uint:]] = OpTypeVector %[[#uint]] 3
|
|
@.str = private unnamed_addr constant [3 x i8] c"In\00", align 1
|
|
@.str.2 = private unnamed_addr constant [4 x i8] c"Out\00", align 1
|
|
|
|
define void @main() local_unnamed_addr #0 {
|
|
entry:
|
|
%in_buffer_handle = tail call target("spirv.VulkanBuffer", [0 x <2 x i32>], 12, 0) @llvm.spv.resource.handlefrombinding(i32 0, i32 0, i32 1, i32 0, ptr nonnull @.str)
|
|
%out_buffer_handle = tail call target("spirv.VulkanBuffer", [0 x <2 x double>], 12, 1) @llvm.spv.resource.handlefrombinding(i32 0, i32 2, i32 1, i32 0, ptr nonnull @.str.2)
|
|
%src0_ptr = tail call noundef align 8 dereferenceable(8) ptr addrspace(11) @llvm.spv.resource.getpointer(target("spirv.VulkanBuffer", [0 x <2 x i32>], 12, 0) %in_buffer_handle, i32 0)
|
|
%src0 = load <2 x i32>, ptr addrspace(11) %src0_ptr, align 8
|
|
%src1_ptr = tail call noundef align 8 dereferenceable(8) ptr addrspace(11) @llvm.spv.resource.getpointer(target("spirv.VulkanBuffer", [0 x <2 x i32>], 12, 0) %in_buffer_handle, i32 1)
|
|
%src1 = load <2 x i32>, ptr addrspace(11) %src1_ptr, align 8
|
|
; CHECK: %[[#tmp:]] = OpVectorShuffle %[[#v4_uint]] {{%[0-9]+}} {{%[0-9]+}} 0 2 1 3
|
|
%shuffled = shufflevector <2 x i32> %src0, <2 x i32> %src1, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
|
|
; CHECK: %[[#access:]] = OpAccessChain {{.*}}
|
|
%dst_ptr = tail call noundef align 16 dereferenceable(16) ptr addrspace(11) @llvm.spv.resource.getpointer(target("spirv.VulkanBuffer", [0 x <2 x double>], 12, 1) %out_buffer_handle, i32 0)
|
|
; CHECK: %[[#bitcast:]] = OpBitcast %[[#v2_double]] %[[#tmp]]
|
|
; CHECK: OpStore %[[#access]] %[[#bitcast]]
|
|
store <4 x i32> %shuffled, ptr addrspace(11) %dst_ptr, align 16
|
|
ret void
|
|
}
|
|
|
|
; This tests a load from a pointer that has been bitcast between vector types
|
|
; which share the same total bit-width but have different numbers of elements.
|
|
; Tests that legalize-pointer-casts works correctly by moving the bitcast to
|
|
; the element that was loaded.
|
|
|
|
define void @main2() local_unnamed_addr #0 {
|
|
entry:
|
|
; CHECK: %[[LOAD:[0-9]+]] = OpLoad %[[#v2_double]] {{.*}}
|
|
; CHECK: %[[BITCAST1:[0-9]+]] = OpBitcast %[[#v4_uint]] %[[LOAD]]
|
|
; CHECK: %[[BITCAST2:[0-9]+]] = OpBitcast %[[#v2_double]] %[[BITCAST1]]
|
|
; CHECK: OpStore {{%[0-9]+}} %[[BITCAST2]] {{.*}}
|
|
|
|
%out_buffer_handle = tail call target("spirv.VulkanBuffer", [0 x <2 x double>], 12, 1) @llvm.spv.resource.handlefrombinding(i32 0, i32 2, i32 1, i32 0, ptr nonnull @.str.2)
|
|
%src_ptr = tail call noundef align 16 dereferenceable(16) ptr addrspace(11) @llvm.spv.resource.getpointer(target("spirv.VulkanBuffer", [0 x <2 x double>], 12, 1) %out_buffer_handle, i32 0)
|
|
%loaded_v4i32 = load <4 x i32>, ptr addrspace(11) %src_ptr
|
|
%dst_ptr = tail call noundef align 16 dereferenceable(16) ptr addrspace(11) @llvm.spv.resource.getpointer(target("spirv.VulkanBuffer", [0 x <2 x double>], 12, 1) %out_buffer_handle, i32 1)
|
|
store <4 x i32> %loaded_v4i32, ptr addrspace(11) %dst_ptr
|
|
ret void
|
|
}
|
|
|
|
@.str.3 = private unnamed_addr constant [4 x i8] c"In2\00", align 1
|
|
@.str.4 = private unnamed_addr constant [5 x i8] c"Out2\00", align 1
|
|
|
|
define void @main3() local_unnamed_addr #0 {
|
|
entry:
|
|
; CHECK: %[[LOAD3:[0-9]+]] = OpLoad %[[#v4_float]] {{.*}}
|
|
; CHECK-NEXT: %[[BITCAST3:[0-9]+]] = OpBitcast %[[#v4_uint]] %[[LOAD3]]
|
|
; CHECK-NEXT: %[[SHUFFLE3:[0-9]+]] = OpVectorShuffle %[[#v2_uint]] %[[BITCAST3]] %[[BITCAST3]] 0 1
|
|
; CHECK: OpStore {{%[0-9]+}} %[[SHUFFLE3]] {{.*}}
|
|
|
|
%in_buffer_handle = tail call target("spirv.VulkanBuffer", [0 x <4 x float>], 12, 0) @llvm.spv.resource.handlefrombinding(i32 1, i32 0, i32 1, i32 0, ptr nonnull @.str.3)
|
|
%out_buffer_handle = tail call target("spirv.VulkanBuffer", [0 x <2 x i32>], 12, 0) @llvm.spv.resource.handlefrombinding(i32 1, i32 1, i32 1, i32 0, ptr nonnull @.str.4)
|
|
%src_ptr = tail call noundef align 16 dereferenceable(16) ptr addrspace(11) @llvm.spv.resource.getpointer(target("spirv.VulkanBuffer", [0 x <4 x float>], 12, 0) %in_buffer_handle, i32 0)
|
|
%loaded_v2i32 = load <2 x i32>, ptr addrspace(11) %src_ptr, align 16
|
|
%dst_ptr = tail call noundef align 8 dereferenceable(8) ptr addrspace(11) @llvm.spv.resource.getpointer(target("spirv.VulkanBuffer", [0 x <2 x i32>], 12, 0) %out_buffer_handle, i32 0)
|
|
store <2 x i32> %loaded_v2i32, ptr addrspace(11) %dst_ptr, align 8
|
|
ret void
|
|
}
|
|
|
|
; Tests loading a vector where the source total bit width is not evenly
|
|
; divisible by the target element bit width.
|
|
|
|
@.str.in = private unnamed_addr constant [4 x i8] c"In3\00", align 1
|
|
@.str.out = private unnamed_addr constant [5 x i8] c"Out3\00", align 1
|
|
|
|
define void @main4() local_unnamed_addr #0 {
|
|
entry:
|
|
; CHECK: %[[LOAD:[0-9]+]] = OpLoad %[[#v3_uint]] {{.*}}
|
|
; CHECK-NEXT: %[[SHUFFLE:[0-9]+]] = OpVectorShuffle %[[#v4_uint]] %[[LOAD]] %[[LOAD]] 0 1 2 0xFFFFFFFF{{.*}}
|
|
; CHECK-NEXT: %[[BITCAST:[0-9]+]] = OpBitcast %[[#v2_ulong]] %[[SHUFFLE]]{{.*}}
|
|
; CHECK: OpStore {{%[0-9]+}} %[[BITCAST]] {{.*}}
|
|
|
|
%in_buffer_handle = tail call target("spirv.VulkanBuffer", [0 x <3 x i32>], 12, 0) @llvm.spv.resource.handlefrombinding(i32 0, i32 0, i32 1, i32 0, ptr nonnull @.str.in)
|
|
%out_buffer_handle = tail call target("spirv.VulkanBuffer", [0 x <2 x i64>], 12, 0) @llvm.spv.resource.handlefrombinding(i32 0, i32 1, i32 1, i32 0, ptr nonnull @.str.out)
|
|
%src_ptr = tail call noundef align 16 dereferenceable(12) ptr addrspace(11) @llvm.spv.resource.getpointer(target("spirv.VulkanBuffer", [0 x <3 x i32>], 12, 0) %in_buffer_handle, i32 0)
|
|
%loaded_v2i64 = load <2 x i64>, ptr addrspace(11) %src_ptr, align 16
|
|
%dst_ptr = tail call noundef align 8 dereferenceable(8) ptr addrspace(11) @llvm.spv.resource.getpointer(target("spirv.VulkanBuffer", [0 x <2 x i64>], 12, 0) %out_buffer_handle, i32 0)
|
|
store <2 x i64> %loaded_v2i64, ptr addrspace(11) %dst_ptr, align 8
|
|
ret void
|
|
}
|
|
|
|
attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" }
|