X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fauxiliary%2Fgallivm%2Flp_bld_tgsi_action.c;h=b9546dbc661b28bca259882e3ef5c91f03d16cd3;hb=52381a7ffba908410f7a53855f082401fca7293a;hp=e5b1b83819d9c4e86806a2f9274a3e0ab8b1eb4a;hpb=dde807b9dc038266fbe594c1a700283df007bf5e;p=mesa.git diff --git a/src/gallium/auxiliary/gallivm/lp_bld_tgsi_action.c b/src/gallium/auxiliary/gallivm/lp_bld_tgsi_action.c index e5b1b83819d..b9546dbc661 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_tgsi_action.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_tgsi_action.c @@ -2,7 +2,7 @@ * * Copyright 2011-2012 Advanced Micro Devices, Inc. * Copyright 2009 VMware, Inc. - * Copyright 2007-2008 Tungsten Graphics, Inc., Cedar Park, Texas. + * Copyright 2007-2008 VMware, Inc. * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a @@ -20,7 +20,7 @@ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. - * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR + * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. @@ -43,6 +43,7 @@ #include "lp_bld_tgsi.h" #include "lp_bld_arit.h" +#include "lp_bld_bitarit.h" #include "lp_bld_const.h" #include "lp_bld_gather.h" #include "lp_bld_logic.h" @@ -102,8 +103,9 @@ arr_emit( struct lp_build_tgsi_context * bld_base, struct lp_build_emit_data * emit_data) { - emit_data->output[emit_data->chan] = lp_build_emit_llvm_unary(bld_base, - TGSI_OPCODE_ROUND, emit_data->args[0]); + LLVMValueRef tmp = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_ROUND, emit_data->args[0]); + emit_data->output[emit_data->chan] = LLVMBuildFPToSI(bld_base->base.gallivm->builder, tmp, + bld_base->uint_bld.vec_type, ""); } /* TGSI_OPCODE_CLAMP */ @@ -166,8 +168,8 @@ dp2_emit( } static struct lp_build_tgsi_action dp2_action = { - .fetch_args = dp2_fetch_args, - .emit = dp2_emit + dp2_fetch_args, /* fetch_args */ + dp2_emit /* emit */ }; /* TGSI_OPCODE_DP2A */ @@ -194,8 +196,8 @@ dp2a_emit( } static struct lp_build_tgsi_action dp2a_action = { - .fetch_args = dp2a_fetch_args, - .emit = dp2a_emit + dp2a_fetch_args, /* fetch_args */ + dp2a_emit /* emit */ }; /* TGSI_OPCODE_DP3 */ @@ -229,8 +231,8 @@ dp3_emit( } static struct lp_build_tgsi_action dp3_action = { - .fetch_args = dp3_fetch_args, - .emit = dp3_emit + dp3_fetch_args, /* fetch_args */ + dp3_emit /* emit */ }; /* TGSI_OPCODDE_DP4 */ @@ -269,8 +271,8 @@ dp4_emit( } static struct lp_build_tgsi_action dp4_action = { - .fetch_args = dp4_fetch_args, - .emit = dp4_emit + dp4_fetch_args, /* fetch_args */ + dp4_emit /* emit */ }; /* TGSI_OPCODE_DPH */ @@ -285,8 +287,8 @@ dph_fetch_args( } const struct lp_build_tgsi_action dph_action = { - .fetch_args = dph_fetch_args, - .emit = dp4_emit + dph_fetch_args, /* fetch_args */ + dp4_emit /* emit */ }; /* TGSI_OPCODE_DST */ @@ -331,8 +333,8 @@ dst_emit( } static struct lp_build_tgsi_action dst_action = { - .fetch_args = dst_fetch_args, - .emit = dst_emit + dst_fetch_args, /* fetch_args */ + dst_emit /* emit */ }; /* TGSI_OPCODE_END */ @@ -375,8 +377,8 @@ exp_emit( } const struct lp_build_tgsi_action exp_action = { - .fetch_args = scalar_unary_fetch_args, - .emit = exp_emit + scalar_unary_fetch_args, /* fetch_args */ + exp_emit /* emit */ }; /* TGSI_OPCODE_FRC */ @@ -394,7 +396,7 @@ frc_emit( TGSI_OPCODE_SUB, emit_data->args[0], tmp); } -/* TGSI_OPCODE_KIL */ +/* TGSI_OPCODE_KILL_IF */ static void kil_fetch_args( @@ -417,7 +419,7 @@ kil_fetch_args( emit_data->dst_type = LLVMVoidTypeInContext(bld_base->base.gallivm->context); } -/* TGSI_OPCODE_KILP */ +/* TGSI_OPCODE_KILL */ static void kilp_fetch_args( @@ -479,8 +481,8 @@ lit_emit( } static struct lp_build_tgsi_action lit_action = { - .fetch_args = lit_fetch_args, - .emit = lit_emit + lit_fetch_args, /* fetch_args */ + lit_emit /* emit */ }; /* TGSI_OPCODE_LOG */ @@ -524,8 +526,8 @@ log_emit( } static struct lp_build_tgsi_action log_action = { - .fetch_args = scalar_unary_fetch_args, - .emit = log_emit + scalar_unary_fetch_args, /* fetch_args */ + log_emit /* emit */ }; /* TGSI_OPCODE_LRP */ @@ -578,8 +580,32 @@ mul_emit( struct lp_build_tgsi_context * bld_base, struct lp_build_emit_data * emit_data) { - emit_data->output[emit_data->chan] = lp_build_mul(&bld_base->base, - emit_data->args[0], emit_data->args[1]); + emit_data->output[emit_data->chan] = LLVMBuildFMul( + bld_base->base.gallivm->builder, + emit_data->args[0], emit_data->args[1], ""); +} + +/*.TGSI_OPCODE_DIV.*/ +static void fdiv_emit( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = LLVMBuildFDiv( + bld_base->base.gallivm->builder, + emit_data->args[0], emit_data->args[1], ""); +} + +/*.TGSI_OPCODE_RCP.*/ +static void rcp_emit( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + LLVMValueRef one; + one = lp_build_const_float(bld_base->base.gallivm, 1.0f); + emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base, + TGSI_OPCODE_DIV, one, emit_data->args[0]); } /* TGSI_OPCODE_POW */ @@ -595,8 +621,8 @@ pow_emit( } static struct lp_build_tgsi_action pow_action = { - .fetch_args = scalar_binary_fetch_args, - .emit = pow_emit + scalar_binary_fetch_args, /* fetch_args */ + pow_emit /* emit */ }; /* TGSI_OPCODE_RSQ */ @@ -607,8 +633,6 @@ rsq_emit( struct lp_build_tgsi_context * bld_base, struct lp_build_emit_data * emit_data) { - emit_data->args[0] = lp_build_emit_llvm_unary(bld_base, TGSI_OPCODE_ABS, - emit_data->args[0]); if (bld_base->rsq_action.emit) { bld_base->rsq_action.emit(&bld_base->rsq_action, bld_base, emit_data); } else { @@ -617,11 +641,31 @@ rsq_emit( } const struct lp_build_tgsi_action rsq_action = { - .fetch_args = scalar_unary_fetch_args, - .emit = rsq_emit + scalar_unary_fetch_args, /* fetch_args */ + rsq_emit /* emit */ }; +/* TGSI_OPCODE_SQRT */ + +static void +sqrt_emit( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + if (bld_base->sqrt_action.emit) { + bld_base->sqrt_action.emit(&bld_base->sqrt_action, bld_base, emit_data); + } else { + emit_data->output[emit_data->chan] = bld_base->base.undef; + } +} + +const struct lp_build_tgsi_action sqrt_action = { + scalar_unary_fetch_args, /* fetch_args */ + sqrt_emit /* emit */ +}; + /* TGSI_OPCODE_SCS */ static void scs_emit( @@ -643,8 +687,8 @@ scs_emit( } const struct lp_build_tgsi_action scs_action = { - .fetch_args = scalar_unary_fetch_args, - .emit = scs_emit + scalar_unary_fetch_args, /* fetch_args */ + scs_emit /* emit */ }; /* TGSI_OPCODE_SFL */ @@ -676,10 +720,145 @@ sub_emit( struct lp_build_tgsi_context * bld_base, struct lp_build_emit_data * emit_data) { - emit_data->output[emit_data->chan] = LLVMBuildFSub( - bld_base->base.gallivm->builder, - emit_data->args[0], - emit_data->args[1], ""); + emit_data->output[emit_data->chan] = + LLVMBuildFSub(bld_base->base.gallivm->builder, + emit_data->args[0], + emit_data->args[1], ""); +} + +/* TGSI_OPCODE_F2U */ +static void +f2u_emit( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = + LLVMBuildFPToUI(bld_base->base.gallivm->builder, + emit_data->args[0], + bld_base->base.int_vec_type, ""); +} + +/* TGSI_OPCODE_U2F */ +static void +u2f_emit( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = + LLVMBuildUIToFP(bld_base->base.gallivm->builder, + emit_data->args[0], + bld_base->base.vec_type, ""); +} + +static void +umad_emit( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + LLVMValueRef tmp; + tmp = lp_build_emit_llvm_binary(bld_base, TGSI_OPCODE_UMUL, + emit_data->args[0], + emit_data->args[1]); + emit_data->output[emit_data->chan] = lp_build_emit_llvm_binary(bld_base, + TGSI_OPCODE_UADD, tmp, emit_data->args[2]); +} + +/* TGSI_OPCODE_UMUL */ +static void +umul_emit( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_mul(&bld_base->uint_bld, + emit_data->args[0], emit_data->args[1]); +} + +/* TGSI_OPCODE_IMUL_HI */ +static void +imul_hi_emit( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + LLVMBuilderRef builder = bld_base->base.gallivm->builder; + struct lp_build_context *int_bld = &bld_base->int_bld; + struct lp_type type = int_bld->type; + LLVMValueRef src0, src1; + LLVMValueRef dst64; + LLVMTypeRef typeRef; + + assert(type.width == 32); + type.width = 64; + typeRef = lp_build_vec_type(bld_base->base.gallivm, type); + src0 = LLVMBuildSExt(builder, emit_data->args[0], typeRef, ""); + src1 = LLVMBuildSExt(builder, emit_data->args[1], typeRef, ""); + dst64 = LLVMBuildMul(builder, src0, src1, ""); + dst64 = LLVMBuildAShr( + builder, dst64, + lp_build_const_vec(bld_base->base.gallivm, type, 32), ""); + type.width = 32; + typeRef = lp_build_vec_type(bld_base->base.gallivm, type); + emit_data->output[emit_data->chan] = + LLVMBuildTrunc(builder, dst64, typeRef, ""); +} + +/* TGSI_OPCODE_UMUL_HI */ +static void +umul_hi_emit( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + LLVMBuilderRef builder = bld_base->base.gallivm->builder; + struct lp_build_context *uint_bld = &bld_base->uint_bld; + struct lp_type type = uint_bld->type; + LLVMValueRef src0, src1; + LLVMValueRef dst64; + LLVMTypeRef typeRef; + + assert(type.width == 32); + type.width = 64; + typeRef = lp_build_vec_type(bld_base->base.gallivm, type); + src0 = LLVMBuildZExt(builder, emit_data->args[0], typeRef, ""); + src1 = LLVMBuildZExt(builder, emit_data->args[1], typeRef, ""); + dst64 = LLVMBuildMul(builder, src0, src1, ""); + dst64 = LLVMBuildLShr( + builder, dst64, + lp_build_const_vec(bld_base->base.gallivm, type, 32), ""); + type.width = 32; + typeRef = lp_build_vec_type(bld_base->base.gallivm, type); + emit_data->output[emit_data->chan] = + LLVMBuildTrunc(builder, dst64, typeRef, ""); +} + +/* TGSI_OPCODE_MAX */ +static void fmax_emit( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + LLVMBuilderRef builder = bld_base->base.gallivm->builder; + emit_data->output[emit_data->chan] = LLVMBuildSelect(builder, + LLVMBuildFCmp(builder, LLVMRealUGE, + emit_data->args[0], emit_data->args[1], ""), + emit_data->args[0], emit_data->args[1], ""); +} + +/* TGSI_OPCODE_MIN */ +static void fmin_emit( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + LLVMBuilderRef builder = bld_base->base.gallivm->builder; + emit_data->output[emit_data->chan] = LLVMBuildSelect(builder, + LLVMBuildFCmp(builder, LLVMRealUGE, + emit_data->args[0], emit_data->args[1], ""), + emit_data->args[1], emit_data->args[0], ""); } /* TGSI_OPCODE_XPD */ @@ -733,8 +912,8 @@ xpd_emit( } const struct lp_build_tgsi_action xpd_action = { - .fetch_args = xpd_fetch_args, - .emit = xpd_emit + xpd_fetch_args, /* fetch_args */ + xpd_emit /* emit */ }; void @@ -750,15 +929,20 @@ lp_set_default_actions(struct lp_build_tgsi_context * bld_base) bld_base->op_actions[TGSI_OPCODE_LIT] = lit_action; bld_base->op_actions[TGSI_OPCODE_LOG] = log_action; bld_base->op_actions[TGSI_OPCODE_RSQ] = rsq_action; + bld_base->op_actions[TGSI_OPCODE_SQRT] = sqrt_action; bld_base->op_actions[TGSI_OPCODE_POW] = pow_action; bld_base->op_actions[TGSI_OPCODE_SCS] = scs_action; bld_base->op_actions[TGSI_OPCODE_XPD] = xpd_action; + bld_base->op_actions[TGSI_OPCODE_BREAKC].fetch_args = scalar_unary_fetch_args; + bld_base->op_actions[TGSI_OPCODE_SWITCH].fetch_args = scalar_unary_fetch_args; + bld_base->op_actions[TGSI_OPCODE_CASE].fetch_args = scalar_unary_fetch_args; bld_base->op_actions[TGSI_OPCODE_COS].fetch_args = scalar_unary_fetch_args; bld_base->op_actions[TGSI_OPCODE_EX2].fetch_args = scalar_unary_fetch_args; bld_base->op_actions[TGSI_OPCODE_IF].fetch_args = scalar_unary_fetch_args; - bld_base->op_actions[TGSI_OPCODE_KIL].fetch_args = kil_fetch_args; - bld_base->op_actions[TGSI_OPCODE_KILP].fetch_args = kilp_fetch_args; + bld_base->op_actions[TGSI_OPCODE_UIF].fetch_args = scalar_unary_fetch_args; + bld_base->op_actions[TGSI_OPCODE_KILL_IF].fetch_args = kil_fetch_args; + bld_base->op_actions[TGSI_OPCODE_KILL].fetch_args = kilp_fetch_args; bld_base->op_actions[TGSI_OPCODE_RCP].fetch_args = scalar_unary_fetch_args; bld_base->op_actions[TGSI_OPCODE_SIN].fetch_args = scalar_unary_fetch_args; bld_base->op_actions[TGSI_OPCODE_LG2].fetch_args = scalar_unary_fetch_args; @@ -772,9 +956,22 @@ lp_set_default_actions(struct lp_build_tgsi_context * bld_base) bld_base->op_actions[TGSI_OPCODE_MAD].emit = mad_emit; bld_base->op_actions[TGSI_OPCODE_MOV].emit = mov_emit; bld_base->op_actions[TGSI_OPCODE_MUL].emit = mul_emit; + bld_base->op_actions[TGSI_OPCODE_DIV].emit = fdiv_emit; + bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit; bld_base->op_actions[TGSI_OPCODE_SFL].emit = sfl_emit; bld_base->op_actions[TGSI_OPCODE_STR].emit = str_emit; bld_base->op_actions[TGSI_OPCODE_SUB].emit = sub_emit; + + bld_base->op_actions[TGSI_OPCODE_UARL].emit = mov_emit; + bld_base->op_actions[TGSI_OPCODE_F2U].emit = f2u_emit; + bld_base->op_actions[TGSI_OPCODE_U2F].emit = u2f_emit; + bld_base->op_actions[TGSI_OPCODE_UMAD].emit = umad_emit; + bld_base->op_actions[TGSI_OPCODE_UMUL].emit = umul_emit; + bld_base->op_actions[TGSI_OPCODE_IMUL_HI].emit = imul_hi_emit; + bld_base->op_actions[TGSI_OPCODE_UMUL_HI].emit = umul_hi_emit; + + bld_base->op_actions[TGSI_OPCODE_MAX].emit = fmax_emit; + bld_base->op_actions[TGSI_OPCODE_MIN].emit = fmin_emit; } /* CPU Only default actions */ @@ -806,6 +1003,41 @@ add_emit_cpu( emit_data->args[0], emit_data->args[1]); } +/* TGSI_OPCODE_AND (CPU Only) */ +static void +and_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_and(&bld_base->uint_bld, + emit_data->args[0], emit_data->args[1]); +} + +/* TGSI_OPCODE_ARL (CPU Only) */ +static void +arl_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + LLVMValueRef tmp; + tmp = lp_build_floor(&bld_base->base, + emit_data->args[0]); + emit_data->output[emit_data->chan] = LLVMBuildFPToSI(bld_base->base.gallivm->builder, tmp, + bld_base->uint_bld.vec_type, ""); +} + +/* TGSI_OPCODE_ARR (CPU Only) */ +static void +arr_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_iround(&bld_base->base, emit_data->args[0]); +} + /* TGSI_OPCODE_CEIL (CPU Only) */ static void ceil_emit_cpu( @@ -813,8 +1045,8 @@ ceil_emit_cpu( struct lp_build_tgsi_context * bld_base, struct lp_build_emit_data * emit_data) { - emit_data->output[emit_data->chan] = lp_build_trunc(&bld_base->base, - emit_data->args[0]); + emit_data->output[emit_data->chan] = lp_build_ceil(&bld_base->base, + emit_data->args[0]); } /* TGSI_OPCODE_CMP (CPU Only) */ @@ -830,6 +1062,26 @@ cmp_emit_cpu( cond, emit_data->args[1], emit_data->args[2]); } +/* TGSI_OPCODE_UCMP (CPU Only) */ +static void +ucmp_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + LLVMBuilderRef builder = bld_base->base.gallivm->builder; + struct lp_build_context *uint_bld = &bld_base->uint_bld; + LLVMValueRef unsigned_cond = + LLVMBuildBitCast(builder, emit_data->args[0], uint_bld->vec_type, ""); + LLVMValueRef cond = lp_build_cmp(uint_bld, PIPE_FUNC_NOTEQUAL, + unsigned_cond, + uint_bld->zero); + emit_data->output[emit_data->chan] = + lp_build_select(&bld_base->base, + cond, emit_data->args[1], emit_data->args[2]); +} + + /* TGSI_OPCODE_CND (CPU Only) */ static void cnd_emit_cpu( @@ -880,18 +1132,79 @@ ex2_emit_cpu( emit_data->args[0]); } -/* TGSI_OPCODE_EXP (CPU Only) */ +/* TGSI_OPCODE_F2I (CPU Only) */ static void -exp_emit_cpu( +f2i_emit_cpu( const struct lp_build_tgsi_action * action, struct lp_build_tgsi_context * bld_base, struct lp_build_emit_data * emit_data) { - lp_build_exp2_approx(&bld_base->base, emit_data->args[0], - &emit_data->output[TGSI_CHAN_X], - &emit_data->output[TGSI_CHAN_Y], - &emit_data->output[TGSI_CHAN_Z]); - emit_data->output[TGSI_CHAN_W] = bld_base->base.one; + emit_data->output[emit_data->chan] = lp_build_itrunc(&bld_base->base, + emit_data->args[0]); +} + +/* TGSI_OPCODE_FSET Helper (CPU Only) */ +static void +fset_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data, + unsigned pipe_func) +{ + LLVMValueRef cond; + + if (pipe_func != PIPE_FUNC_NOTEQUAL) { + cond = lp_build_cmp_ordered(&bld_base->base, pipe_func, + emit_data->args[0], emit_data->args[1]); + } + else { + cond = lp_build_cmp(&bld_base->base, pipe_func, + emit_data->args[0], emit_data->args[1]); + + } + emit_data->output[emit_data->chan] = cond; +} + + +/* TGSI_OPCODE_FSEQ (CPU Only) */ +static void +fseq_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL); +} + +/* TGSI_OPCODE_ISGE (CPU Only) */ +static void +fsge_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL); +} + +/* TGSI_OPCODE_ISLT (CPU Only) */ +static void +fslt_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS); +} + +/* TGSI_OPCODE_USNE (CPU Only) */ + +static void +fsne_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + fset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL); } /* TGSI_OPCODE_FLR (CPU Only) */ @@ -906,6 +1219,133 @@ flr_emit_cpu( emit_data->args[0]); } +/* TGSI_OPCODE_I2F (CPU Only) */ +static void +i2f_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_int_to_float(&bld_base->base, + emit_data->args[0]); +} + +/* TGSI_OPCODE_IABS (CPU Only) */ +static void +iabs_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_abs(&bld_base->int_bld, + emit_data->args[0]); +} + +/* TGSI_OPCODE_IDIV (CPU Only) */ +static void +idiv_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_div(&bld_base->int_bld, + emit_data->args[0], emit_data->args[1]); +} + +/* TGSI_OPCODE_INEG (CPU Only) */ +static void +ineg_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_sub(&bld_base->int_bld, + bld_base->int_bld.zero, + emit_data->args[0]); +} + +/* TGSI_OPCODE_ISET Helper (CPU Only) */ +static void +iset_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data, + unsigned pipe_func) +{ + LLVMValueRef cond = lp_build_cmp(&bld_base->int_bld, pipe_func, + emit_data->args[0], emit_data->args[1]); + emit_data->output[emit_data->chan] = cond; +} + +/* TGSI_OPCODE_IMAX (CPU Only) */ +static void +imax_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_max(&bld_base->int_bld, + emit_data->args[0], emit_data->args[1]); +} + +/* TGSI_OPCODE_IMIN (CPU Only) */ +static void +imin_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_min(&bld_base->int_bld, + emit_data->args[0], emit_data->args[1]); +} + +/* TGSI_OPCODE_ISGE (CPU Only) */ +static void +isge_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL); +} + +/* TGSI_OPCODE_ISHR (CPU Only) */ +static void +ishr_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + struct lp_build_context *int_bld = &bld_base->int_bld; + LLVMValueRef mask = lp_build_const_vec(int_bld->gallivm, int_bld->type, + int_bld->type.width - 1); + LLVMValueRef masked_count = lp_build_and(int_bld, emit_data->args[1], mask); + emit_data->output[emit_data->chan] = lp_build_shr(int_bld, emit_data->args[0], + masked_count); +} + +/* TGSI_OPCODE_ISLT (CPU Only) */ +static void +islt_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + iset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS); +} + + +/* TGSI_OPCODE_ISSG (CPU Only) */ +static void +issg_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_sgn(&bld_base->int_bld, + emit_data->args[0]); +} + /* TGSI_OPCODE_LG2 (CPU Only) */ static void lg2_emit_cpu( @@ -913,8 +1353,8 @@ lg2_emit_cpu( struct lp_build_tgsi_context * bld_base, struct lp_build_emit_data * emit_data) { - emit_data->output[emit_data->chan] = lp_build_log2(&bld_base->base, - emit_data->args[0]); + emit_data->output[emit_data->chan] = lp_build_log2_safe(&bld_base->base, + emit_data->args[0]); } /* TGSI_OPCODE_LOG (CPU Only) */ @@ -930,7 +1370,7 @@ log_emit_cpu( LLVMValueRef src0 = emit_data->args[0]; lp_build_log2_approx(&bld_base->base, src0, - &p_exp, &p_floor_log2, &p_log2); + &p_exp, &p_floor_log2, &p_log2, FALSE); emit_data->output[TGSI_CHAN_X] = p_floor_log2; @@ -951,8 +1391,10 @@ max_emit_cpu( struct lp_build_tgsi_context * bld_base, struct lp_build_emit_data * emit_data) { - emit_data->output[emit_data->chan] = lp_build_max(&bld_base->base, - emit_data->args[0], emit_data->args[1]); + emit_data->output[emit_data->chan] = + lp_build_max_ext(&bld_base->base, + emit_data->args[0], emit_data->args[1], + GALLIVM_NAN_RETURN_OTHER); } /* TGSI_OPCODE_MIN (CPU Only) */ @@ -962,7 +1404,42 @@ min_emit_cpu( struct lp_build_tgsi_context * bld_base, struct lp_build_emit_data * emit_data) { - emit_data->output[emit_data->chan] = lp_build_min(&bld_base->base, + emit_data->output[emit_data->chan] = + lp_build_min_ext(&bld_base->base, + emit_data->args[0], emit_data->args[1], + GALLIVM_NAN_RETURN_OTHER); +} + +/* TGSI_OPCODE_MOD (CPU Only) */ +static void +mod_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_mod(&bld_base->int_bld, + emit_data->args[0], emit_data->args[1]); +} + +/* TGSI_OPCODE_NOT */ +static void +not_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_not(&bld_base->uint_bld, + emit_data->args[0]); +} + +/* TGSI_OPCODE_OR (CPU Only) */ +static void +or_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_or(&bld_base->uint_bld, emit_data->args[0], emit_data->args[1]); } @@ -991,9 +1468,6 @@ rcp_emit_cpu( } /* Reciprical squareroot (CPU Only) */ - -/* This is not the same as TGSI_OPCODE_RSQ, which requres the argument to be - * greater than or equal to 0 */ static void recip_sqrt_emit_cpu( const struct lp_build_tgsi_action * action, @@ -1004,6 +1478,17 @@ recip_sqrt_emit_cpu( emit_data->args[0]); } +static void +sqrt_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_sqrt(&bld_base->base, + emit_data->args[0]); +} + + /* TGSI_OPCODE_ROUND (CPU Only) */ static void round_emit_cpu( @@ -1024,8 +1509,17 @@ set_emit_cpu( struct lp_build_emit_data * emit_data, unsigned pipe_func) { - LLVMValueRef cond = lp_build_cmp(&bld_base->base, pipe_func, - emit_data->args[0], emit_data->args[1]); + LLVMValueRef cond; + + if (pipe_func != PIPE_FUNC_NOTEQUAL) { + cond = lp_build_cmp_ordered(&bld_base->base, pipe_func, + emit_data->args[0], emit_data->args[1]); + } + else { + cond = lp_build_cmp(&bld_base->base, pipe_func, + emit_data->args[0], emit_data->args[1]); + + } emit_data->output[emit_data->chan] = lp_build_select(&bld_base->base, cond, bld_base->base.one, @@ -1064,6 +1558,21 @@ sgt_emit_cpu( set_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GREATER); } +/* TGSI_OPCODE_SHL (CPU Only) */ +static void +shl_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + struct lp_build_context *uint_bld = &bld_base->uint_bld; + LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type, + uint_bld->type.width - 1); + LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask); + emit_data->output[emit_data->chan] = lp_build_shl(uint_bld, emit_data->args[0], + masked_count); +} + /* TGSI_OPCODE_SIN (CPU Only) */ static void sin_emit_cpu( @@ -1086,7 +1595,6 @@ sle_emit_cpu( } /* TGSI_OPCODE_SLT (CPU Only) */ - static void slt_emit_cpu( const struct lp_build_tgsi_action * action, @@ -1144,6 +1652,172 @@ trunc_emit_cpu( emit_data->args[0]); } +/* TGSI_OPCODE_UADD (CPU Only) */ +static void +uadd_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_add(&bld_base->uint_bld, + emit_data->args[0], emit_data->args[1]); +} + +/* TGSI_OPCODE_UDIV (CPU Only) */ +static void +udiv_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + + LLVMBuilderRef builder = bld_base->base.gallivm->builder; + LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld, + PIPE_FUNC_EQUAL, emit_data->args[1], + bld_base->uint_bld.zero); + /* We want to make sure that we never divide/mod by zero to not + * generate sigfpe. We don't want to crash just because the + * shader is doing something weird. */ + LLVMValueRef divisor = LLVMBuildOr(builder, + div_mask, + emit_data->args[1], ""); + LLVMValueRef result = lp_build_div(&bld_base->uint_bld, + emit_data->args[0], divisor); + /* udiv by zero is guaranteed to return 0xffffffff */ + emit_data->output[emit_data->chan] = LLVMBuildOr(builder, + div_mask, + result, ""); +} + +/* TGSI_OPCODE_UMAX (CPU Only) */ +static void +umax_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_max(&bld_base->uint_bld, + emit_data->args[0], emit_data->args[1]); +} + +/* TGSI_OPCODE_UMIN (CPU Only) */ +static void +umin_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_min(&bld_base->uint_bld, + emit_data->args[0], emit_data->args[1]); +} + +/* TGSI_OPCODE_UMOD (CPU Only) */ +static void +umod_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + LLVMBuilderRef builder = bld_base->base.gallivm->builder; + LLVMValueRef div_mask = lp_build_cmp(&bld_base->uint_bld, + PIPE_FUNC_EQUAL, emit_data->args[1], + bld_base->uint_bld.zero); + /* We want to make sure that we never divide/mod by zero to not + * generate sigfpe. We don't want to crash just because the + * shader is doing something weird. */ + LLVMValueRef divisor = LLVMBuildOr(builder, + div_mask, + emit_data->args[1], ""); + LLVMValueRef result = lp_build_mod(&bld_base->uint_bld, + emit_data->args[0], divisor); + /* umod by zero is guaranteed to return 0xffffffff */ + emit_data->output[emit_data->chan] = LLVMBuildOr(builder, + div_mask, + result, ""); +} + +/* TGSI_OPCODE_USET Helper (CPU Only) */ +static void +uset_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data, + unsigned pipe_func) +{ + LLVMValueRef cond = lp_build_cmp(&bld_base->uint_bld, pipe_func, + emit_data->args[0], emit_data->args[1]); + emit_data->output[emit_data->chan] = cond; +} + + +/* TGSI_OPCODE_USEQ (CPU Only) */ +static void +useq_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_EQUAL); +} + +/* TGSI_OPCODE_ISGE (CPU Only) */ +static void +usge_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_GEQUAL); +} + +/* TGSI_OPCODE_USHR (CPU Only) */ +static void +ushr_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + struct lp_build_context *uint_bld = &bld_base->uint_bld; + LLVMValueRef mask = lp_build_const_vec(uint_bld->gallivm, uint_bld->type, + uint_bld->type.width - 1); + LLVMValueRef masked_count = lp_build_and(uint_bld, emit_data->args[1], mask); + emit_data->output[emit_data->chan] = lp_build_shr(uint_bld, emit_data->args[0], + masked_count); +} + +/* TGSI_OPCODE_ISLT (CPU Only) */ +static void +uslt_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_LESS); +} + +/* TGSI_OPCODE_USNE (CPU Only) */ + +static void +usne_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + uset_emit_cpu(action, bld_base, emit_data, PIPE_FUNC_NOTEQUAL); +} + +/* TGSI_OPCODE_XOR */ +static void +xor_emit_cpu( + const struct lp_build_tgsi_action * action, + struct lp_build_tgsi_context * bld_base, + struct lp_build_emit_data * emit_data) +{ + emit_data->output[emit_data->chan] = lp_build_xor(&bld_base->uint_bld, + emit_data->args[0], + emit_data->args[1]); +} + void lp_set_default_actions_cpu( struct lp_build_tgsi_context * bld_base) @@ -1151,19 +1825,40 @@ lp_set_default_actions_cpu( lp_set_default_actions(bld_base); bld_base->op_actions[TGSI_OPCODE_ABS].emit = abs_emit_cpu; bld_base->op_actions[TGSI_OPCODE_ADD].emit = add_emit_cpu; - bld_base->op_actions[TGSI_OPCODE_ARL].emit = flr_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_AND].emit = and_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_ARL].emit = arl_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_ARR].emit = arr_emit_cpu; bld_base->op_actions[TGSI_OPCODE_CEIL].emit = ceil_emit_cpu; bld_base->op_actions[TGSI_OPCODE_CND].emit = cnd_emit_cpu; bld_base->op_actions[TGSI_OPCODE_COS].emit = cos_emit_cpu; bld_base->op_actions[TGSI_OPCODE_CMP].emit = cmp_emit_cpu; bld_base->op_actions[TGSI_OPCODE_DIV].emit = div_emit_cpu; bld_base->op_actions[TGSI_OPCODE_EX2].emit = ex2_emit_cpu; - bld_base->op_actions[TGSI_OPCODE_EXP].emit = exp_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_F2I].emit = f2i_emit_cpu; bld_base->op_actions[TGSI_OPCODE_FLR].emit = flr_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_FSEQ].emit = fseq_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_FSGE].emit = fsge_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_FSLT].emit = fslt_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_FSNE].emit = fsne_emit_cpu; + + bld_base->op_actions[TGSI_OPCODE_I2F].emit = i2f_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_IABS].emit = iabs_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_IDIV].emit = idiv_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_INEG].emit = ineg_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_IMAX].emit = imax_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_IMIN].emit = imin_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_ISGE].emit = isge_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_ISHR].emit = ishr_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_ISLT].emit = islt_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_ISSG].emit = issg_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_LG2].emit = lg2_emit_cpu; bld_base->op_actions[TGSI_OPCODE_LOG].emit = log_emit_cpu; bld_base->op_actions[TGSI_OPCODE_MAX].emit = max_emit_cpu; bld_base->op_actions[TGSI_OPCODE_MIN].emit = min_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_MOD].emit = mod_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_NOT].emit = not_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_OR].emit = or_emit_cpu; bld_base->op_actions[TGSI_OPCODE_POW].emit = pow_emit_cpu; bld_base->op_actions[TGSI_OPCODE_RCP].emit = rcp_emit_cpu; bld_base->op_actions[TGSI_OPCODE_ROUND].emit = round_emit_cpu; @@ -1171,6 +1866,7 @@ lp_set_default_actions_cpu( bld_base->op_actions[TGSI_OPCODE_SGE].emit = sge_emit_cpu; bld_base->op_actions[TGSI_OPCODE_SGT].emit = sgt_emit_cpu; bld_base->op_actions[TGSI_OPCODE_SIN].emit = sin_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_SHL].emit = shl_emit_cpu; bld_base->op_actions[TGSI_OPCODE_SLE].emit = sle_emit_cpu; bld_base->op_actions[TGSI_OPCODE_SLT].emit = slt_emit_cpu; bld_base->op_actions[TGSI_OPCODE_SNE].emit = sne_emit_cpu; @@ -1179,4 +1875,20 @@ lp_set_default_actions_cpu( bld_base->op_actions[TGSI_OPCODE_TRUNC].emit = trunc_emit_cpu; bld_base->rsq_action.emit = recip_sqrt_emit_cpu; + bld_base->sqrt_action.emit = sqrt_emit_cpu; + + bld_base->op_actions[TGSI_OPCODE_UADD].emit = uadd_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_UCMP].emit = ucmp_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_UDIV].emit = udiv_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_UMAX].emit = umax_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_UMIN].emit = umin_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_UMOD].emit = umod_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_USEQ].emit = useq_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_USGE].emit = usge_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_USHR].emit = ushr_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_USLT].emit = uslt_emit_cpu; + bld_base->op_actions[TGSI_OPCODE_USNE].emit = usne_emit_cpu; + + bld_base->op_actions[TGSI_OPCODE_XOR].emit = xor_emit_cpu; + }