shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
llvm-project/llvm/test/CodeGen/NVPTX/i16x2-instructions.ll

1053 lines
37 KiB
LLVM
Raw Blame History

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 5
; ## Support i16x2 instructions
; RUN: llc < %s -mtriple=nvptx64-nvidia-cuda -mcpu=sm_90 -mattr=+ptx80 \
; RUN: -O0 -disable-post-ra -frame-pointer=all -verify-machineinstrs \
; RUN: | FileCheck -allow-deprecated-dag-overlap -check-prefixes COMMON,I16x2 %s
; RUN: %if ptxas %{ \
; RUN: llc < %s -mtriple=nvptx64-nvidia-cuda -mcpu=sm_90 \
; RUN: -O0 -disable-post-ra -frame-pointer=all -verify-machineinstrs \
; RUN: | %ptxas-verify -arch=sm_90 \
; RUN: %}
; ## No support for i16x2 instructions
; RUN: llc < %s -mtriple=nvptx64-nvidia-cuda -mcpu=sm_53 \
; RUN: -O0 -disable-post-ra -frame-pointer=all -verify-machineinstrs \
; RUN: | FileCheck -allow-deprecated-dag-overlap -check-prefixes COMMON,NO-I16x2 %s
; RUN: %if ptxas %{ \
; RUN: llc < %s -mtriple=nvptx64-nvidia-cuda -mcpu=sm_53 \
; RUN: -O0 -disable-post-ra -frame-pointer=all -verify-machineinstrs \
; RUN: | %ptxas-verify -arch=sm_53 \
; RUN: %}
target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
define <2 x i16> @test_ret_const() #0 {
; COMMON-LABEL: test_ret_const(
; COMMON: {
; COMMON-EMPTY:
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: st.param.b32 [func_retval0], 131073;
; COMMON-NEXT: ret;
ret <2 x i16> <i16 1, i16 2>
}
define i16 @test_extract_0(<2 x i16> %a) #0 {
; I16x2-LABEL: test_extract_0(
; I16x2: {
; I16x2-NEXT: .reg .b16 %rs<2>;
; I16x2-NEXT: .reg .b32 %r<3>;
; I16x2-EMPTY:
; I16x2-NEXT: // %bb.0:
; I16x2-NEXT: ld.param.b32 %r1, [test_extract_0_param_0];
; I16x2-NEXT: mov.b32 {%rs1, _}, %r1;
; I16x2-NEXT: cvt.u32.u16 %r2, %rs1;
; I16x2-NEXT: st.param.b32 [func_retval0], %r2;
; I16x2-NEXT: ret;
;
; NO-I16x2-LABEL: test_extract_0(
; NO-I16x2: {
; NO-I16x2-NEXT: .reg .b16 %rs<2>;
; NO-I16x2-NEXT: .reg .b32 %r<3>;
; NO-I16x2-EMPTY:
; NO-I16x2-NEXT: // %bb.0:
; NO-I16x2-NEXT: ld.param.b32 %r1, [test_extract_0_param_0];
; NO-I16x2-NEXT: { .reg .b16 tmp; mov.b32 {%rs1, tmp}, %r1; }
; NO-I16x2-NEXT: cvt.u32.u16 %r2, %rs1;
; NO-I16x2-NEXT: st.param.b32 [func_retval0], %r2;
; NO-I16x2-NEXT: ret;
%e = extractelement <2 x i16> %a, i32 0
ret i16 %e
}
define i16 @test_extract_1(<2 x i16> %a) #0 {
; I16x2-LABEL: test_extract_1(
; I16x2: {
; I16x2-NEXT: .reg .b16 %rs<2>;
; I16x2-NEXT: .reg .b32 %r<3>;
; I16x2-EMPTY:
; I16x2-NEXT: // %bb.0:
; I16x2-NEXT: ld.param.b32 %r1, [test_extract_1_param_0];
; I16x2-NEXT: mov.b32 {_, %rs1}, %r1;
; I16x2-NEXT: cvt.u32.u16 %r2, %rs1;
; I16x2-NEXT: st.param.b32 [func_retval0], %r2;
; I16x2-NEXT: ret;
;
; NO-I16x2-LABEL: test_extract_1(
; NO-I16x2: {
; NO-I16x2-NEXT: .reg .b16 %rs<2>;
; NO-I16x2-NEXT: .reg .b32 %r<3>;
; NO-I16x2-EMPTY:
; NO-I16x2-NEXT: // %bb.0:
; NO-I16x2-NEXT: ld.param.b32 %r1, [test_extract_1_param_0];
; NO-I16x2-NEXT: { .reg .b16 tmp; mov.b32 {tmp, %rs1}, %r1; }
; NO-I16x2-NEXT: cvt.u32.u16 %r2, %rs1;
; NO-I16x2-NEXT: st.param.b32 [func_retval0], %r2;
; NO-I16x2-NEXT: ret;
%e = extractelement <2 x i16> %a, i32 1
ret i16 %e
}
define i16 @test_extract_i(<2 x i16> %a, i64 %idx) #0 {
; COMMON-LABEL: test_extract_i(
; COMMON: {
; COMMON-NEXT: .reg .pred %p<2>;
; COMMON-NEXT: .reg .b16 %rs<4>;
; COMMON-NEXT: .reg .b32 %r<3>;
; COMMON-NEXT: .reg .b64 %rd<2>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b64 %rd1, [test_extract_i_param_1];
; COMMON-NEXT: ld.param.b32 %r1, [test_extract_i_param_0];
; COMMON-NEXT: setp.eq.b64 %p1, %rd1, 0;
; COMMON-NEXT: mov.b32 {%rs1, %rs2}, %r1;
; COMMON-NEXT: selp.b16 %rs3, %rs1, %rs2, %p1;
; COMMON-NEXT: cvt.u32.u16 %r2, %rs3;
; COMMON-NEXT: st.param.b32 [func_retval0], %r2;
; COMMON-NEXT: ret;
%e = extractelement <2 x i16> %a, i64 %idx
ret i16 %e
}
define <2 x i16> @test_add(<2 x i16> %a, <2 x i16> %b) #0 {
; I16x2-LABEL: test_add(
; I16x2: {
; I16x2-NEXT: .reg .b32 %r<4>;
; I16x2-EMPTY:
; I16x2-NEXT: // %bb.0:
; I16x2-NEXT: ld.param.b32 %r2, [test_add_param_1];
; I16x2-NEXT: ld.param.b32 %r1, [test_add_param_0];
; I16x2-NEXT: add.s16x2 %r3, %r1, %r2;
; I16x2-NEXT: st.param.b32 [func_retval0], %r3;
; I16x2-NEXT: ret;
;
; NO-I16x2-LABEL: test_add(
; NO-I16x2: {
; NO-I16x2-NEXT: .reg .b16 %rs<7>;
; NO-I16x2-NEXT: .reg .b32 %r<3>;
; NO-I16x2-EMPTY:
; NO-I16x2-NEXT: // %bb.0:
; NO-I16x2-NEXT: ld.param.b32 %r2, [test_add_param_1];
; NO-I16x2-NEXT: ld.param.b32 %r1, [test_add_param_0];
; NO-I16x2-NEXT: mov.b32 {%rs1, %rs2}, %r2;
; NO-I16x2-NEXT: mov.b32 {%rs3, %rs4}, %r1;
; NO-I16x2-NEXT: add.s16 %rs5, %rs4, %rs2;
; NO-I16x2-NEXT: add.s16 %rs6, %rs3, %rs1;
; NO-I16x2-NEXT: st.param.v2.b16 [func_retval0], {%rs6, %rs5};
; NO-I16x2-NEXT: ret;
%r = add <2 x i16> %a, %b
ret <2 x i16> %r
}
; Check that we can lower add with immediate arguments.
define <2 x i16> @test_add_imm_0(<2 x i16> %a) #0 {
; I16x2-LABEL: test_add_imm_0(
; I16x2: {
; I16x2-NEXT: .reg .b32 %r<4>;
; I16x2-EMPTY:
; I16x2-NEXT: // %bb.0:
; I16x2-NEXT: ld.param.b32 %r1, [test_add_imm_0_param_0];
; I16x2-NEXT: mov.b32 %r2, 131073;
; I16x2-NEXT: add.s16x2 %r3, %r1, %r2;
; I16x2-NEXT: st.param.b32 [func_retval0], %r3;
; I16x2-NEXT: ret;
;
; NO-I16x2-LABEL: test_add_imm_0(
; NO-I16x2: {
; NO-I16x2-NEXT: .reg .b16 %rs<5>;
; NO-I16x2-NEXT: .reg .b32 %r<2>;
; NO-I16x2-EMPTY:
; NO-I16x2-NEXT: // %bb.0:
; NO-I16x2-NEXT: ld.param.b32 %r1, [test_add_imm_0_param_0];
; NO-I16x2-NEXT: mov.b32 {%rs1, %rs2}, %r1;
; NO-I16x2-NEXT: add.s16 %rs3, %rs2, 2;
; NO-I16x2-NEXT: add.s16 %rs4, %rs1, 1;
; NO-I16x2-NEXT: st.param.v2.b16 [func_retval0], {%rs4, %rs3};
; NO-I16x2-NEXT: ret;
%r = add <2 x i16> <i16 1, i16 2>, %a
ret <2 x i16> %r
}
define <2 x i16> @test_add_imm_1(<2 x i16> %a) #0 {
; I16x2-LABEL: test_add_imm_1(
; I16x2: {
; I16x2-NEXT: .reg .b32 %r<4>;
; I16x2-EMPTY:
; I16x2-NEXT: // %bb.0:
; I16x2-NEXT: ld.param.b32 %r1, [test_add_imm_1_param_0];
; I16x2-NEXT: mov.b32 %r2, 131073;
; I16x2-NEXT: add.s16x2 %r3, %r1, %r2;
; I16x2-NEXT: st.param.b32 [func_retval0], %r3;
; I16x2-NEXT: ret;
;
; NO-I16x2-LABEL: test_add_imm_1(
; NO-I16x2: {
; NO-I16x2-NEXT: .reg .b16 %rs<5>;
; NO-I16x2-NEXT: .reg .b32 %r<2>;
; NO-I16x2-EMPTY:
; NO-I16x2-NEXT: // %bb.0:
; NO-I16x2-NEXT: ld.param.b32 %r1, [test_add_imm_1_param_0];
; NO-I16x2-NEXT: mov.b32 {%rs1, %rs2}, %r1;
; NO-I16x2-NEXT: add.s16 %rs3, %rs2, 2;
; NO-I16x2-NEXT: add.s16 %rs4, %rs1, 1;
; NO-I16x2-NEXT: st.param.v2.b16 [func_retval0], {%rs4, %rs3};
; NO-I16x2-NEXT: ret;
%r = add <2 x i16> %a, <i16 1, i16 2>
ret <2 x i16> %r
}
define <2 x i16> @test_sub(<2 x i16> %a, <2 x i16> %b) #0 {
; COMMON-LABEL: test_sub(
; COMMON: {
; COMMON-NEXT: .reg .b16 %rs<7>;
; COMMON-NEXT: .reg .b32 %r<3>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r2, [test_sub_param_1];
; COMMON-NEXT: ld.param.b32 %r1, [test_sub_param_0];
; COMMON-NEXT: mov.b32 {%rs1, %rs2}, %r2;
; COMMON-NEXT: mov.b32 {%rs3, %rs4}, %r1;
; COMMON-NEXT: sub.s16 %rs5, %rs4, %rs2;
; COMMON-NEXT: sub.s16 %rs6, %rs3, %rs1;
; COMMON-NEXT: st.param.v2.b16 [func_retval0], {%rs6, %rs5};
; COMMON-NEXT: ret;
%r = sub <2 x i16> %a, %b
ret <2 x i16> %r
}
define <2 x i16> @test_smax(<2 x i16> %a, <2 x i16> %b) #0 {
; I16x2-LABEL: test_smax(
; I16x2: {
; I16x2-NEXT: .reg .b32 %r<4>;
; I16x2-EMPTY:
; I16x2-NEXT: // %bb.0:
; I16x2-NEXT: ld.param.b32 %r2, [test_smax_param_1];
; I16x2-NEXT: ld.param.b32 %r1, [test_smax_param_0];
; I16x2-NEXT: max.s16x2 %r3, %r1, %r2;
; I16x2-NEXT: st.param.b32 [func_retval0], %r3;
; I16x2-NEXT: ret;
;
; NO-I16x2-LABEL: test_smax(
; NO-I16x2: {
; NO-I16x2-NEXT: .reg .b16 %rs<7>;
; NO-I16x2-NEXT: .reg .b32 %r<3>;
; NO-I16x2-EMPTY:
; NO-I16x2-NEXT: // %bb.0:
; NO-I16x2-NEXT: ld.param.b32 %r2, [test_smax_param_1];
; NO-I16x2-NEXT: ld.param.b32 %r1, [test_smax_param_0];
; NO-I16x2-NEXT: mov.b32 {%rs1, %rs2}, %r2;
; NO-I16x2-NEXT: mov.b32 {%rs3, %rs4}, %r1;
; NO-I16x2-NEXT: max.s16 %rs5, %rs4, %rs2;
; NO-I16x2-NEXT: max.s16 %rs6, %rs3, %rs1;
; NO-I16x2-NEXT: st.param.v2.b16 [func_retval0], {%rs6, %rs5};
; NO-I16x2-NEXT: ret;
%cmp = icmp sgt <2 x i16> %a, %b
%r = select <2 x i1> %cmp, <2 x i16> %a, <2 x i16> %b
ret <2 x i16> %r
}
define <2 x i16> @test_umax(<2 x i16> %a, <2 x i16> %b) #0 {
; I16x2-LABEL: test_umax(
; I16x2: {
; I16x2-NEXT: .reg .b32 %r<4>;
; I16x2-EMPTY:
; I16x2-NEXT: // %bb.0:
; I16x2-NEXT: ld.param.b32 %r2, [test_umax_param_1];
; I16x2-NEXT: ld.param.b32 %r1, [test_umax_param_0];
; I16x2-NEXT: max.u16x2 %r3, %r1, %r2;
; I16x2-NEXT: st.param.b32 [func_retval0], %r3;
; I16x2-NEXT: ret;
;
; NO-I16x2-LABEL: test_umax(
; NO-I16x2: {
; NO-I16x2-NEXT: .reg .b16 %rs<7>;
; NO-I16x2-NEXT: .reg .b32 %r<3>;
; NO-I16x2-EMPTY:
; NO-I16x2-NEXT: // %bb.0:
; NO-I16x2-NEXT: ld.param.b32 %r2, [test_umax_param_1];
; NO-I16x2-NEXT: ld.param.b32 %r1, [test_umax_param_0];
; NO-I16x2-NEXT: mov.b32 {%rs1, %rs2}, %r2;
; NO-I16x2-NEXT: mov.b32 {%rs3, %rs4}, %r1;
; NO-I16x2-NEXT: max.u16 %rs5, %rs4, %rs2;
; NO-I16x2-NEXT: max.u16 %rs6, %rs3, %rs1;
; NO-I16x2-NEXT: st.param.v2.b16 [func_retval0], {%rs6, %rs5};
; NO-I16x2-NEXT: ret;
%cmp = icmp ugt <2 x i16> %a, %b
%r = select <2 x i1> %cmp, <2 x i16> %a, <2 x i16> %b
ret <2 x i16> %r
}
define <2 x i16> @test_smin(<2 x i16> %a, <2 x i16> %b) #0 {
; I16x2-LABEL: test_smin(
; I16x2: {
; I16x2-NEXT: .reg .b32 %r<4>;
; I16x2-EMPTY:
; I16x2-NEXT: // %bb.0:
; I16x2-NEXT: ld.param.b32 %r2, [test_smin_param_1];
; I16x2-NEXT: ld.param.b32 %r1, [test_smin_param_0];
; I16x2-NEXT: min.s16x2 %r3, %r1, %r2;
; I16x2-NEXT: st.param.b32 [func_retval0], %r3;
; I16x2-NEXT: ret;
;
; NO-I16x2-LABEL: test_smin(
; NO-I16x2: {
; NO-I16x2-NEXT: .reg .b16 %rs<7>;
; NO-I16x2-NEXT: .reg .b32 %r<3>;
; NO-I16x2-EMPTY:
; NO-I16x2-NEXT: // %bb.0:
; NO-I16x2-NEXT: ld.param.b32 %r2, [test_smin_param_1];
; NO-I16x2-NEXT: ld.param.b32 %r1, [test_smin_param_0];
; NO-I16x2-NEXT: mov.b32 {%rs1, %rs2}, %r2;
; NO-I16x2-NEXT: mov.b32 {%rs3, %rs4}, %r1;
; NO-I16x2-NEXT: min.s16 %rs5, %rs4, %rs2;
; NO-I16x2-NEXT: min.s16 %rs6, %rs3, %rs1;
; NO-I16x2-NEXT: st.param.v2.b16 [func_retval0], {%rs6, %rs5};
; NO-I16x2-NEXT: ret;
%cmp = icmp sle <2 x i16> %a, %b
%r = select <2 x i1> %cmp, <2 x i16> %a, <2 x i16> %b
ret <2 x i16> %r
}
define <2 x i16> @test_umin(<2 x i16> %a, <2 x i16> %b) #0 {
; I16x2-LABEL: test_umin(
; I16x2: {
; I16x2-NEXT: .reg .b32 %r<4>;
; I16x2-EMPTY:
; I16x2-NEXT: // %bb.0:
; I16x2-NEXT: ld.param.b32 %r2, [test_umin_param_1];
; I16x2-NEXT: ld.param.b32 %r1, [test_umin_param_0];
; I16x2-NEXT: min.u16x2 %r3, %r1, %r2;
; I16x2-NEXT: st.param.b32 [func_retval0], %r3;
; I16x2-NEXT: ret;
;
; NO-I16x2-LABEL: test_umin(
; NO-I16x2: {
; NO-I16x2-NEXT: .reg .b16 %rs<7>;
; NO-I16x2-NEXT: .reg .b32 %r<3>;
; NO-I16x2-EMPTY:
; NO-I16x2-NEXT: // %bb.0:
; NO-I16x2-NEXT: ld.param.b32 %r2, [test_umin_param_1];
; NO-I16x2-NEXT: ld.param.b32 %r1, [test_umin_param_0];
; NO-I16x2-NEXT: mov.b32 {%rs1, %rs2}, %r2;
; NO-I16x2-NEXT: mov.b32 {%rs3, %rs4}, %r1;
; NO-I16x2-NEXT: min.u16 %rs5, %rs4, %rs2;
; NO-I16x2-NEXT: min.u16 %rs6, %rs3, %rs1;
; NO-I16x2-NEXT: st.param.v2.b16 [func_retval0], {%rs6, %rs5};
; NO-I16x2-NEXT: ret;
%cmp = icmp ule <2 x i16> %a, %b
%r = select <2 x i1> %cmp, <2 x i16> %a, <2 x i16> %b
ret <2 x i16> %r
}
define <2 x i16> @test_mul(<2 x i16> %a, <2 x i16> %b) #0 {
; COMMON-LABEL: test_mul(
; COMMON: {
; COMMON-NEXT: .reg .b16 %rs<7>;
; COMMON-NEXT: .reg .b32 %r<3>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r2, [test_mul_param_1];
; COMMON-NEXT: ld.param.b32 %r1, [test_mul_param_0];
; COMMON-NEXT: mov.b32 {%rs1, %rs2}, %r2;
; COMMON-NEXT: mov.b32 {%rs3, %rs4}, %r1;
; COMMON-NEXT: mul.lo.s16 %rs5, %rs4, %rs2;
; COMMON-NEXT: mul.lo.s16 %rs6, %rs3, %rs1;
; COMMON-NEXT: st.param.v2.b16 [func_retval0], {%rs6, %rs5};
; COMMON-NEXT: ret;
%r = mul <2 x i16> %a, %b
ret <2 x i16> %r
}
;; Logical ops are available on all GPUs as regular 32-bit logical ops
define <2 x i16> @test_or(<2 x i16> %a, <2 x i16> %b) #0 {
; COMMON-LABEL: test_or(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<4>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r2, [test_or_param_1];
; COMMON-NEXT: ld.param.b32 %r1, [test_or_param_0];
; COMMON-NEXT: or.b32 %r3, %r1, %r2;
; COMMON-NEXT: st.param.b32 [func_retval0], %r3;
; COMMON-NEXT: ret;
%r = or <2 x i16> %a, %b
ret <2 x i16> %r
}
; Ops that operate on computed arguments go though a different lowering path.
; compared to the ones that operate on loaded data. So we test them separately.
define <2 x i16> @test_or_computed(i16 %a) {
; COMMON-LABEL: test_or_computed(
; COMMON: {
; COMMON-NEXT: .reg .b16 %rs<4>;
; COMMON-NEXT: .reg .b32 %r<4>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b16 %rs1, [test_or_computed_param_0];
; COMMON-NEXT: mov.b16 %rs2, 0;
; COMMON-NEXT: mov.b32 %r1, {%rs1, %rs2};
; COMMON-NEXT: mov.b16 %rs3, 5;
; COMMON-NEXT: mov.b32 %r2, {%rs1, %rs3};
; COMMON-NEXT: or.b32 %r3, %r2, %r1;
; COMMON-NEXT: st.param.b32 [func_retval0], %r3;
; COMMON-NEXT: ret;
%ins.0 = insertelement <2 x i16> zeroinitializer, i16 %a, i32 0
%ins.1 = insertelement <2 x i16> %ins.0, i16 5, i32 1
%r = or <2 x i16> %ins.1, %ins.0
ret <2 x i16> %r
}
; Check that we can lower or with immediate arguments.
define <2 x i16> @test_or_imm_0(<2 x i16> %a) #0 {
; COMMON-LABEL: test_or_imm_0(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<3>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r1, [test_or_imm_0_param_0];
; COMMON-NEXT: or.b32 %r2, %r1, 131073;
; COMMON-NEXT: st.param.b32 [func_retval0], %r2;
; COMMON-NEXT: ret;
%r = or <2 x i16> <i16 1, i16 2>, %a
ret <2 x i16> %r
}
define <2 x i16> @test_or_imm_1(<2 x i16> %a) #0 {
; COMMON-LABEL: test_or_imm_1(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<3>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r1, [test_or_imm_1_param_0];
; COMMON-NEXT: or.b32 %r2, %r1, 131073;
; COMMON-NEXT: st.param.b32 [func_retval0], %r2;
; COMMON-NEXT: ret;
%r = or <2 x i16> %a, <i16 1, i16 2>
ret <2 x i16> %r
}
define <2 x i16> @test_xor(<2 x i16> %a, <2 x i16> %b) #0 {
; COMMON-LABEL: test_xor(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<4>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r2, [test_xor_param_1];
; COMMON-NEXT: ld.param.b32 %r1, [test_xor_param_0];
; COMMON-NEXT: xor.b32 %r3, %r1, %r2;
; COMMON-NEXT: st.param.b32 [func_retval0], %r3;
; COMMON-NEXT: ret;
%r = xor <2 x i16> %a, %b
ret <2 x i16> %r
}
define <2 x i16> @test_xor_computed(i16 %a) {
; COMMON-LABEL: test_xor_computed(
; COMMON: {
; COMMON-NEXT: .reg .b16 %rs<4>;
; COMMON-NEXT: .reg .b32 %r<4>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b16 %rs1, [test_xor_computed_param_0];
; COMMON-NEXT: mov.b16 %rs2, 0;
; COMMON-NEXT: mov.b32 %r1, {%rs1, %rs2};
; COMMON-NEXT: mov.b16 %rs3, 5;
; COMMON-NEXT: mov.b32 %r2, {%rs1, %rs3};
; COMMON-NEXT: xor.b32 %r3, %r2, %r1;
; COMMON-NEXT: st.param.b32 [func_retval0], %r3;
; COMMON-NEXT: ret;
%ins.0 = insertelement <2 x i16> zeroinitializer, i16 %a, i32 0
%ins.1 = insertelement <2 x i16> %ins.0, i16 5, i32 1
%r = xor <2 x i16> %ins.1, %ins.0
ret <2 x i16> %r
}
; Check that we can lower xor with immediate arguments.
define <2 x i16> @test_xor_imm_0(<2 x i16> %a) #0 {
; COMMON-LABEL: test_xor_imm_0(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<3>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r1, [test_xor_imm_0_param_0];
; COMMON-NEXT: xor.b32 %r2, %r1, 131073;
; COMMON-NEXT: st.param.b32 [func_retval0], %r2;
; COMMON-NEXT: ret;
%r = xor <2 x i16> <i16 1, i16 2>, %a
ret <2 x i16> %r
}
define <2 x i16> @test_xor_imm_1(<2 x i16> %a) #0 {
; COMMON-LABEL: test_xor_imm_1(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<3>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r1, [test_xor_imm_1_param_0];
; COMMON-NEXT: xor.b32 %r2, %r1, 131073;
; COMMON-NEXT: st.param.b32 [func_retval0], %r2;
; COMMON-NEXT: ret;
%r = xor <2 x i16> %a, <i16 1, i16 2>
ret <2 x i16> %r
}
define <2 x i16> @test_and(<2 x i16> %a, <2 x i16> %b) #0 {
; COMMON-LABEL: test_and(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<4>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r2, [test_and_param_1];
; COMMON-NEXT: ld.param.b32 %r1, [test_and_param_0];
; COMMON-NEXT: and.b32 %r3, %r1, %r2;
; COMMON-NEXT: st.param.b32 [func_retval0], %r3;
; COMMON-NEXT: ret;
%r = and <2 x i16> %a, %b
ret <2 x i16> %r
}
; Ops that operate on computed arguments go though a different lowering path.
; compared to the ones that operate on loaded data. So we test them separately.
define <2 x i16> @test_and_computed(i16 %a) {
; COMMON-LABEL: test_and_computed(
; COMMON: {
; COMMON-NEXT: .reg .b16 %rs<4>;
; COMMON-NEXT: .reg .b32 %r<4>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b16 %rs1, [test_and_computed_param_0];
; COMMON-NEXT: mov.b16 %rs2, 0;
; COMMON-NEXT: mov.b32 %r1, {%rs1, %rs2};
; COMMON-NEXT: mov.b16 %rs3, 5;
; COMMON-NEXT: mov.b32 %r2, {%rs1, %rs3};
; COMMON-NEXT: and.b32 %r3, %r2, %r1;
; COMMON-NEXT: st.param.b32 [func_retval0], %r3;
; COMMON-NEXT: ret;
%ins.0 = insertelement <2 x i16> zeroinitializer, i16 %a, i32 0
%ins.1 = insertelement <2 x i16> %ins.0, i16 5, i32 1
%r = and <2 x i16> %ins.1, %ins.0
ret <2 x i16> %r
}
; Check that we can lower and with immediate arguments.
define <2 x i16> @test_and_imm_0(<2 x i16> %a) #0 {
; COMMON-LABEL: test_and_imm_0(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<3>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r1, [test_and_imm_0_param_0];
; COMMON-NEXT: and.b32 %r2, %r1, 131073;
; COMMON-NEXT: st.param.b32 [func_retval0], %r2;
; COMMON-NEXT: ret;
%r = and <2 x i16> <i16 1, i16 2>, %a
ret <2 x i16> %r
}
define <2 x i16> @test_and_imm_1(<2 x i16> %a) #0 {
; COMMON-LABEL: test_and_imm_1(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<3>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r1, [test_and_imm_1_param_0];
; COMMON-NEXT: and.b32 %r2, %r1, 131073;
; COMMON-NEXT: st.param.b32 [func_retval0], %r2;
; COMMON-NEXT: ret;
%r = and <2 x i16> %a, <i16 1, i16 2>
ret <2 x i16> %r
}
define void @test_ldst_v2i16(ptr %a, ptr %b) {
; COMMON-LABEL: test_ldst_v2i16(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<2>;
; COMMON-NEXT: .reg .b64 %rd<3>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b64 %rd2, [test_ldst_v2i16_param_1];
; COMMON-NEXT: ld.param.b64 %rd1, [test_ldst_v2i16_param_0];
; COMMON-NEXT: ld.b32 %r1, [%rd1];
; COMMON-NEXT: st.b32 [%rd2], %r1;
; COMMON-NEXT: ret;
%t1 = load <2 x i16>, ptr %a
store <2 x i16> %t1, ptr %b, align 16
ret void
}
; -- v3 is inconvenient to capture as it's lowered as ld.b64 + fair
; number of bitshifting instructions that may change at llvm's whim.
; So we only verify that we only issue correct number of writes using
; correct offset, but not the values we write.
define void @test_ldst_v3i16(ptr %a, ptr %b) {
; COMMON-LABEL: test_ldst_v3i16(
; COMMON: {
; COMMON-NEXT: .reg .b64 %rd<5>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b64 %rd2, [test_ldst_v3i16_param_1];
; COMMON-NEXT: ld.param.b64 %rd1, [test_ldst_v3i16_param_0];
; COMMON-NEXT: ld.b64 %rd3, [%rd1];
; COMMON-NEXT: shr.u64 %rd4, %rd3, 32;
; COMMON-NEXT: st.b32 [%rd2], %rd3;
; COMMON-NEXT: st.b16 [%rd2+4], %rd4;
; COMMON-NEXT: ret;
%t1 = load <3 x i16>, ptr %a
store <3 x i16> %t1, ptr %b, align 16
ret void
}
define void @test_ldst_v4i16(ptr %a, ptr %b) {
; COMMON-LABEL: test_ldst_v4i16(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<3>;
; COMMON-NEXT: .reg .b64 %rd<3>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b64 %rd2, [test_ldst_v4i16_param_1];
; COMMON-NEXT: ld.param.b64 %rd1, [test_ldst_v4i16_param_0];
; COMMON-NEXT: ld.v2.b32 {%r1, %r2}, [%rd1];
; COMMON-NEXT: st.v2.b32 [%rd2], {%r1, %r2};
; COMMON-NEXT: ret;
%t1 = load <4 x i16>, ptr %a
store <4 x i16> %t1, ptr %b, align 16
ret void
}
define void @test_ldst_v8i16(ptr %a, ptr %b) {
; COMMON-LABEL: test_ldst_v8i16(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<5>;
; COMMON-NEXT: .reg .b64 %rd<3>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b64 %rd2, [test_ldst_v8i16_param_1];
; COMMON-NEXT: ld.param.b64 %rd1, [test_ldst_v8i16_param_0];
; COMMON-NEXT: ld.v4.b32 {%r1, %r2, %r3, %r4}, [%rd1];
; COMMON-NEXT: st.v4.b32 [%rd2], {%r1, %r2, %r3, %r4};
; COMMON-NEXT: ret;
%t1 = load <8 x i16>, ptr %a
store <8 x i16> %t1, ptr %b, align 16
ret void
}
declare <2 x i16> @test_callee(<2 x i16> %a, <2 x i16> %b) #0
define <2 x i16> @test_call(<2 x i16> %a, <2 x i16> %b) #0 {
; COMMON-LABEL: test_call(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<5>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r2, [test_call_param_1];
; COMMON-NEXT: ld.param.b32 %r1, [test_call_param_0];
; COMMON-NEXT: { // callseq 0, 0
; COMMON-NEXT: .param .align 4 .b8 param0[4];
; COMMON-NEXT: .param .align 4 .b8 param1[4];
; COMMON-NEXT: .param .align 4 .b8 retval0[4];
; COMMON-NEXT: st.param.b32 [param1], %r2;
; COMMON-NEXT: st.param.b32 [param0], %r1;
; COMMON-NEXT: call.uni (retval0), test_callee, (param0, param1);
; COMMON-NEXT: ld.param.b32 %r3, [retval0];
; COMMON-NEXT: } // callseq 0
; COMMON-NEXT: st.param.b32 [func_retval0], %r3;
; COMMON-NEXT: ret;
%r = call <2 x i16> @test_callee(<2 x i16> %a, <2 x i16> %b)
ret <2 x i16> %r
}
define <2 x i16> @test_call_flipped(<2 x i16> %a, <2 x i16> %b) #0 {
; COMMON-LABEL: test_call_flipped(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<5>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r2, [test_call_flipped_param_1];
; COMMON-NEXT: ld.param.b32 %r1, [test_call_flipped_param_0];
; COMMON-NEXT: { // callseq 1, 0
; COMMON-NEXT: .param .align 4 .b8 param0[4];
; COMMON-NEXT: .param .align 4 .b8 param1[4];
; COMMON-NEXT: .param .align 4 .b8 retval0[4];
; COMMON-NEXT: st.param.b32 [param1], %r1;
; COMMON-NEXT: st.param.b32 [param0], %r2;
; COMMON-NEXT: call.uni (retval0), test_callee, (param0, param1);
; COMMON-NEXT: ld.param.b32 %r3, [retval0];
; COMMON-NEXT: } // callseq 1
; COMMON-NEXT: st.param.b32 [func_retval0], %r3;
; COMMON-NEXT: ret;
%r = call <2 x i16> @test_callee(<2 x i16> %b, <2 x i16> %a)
ret <2 x i16> %r
}
define <2 x i16> @test_tailcall_flipped(<2 x i16> %a, <2 x i16> %b) #0 {
; COMMON-LABEL: test_tailcall_flipped(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<5>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r2, [test_tailcall_flipped_param_1];
; COMMON-NEXT: ld.param.b32 %r1, [test_tailcall_flipped_param_0];
; COMMON-NEXT: { // callseq 2, 0
; COMMON-NEXT: .param .align 4 .b8 param0[4];
; COMMON-NEXT: .param .align 4 .b8 param1[4];
; COMMON-NEXT: .param .align 4 .b8 retval0[4];
; COMMON-NEXT: st.param.b32 [param1], %r1;
; COMMON-NEXT: st.param.b32 [param0], %r2;
; COMMON-NEXT: call.uni (retval0), test_callee, (param0, param1);
; COMMON-NEXT: ld.param.b32 %r3, [retval0];
; COMMON-NEXT: } // callseq 2
; COMMON-NEXT: st.param.b32 [func_retval0], %r3;
; COMMON-NEXT: ret;
%r = tail call <2 x i16> @test_callee(<2 x i16> %b, <2 x i16> %a)
ret <2 x i16> %r
}
define <2 x i16> @test_select(<2 x i16> %a, <2 x i16> %b, i1 zeroext %c) #0 {
; COMMON-LABEL: test_select(
; COMMON: {
; COMMON-NEXT: .reg .pred %p<2>;
; COMMON-NEXT: .reg .b16 %rs<3>;
; COMMON-NEXT: .reg .b32 %r<4>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b8 %rs1, [test_select_param_2];
; COMMON-NEXT: and.b16 %rs2, %rs1, 1;
; COMMON-NEXT: setp.ne.b16 %p1, %rs2, 0;
; COMMON-NEXT: ld.param.b32 %r2, [test_select_param_1];
; COMMON-NEXT: ld.param.b32 %r1, [test_select_param_0];
; COMMON-NEXT: selp.b32 %r3, %r1, %r2, %p1;
; COMMON-NEXT: st.param.b32 [func_retval0], %r3;
; COMMON-NEXT: ret;
%r = select i1 %c, <2 x i16> %a, <2 x i16> %b
ret <2 x i16> %r
}
define <2 x i16> @test_select_cc(<2 x i16> %a, <2 x i16> %b, <2 x i16> %c, <2 x i16> %d) #0 {
; COMMON-LABEL: test_select_cc(
; COMMON: {
; COMMON-NEXT: .reg .pred %p<3>;
; COMMON-NEXT: .reg .b16 %rs<11>;
; COMMON-NEXT: .reg .b32 %r<5>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r4, [test_select_cc_param_3];
; COMMON-NEXT: ld.param.b32 %r3, [test_select_cc_param_2];
; COMMON-NEXT: ld.param.b32 %r2, [test_select_cc_param_1];
; COMMON-NEXT: ld.param.b32 %r1, [test_select_cc_param_0];
; COMMON-NEXT: mov.b32 {%rs1, %rs2}, %r4;
; COMMON-NEXT: mov.b32 {%rs3, %rs4}, %r3;
; COMMON-NEXT: setp.ne.b16 %p1, %rs3, %rs1;
; COMMON-NEXT: setp.ne.b16 %p2, %rs4, %rs2;
; COMMON-NEXT: mov.b32 {%rs5, %rs6}, %r2;
; COMMON-NEXT: mov.b32 {%rs7, %rs8}, %r1;
; COMMON-NEXT: selp.b16 %rs9, %rs8, %rs6, %p2;
; COMMON-NEXT: selp.b16 %rs10, %rs7, %rs5, %p1;
; COMMON-NEXT: st.param.v2.b16 [func_retval0], {%rs10, %rs9};
; COMMON-NEXT: ret;
%cc = icmp ne <2 x i16> %c, %d
%r = select <2 x i1> %cc, <2 x i16> %a, <2 x i16> %b
ret <2 x i16> %r
}
define <2 x i32> @test_select_cc_i32_i16(<2 x i32> %a, <2 x i32> %b,
; COMMON-LABEL: test_select_cc_i32_i16(
; COMMON: {
; COMMON-NEXT: .reg .pred %p<3>;
; COMMON-NEXT: .reg .b16 %rs<5>;
; COMMON-NEXT: .reg .b32 %r<9>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.v2.b32 {%r3, %r4}, [test_select_cc_i32_i16_param_1];
; COMMON-NEXT: ld.param.v2.b32 {%r1, %r2}, [test_select_cc_i32_i16_param_0];
; COMMON-NEXT: ld.param.b32 %r6, [test_select_cc_i32_i16_param_3];
; COMMON-NEXT: ld.param.b32 %r5, [test_select_cc_i32_i16_param_2];
; COMMON-NEXT: mov.b32 {%rs1, %rs2}, %r6;
; COMMON-NEXT: mov.b32 {%rs3, %rs4}, %r5;
; COMMON-NEXT: setp.ne.b16 %p1, %rs3, %rs1;
; COMMON-NEXT: setp.ne.b16 %p2, %rs4, %rs2;
; COMMON-NEXT: selp.b32 %r7, %r2, %r4, %p2;
; COMMON-NEXT: selp.b32 %r8, %r1, %r3, %p1;
; COMMON-NEXT: st.param.v2.b32 [func_retval0], {%r8, %r7};
; COMMON-NEXT: ret;
<2 x i16> %c, <2 x i16> %d) #0 {
%cc = icmp ne <2 x i16> %c, %d
%r = select <2 x i1> %cc, <2 x i32> %a, <2 x i32> %b
ret <2 x i32> %r
}
define <2 x i16> @test_select_cc_i16_i32(<2 x i16> %a, <2 x i16> %b,
; COMMON-LABEL: test_select_cc_i16_i32(
; COMMON: {
; COMMON-NEXT: .reg .pred %p<3>;
; COMMON-NEXT: .reg .b16 %rs<7>;
; COMMON-NEXT: .reg .b32 %r<7>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.v2.b32 {%r5, %r6}, [test_select_cc_i16_i32_param_3];
; COMMON-NEXT: ld.param.v2.b32 {%r3, %r4}, [test_select_cc_i16_i32_param_2];
; COMMON-NEXT: ld.param.b32 %r2, [test_select_cc_i16_i32_param_1];
; COMMON-NEXT: ld.param.b32 %r1, [test_select_cc_i16_i32_param_0];
; COMMON-NEXT: setp.ne.b32 %p1, %r3, %r5;
; COMMON-NEXT: setp.ne.b32 %p2, %r4, %r6;
; COMMON-NEXT: mov.b32 {%rs1, %rs2}, %r2;
; COMMON-NEXT: mov.b32 {%rs3, %rs4}, %r1;
; COMMON-NEXT: selp.b16 %rs5, %rs4, %rs2, %p2;
; COMMON-NEXT: selp.b16 %rs6, %rs3, %rs1, %p1;
; COMMON-NEXT: st.param.v2.b16 [func_retval0], {%rs6, %rs5};
; COMMON-NEXT: ret;
<2 x i32> %c, <2 x i32> %d) #0 {
%cc = icmp ne <2 x i32> %c, %d
%r = select <2 x i1> %cc, <2 x i16> %a, <2 x i16> %b
ret <2 x i16> %r
}
define <2 x i16> @test_trunc_2xi32(<2 x i32> %a) #0 {
; COMMON-LABEL: test_trunc_2xi32(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<4>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.v2.b32 {%r1, %r2}, [test_trunc_2xi32_param_0];
; COMMON-NEXT: prmt.b32 %r3, %r1, %r2, 0x5410U;
; COMMON-NEXT: st.param.b32 [func_retval0], %r3;
; COMMON-NEXT: ret;
%r = trunc <2 x i32> %a to <2 x i16>
ret <2 x i16> %r
}
define <2 x i16> @test_trunc_2xi32_muliple_use0(<2 x i32> %a, ptr %p) #0 {
; I16x2-LABEL: test_trunc_2xi32_muliple_use0(
; I16x2: {
; I16x2-NEXT: .reg .b32 %r<6>;
; I16x2-NEXT: .reg .b64 %rd<2>;
; I16x2-EMPTY:
; I16x2-NEXT: // %bb.0:
; I16x2-NEXT: ld.param.v2.b32 {%r1, %r2}, [test_trunc_2xi32_muliple_use0_param_0];
; I16x2-NEXT: ld.param.b64 %rd1, [test_trunc_2xi32_muliple_use0_param_1];
; I16x2-NEXT: prmt.b32 %r3, %r1, %r2, 0x5410U;
; I16x2-NEXT: mov.b32 %r4, 65537;
; I16x2-NEXT: add.s16x2 %r5, %r3, %r4;
; I16x2-NEXT: st.b32 [%rd1], %r5;
; I16x2-NEXT: st.param.b32 [func_retval0], %r3;
; I16x2-NEXT: ret;
;
; NO-I16x2-LABEL: test_trunc_2xi32_muliple_use0(
; NO-I16x2: {
; NO-I16x2-NEXT: .reg .b16 %rs<5>;
; NO-I16x2-NEXT: .reg .b32 %r<4>;
; NO-I16x2-NEXT: .reg .b64 %rd<2>;
; NO-I16x2-EMPTY:
; NO-I16x2-NEXT: // %bb.0:
; NO-I16x2-NEXT: ld.param.v2.b32 {%r1, %r2}, [test_trunc_2xi32_muliple_use0_param_0];
; NO-I16x2-NEXT: ld.param.b64 %rd1, [test_trunc_2xi32_muliple_use0_param_1];
; NO-I16x2-NEXT: cvt.u16.u32 %rs1, %r2;
; NO-I16x2-NEXT: cvt.u16.u32 %rs2, %r1;
; NO-I16x2-NEXT: mov.b32 %r3, {%rs2, %rs1};
; NO-I16x2-NEXT: add.s16 %rs3, %rs1, 1;
; NO-I16x2-NEXT: add.s16 %rs4, %rs2, 1;
; NO-I16x2-NEXT: st.v2.b16 [%rd1], {%rs4, %rs3};
; NO-I16x2-NEXT: st.param.b32 [func_retval0], %r3;
; NO-I16x2-NEXT: ret;
%r = trunc <2 x i32> %a to <2 x i16>
; Reuse the truncate - optimizing to PRMT when we don't have i16x2 vectors
; would increase register pressure
%s = add <2 x i16> %r, splat (i16 1)
store <2 x i16> %s, ptr %p
ret <2 x i16> %r
}
define <2 x i16> @test_trunc_2xi32_muliple_use1(<2 x i32> %a, ptr %p) #0 {
; COMMON-LABEL: test_trunc_2xi32_muliple_use1(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<6>;
; COMMON-NEXT: .reg .b64 %rd<2>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.v2.b32 {%r1, %r2}, [test_trunc_2xi32_muliple_use1_param_0];
; COMMON-NEXT: ld.param.b64 %rd1, [test_trunc_2xi32_muliple_use1_param_1];
; COMMON-NEXT: prmt.b32 %r3, %r1, %r2, 0x5410U;
; COMMON-NEXT: add.s32 %r4, %r2, 1;
; COMMON-NEXT: add.s32 %r5, %r1, 1;
; COMMON-NEXT: st.v2.b32 [%rd1], {%r5, %r4};
; COMMON-NEXT: st.param.b32 [func_retval0], %r3;
; COMMON-NEXT: ret;
%r = trunc <2 x i32> %a to <2 x i16>
; Reuse the original value - optimizing to PRMT does not increase register
; pressure
%s = add <2 x i32> %a, splat (i32 1)
store <2 x i32> %s, ptr %p
ret <2 x i16> %r
}
define <2 x i16> @test_trunc_2xi64(<2 x i64> %a) #0 {
; COMMON-LABEL: test_trunc_2xi64(
; COMMON: {
; COMMON-NEXT: .reg .b16 %rs<3>;
; COMMON-NEXT: .reg .b64 %rd<3>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.v2.b64 {%rd1, %rd2}, [test_trunc_2xi64_param_0];
; COMMON-NEXT: cvt.u16.u64 %rs1, %rd2;
; COMMON-NEXT: cvt.u16.u64 %rs2, %rd1;
; COMMON-NEXT: st.param.v2.b16 [func_retval0], {%rs2, %rs1};
; COMMON-NEXT: ret;
%r = trunc <2 x i64> %a to <2 x i16>
ret <2 x i16> %r
}
define <2 x i32> @test_zext_2xi32(<2 x i16> %a) #0 {
; COMMON-LABEL: test_zext_2xi32(
; COMMON: {
; COMMON-NEXT: .reg .b16 %rs<3>;
; COMMON-NEXT: .reg .b32 %r<4>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r1, [test_zext_2xi32_param_0];
; COMMON-NEXT: mov.b32 {%rs1, %rs2}, %r1;
; COMMON-NEXT: cvt.u32.u16 %r2, %rs2;
; COMMON-NEXT: cvt.u32.u16 %r3, %rs1;
; COMMON-NEXT: st.param.v2.b32 [func_retval0], {%r3, %r2};
; COMMON-NEXT: ret;
%r = zext <2 x i16> %a to <2 x i32>
ret <2 x i32> %r
}
define <2 x i64> @test_zext_2xi64(<2 x i16> %a) #0 {
; COMMON-LABEL: test_zext_2xi64(
; COMMON: {
; COMMON-NEXT: .reg .b16 %rs<3>;
; COMMON-NEXT: .reg .b32 %r<2>;
; COMMON-NEXT: .reg .b64 %rd<3>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r1, [test_zext_2xi64_param_0];
; COMMON-NEXT: mov.b32 {%rs1, %rs2}, %r1;
; COMMON-NEXT: cvt.u64.u16 %rd1, %rs2;
; COMMON-NEXT: cvt.u64.u16 %rd2, %rs1;
; COMMON-NEXT: st.param.v2.b64 [func_retval0], {%rd2, %rd1};
; COMMON-NEXT: ret;
%r = zext <2 x i16> %a to <2 x i64>
ret <2 x i64> %r
}
define <2 x i16> @test_bitcast_i32_to_2xi16(i32 %a) #0 {
; COMMON-LABEL: test_bitcast_i32_to_2xi16(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<2>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r1, [test_bitcast_i32_to_2xi16_param_0];
; COMMON-NEXT: st.param.b32 [func_retval0], %r1;
; COMMON-NEXT: ret;
%r = bitcast i32 %a to <2 x i16>
ret <2 x i16> %r
}
define i32 @test_bitcast_2xi16_to_i32(<2 x i16> %a) #0 {
; COMMON-LABEL: test_bitcast_2xi16_to_i32(
; COMMON: {
; COMMON-NEXT: .reg .b32 %r<2>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r1, [test_bitcast_2xi16_to_i32_param_0];
; COMMON-NEXT: st.param.b32 [func_retval0], %r1;
; COMMON-NEXT: ret;
%r = bitcast <2 x i16> %a to i32
ret i32 %r
}
define <2 x half> @test_bitcast_2xi16_to_2xhalf(i16 %a) #0 {
; COMMON-LABEL: test_bitcast_2xi16_to_2xhalf(
; COMMON: {
; COMMON-NEXT: .reg .b16 %rs<2>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b16 %rs1, [test_bitcast_2xi16_to_2xhalf_param_0];
; COMMON-NEXT: st.param.v2.b16 [func_retval0], {%rs1, 5};
; COMMON-NEXT: ret;
%ins.0 = insertelement <2 x i16> undef, i16 %a, i32 0
%ins.1 = insertelement <2 x i16> %ins.0, i16 5, i32 1
%r = bitcast <2 x i16> %ins.1 to <2 x half>
ret <2 x half> %r
}
define <2 x i16> @test_shufflevector(<2 x i16> %a) #0 {
; COMMON-LABEL: test_shufflevector(
; COMMON: {
; COMMON-NEXT: .reg .b16 %rs<3>;
; COMMON-NEXT: .reg .b32 %r<2>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r1, [test_shufflevector_param_0];
; COMMON-NEXT: mov.b32 {%rs1, %rs2}, %r1;
; COMMON-NEXT: st.param.v2.b16 [func_retval0], {%rs2, %rs1};
; COMMON-NEXT: ret;
%s = shufflevector <2 x i16> %a, <2 x i16> undef, <2 x i32> <i32 1, i32 0>
ret <2 x i16> %s
}
define <2 x i16> @test_insertelement(<2 x i16> %a, i16 %x) #0 {
; I16x2-LABEL: test_insertelement(
; I16x2: {
; I16x2-NEXT: .reg .b16 %rs<3>;
; I16x2-NEXT: .reg .b32 %r<2>;
; I16x2-EMPTY:
; I16x2-NEXT: // %bb.0:
; I16x2-NEXT: ld.param.b16 %rs1, [test_insertelement_param_1];
; I16x2-NEXT: ld.param.b32 %r1, [test_insertelement_param_0];
; I16x2-NEXT: mov.b32 {%rs2, _}, %r1;
; I16x2-NEXT: st.param.v2.b16 [func_retval0], {%rs2, %rs1};
; I16x2-NEXT: ret;
;
; NO-I16x2-LABEL: test_insertelement(
; NO-I16x2: {
; NO-I16x2-NEXT: .reg .b16 %rs<3>;
; NO-I16x2-NEXT: .reg .b32 %r<2>;
; NO-I16x2-EMPTY:
; NO-I16x2-NEXT: // %bb.0:
; NO-I16x2-NEXT: ld.param.b16 %rs1, [test_insertelement_param_1];
; NO-I16x2-NEXT: ld.param.b32 %r1, [test_insertelement_param_0];
; NO-I16x2-NEXT: { .reg .b16 tmp; mov.b32 {%rs2, tmp}, %r1; }
; NO-I16x2-NEXT: st.param.v2.b16 [func_retval0], {%rs2, %rs1};
; NO-I16x2-NEXT: ret;
%i = insertelement <2 x i16> %a, i16 %x, i64 1
ret <2 x i16> %i
}
define <2 x i16> @test_fptosi_2xhalf_to_2xi16(<2 x half> %a) #0 {
; COMMON-LABEL: test_fptosi_2xhalf_to_2xi16(
; COMMON: {
; COMMON-NEXT: .reg .b16 %rs<5>;
; COMMON-NEXT: .reg .b32 %r<2>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r1, [test_fptosi_2xhalf_to_2xi16_param_0];
; COMMON-NEXT: mov.b32 {%rs1, %rs2}, %r1;
; COMMON-NEXT: cvt.rzi.s16.f16 %rs3, %rs2;
; COMMON-NEXT: cvt.rzi.s16.f16 %rs4, %rs1;
; COMMON-NEXT: st.param.v2.b16 [func_retval0], {%rs4, %rs3};
; COMMON-NEXT: ret;
%r = fptosi <2 x half> %a to <2 x i16>
ret <2 x i16> %r
}
define <2 x i16> @test_fptoui_2xhalf_to_2xi16(<2 x half> %a) #0 {
; COMMON-LABEL: test_fptoui_2xhalf_to_2xi16(
; COMMON: {
; COMMON-NEXT: .reg .b16 %rs<5>;
; COMMON-NEXT: .reg .b32 %r<2>;
; COMMON-EMPTY:
; COMMON-NEXT: // %bb.0:
; COMMON-NEXT: ld.param.b32 %r1, [test_fptoui_2xhalf_to_2xi16_param_0];
; COMMON-NEXT: mov.b32 {%rs1, %rs2}, %r1;
; COMMON-NEXT: cvt.rzi.u16.f16 %rs3, %rs2;
; COMMON-NEXT: cvt.rzi.u16.f16 %rs4, %rs1;
; COMMON-NEXT: st.param.v2.b16 [func_retval0], {%rs4, %rs3};
; COMMON-NEXT: ret;
%r = fptoui <2 x half> %a to <2 x i16>
ret <2 x i16> %r
}
attributes #0 = { nounwind }
Reference in New Issue View Git Blame Copy Permalink