derek/TheRock
1
0 Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
1a182e2dac58879f215c0fad0f5f78c76dcafe56
TheRock/compiler/amd-llvm/llvm/test/CodeGen/SPIRV/hlsl-intrinsics/atan2_mat.ll
T
derek.holloway 7502bf64a4
CodeQL / Analyze (actions) (push) Canceled after 0s
Details
CodeQL / Analyze (python) (push) Canceled after 0s
Details
pre-commit / pre-commit (push) Canceled after 0s
Details
Multi-Arch CI / setup (push) Canceled after 0s
Details
Publish build_manylinux_x86_64 images / publish_build_manylinux_x86_64 (push) Canceled after 0s
Details
Setup (Multi-Arch) / setup (push) Canceled after 0s
Details
Multi-Arch CI / Linux::${{ fromJSON(needs.setup.outputs.linux_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Details
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Details
Publish no_rocm_image_ubi10 image / publish_no_rocm_image_ubi10 (push) Canceled after 0s
Details
Multi-Arch CI / Windows::${{ fromJSON(needs.setup.outputs.windows_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Details
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Details
Multi-Arch CI / Manifest Diff (push) Canceled after 0s
Details
TheRock Manifest Diff Report / Generate Manifest Diff Report (push) Canceled after 0s
Details
Multi-Arch CI / CI Summary (push) Canceled after 0s
Details
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04 (push) Canceled after 0s
Details
Publish no_rocm_image_ubuntu24_04_ocl_rt images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Details
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Details
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Details
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Details
Publish no_rocm_image_ubuntu24_04_rocgdb images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Details
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Details
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Details
Unit Tests / Unit Tests :: ubuntu-24.04 (push) Canceled after 0s
Details
Unit Tests / Unit Tests :: windows-2022 (push) Canceled after 0s
Details
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_media (push) Canceled after 0s
Details
Unit Tests / Unit Tests Summary (push) Canceled after 0s
Details
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_openmpi (push) Canceled after 0s
Details
Flatten subprojects into a single base monorepo
2026-09-02 16:34:47 -07:00

552 lines
33 KiB
LLVM
Raw Blame History

; RUN: llc -O0 -verify-machineinstrs -mtriple=spirv-unknown-vulkan %s -o - | FileCheck %s
; RUN: %if spirv-tools %{ llc -O0 -mtriple=spirv-unknown-vulkan %s -o - -filetype=obj | spirv-val %}
; Vulkan/Shader does not allow the Vector16 capability, so an MxN HLSL matrix
; is represented as [M x <N x float>] in LLVM IR and elementwise atan2 is
; computed per-row as M OpExtInst Atan2 calls on <N x float> (and similarly
; for half). Matrices with N=3 exercise the legalizer's handling of
; non-power-of-2 vector widths (legal for shader via allShaderFloatVectors).
; CHECK-NOT: OpCapability Vector16
; CHECK-DAG: %[[#op_ext_glsl:]] = OpExtInstImport "GLSL.std.450"
; CHECK-DAG: %[[#void:]] = OpTypeVoid
; CHECK-DAG: %[[#float_32:]] = OpTypeFloat 32
; CHECK-DAG: %[[#float_16:]] = OpTypeFloat 16
; CHECK-DAG: %[[#vec4_float_32:]] = OpTypeVector %[[#float_32]] 4
; CHECK-DAG: %[[#vec4_float_16:]] = OpTypeVector %[[#float_16]] 4
; CHECK-DAG: %[[#vec3_float_32:]] = OpTypeVector %[[#float_32]] 3
; CHECK-DAG: %[[#vec3_float_16:]] = OpTypeVector %[[#float_16]] 3
; CHECK-DAG: %[[#vec2_float_32:]] = OpTypeVector %[[#float_32]] 2
; CHECK-DAG: %[[#vec2_float_16:]] = OpTypeVector %[[#float_16]] 2
; CHECK-DAG: %[[#int_32:]] = OpTypeInt 32 0
; CHECK-DAG: %[[#const_0:]] = OpConstant %[[#int_32]] 0
; CHECK-DAG: %[[#const_1:]] = OpConstant %[[#int_32]] 1
; CHECK-DAG: %[[#const_2:]] = OpConstant %[[#int_32]] 2
; CHECK-DAG: %[[#const_3:]] = OpConstant %[[#int_32]] 3
; CHECK-DAG: %[[#const_4:]] = OpConstant %[[#int_32]] 4
; CHECK-DAG: %[[#arr_f32:]] = OpTypeArray %[[#vec4_float_32]] %[[#const_4]]
; CHECK-DAG: %[[#arr_f16:]] = OpTypeArray %[[#vec4_float_16]] %[[#const_4]]
; CHECK-DAG: %[[#arr3_f32:]] = OpTypeArray %[[#vec3_float_32]] %[[#const_3]]
; CHECK-DAG: %[[#arr3_f16:]] = OpTypeArray %[[#vec3_float_16]] %[[#const_3]]
; CHECK-DAG: %[[#ptr_arr_f32:]] = OpTypePointer Private %[[#arr_f32]]
; CHECK-DAG: %[[#ptr_arr_f16:]] = OpTypePointer Private %[[#arr_f16]]
; CHECK-DAG: %[[#ptr_arr3_f32:]] = OpTypePointer Private %[[#arr3_f32]]
; CHECK-DAG: %[[#ptr_arr3_f16:]] = OpTypePointer Private %[[#arr3_f16]]
; CHECK-DAG: %[[#ptr_vec4_f32:]] = OpTypePointer Private %[[#vec4_float_32]]
; CHECK-DAG: %[[#ptr_vec4_f16:]] = OpTypePointer Private %[[#vec4_float_16]]
; CHECK-DAG: %[[#ptr_vec3_f32:]] = OpTypePointer Private %[[#vec3_float_32]]
; CHECK-DAG: %[[#ptr_vec3_f16:]] = OpTypePointer Private %[[#vec3_float_16]]
; CHECK-DAG: %[[#fn_f32:]] = OpTypeFunction %[[#void]] %[[#ptr_arr_f32]] %[[#ptr_arr_f32]] %[[#ptr_arr_f32]]
; CHECK-DAG: %[[#fn_f16:]] = OpTypeFunction %[[#void]] %[[#ptr_arr_f16]] %[[#ptr_arr_f16]] %[[#ptr_arr_f16]]
; CHECK-DAG: %[[#fn3_f32:]] = OpTypeFunction %[[#void]] %[[#ptr_arr3_f32]] %[[#ptr_arr3_f32]] %[[#ptr_arr3_f32]]
; CHECK-DAG: %[[#fn3_f16:]] = OpTypeFunction %[[#void]] %[[#ptr_arr3_f16]] %[[#ptr_arr3_f16]] %[[#ptr_arr3_f16]]
define internal void @atan2_float4x4(ptr addrspace(10) %out, ptr addrspace(10) %a, ptr addrspace(10) %b) {
entry:
; CHECK: OpFunction %[[#void]] None %[[#fn_f32]]
; CHECK: %[[#out_f32:]] = OpFunctionParameter %[[#ptr_arr_f32]]
; CHECK: %[[#a_f32:]] = OpFunctionParameter %[[#ptr_arr_f32]]
; CHECK: %[[#b_f32:]] = OpFunctionParameter %[[#ptr_arr_f32]]
; CHECK: %[[#a0_ptr_f32:]] = OpAccessChain %[[#ptr_vec4_f32]] %[[#a_f32]] %[[#const_0]]
; CHECK: %[[#a1_ptr_f32:]] = OpAccessChain %[[#ptr_vec4_f32]] %[[#a_f32]] %[[#const_1]]
; CHECK: %[[#a2_ptr_f32:]] = OpAccessChain %[[#ptr_vec4_f32]] %[[#a_f32]] %[[#const_2]]
; CHECK: %[[#a3_ptr_f32:]] = OpAccessChain %[[#ptr_vec4_f32]] %[[#a_f32]] %[[#const_3]]
; CHECK: %[[#b0_ptr_f32:]] = OpAccessChain %[[#ptr_vec4_f32]] %[[#b_f32]] %[[#const_0]]
; CHECK: %[[#b1_ptr_f32:]] = OpAccessChain %[[#ptr_vec4_f32]] %[[#b_f32]] %[[#const_1]]
; CHECK: %[[#b2_ptr_f32:]] = OpAccessChain %[[#ptr_vec4_f32]] %[[#b_f32]] %[[#const_2]]
; CHECK: %[[#b3_ptr_f32:]] = OpAccessChain %[[#ptr_vec4_f32]] %[[#b_f32]] %[[#const_3]]
; CHECK: %[[#a0_f32:]] = OpLoad %[[#vec4_float_32]] %[[#a0_ptr_f32]]
; CHECK: %[[#a1_f32:]] = OpLoad %[[#vec4_float_32]] %[[#a1_ptr_f32]]
; CHECK: %[[#a2_f32:]] = OpLoad %[[#vec4_float_32]] %[[#a2_ptr_f32]]
; CHECK: %[[#a3_f32:]] = OpLoad %[[#vec4_float_32]] %[[#a3_ptr_f32]]
; CHECK: %[[#b0_f32:]] = OpLoad %[[#vec4_float_32]] %[[#b0_ptr_f32]]
; CHECK: %[[#b1_f32:]] = OpLoad %[[#vec4_float_32]] %[[#b1_ptr_f32]]
; CHECK: %[[#b2_f32:]] = OpLoad %[[#vec4_float_32]] %[[#b2_ptr_f32]]
; CHECK: %[[#b3_f32:]] = OpLoad %[[#vec4_float_32]] %[[#b3_ptr_f32]]
; CHECK: OpExtInst %[[#vec4_float_32]] %[[#op_ext_glsl]] Atan2 %[[#a0_f32]] %[[#b0_f32]]
; CHECK: OpExtInst %[[#vec4_float_32]] %[[#op_ext_glsl]] Atan2 %[[#a1_f32]] %[[#b1_f32]]
; CHECK: OpExtInst %[[#vec4_float_32]] %[[#op_ext_glsl]] Atan2 %[[#a2_f32]] %[[#b2_f32]]
; CHECK: OpExtInst %[[#vec4_float_32]] %[[#op_ext_glsl]] Atan2 %[[#a3_f32]] %[[#b3_f32]]
%a0 = getelementptr [4 x <4 x float>], ptr addrspace(10) %a, i32 0, i32 0
%a1 = getelementptr [4 x <4 x float>], ptr addrspace(10) %a, i32 0, i32 1
%a2 = getelementptr [4 x <4 x float>], ptr addrspace(10) %a, i32 0, i32 2
%a3 = getelementptr [4 x <4 x float>], ptr addrspace(10) %a, i32 0, i32 3
%b0 = getelementptr [4 x <4 x float>], ptr addrspace(10) %b, i32 0, i32 0
%b1 = getelementptr [4 x <4 x float>], ptr addrspace(10) %b, i32 0, i32 1
%b2 = getelementptr [4 x <4 x float>], ptr addrspace(10) %b, i32 0, i32 2
%b3 = getelementptr [4 x <4 x float>], ptr addrspace(10) %b, i32 0, i32 3
%va0 = load <4 x float>, ptr addrspace(10) %a0
%va1 = load <4 x float>, ptr addrspace(10) %a1
%va2 = load <4 x float>, ptr addrspace(10) %a2
%va3 = load <4 x float>, ptr addrspace(10) %a3
%vb0 = load <4 x float>, ptr addrspace(10) %b0
%vb1 = load <4 x float>, ptr addrspace(10) %b1
%vb2 = load <4 x float>, ptr addrspace(10) %b2
%vb3 = load <4 x float>, ptr addrspace(10) %b3
%r0 = call <4 x float> @llvm.atan2.v4f32(<4 x float> %va0, <4 x float> %vb0)
%r1 = call <4 x float> @llvm.atan2.v4f32(<4 x float> %va1, <4 x float> %vb1)
%r2 = call <4 x float> @llvm.atan2.v4f32(<4 x float> %va2, <4 x float> %vb2)
%r3 = call <4 x float> @llvm.atan2.v4f32(<4 x float> %va3, <4 x float> %vb3)
%out0 = getelementptr [4 x <4 x float>], ptr addrspace(10) %out, i32 0, i32 0
%out1 = getelementptr [4 x <4 x float>], ptr addrspace(10) %out, i32 0, i32 1
%out2 = getelementptr [4 x <4 x float>], ptr addrspace(10) %out, i32 0, i32 2
%out3 = getelementptr [4 x <4 x float>], ptr addrspace(10) %out, i32 0, i32 3
store <4 x float> %r0, ptr addrspace(10) %out0
store <4 x float> %r1, ptr addrspace(10) %out1
store <4 x float> %r2, ptr addrspace(10) %out2
store <4 x float> %r3, ptr addrspace(10) %out3
ret void
}
define internal void @atan2_half4x4(ptr addrspace(10) %out, ptr addrspace(10) %a, ptr addrspace(10) %b) {
entry:
; CHECK: OpFunction %[[#void]] None %[[#fn_f16]]
; CHECK: %[[#out_f16:]] = OpFunctionParameter %[[#ptr_arr_f16]]
; CHECK: %[[#a_f16:]] = OpFunctionParameter %[[#ptr_arr_f16]]
; CHECK: %[[#b_f16:]] = OpFunctionParameter %[[#ptr_arr_f16]]
; CHECK: %[[#a0_ptr_f16:]] = OpAccessChain %[[#ptr_vec4_f16]] %[[#a_f16]] %[[#const_0]]
; CHECK: %[[#a1_ptr_f16:]] = OpAccessChain %[[#ptr_vec4_f16]] %[[#a_f16]] %[[#const_1]]
; CHECK: %[[#a2_ptr_f16:]] = OpAccessChain %[[#ptr_vec4_f16]] %[[#a_f16]] %[[#const_2]]
; CHECK: %[[#a3_ptr_f16:]] = OpAccessChain %[[#ptr_vec4_f16]] %[[#a_f16]] %[[#const_3]]
; CHECK: %[[#b0_ptr_f16:]] = OpAccessChain %[[#ptr_vec4_f16]] %[[#b_f16]] %[[#const_0]]
; CHECK: %[[#b1_ptr_f16:]] = OpAccessChain %[[#ptr_vec4_f16]] %[[#b_f16]] %[[#const_1]]
; CHECK: %[[#b2_ptr_f16:]] = OpAccessChain %[[#ptr_vec4_f16]] %[[#b_f16]] %[[#const_2]]
; CHECK: %[[#b3_ptr_f16:]] = OpAccessChain %[[#ptr_vec4_f16]] %[[#b_f16]] %[[#const_3]]
; CHECK: %[[#a0_f16:]] = OpLoad %[[#vec4_float_16]] %[[#a0_ptr_f16]]
; CHECK: %[[#a1_f16:]] = OpLoad %[[#vec4_float_16]] %[[#a1_ptr_f16]]
; CHECK: %[[#a2_f16:]] = OpLoad %[[#vec4_float_16]] %[[#a2_ptr_f16]]
; CHECK: %[[#a3_f16:]] = OpLoad %[[#vec4_float_16]] %[[#a3_ptr_f16]]
; CHECK: %[[#b0_f16:]] = OpLoad %[[#vec4_float_16]] %[[#b0_ptr_f16]]
; CHECK: %[[#b1_f16:]] = OpLoad %[[#vec4_float_16]] %[[#b1_ptr_f16]]
; CHECK: %[[#b2_f16:]] = OpLoad %[[#vec4_float_16]] %[[#b2_ptr_f16]]
; CHECK: %[[#b3_f16:]] = OpLoad %[[#vec4_float_16]] %[[#b3_ptr_f16]]
; CHECK: OpExtInst %[[#vec4_float_16]] %[[#op_ext_glsl]] Atan2 %[[#a0_f16]] %[[#b0_f16]]
; CHECK: OpExtInst %[[#vec4_float_16]] %[[#op_ext_glsl]] Atan2 %[[#a1_f16]] %[[#b1_f16]]
; CHECK: OpExtInst %[[#vec4_float_16]] %[[#op_ext_glsl]] Atan2 %[[#a2_f16]] %[[#b2_f16]]
; CHECK: OpExtInst %[[#vec4_float_16]] %[[#op_ext_glsl]] Atan2 %[[#a3_f16]] %[[#b3_f16]]
%a0 = getelementptr [4 x <4 x half>], ptr addrspace(10) %a, i32 0, i32 0
%a1 = getelementptr [4 x <4 x half>], ptr addrspace(10) %a, i32 0, i32 1
%a2 = getelementptr [4 x <4 x half>], ptr addrspace(10) %a, i32 0, i32 2
%a3 = getelementptr [4 x <4 x half>], ptr addrspace(10) %a, i32 0, i32 3
%b0 = getelementptr [4 x <4 x half>], ptr addrspace(10) %b, i32 0, i32 0
%b1 = getelementptr [4 x <4 x half>], ptr addrspace(10) %b, i32 0, i32 1
%b2 = getelementptr [4 x <4 x half>], ptr addrspace(10) %b, i32 0, i32 2
%b3 = getelementptr [4 x <4 x half>], ptr addrspace(10) %b, i32 0, i32 3
%va0 = load <4 x half>, ptr addrspace(10) %a0
%va1 = load <4 x half>, ptr addrspace(10) %a1
%va2 = load <4 x half>, ptr addrspace(10) %a2
%va3 = load <4 x half>, ptr addrspace(10) %a3
%vb0 = load <4 x half>, ptr addrspace(10) %b0
%vb1 = load <4 x half>, ptr addrspace(10) %b1
%vb2 = load <4 x half>, ptr addrspace(10) %b2
%vb3 = load <4 x half>, ptr addrspace(10) %b3
%r0 = call <4 x half> @llvm.atan2.v4f16(<4 x half> %va0, <4 x half> %vb0)
%r1 = call <4 x half> @llvm.atan2.v4f16(<4 x half> %va1, <4 x half> %vb1)
%r2 = call <4 x half> @llvm.atan2.v4f16(<4 x half> %va2, <4 x half> %vb2)
%r3 = call <4 x half> @llvm.atan2.v4f16(<4 x half> %va3, <4 x half> %vb3)
%out0 = getelementptr [4 x <4 x half>], ptr addrspace(10) %out, i32 0, i32 0
%out1 = getelementptr [4 x <4 x half>], ptr addrspace(10) %out, i32 0, i32 1
%out2 = getelementptr [4 x <4 x half>], ptr addrspace(10) %out, i32 0, i32 2
%out3 = getelementptr [4 x <4 x half>], ptr addrspace(10) %out, i32 0, i32 3
store <4 x half> %r0, ptr addrspace(10) %out0
store <4 x half> %r1, ptr addrspace(10) %out1
store <4 x half> %r2, ptr addrspace(10) %out2
store <4 x half> %r3, ptr addrspace(10) %out3
ret void
}
define internal void @atan2_float3x3(ptr addrspace(10) %out, ptr addrspace(10) %a, ptr addrspace(10) %b) {
entry:
; CHECK: OpFunction %[[#void]] None %[[#fn3_f32]]
; CHECK: %[[#out3_f32:]] = OpFunctionParameter %[[#ptr_arr3_f32]]
; CHECK: %[[#a3v_f32:]] = OpFunctionParameter %[[#ptr_arr3_f32]]
; CHECK: %[[#b3v_f32:]] = OpFunctionParameter %[[#ptr_arr3_f32]]
; CHECK: %[[#a3v0_ptr_f32:]] = OpAccessChain %[[#ptr_vec3_f32]] %[[#a3v_f32]] %[[#const_0]]
; CHECK: %[[#a3v1_ptr_f32:]] = OpAccessChain %[[#ptr_vec3_f32]] %[[#a3v_f32]] %[[#const_1]]
; CHECK: %[[#a3v2_ptr_f32:]] = OpAccessChain %[[#ptr_vec3_f32]] %[[#a3v_f32]] %[[#const_2]]
; CHECK: %[[#b3v0_ptr_f32:]] = OpAccessChain %[[#ptr_vec3_f32]] %[[#b3v_f32]] %[[#const_0]]
; CHECK: %[[#b3v1_ptr_f32:]] = OpAccessChain %[[#ptr_vec3_f32]] %[[#b3v_f32]] %[[#const_1]]
; CHECK: %[[#b3v2_ptr_f32:]] = OpAccessChain %[[#ptr_vec3_f32]] %[[#b3v_f32]] %[[#const_2]]
; CHECK: %[[#a3v0_f32:]] = OpLoad %[[#vec3_float_32]] %[[#a3v0_ptr_f32]]
; CHECK: %[[#a3v1_f32:]] = OpLoad %[[#vec3_float_32]] %[[#a3v1_ptr_f32]]
; CHECK: %[[#a3v2_f32:]] = OpLoad %[[#vec3_float_32]] %[[#a3v2_ptr_f32]]
; CHECK: %[[#b3v0_f32:]] = OpLoad %[[#vec3_float_32]] %[[#b3v0_ptr_f32]]
; CHECK: %[[#b3v1_f32:]] = OpLoad %[[#vec3_float_32]] %[[#b3v1_ptr_f32]]
; CHECK: %[[#b3v2_f32:]] = OpLoad %[[#vec3_float_32]] %[[#b3v2_ptr_f32]]
; CHECK: OpExtInst %[[#vec3_float_32]] %[[#op_ext_glsl]] Atan2 %[[#a3v0_f32]] %[[#b3v0_f32]]
; CHECK: OpExtInst %[[#vec3_float_32]] %[[#op_ext_glsl]] Atan2 %[[#a3v1_f32]] %[[#b3v1_f32]]
; CHECK: OpExtInst %[[#vec3_float_32]] %[[#op_ext_glsl]] Atan2 %[[#a3v2_f32]] %[[#b3v2_f32]]
%a0 = getelementptr [3 x <3 x float>], ptr addrspace(10) %a, i32 0, i32 0
%a1 = getelementptr [3 x <3 x float>], ptr addrspace(10) %a, i32 0, i32 1
%a2 = getelementptr [3 x <3 x float>], ptr addrspace(10) %a, i32 0, i32 2
%b0 = getelementptr [3 x <3 x float>], ptr addrspace(10) %b, i32 0, i32 0
%b1 = getelementptr [3 x <3 x float>], ptr addrspace(10) %b, i32 0, i32 1
%b2 = getelementptr [3 x <3 x float>], ptr addrspace(10) %b, i32 0, i32 2
%va0 = load <3 x float>, ptr addrspace(10) %a0
%va1 = load <3 x float>, ptr addrspace(10) %a1
%va2 = load <3 x float>, ptr addrspace(10) %a2
%vb0 = load <3 x float>, ptr addrspace(10) %b0
%vb1 = load <3 x float>, ptr addrspace(10) %b1
%vb2 = load <3 x float>, ptr addrspace(10) %b2
%r0 = call <3 x float> @llvm.atan2.v3f32(<3 x float> %va0, <3 x float> %vb0)
%r1 = call <3 x float> @llvm.atan2.v3f32(<3 x float> %va1, <3 x float> %vb1)
%r2 = call <3 x float> @llvm.atan2.v3f32(<3 x float> %va2, <3 x float> %vb2)
%out0 = getelementptr [3 x <3 x float>], ptr addrspace(10) %out, i32 0, i32 0
%out1 = getelementptr [3 x <3 x float>], ptr addrspace(10) %out, i32 0, i32 1
%out2 = getelementptr [3 x <3 x float>], ptr addrspace(10) %out, i32 0, i32 2
store <3 x float> %r0, ptr addrspace(10) %out0
store <3 x float> %r1, ptr addrspace(10) %out1
store <3 x float> %r2, ptr addrspace(10) %out2
ret void
}
define internal void @atan2_half3x3(ptr addrspace(10) %out, ptr addrspace(10) %a, ptr addrspace(10) %b) {
entry:
; CHECK: OpFunction %[[#void]] None %[[#fn3_f16]]
; CHECK: %[[#out3_f16:]] = OpFunctionParameter %[[#ptr_arr3_f16]]
; CHECK: %[[#a3v_f16:]] = OpFunctionParameter %[[#ptr_arr3_f16]]
; CHECK: %[[#b3v_f16:]] = OpFunctionParameter %[[#ptr_arr3_f16]]
; CHECK: %[[#a3v0_ptr_f16:]] = OpAccessChain %[[#ptr_vec3_f16]] %[[#a3v_f16]] %[[#const_0]]
; CHECK: %[[#a3v1_ptr_f16:]] = OpAccessChain %[[#ptr_vec3_f16]] %[[#a3v_f16]] %[[#const_1]]
; CHECK: %[[#a3v2_ptr_f16:]] = OpAccessChain %[[#ptr_vec3_f16]] %[[#a3v_f16]] %[[#const_2]]
; CHECK: %[[#b3v0_ptr_f16:]] = OpAccessChain %[[#ptr_vec3_f16]] %[[#b3v_f16]] %[[#const_0]]
; CHECK: %[[#b3v1_ptr_f16:]] = OpAccessChain %[[#ptr_vec3_f16]] %[[#b3v_f16]] %[[#const_1]]
; CHECK: %[[#b3v2_ptr_f16:]] = OpAccessChain %[[#ptr_vec3_f16]] %[[#b3v_f16]] %[[#const_2]]
; CHECK: %[[#a3v0_f16:]] = OpLoad %[[#vec3_float_16]] %[[#a3v0_ptr_f16]]
; CHECK: %[[#a3v1_f16:]] = OpLoad %[[#vec3_float_16]] %[[#a3v1_ptr_f16]]
; CHECK: %[[#a3v2_f16:]] = OpLoad %[[#vec3_float_16]] %[[#a3v2_ptr_f16]]
; CHECK: %[[#b3v0_f16:]] = OpLoad %[[#vec3_float_16]] %[[#b3v0_ptr_f16]]
; CHECK: %[[#b3v1_f16:]] = OpLoad %[[#vec3_float_16]] %[[#b3v1_ptr_f16]]
; CHECK: %[[#b3v2_f16:]] = OpLoad %[[#vec3_float_16]] %[[#b3v2_ptr_f16]]
; CHECK: OpExtInst %[[#vec3_float_16]] %[[#op_ext_glsl]] Atan2 %[[#a3v0_f16]] %[[#b3v0_f16]]
; CHECK: OpExtInst %[[#vec3_float_16]] %[[#op_ext_glsl]] Atan2 %[[#a3v1_f16]] %[[#b3v1_f16]]
; CHECK: OpExtInst %[[#vec3_float_16]] %[[#op_ext_glsl]] Atan2 %[[#a3v2_f16]] %[[#b3v2_f16]]
%a0 = getelementptr [3 x <3 x half>], ptr addrspace(10) %a, i32 0, i32 0
%a1 = getelementptr [3 x <3 x half>], ptr addrspace(10) %a, i32 0, i32 1
%a2 = getelementptr [3 x <3 x half>], ptr addrspace(10) %a, i32 0, i32 2
%b0 = getelementptr [3 x <3 x half>], ptr addrspace(10) %b, i32 0, i32 0
%b1 = getelementptr [3 x <3 x half>], ptr addrspace(10) %b, i32 0, i32 1
%b2 = getelementptr [3 x <3 x half>], ptr addrspace(10) %b, i32 0, i32 2
%va0 = load <3 x half>, ptr addrspace(10) %a0
%va1 = load <3 x half>, ptr addrspace(10) %a1
%va2 = load <3 x half>, ptr addrspace(10) %a2
%vb0 = load <3 x half>, ptr addrspace(10) %b0
%vb1 = load <3 x half>, ptr addrspace(10) %b1
%vb2 = load <3 x half>, ptr addrspace(10) %b2
%r0 = call <3 x half> @llvm.atan2.v3f16(<3 x half> %va0, <3 x half> %vb0)
%r1 = call <3 x half> @llvm.atan2.v3f16(<3 x half> %va1, <3 x half> %vb1)
%r2 = call <3 x half> @llvm.atan2.v3f16(<3 x half> %va2, <3 x half> %vb2)
%out0 = getelementptr [3 x <3 x half>], ptr addrspace(10) %out, i32 0, i32 0
%out1 = getelementptr [3 x <3 x half>], ptr addrspace(10) %out, i32 0, i32 1
%out2 = getelementptr [3 x <3 x half>], ptr addrspace(10) %out, i32 0, i32 2
store <3 x half> %r0, ptr addrspace(10) %out0
store <3 x half> %r1, ptr addrspace(10) %out1
store <3 x half> %r2, ptr addrspace(10) %out2
ret void
}
define internal void @atan2_float2x2(ptr addrspace(10) %out, ptr addrspace(10) %a, ptr addrspace(10) %b) {
entry:
; CHECK: OpFunction %[[#void]] None
; CHECK-COUNT-2: OpExtInst %[[#vec2_float_32]] %[[#op_ext_glsl]] Atan2
%a0 = getelementptr [2 x <2 x float>], ptr addrspace(10) %a, i32 0, i32 0
%a1 = getelementptr [2 x <2 x float>], ptr addrspace(10) %a, i32 0, i32 1
%b0 = getelementptr [2 x <2 x float>], ptr addrspace(10) %b, i32 0, i32 0
%b1 = getelementptr [2 x <2 x float>], ptr addrspace(10) %b, i32 0, i32 1
%va0 = load <2 x float>, ptr addrspace(10) %a0
%va1 = load <2 x float>, ptr addrspace(10) %a1
%vb0 = load <2 x float>, ptr addrspace(10) %b0
%vb1 = load <2 x float>, ptr addrspace(10) %b1
%r0 = call <2 x float> @llvm.atan2.v2f32(<2 x float> %va0, <2 x float> %vb0)
%r1 = call <2 x float> @llvm.atan2.v2f32(<2 x float> %va1, <2 x float> %vb1)
%out0 = getelementptr [2 x <2 x float>], ptr addrspace(10) %out, i32 0, i32 0
%out1 = getelementptr [2 x <2 x float>], ptr addrspace(10) %out, i32 0, i32 1
store <2 x float> %r0, ptr addrspace(10) %out0
store <2 x float> %r1, ptr addrspace(10) %out1
ret void
}
define internal void @atan2_half2x2(ptr addrspace(10) %out, ptr addrspace(10) %a, ptr addrspace(10) %b) {
entry:
; CHECK: OpFunction %[[#void]] None
; CHECK-COUNT-2: OpExtInst %[[#vec2_float_16]] %[[#op_ext_glsl]] Atan2
%a0 = getelementptr [2 x <2 x half>], ptr addrspace(10) %a, i32 0, i32 0
%a1 = getelementptr [2 x <2 x half>], ptr addrspace(10) %a, i32 0, i32 1
%b0 = getelementptr [2 x <2 x half>], ptr addrspace(10) %b, i32 0, i32 0
%b1 = getelementptr [2 x <2 x half>], ptr addrspace(10) %b, i32 0, i32 1
%va0 = load <2 x half>, ptr addrspace(10) %a0
%va1 = load <2 x half>, ptr addrspace(10) %a1
%vb0 = load <2 x half>, ptr addrspace(10) %b0
%vb1 = load <2 x half>, ptr addrspace(10) %b1
%r0 = call <2 x half> @llvm.atan2.v2f16(<2 x half> %va0, <2 x half> %vb0)
%r1 = call <2 x half> @llvm.atan2.v2f16(<2 x half> %va1, <2 x half> %vb1)
%out0 = getelementptr [2 x <2 x half>], ptr addrspace(10) %out, i32 0, i32 0
%out1 = getelementptr [2 x <2 x half>], ptr addrspace(10) %out, i32 0, i32 1
store <2 x half> %r0, ptr addrspace(10) %out0
store <2 x half> %r1, ptr addrspace(10) %out1
ret void
}
; 2x3: 2 rows of <3 x float> — non-power-of-2 vector width.
define internal void @atan2_float2x3(ptr addrspace(10) %out, ptr addrspace(10) %a, ptr addrspace(10) %b) {
entry:
; CHECK: OpFunction %[[#void]] None
; CHECK-COUNT-2: OpExtInst %[[#vec3_float_32]] %[[#op_ext_glsl]] Atan2
%a0 = getelementptr [2 x <3 x float>], ptr addrspace(10) %a, i32 0, i32 0
%a1 = getelementptr [2 x <3 x float>], ptr addrspace(10) %a, i32 0, i32 1
%b0 = getelementptr [2 x <3 x float>], ptr addrspace(10) %b, i32 0, i32 0
%b1 = getelementptr [2 x <3 x float>], ptr addrspace(10) %b, i32 0, i32 1
%va0 = load <3 x float>, ptr addrspace(10) %a0
%va1 = load <3 x float>, ptr addrspace(10) %a1
%vb0 = load <3 x float>, ptr addrspace(10) %b0
%vb1 = load <3 x float>, ptr addrspace(10) %b1
%r0 = call <3 x float> @llvm.atan2.v3f32(<3 x float> %va0, <3 x float> %vb0)
%r1 = call <3 x float> @llvm.atan2.v3f32(<3 x float> %va1, <3 x float> %vb1)
%out0 = getelementptr [2 x <3 x float>], ptr addrspace(10) %out, i32 0, i32 0
%out1 = getelementptr [2 x <3 x float>], ptr addrspace(10) %out, i32 0, i32 1
store <3 x float> %r0, ptr addrspace(10) %out0
store <3 x float> %r1, ptr addrspace(10) %out1
ret void
}
define internal void @atan2_half2x3(ptr addrspace(10) %out, ptr addrspace(10) %a, ptr addrspace(10) %b) {
entry:
; CHECK: OpFunction %[[#void]] None
; CHECK-COUNT-2: OpExtInst %[[#vec3_float_16]] %[[#op_ext_glsl]] Atan2
%a0 = getelementptr [2 x <3 x half>], ptr addrspace(10) %a, i32 0, i32 0
%a1 = getelementptr [2 x <3 x half>], ptr addrspace(10) %a, i32 0, i32 1
%b0 = getelementptr [2 x <3 x half>], ptr addrspace(10) %b, i32 0, i32 0
%b1 = getelementptr [2 x <3 x half>], ptr addrspace(10) %b, i32 0, i32 1
%va0 = load <3 x half>, ptr addrspace(10) %a0
%va1 = load <3 x half>, ptr addrspace(10) %a1
%vb0 = load <3 x half>, ptr addrspace(10) %b0
%vb1 = load <3 x half>, ptr addrspace(10) %b1
%r0 = call <3 x half> @llvm.atan2.v3f16(<3 x half> %va0, <3 x half> %vb0)
%r1 = call <3 x half> @llvm.atan2.v3f16(<3 x half> %va1, <3 x half> %vb1)
%out0 = getelementptr [2 x <3 x half>], ptr addrspace(10) %out, i32 0, i32 0
%out1 = getelementptr [2 x <3 x half>], ptr addrspace(10) %out, i32 0, i32 1
store <3 x half> %r0, ptr addrspace(10) %out0
store <3 x half> %r1, ptr addrspace(10) %out1
ret void
}
define internal void @atan2_float3x2(ptr addrspace(10) %out, ptr addrspace(10) %a, ptr addrspace(10) %b) {
entry:
; CHECK: OpFunction %[[#void]] None
; CHECK-COUNT-3: OpExtInst %[[#vec2_float_32]] %[[#op_ext_glsl]] Atan2
%a0 = getelementptr [3 x <2 x float>], ptr addrspace(10) %a, i32 0, i32 0
%a1 = getelementptr [3 x <2 x float>], ptr addrspace(10) %a, i32 0, i32 1
%a2 = getelementptr [3 x <2 x float>], ptr addrspace(10) %a, i32 0, i32 2
%b0 = getelementptr [3 x <2 x float>], ptr addrspace(10) %b, i32 0, i32 0
%b1 = getelementptr [3 x <2 x float>], ptr addrspace(10) %b, i32 0, i32 1
%b2 = getelementptr [3 x <2 x float>], ptr addrspace(10) %b, i32 0, i32 2
%va0 = load <2 x float>, ptr addrspace(10) %a0
%va1 = load <2 x float>, ptr addrspace(10) %a1
%va2 = load <2 x float>, ptr addrspace(10) %a2
%vb0 = load <2 x float>, ptr addrspace(10) %b0
%vb1 = load <2 x float>, ptr addrspace(10) %b1
%vb2 = load <2 x float>, ptr addrspace(10) %b2
%r0 = call <2 x float> @llvm.atan2.v2f32(<2 x float> %va0, <2 x float> %vb0)
%r1 = call <2 x float> @llvm.atan2.v2f32(<2 x float> %va1, <2 x float> %vb1)
%r2 = call <2 x float> @llvm.atan2.v2f32(<2 x float> %va2, <2 x float> %vb2)
%out0 = getelementptr [3 x <2 x float>], ptr addrspace(10) %out, i32 0, i32 0
%out1 = getelementptr [3 x <2 x float>], ptr addrspace(10) %out, i32 0, i32 1
%out2 = getelementptr [3 x <2 x float>], ptr addrspace(10) %out, i32 0, i32 2
store <2 x float> %r0, ptr addrspace(10) %out0
store <2 x float> %r1, ptr addrspace(10) %out1
store <2 x float> %r2, ptr addrspace(10) %out2
ret void
}
define internal void @atan2_float2x4(ptr addrspace(10) %out, ptr addrspace(10) %a, ptr addrspace(10) %b) {
entry:
; CHECK: OpFunction %[[#void]] None
; CHECK-COUNT-2: OpExtInst %[[#vec4_float_32]] %[[#op_ext_glsl]] Atan2
%a0 = getelementptr [2 x <4 x float>], ptr addrspace(10) %a, i32 0, i32 0
%a1 = getelementptr [2 x <4 x float>], ptr addrspace(10) %a, i32 0, i32 1
%b0 = getelementptr [2 x <4 x float>], ptr addrspace(10) %b, i32 0, i32 0
%b1 = getelementptr [2 x <4 x float>], ptr addrspace(10) %b, i32 0, i32 1
%va0 = load <4 x float>, ptr addrspace(10) %a0
%va1 = load <4 x float>, ptr addrspace(10) %a1
%vb0 = load <4 x float>, ptr addrspace(10) %b0
%vb1 = load <4 x float>, ptr addrspace(10) %b1
%r0 = call <4 x float> @llvm.atan2.v4f32(<4 x float> %va0, <4 x float> %vb0)
%r1 = call <4 x float> @llvm.atan2.v4f32(<4 x float> %va1, <4 x float> %vb1)
%out0 = getelementptr [2 x <4 x float>], ptr addrspace(10) %out, i32 0, i32 0
%out1 = getelementptr [2 x <4 x float>], ptr addrspace(10) %out, i32 0, i32 1
store <4 x float> %r0, ptr addrspace(10) %out0
store <4 x float> %r1, ptr addrspace(10) %out1
ret void
}
define internal void @atan2_float4x2(ptr addrspace(10) %out, ptr addrspace(10) %a, ptr addrspace(10) %b) {
entry:
; CHECK: OpFunction %[[#void]] None
; CHECK-COUNT-4: OpExtInst %[[#vec2_float_32]] %[[#op_ext_glsl]] Atan2
%a0 = getelementptr [4 x <2 x float>], ptr addrspace(10) %a, i32 0, i32 0
%a1 = getelementptr [4 x <2 x float>], ptr addrspace(10) %a, i32 0, i32 1
%a2 = getelementptr [4 x <2 x float>], ptr addrspace(10) %a, i32 0, i32 2
%a3 = getelementptr [4 x <2 x float>], ptr addrspace(10) %a, i32 0, i32 3
%b0 = getelementptr [4 x <2 x float>], ptr addrspace(10) %b, i32 0, i32 0
%b1 = getelementptr [4 x <2 x float>], ptr addrspace(10) %b, i32 0, i32 1
%b2 = getelementptr [4 x <2 x float>], ptr addrspace(10) %b, i32 0, i32 2
%b3 = getelementptr [4 x <2 x float>], ptr addrspace(10) %b, i32 0, i32 3
%va0 = load <2 x float>, ptr addrspace(10) %a0
%va1 = load <2 x float>, ptr addrspace(10) %a1
%va2 = load <2 x float>, ptr addrspace(10) %a2
%va3 = load <2 x float>, ptr addrspace(10) %a3
%vb0 = load <2 x float>, ptr addrspace(10) %b0
%vb1 = load <2 x float>, ptr addrspace(10) %b1
%vb2 = load <2 x float>, ptr addrspace(10) %b2
%vb3 = load <2 x float>, ptr addrspace(10) %b3
%r0 = call <2 x float> @llvm.atan2.v2f32(<2 x float> %va0, <2 x float> %vb0)
%r1 = call <2 x float> @llvm.atan2.v2f32(<2 x float> %va1, <2 x float> %vb1)
%r2 = call <2 x float> @llvm.atan2.v2f32(<2 x float> %va2, <2 x float> %vb2)
%r3 = call <2 x float> @llvm.atan2.v2f32(<2 x float> %va3, <2 x float> %vb3)
%out0 = getelementptr [4 x <2 x float>], ptr addrspace(10) %out, i32 0, i32 0
%out1 = getelementptr [4 x <2 x float>], ptr addrspace(10) %out, i32 0, i32 1
%out2 = getelementptr [4 x <2 x float>], ptr addrspace(10) %out, i32 0, i32 2
%out3 = getelementptr [4 x <2 x float>], ptr addrspace(10) %out, i32 0, i32 3
store <2 x float> %r0, ptr addrspace(10) %out0
store <2 x float> %r1, ptr addrspace(10) %out1
store <2 x float> %r2, ptr addrspace(10) %out2
store <2 x float> %r3, ptr addrspace(10) %out3
ret void
}
; 3x4: 3 rows of <4 x float>.
define internal void @atan2_float3x4(ptr addrspace(10) %out, ptr addrspace(10) %a, ptr addrspace(10) %b) {
entry:
; CHECK: OpFunction %[[#void]] None
; CHECK-COUNT-3: OpExtInst %[[#vec4_float_32]] %[[#op_ext_glsl]] Atan2
%a0 = getelementptr [3 x <4 x float>], ptr addrspace(10) %a, i32 0, i32 0
%a1 = getelementptr [3 x <4 x float>], ptr addrspace(10) %a, i32 0, i32 1
%a2 = getelementptr [3 x <4 x float>], ptr addrspace(10) %a, i32 0, i32 2
%b0 = getelementptr [3 x <4 x float>], ptr addrspace(10) %b, i32 0, i32 0
%b1 = getelementptr [3 x <4 x float>], ptr addrspace(10) %b, i32 0, i32 1
%b2 = getelementptr [3 x <4 x float>], ptr addrspace(10) %b, i32 0, i32 2
%va0 = load <4 x float>, ptr addrspace(10) %a0
%va1 = load <4 x float>, ptr addrspace(10) %a1
%va2 = load <4 x float>, ptr addrspace(10) %a2
%vb0 = load <4 x float>, ptr addrspace(10) %b0
%vb1 = load <4 x float>, ptr addrspace(10) %b1
%vb2 = load <4 x float>, ptr addrspace(10) %b2
%r0 = call <4 x float> @llvm.atan2.v4f32(<4 x float> %va0, <4 x float> %vb0)
%r1 = call <4 x float> @llvm.atan2.v4f32(<4 x float> %va1, <4 x float> %vb1)
%r2 = call <4 x float> @llvm.atan2.v4f32(<4 x float> %va2, <4 x float> %vb2)
%out0 = getelementptr [3 x <4 x float>], ptr addrspace(10) %out, i32 0, i32 0
%out1 = getelementptr [3 x <4 x float>], ptr addrspace(10) %out, i32 0, i32 1
%out2 = getelementptr [3 x <4 x float>], ptr addrspace(10) %out, i32 0, i32 2
store <4 x float> %r0, ptr addrspace(10) %out0
store <4 x float> %r1, ptr addrspace(10) %out1
store <4 x float> %r2, ptr addrspace(10) %out2
ret void
}
define internal void @atan2_half3x4(ptr addrspace(10) %out, ptr addrspace(10) %a, ptr addrspace(10) %b) {
entry:
; CHECK: OpFunction %[[#void]] None
; CHECK-COUNT-3: OpExtInst %[[#vec4_float_16]] %[[#op_ext_glsl]] Atan2
%a0 = getelementptr [3 x <4 x half>], ptr addrspace(10) %a, i32 0, i32 0
%a1 = getelementptr [3 x <4 x half>], ptr addrspace(10) %a, i32 0, i32 1
%a2 = getelementptr [3 x <4 x half>], ptr addrspace(10) %a, i32 0, i32 2
%b0 = getelementptr [3 x <4 x half>], ptr addrspace(10) %b, i32 0, i32 0
%b1 = getelementptr [3 x <4 x half>], ptr addrspace(10) %b, i32 0, i32 1
%b2 = getelementptr [3 x <4 x half>], ptr addrspace(10) %b, i32 0, i32 2
%va0 = load <4 x half>, ptr addrspace(10) %a0
%va1 = load <4 x half>, ptr addrspace(10) %a1
%va2 = load <4 x half>, ptr addrspace(10) %a2
%vb0 = load <4 x half>, ptr addrspace(10) %b0
%vb1 = load <4 x half>, ptr addrspace(10) %b1
%vb2 = load <4 x half>, ptr addrspace(10) %b2
%r0 = call <4 x half> @llvm.atan2.v4f16(<4 x half> %va0, <4 x half> %vb0)
%r1 = call <4 x half> @llvm.atan2.v4f16(<4 x half> %va1, <4 x half> %vb1)
%r2 = call <4 x half> @llvm.atan2.v4f16(<4 x half> %va2, <4 x half> %vb2)
%out0 = getelementptr [3 x <4 x half>], ptr addrspace(10) %out, i32 0, i32 0
%out1 = getelementptr [3 x <4 x half>], ptr addrspace(10) %out, i32 0, i32 1
%out2 = getelementptr [3 x <4 x half>], ptr addrspace(10) %out, i32 0, i32 2
store <4 x half> %r0, ptr addrspace(10) %out0
store <4 x half> %r1, ptr addrspace(10) %out1
store <4 x half> %r2, ptr addrspace(10) %out2
ret void
}
; 4x3: 4 rows of <3 x float> — non-power-of-2 vector width.
define internal void @atan2_float4x3(ptr addrspace(10) %out, ptr addrspace(10) %a, ptr addrspace(10) %b) {
entry:
; CHECK: OpFunction %[[#void]] None
; CHECK-COUNT-4: OpExtInst %[[#vec3_float_32]] %[[#op_ext_glsl]] Atan2
%a0 = getelementptr [4 x <3 x float>], ptr addrspace(10) %a, i32 0, i32 0
%a1 = getelementptr [4 x <3 x float>], ptr addrspace(10) %a, i32 0, i32 1
%a2 = getelementptr [4 x <3 x float>], ptr addrspace(10) %a, i32 0, i32 2
%a3 = getelementptr [4 x <3 x float>], ptr addrspace(10) %a, i32 0, i32 3
%b0 = getelementptr [4 x <3 x float>], ptr addrspace(10) %b, i32 0, i32 0
%b1 = getelementptr [4 x <3 x float>], ptr addrspace(10) %b, i32 0, i32 1
%b2 = getelementptr [4 x <3 x float>], ptr addrspace(10) %b, i32 0, i32 2
%b3 = getelementptr [4 x <3 x float>], ptr addrspace(10) %b, i32 0, i32 3
%va0 = load <3 x float>, ptr addrspace(10) %a0
%va1 = load <3 x float>, ptr addrspace(10) %a1
%va2 = load <3 x float>, ptr addrspace(10) %a2
%va3 = load <3 x float>, ptr addrspace(10) %a3
%vb0 = load <3 x float>, ptr addrspace(10) %b0
%vb1 = load <3 x float>, ptr addrspace(10) %b1
%vb2 = load <3 x float>, ptr addrspace(10) %b2
%vb3 = load <3 x float>, ptr addrspace(10) %b3
%r0 = call <3 x float> @llvm.atan2.v3f32(<3 x float> %va0, <3 x float> %vb0)
%r1 = call <3 x float> @llvm.atan2.v3f32(<3 x float> %va1, <3 x float> %vb1)
%r2 = call <3 x float> @llvm.atan2.v3f32(<3 x float> %va2, <3 x float> %vb2)
%r3 = call <3 x float> @llvm.atan2.v3f32(<3 x float> %va3, <3 x float> %vb3)
%out0 = getelementptr [4 x <3 x float>], ptr addrspace(10) %out, i32 0, i32 0
%out1 = getelementptr [4 x <3 x float>], ptr addrspace(10) %out, i32 0, i32 1
%out2 = getelementptr [4 x <3 x float>], ptr addrspace(10) %out, i32 0, i32 2
%out3 = getelementptr [4 x <3 x float>], ptr addrspace(10) %out, i32 0, i32 3
store <3 x float> %r0, ptr addrspace(10) %out0
store <3 x float> %r1, ptr addrspace(10) %out1
store <3 x float> %r2, ptr addrspace(10) %out2
store <3 x float> %r3, ptr addrspace(10) %out3
ret void
}
define internal void @atan2_half4x3(ptr addrspace(10) %out, ptr addrspace(10) %a, ptr addrspace(10) %b) {
entry:
; CHECK: OpFunction %[[#void]] None
; CHECK-COUNT-4: OpExtInst %[[#vec3_float_16]] %[[#op_ext_glsl]] Atan2
%a0 = getelementptr [4 x <3 x half>], ptr addrspace(10) %a, i32 0, i32 0
%a1 = getelementptr [4 x <3 x half>], ptr addrspace(10) %a, i32 0, i32 1
%a2 = getelementptr [4 x <3 x half>], ptr addrspace(10) %a, i32 0, i32 2
%a3 = getelementptr [4 x <3 x half>], ptr addrspace(10) %a, i32 0, i32 3
%b0 = getelementptr [4 x <3 x half>], ptr addrspace(10) %b, i32 0, i32 0
%b1 = getelementptr [4 x <3 x half>], ptr addrspace(10) %b, i32 0, i32 1
%b2 = getelementptr [4 x <3 x half>], ptr addrspace(10) %b, i32 0, i32 2
%b3 = getelementptr [4 x <3 x half>], ptr addrspace(10) %b, i32 0, i32 3
%va0 = load <3 x half>, ptr addrspace(10) %a0
%va1 = load <3 x half>, ptr addrspace(10) %a1
%va2 = load <3 x half>, ptr addrspace(10) %a2
%va3 = load <3 x half>, ptr addrspace(10) %a3
%vb0 = load <3 x half>, ptr addrspace(10) %b0
%vb1 = load <3 x half>, ptr addrspace(10) %b1
%vb2 = load <3 x half>, ptr addrspace(10) %b2
%vb3 = load <3 x half>, ptr addrspace(10) %b3
%r0 = call <3 x half> @llvm.atan2.v3f16(<3 x half> %va0, <3 x half> %vb0)
%r1 = call <3 x half> @llvm.atan2.v3f16(<3 x half> %va1, <3 x half> %vb1)
%r2 = call <3 x half> @llvm.atan2.v3f16(<3 x half> %va2, <3 x half> %vb2)
%r3 = call <3 x half> @llvm.atan2.v3f16(<3 x half> %va3, <3 x half> %vb3)
%out0 = getelementptr [4 x <3 x half>], ptr addrspace(10) %out, i32 0, i32 0
%out1 = getelementptr [4 x <3 x half>], ptr addrspace(10) %out, i32 0, i32 1
%out2 = getelementptr [4 x <3 x half>], ptr addrspace(10) %out, i32 0, i32 2
%out3 = getelementptr [4 x <3 x half>], ptr addrspace(10) %out, i32 0, i32 3
store <3 x half> %r0, ptr addrspace(10) %out0
store <3 x half> %r1, ptr addrspace(10) %out1
store <3 x half> %r2, ptr addrspace(10) %out2
store <3 x half> %r3, ptr addrspace(10) %out3
ret void
}
declare <4 x float> @llvm.atan2.v4f32(<4 x float>, <4 x float>)
declare <4 x half> @llvm.atan2.v4f16(<4 x half>, <4 x half>)
declare <3 x float> @llvm.atan2.v3f32(<3 x float>, <3 x float>)
declare <3 x half> @llvm.atan2.v3f16(<3 x half>, <3 x half>)
declare <2 x float> @llvm.atan2.v2f32(<2 x float>, <2 x float>)
declare <2 x half> @llvm.atan2.v2f16(<2 x half>, <2 x half>)
Reference in new issue View Git Blame Copy Permalink