diff --git a/src/gallium/auxiliary/gallivm/lp_bld_tgsi.h b/src/gallium/auxiliary/gallivm/lp_bld_tgsi.h index a4435e282c8..9ca4c6e380d 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_tgsi.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_tgsi.h @@ -301,18 +301,6 @@ lp_build_tgsi_soa(struct gallivm_state *gallivm, const struct lp_build_tgsi_params *params, LLVMValueRef (*outputs)[4]); -void -lp_build_tgsi_aos(struct gallivm_state *gallivm, - const struct tgsi_token *tokens, - struct lp_type type, - const unsigned char swizzles[4], - LLVMValueRef consts_ptr, - const LLVMValueRef *inputs, - LLVMValueRef *outputs, - const struct lp_build_sampler_aos *sampler, - const struct tgsi_shader_info *info); - - struct lp_build_tgsi_inst_list { struct tgsi_full_instruction *instructions; @@ -640,87 +628,16 @@ lp_get_output_ptr( unsigned index, unsigned chan); -struct lp_build_tgsi_aos_context -{ - struct lp_build_tgsi_context bld_base; - - /* Builder for integer masks and indices */ - struct lp_build_context int_bld; - - /* - * AoS swizzle used: - * - swizzles[0] = red index - * - swizzles[1] = green index - * - swizzles[2] = blue index - * - swizzles[3] = alpha index - */ - unsigned char swizzles[4]; - unsigned char inv_swizzles[4]; - - LLVMValueRef consts_ptr; - const LLVMValueRef *inputs; - LLVMValueRef *outputs; - - const struct lp_build_sampler_aos *sampler; - - struct tgsi_declaration_sampler_view sv[PIPE_MAX_SHADER_SAMPLER_VIEWS]; - - LLVMValueRef immediates[LP_MAX_INLINED_IMMEDIATES]; - LLVMValueRef temps[LP_MAX_INLINED_TEMPS]; - LLVMValueRef addr[LP_MAX_TGSI_ADDRS]; - - /* We allocate/use this array of temps if (1 << TGSI_FILE_TEMPORARY) is - * set in the indirect_files field. - * The temps[] array above is unused then. - */ - LLVMValueRef temps_array; - - /** bitmask indicating which register files are accessed indirectly */ - unsigned indirect_files; - -}; - static inline struct lp_build_tgsi_soa_context * lp_soa_context(struct lp_build_tgsi_context *bld_base) { return (struct lp_build_tgsi_soa_context *)bld_base; } -static inline struct lp_build_tgsi_aos_context * -lp_aos_context(struct lp_build_tgsi_context *bld_base) -{ - return (struct lp_build_tgsi_aos_context *)bld_base; -} - -void -lp_emit_declaration_aos( - struct lp_build_tgsi_aos_context *bld, - const struct tgsi_full_declaration *decl); - - -bool -lp_emit_instruction_aos( - struct lp_build_tgsi_aos_context *bld, - const struct tgsi_full_instruction *inst, - const struct tgsi_opcode_info *info, - int *pc); - -void -lp_emit_store_aos( - struct lp_build_tgsi_aos_context *bld, - const struct tgsi_full_instruction *inst, - unsigned index, - LLVMValueRef value); - void lp_build_fetch_args( struct lp_build_tgsi_context * bld_base, struct lp_build_emit_data * emit_data); -LLVMValueRef -lp_build_tgsi_inst_llvm_aos( - struct lp_build_tgsi_context * bld_base, - const struct tgsi_full_instruction *inst); - void lp_build_tgsi_intrinsic( const struct lp_build_tgsi_action * action, diff --git a/src/gallium/auxiliary/gallivm/lp_bld_tgsi_aos.c b/src/gallium/auxiliary/gallivm/lp_bld_tgsi_aos.c deleted file mode 100644 index 6f8f4e6a5a4..00000000000 --- a/src/gallium/auxiliary/gallivm/lp_bld_tgsi_aos.c +++ /dev/null @@ -1,980 +0,0 @@ -/************************************************************************** - * - * Copyright 2010 VMware, Inc. - * All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the - * "Software"), to deal in the Software without restriction, including - * without limitation the rights to use, copy, modify, merge, publish, - * distribute, sub license, and/or sell copies of the Software, and to - * permit persons to whom the Software is furnished to do so, subject to - * the following conditions: - * - * The above copyright notice and this permission notice (including the - * next paragraph) shall be included in all copies or substantial portions - * of the Software. - * - * 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 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. - * - **************************************************************************/ - -/** - * @file - * TGSI to LLVM IR translation -- AoS. - * - * FIXME: - * - No control flow support: the existing control flow code should be factored - * out into from the SoA code into a common module and shared. - * - No derivatives. Derivate logic should be pluggable, just like the samplers. - * - * @author Jose Fonseca - */ - -#include "util/detect.h" -#include "pipe/p_shader_tokens.h" -#include "util/u_debug.h" -#include "util/u_math.h" -#include "util/u_memory.h" -#include "tgsi/tgsi_dump.h" -#include "tgsi/tgsi_info.h" -#include "tgsi/tgsi_parse.h" -#include "tgsi/tgsi_scan.h" -#include "lp_bld_type.h" -#include "lp_bld_const.h" -#include "lp_bld_arit.h" -#include "lp_bld_logic.h" -#include "lp_bld_swizzle.h" -#include "lp_bld_flow.h" -#include "lp_bld_quad.h" -#include "lp_bld_tgsi.h" -#include "lp_bld_debug.h" -#include "lp_bld_sample.h" - - -/** - * Wrapper around lp_build_swizzle_aos which translates swizzles to another - * ordering. - */ -static LLVMValueRef -swizzle_aos(struct lp_build_tgsi_context *bld_base, - LLVMValueRef a, - unsigned swizzle_x, - unsigned swizzle_y, - unsigned swizzle_z, - unsigned swizzle_w) -{ - unsigned char swizzles[4]; - struct lp_build_tgsi_aos_context *bld = lp_aos_context(bld_base); - - assert(swizzle_x < 4); - assert(swizzle_y < 4); - assert(swizzle_z < 4); - assert(swizzle_w < 4); - - swizzles[bld->inv_swizzles[0]] = bld->swizzles[swizzle_x]; - swizzles[bld->inv_swizzles[1]] = bld->swizzles[swizzle_y]; - swizzles[bld->inv_swizzles[2]] = bld->swizzles[swizzle_z]; - swizzles[bld->inv_swizzles[3]] = bld->swizzles[swizzle_w]; - - return lp_build_swizzle_aos(&bld->bld_base.base, a, swizzles); -} - - -static LLVMValueRef -swizzle_scalar_aos(struct lp_build_tgsi_aos_context *bld, - LLVMValueRef a, - unsigned chan) -{ - chan = bld->swizzles[chan]; - return lp_build_swizzle_scalar_aos(&bld->bld_base.base, a, chan, 4); -} - - -static LLVMValueRef -emit_fetch_constant( - struct lp_build_tgsi_context * bld_base, - const struct tgsi_full_src_register * reg, - enum tgsi_opcode_type stype, - unsigned swizzle) -{ - struct lp_build_tgsi_aos_context * bld = lp_aos_context(bld_base); - LLVMBuilderRef builder = bld_base->base.gallivm->builder; - struct lp_type type = bld_base->base.type; - LLVMValueRef res; - unsigned chan; - LLVMTypeRef i8t = LLVMInt8TypeInContext(bld_base->base.gallivm->context); - assert(!reg->Register.Indirect); - - /* - * Get the constants components - */ - - res = bld->bld_base.base.undef; - for (chan = 0; chan < 4; ++chan) { - LLVMValueRef index; - LLVMValueRef scalar_ptr; - LLVMValueRef scalar; - LLVMValueRef swizzle; - - index = lp_build_const_int32(bld->bld_base.base.gallivm, - reg->Register.Index * 4 + chan); - - scalar_ptr = LLVMBuildGEP2(builder, i8t, bld->consts_ptr, &index, 1, ""); - - scalar = LLVMBuildLoad2(builder, i8t, scalar_ptr, ""); - - lp_build_name(scalar, "const[%u].%c", reg->Register.Index, "xyzw"[chan]); - - /* - * NOTE: constants array is always assumed to be RGBA - */ - - swizzle = lp_build_const_int32(bld->bld_base.base.gallivm, - bld->swizzles[chan]); - - res = LLVMBuildInsertElement(builder, res, scalar, swizzle, ""); - } - - /* - * Broadcast the first quaternion to all others. - * - * XXX: could be factored into a reusable function. - */ - - if (type.length > 4) { - LLVMValueRef shuffles[LP_MAX_VECTOR_LENGTH]; - unsigned i; - - for (chan = 0; chan < 4; ++chan) { - shuffles[chan] = lp_build_const_int32(bld->bld_base.base.gallivm, chan); - } - - for (i = 4; i < type.length; ++i) { - shuffles[i] = shuffles[i % 4]; - } - - res = LLVMBuildShuffleVector(builder, - res, bld->bld_base.base.undef, - LLVMConstVector(shuffles, type.length), - ""); - } - return res; -} - -static LLVMValueRef -emit_fetch_immediate( - struct lp_build_tgsi_context * bld_base, - const struct tgsi_full_src_register * reg, - enum tgsi_opcode_type stype, - unsigned swizzle) -{ - struct lp_build_tgsi_aos_context * bld = lp_aos_context(bld_base); - LLVMValueRef res = bld->immediates[reg->Register.Index]; - assert(res); - return res; -} - -static LLVMValueRef -emit_fetch_input( - struct lp_build_tgsi_context * bld_base, - const struct tgsi_full_src_register * reg, - enum tgsi_opcode_type stype, - unsigned swizzle) -{ - struct lp_build_tgsi_aos_context * bld = lp_aos_context(bld_base); - LLVMValueRef res = bld->inputs[reg->Register.Index]; - assert(!reg->Register.Indirect); - assert(res); - return res; -} - -static LLVMValueRef -emit_fetch_temporary( - struct lp_build_tgsi_context * bld_base, - const struct tgsi_full_src_register * reg, - enum tgsi_opcode_type stype, - unsigned swizzle) -{ - struct lp_build_tgsi_aos_context * bld = lp_aos_context(bld_base); - LLVMBuilderRef builder = bld_base->base.gallivm->builder; - LLVMValueRef temp_ptr = bld->temps[reg->Register.Index]; - LLVMTypeRef vec_type = lp_build_vec_type(bld->bld_base.base.gallivm, bld->bld_base.base.type); - LLVMValueRef res = LLVMBuildLoad2(builder, vec_type, temp_ptr, ""); - assert(!reg->Register.Indirect); - if (!res) - return bld->bld_base.base.undef; - - return res; -} - -/** - * Register store. - */ -void -lp_emit_store_aos( - struct lp_build_tgsi_aos_context *bld, - const struct tgsi_full_instruction *inst, - unsigned index, - LLVMValueRef value) -{ - LLVMBuilderRef builder = bld->bld_base.base.gallivm->builder; - const struct tgsi_full_dst_register *reg = &inst->Dst[index]; - LLVMValueRef mask = NULL; - LLVMValueRef ptr; - - /* - * Saturate the value - */ - if (inst->Instruction.Saturate) { - value = lp_build_max(&bld->bld_base.base, value, bld->bld_base.base.zero); - value = lp_build_min(&bld->bld_base.base, value, bld->bld_base.base.one); - } - - /* - * Translate the register file - */ - - assert(!reg->Register.Indirect); - - switch (reg->Register.File) { - case TGSI_FILE_OUTPUT: - ptr = bld->outputs[reg->Register.Index]; - break; - - case TGSI_FILE_TEMPORARY: - ptr = bld->temps[reg->Register.Index]; - break; - - case TGSI_FILE_ADDRESS: - ptr = bld->addr[reg->Indirect.Index]; - break; - - default: - assert(0); - return; - } - - if (!ptr) - return; - - /* - * Writemask - */ - - if (reg->Register.WriteMask != TGSI_WRITEMASK_XYZW) { - LLVMValueRef writemask; - - writemask = lp_build_const_mask_aos_swizzled(bld->bld_base.base.gallivm, - bld->bld_base.base.type, - reg->Register.WriteMask, - TGSI_NUM_CHANNELS, - bld->swizzles); - - if (mask) { - mask = LLVMBuildAnd(builder, mask, writemask, ""); - } else { - mask = writemask; - } - } - - if (mask) { - LLVMValueRef orig_value; - LLVMTypeRef vec_type = lp_build_vec_type(bld->bld_base.base.gallivm, bld->bld_base.base.type); - orig_value = LLVMBuildLoad2(builder, vec_type, ptr, ""); - value = lp_build_select(&bld->bld_base.base, - mask, value, orig_value); - } - - LLVMBuildStore(builder, value, ptr); -} - - -/** - * High-level instruction translators. - */ - -static LLVMValueRef -emit_tex(struct lp_build_tgsi_aos_context *bld, - const struct tgsi_full_instruction *inst, - enum lp_build_tex_modifier modifier) -{ - unsigned target; - unsigned unit; - LLVMValueRef coords; - struct lp_derivatives derivs = { {NULL}, {NULL} }; - - if (!bld->sampler) { - _debug_printf("warning: found texture instruction but no sampler generator supplied\n"); - return bld->bld_base.base.undef; - } - - target = inst->Texture.Texture; - - coords = lp_build_emit_fetch( &bld->bld_base, inst, 0 , LP_CHAN_ALL); - - if (modifier == LP_BLD_TEX_MODIFIER_EXPLICIT_DERIV) { - /* probably not going to work */ - derivs.ddx[0] = lp_build_emit_fetch( &bld->bld_base, inst, 1 , LP_CHAN_ALL); - derivs.ddy[0] = lp_build_emit_fetch( &bld->bld_base, inst, 2 , LP_CHAN_ALL); - unit = inst->Src[3].Register.Index; - } - else { - unit = inst->Src[1].Register.Index; - } - return bld->sampler->emit_fetch_texel(bld->sampler, - &bld->bld_base.base, - target, unit, - coords, derivs, - modifier); -} - - -static LLVMValueRef -emit_sample(struct lp_build_tgsi_aos_context *bld, - const struct tgsi_full_instruction *inst, - enum lp_build_tex_modifier modifier) -{ - unsigned target; - unsigned unit; - LLVMValueRef coords; - struct lp_derivatives derivs = { {NULL}, {NULL} }; - - if (!bld->sampler) { - _debug_printf("warning: found texture instruction but no sampler generator supplied\n"); - return bld->bld_base.base.undef; - } - - coords = lp_build_emit_fetch( &bld->bld_base, inst, 0 , LP_CHAN_ALL); - - /* ignore modifiers, can't handle different sampler / sampler view, etc... */ - unit = inst->Src[1].Register.Index; - assert(inst->Src[2].Register.Index == unit); - - target = bld->sv[unit].Resource; - - return bld->sampler->emit_fetch_texel(bld->sampler, - &bld->bld_base.base, - target, unit, - coords, derivs, - modifier); -} - - -void -lp_emit_declaration_aos( - struct lp_build_tgsi_aos_context *bld, - const struct tgsi_full_declaration *decl) -{ - struct gallivm_state *gallivm = bld->bld_base.base.gallivm; - LLVMTypeRef vec_type = lp_build_vec_type(bld->bld_base.base.gallivm, bld->bld_base.base.type); - - unsigned first = decl->Range.First; - unsigned last = decl->Range.Last; - unsigned idx; - - for (idx = first; idx <= last; ++idx) { - switch (decl->Declaration.File) { - case TGSI_FILE_TEMPORARY: - assert(idx < LP_MAX_INLINED_TEMPS); - if (bld->indirect_files & (1 << TGSI_FILE_TEMPORARY)) { - LLVMValueRef array_size = lp_build_const_int32(gallivm, last + 1); - bld->temps_array = lp_build_array_alloca(bld->bld_base.base.gallivm, - vec_type, array_size, ""); - } else { - bld->temps[idx] = lp_build_alloca(gallivm, vec_type, ""); - } - break; - - case TGSI_FILE_OUTPUT: - bld->outputs[idx] = lp_build_alloca(gallivm, vec_type, ""); - break; - - case TGSI_FILE_ADDRESS: - assert(idx < LP_MAX_TGSI_ADDRS); - bld->addr[idx] = lp_build_alloca(gallivm, vec_type, ""); - break; - - case TGSI_FILE_SAMPLER_VIEW: - /* - * The target stored here MUST match whatever there actually - * is in the set sampler views (what about return type?). - */ - assert(last < PIPE_MAX_SHADER_SAMPLER_VIEWS); - for (idx = first; idx <= last; ++idx) { - bld->sv[idx] = decl->SamplerView; - } - break; - - default: - /* don't need to declare other vars */ - break; - } - } -} - - -/** - * Emit LLVM for one TGSI instruction. - * \param return TRUE for success, FALSE otherwise - */ -bool -lp_emit_instruction_aos( - struct lp_build_tgsi_aos_context *bld, - const struct tgsi_full_instruction *inst, - const struct tgsi_opcode_info *info, - int *pc) -{ - LLVMValueRef src0, src1, src2; - LLVMValueRef tmp0; - LLVMValueRef dst0 = NULL; - - /* - * Stores and write masks are handled in a general fashion after the long - * instruction opcode switch statement. - * - * Although not stricitly necessary, we avoid generating instructions for - * channels which won't be stored, in cases where's that easy. For some - * complex instructions, like texture sampling, it is more convenient to - * assume a full writemask and then let LLVM optimization passes eliminate - * redundant code. - */ - - (*pc)++; - - assert(info->num_dst <= 1); - if (info->num_dst) { - dst0 = bld->bld_base.base.undef; - } - - switch (inst->Instruction.Opcode) { - case TGSI_OPCODE_ARL: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - dst0 = lp_build_floor(&bld->bld_base.base, src0); - break; - - case TGSI_OPCODE_MOV: - dst0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - break; - - case TGSI_OPCODE_LIT: - return false; - - case TGSI_OPCODE_RCP: - /* TGSI_OPCODE_RECIP */ - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - dst0 = lp_build_rcp(&bld->bld_base.base, src0); - break; - - case TGSI_OPCODE_RSQ: - /* TGSI_OPCODE_RECIPSQRT */ - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - tmp0 = lp_build_abs(&bld->bld_base.base, src0); - dst0 = lp_build_rsqrt(&bld->bld_base.base, tmp0); - break; - - case TGSI_OPCODE_EXP: - return false; - - case TGSI_OPCODE_LOG: - return false; - - case TGSI_OPCODE_MUL: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL); - dst0 = lp_build_mul(&bld->bld_base.base, src0, src1); - break; - - case TGSI_OPCODE_ADD: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL); - dst0 = lp_build_add(&bld->bld_base.base, src0, src1); - break; - - case TGSI_OPCODE_DP3: - /* TGSI_OPCODE_DOT3 */ - return false; - - case TGSI_OPCODE_DP4: - /* TGSI_OPCODE_DOT4 */ - return false; - - case TGSI_OPCODE_DST: - return false; - - case TGSI_OPCODE_MIN: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL); - dst0 = lp_build_min(&bld->bld_base.base, src0, src1); - break; - - case TGSI_OPCODE_MAX: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL); - dst0 = lp_build_max(&bld->bld_base.base, src0, src1); - break; - - case TGSI_OPCODE_SLT: - /* TGSI_OPCODE_SETLT */ - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL); - tmp0 = lp_build_cmp(&bld->bld_base.base, PIPE_FUNC_LESS, src0, src1); - dst0 = lp_build_select(&bld->bld_base.base, tmp0, bld->bld_base.base.one, bld->bld_base.base.zero); - break; - - case TGSI_OPCODE_SGE: - /* TGSI_OPCODE_SETGE */ - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL); - tmp0 = lp_build_cmp(&bld->bld_base.base, PIPE_FUNC_GEQUAL, src0, src1); - dst0 = lp_build_select(&bld->bld_base.base, tmp0, bld->bld_base.base.one, bld->bld_base.base.zero); - break; - - case TGSI_OPCODE_MAD: - /* TGSI_OPCODE_MADD */ - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL); - src2 = lp_build_emit_fetch(&bld->bld_base, inst, 2, LP_CHAN_ALL); - tmp0 = lp_build_mul(&bld->bld_base.base, src0, src1); - dst0 = lp_build_add(&bld->bld_base.base, tmp0, src2); - break; - - case TGSI_OPCODE_LRP: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL); - src2 = lp_build_emit_fetch(&bld->bld_base, inst, 2, LP_CHAN_ALL); - tmp0 = lp_build_sub(&bld->bld_base.base, src1, src2); - tmp0 = lp_build_mul(&bld->bld_base.base, src0, tmp0); - dst0 = lp_build_add(&bld->bld_base.base, tmp0, src2); - break; - - case TGSI_OPCODE_FRC: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - tmp0 = lp_build_floor(&bld->bld_base.base, src0); - dst0 = lp_build_sub(&bld->bld_base.base, src0, tmp0); - break; - - case TGSI_OPCODE_FLR: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - dst0 = lp_build_floor(&bld->bld_base.base, src0); - break; - - case TGSI_OPCODE_ROUND: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - dst0 = lp_build_round(&bld->bld_base.base, src0); - break; - - case TGSI_OPCODE_EX2: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - tmp0 = lp_build_swizzle_scalar_aos(&bld->bld_base.base, src0, TGSI_SWIZZLE_X, TGSI_NUM_CHANNELS); - dst0 = lp_build_exp2(&bld->bld_base.base, tmp0); - break; - - case TGSI_OPCODE_LG2: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - tmp0 = swizzle_scalar_aos(bld, src0, TGSI_SWIZZLE_X); - dst0 = lp_build_log2(&bld->bld_base.base, tmp0); - break; - - case TGSI_OPCODE_POW: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - src0 = swizzle_scalar_aos(bld, src0, TGSI_SWIZZLE_X); - src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL); - src1 = swizzle_scalar_aos(bld, src1, TGSI_SWIZZLE_X); - dst0 = lp_build_pow(&bld->bld_base.base, src0, src1); - break; - - case TGSI_OPCODE_COS: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - tmp0 = swizzle_scalar_aos(bld, src0, TGSI_SWIZZLE_X); - dst0 = lp_build_cos(&bld->bld_base.base, tmp0); - break; - - case TGSI_OPCODE_DDX: - return false; - - case TGSI_OPCODE_DDY: - return false; - - case TGSI_OPCODE_KILL: - return false; - - case TGSI_OPCODE_KILL_IF: - return false; - - case TGSI_OPCODE_PK2H: - return false; - break; - - case TGSI_OPCODE_PK2US: - return false; - break; - - case TGSI_OPCODE_PK4B: - return false; - break; - - case TGSI_OPCODE_PK4UB: - return false; - - case TGSI_OPCODE_SEQ: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL); - tmp0 = lp_build_cmp(&bld->bld_base.base, PIPE_FUNC_EQUAL, src0, src1); - dst0 = lp_build_select(&bld->bld_base.base, tmp0, bld->bld_base.base.one, bld->bld_base.base.zero); - break; - - case TGSI_OPCODE_SGT: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL); - tmp0 = lp_build_cmp(&bld->bld_base.base, PIPE_FUNC_GREATER, src0, src1); - dst0 = lp_build_select(&bld->bld_base.base, tmp0, bld->bld_base.base.one, bld->bld_base.base.zero); - break; - - case TGSI_OPCODE_SIN: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - tmp0 = swizzle_scalar_aos(bld, src0, TGSI_SWIZZLE_X); - dst0 = lp_build_sin(&bld->bld_base.base, tmp0); - break; - - case TGSI_OPCODE_SLE: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL); - tmp0 = lp_build_cmp(&bld->bld_base.base, PIPE_FUNC_LEQUAL, src0, src1); - dst0 = lp_build_select(&bld->bld_base.base, tmp0, bld->bld_base.base.one, bld->bld_base.base.zero); - break; - - case TGSI_OPCODE_SNE: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL); - tmp0 = lp_build_cmp(&bld->bld_base.base, PIPE_FUNC_NOTEQUAL, src0, src1); - dst0 = lp_build_select(&bld->bld_base.base, tmp0, bld->bld_base.base.one, bld->bld_base.base.zero); - break; - - case TGSI_OPCODE_TEX: - dst0 = emit_tex(bld, inst, LP_BLD_TEX_MODIFIER_NONE); - break; - - case TGSI_OPCODE_TXD: - dst0 = emit_tex(bld, inst, LP_BLD_TEX_MODIFIER_EXPLICIT_DERIV); - break; - - case TGSI_OPCODE_UP2H: - /* deprecated */ - assert (0); - return false; - break; - - case TGSI_OPCODE_UP2US: - /* deprecated */ - assert(0); - return false; - break; - - case TGSI_OPCODE_UP4B: - /* deprecated */ - assert(0); - return false; - break; - - case TGSI_OPCODE_UP4UB: - /* deprecated */ - assert(0); - return false; - break; - - case TGSI_OPCODE_ARR: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - dst0 = lp_build_round(&bld->bld_base.base, src0); - break; - - case TGSI_OPCODE_CAL: - return false; - - case TGSI_OPCODE_RET: - /* safe to ignore at end */ - break; - - case TGSI_OPCODE_END: - *pc = -1; - break; - - case TGSI_OPCODE_SSG: - /* TGSI_OPCODE_SGN */ - tmp0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - dst0 = lp_build_sgn(&bld->bld_base.base, tmp0); - break; - - case TGSI_OPCODE_CMP: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - src1 = lp_build_emit_fetch(&bld->bld_base, inst, 1, LP_CHAN_ALL); - src2 = lp_build_emit_fetch(&bld->bld_base, inst, 2, LP_CHAN_ALL); - tmp0 = lp_build_cmp(&bld->bld_base.base, PIPE_FUNC_LESS, src0, bld->bld_base.base.zero); - dst0 = lp_build_select(&bld->bld_base.base, tmp0, src1, src2); - break; - - case TGSI_OPCODE_TXB: - dst0 = emit_tex(bld, inst, LP_BLD_TEX_MODIFIER_LOD_BIAS); - break; - - case TGSI_OPCODE_DIV: - assert(0); - return false; - break; - - case TGSI_OPCODE_DP2: - return false; - - case TGSI_OPCODE_TXL: - dst0 = emit_tex(bld, inst, LP_BLD_TEX_MODIFIER_EXPLICIT_LOD); - break; - - case TGSI_OPCODE_TXP: - dst0 = emit_tex(bld, inst, LP_BLD_TEX_MODIFIER_PROJECTED); - break; - - case TGSI_OPCODE_BRK: - return false; - - case TGSI_OPCODE_IF: - case TGSI_OPCODE_UIF: - return false; - - case TGSI_OPCODE_BGNLOOP: - return false; - - case TGSI_OPCODE_BGNSUB: - return false; - - case TGSI_OPCODE_ELSE: - return false; - - case TGSI_OPCODE_ENDIF: - return false; - - case TGSI_OPCODE_ENDLOOP: - return false; - - case TGSI_OPCODE_ENDSUB: - return false; - - case TGSI_OPCODE_CEIL: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - dst0 = lp_build_ceil(&bld->bld_base.base, src0); - break; - - case TGSI_OPCODE_I2F: - assert(0); - return false; - break; - - case TGSI_OPCODE_NOT: - assert(0); - return false; - break; - - case TGSI_OPCODE_TRUNC: - src0 = lp_build_emit_fetch(&bld->bld_base, inst, 0, LP_CHAN_ALL); - dst0 = lp_build_trunc(&bld->bld_base.base, src0); - break; - - case TGSI_OPCODE_SHL: - assert(0); - return false; - break; - - case TGSI_OPCODE_ISHR: - assert(0); - return false; - break; - - case TGSI_OPCODE_AND: - assert(0); - return false; - break; - - case TGSI_OPCODE_OR: - assert(0); - return false; - break; - - case TGSI_OPCODE_MOD: - assert(0); - return false; - break; - - case TGSI_OPCODE_XOR: - assert(0); - return false; - break; - - case TGSI_OPCODE_TXF: - assert(0); - return false; - break; - - case TGSI_OPCODE_TXQ: - assert(0); - return false; - break; - - case TGSI_OPCODE_CONT: - return false; - - case TGSI_OPCODE_EMIT: - return false; - break; - - case TGSI_OPCODE_ENDPRIM: - return false; - break; - - case TGSI_OPCODE_NOP: - break; - - case TGSI_OPCODE_SAMPLE: - dst0 = emit_sample(bld, inst, LP_BLD_TEX_MODIFIER_NONE); - break; - - default: - return false; - } - - if (info->num_dst) { - lp_emit_store_aos(bld, inst, 0, dst0); - } - - return true; -} - - -void -lp_build_tgsi_aos(struct gallivm_state *gallivm, - const struct tgsi_token *tokens, - struct lp_type type, - const unsigned char swizzles[4], - LLVMValueRef consts_ptr, - const LLVMValueRef *inputs, - LLVMValueRef *outputs, - const struct lp_build_sampler_aos *sampler, - const struct tgsi_shader_info *info) -{ - struct lp_build_tgsi_aos_context bld; - struct tgsi_parse_context parse; - unsigned num_immediates = 0; - unsigned chan; - int pc = 0; - - /* Setup build context */ - memset(&bld, 0, sizeof bld); - lp_build_context_init(&bld.bld_base.base, gallivm, type); - lp_build_context_init(&bld.bld_base.uint_bld, gallivm, lp_uint_type(type)); - lp_build_context_init(&bld.bld_base.int_bld, gallivm, lp_int_type(type)); - lp_build_context_init(&bld.int_bld, gallivm, lp_int_type(type)); - - for (chan = 0; chan < 4; ++chan) { - bld.swizzles[chan] = swizzles[chan]; - bld.inv_swizzles[swizzles[chan]] = chan; - } - - bld.inputs = inputs; - bld.outputs = outputs; - bld.consts_ptr = consts_ptr; - bld.sampler = sampler; - bld.indirect_files = info->indirect_files; - bld.bld_base.emit_swizzle = swizzle_aos; - bld.bld_base.info = info; - - bld.bld_base.emit_fetch_funcs[TGSI_FILE_CONSTANT] = emit_fetch_constant; - bld.bld_base.emit_fetch_funcs[TGSI_FILE_IMMEDIATE] = emit_fetch_immediate; - bld.bld_base.emit_fetch_funcs[TGSI_FILE_INPUT] = emit_fetch_input; - bld.bld_base.emit_fetch_funcs[TGSI_FILE_TEMPORARY] = emit_fetch_temporary; - - /* Set opcode actions */ - lp_set_default_actions_cpu(&bld.bld_base); - - if (!lp_bld_tgsi_list_init(&bld.bld_base)) { - return; - } - - tgsi_parse_init(&parse, tokens); - - while (!tgsi_parse_end_of_tokens(&parse)) { - tgsi_parse_token(&parse); - - switch(parse.FullToken.Token.Type) { - case TGSI_TOKEN_TYPE_DECLARATION: - /* Inputs already interpolated */ - lp_emit_declaration_aos(&bld, &parse.FullToken.FullDeclaration); - break; - - case TGSI_TOKEN_TYPE_INSTRUCTION: - /* save expanded instruction */ - lp_bld_tgsi_add_instruction(&bld.bld_base, - &parse.FullToken.FullInstruction); - break; - - case TGSI_TOKEN_TYPE_IMMEDIATE: - /* simply copy the immediate values into the next immediates[] slot */ - { - const unsigned size = parse.FullToken.FullImmediate.Immediate.NrTokens - 1; - float imm[4]; - assert(size <= 4); - assert(num_immediates < LP_MAX_INLINED_IMMEDIATES); - for (chan = 0; chan < 4; ++chan) { - imm[chan] = 0.0f; - } - for (chan = 0; chan < size; ++chan) { - unsigned swizzle = bld.swizzles[chan]; - imm[swizzle] = parse.FullToken.FullImmediate.u[chan].Float; - } - bld.immediates[num_immediates] = - lp_build_const_aos(gallivm, type, - imm[0], imm[1], imm[2], imm[3], - NULL); - num_immediates++; - } - break; - - case TGSI_TOKEN_TYPE_PROPERTY: - break; - - default: - assert(0); - } - } - - while (pc != -1) { - struct tgsi_full_instruction *instr = bld.bld_base.instructions + pc; - const struct tgsi_opcode_info *opcode_info = - tgsi_get_opcode_info(instr->Instruction.Opcode); - if (!lp_emit_instruction_aos(&bld, instr, opcode_info, &pc)) - _debug_printf("warning: failed to translate tgsi opcode %s to LLVM\n", - tgsi_get_opcode_name(instr->Instruction.Opcode)); - } - - if (0) { - LLVMBasicBlockRef block = LLVMGetInsertBlock(gallivm->builder); - LLVMValueRef function = LLVMGetBasicBlockParent(block); - debug_printf("11111111111111111111111111111 \n"); - tgsi_dump(tokens, 0); - lp_debug_dump_value(function); - debug_printf("2222222222222222222222222222 \n"); - } - tgsi_parse_free(&parse); - FREE(bld.bld_base.instructions); - - if (0) { - LLVMModuleRef module = LLVMGetGlobalParent( - LLVMGetBasicBlockParent(LLVMGetInsertBlock(gallivm->builder))); - LLVMDumpModule(module); - } - -} - diff --git a/src/gallium/auxiliary/meson.build b/src/gallium/auxiliary/meson.build index 8547160ae3e..e7dde65f6a1 100644 --- a/src/gallium/auxiliary/meson.build +++ b/src/gallium/auxiliary/meson.build @@ -382,7 +382,6 @@ if draw_with_llvm 'gallivm/lp_bld_swizzle.h', 'gallivm/lp_bld_tgsi_action.c', 'gallivm/lp_bld_tgsi_action.h', - 'gallivm/lp_bld_tgsi_aos.c', 'gallivm/lp_bld_tgsi.c', 'gallivm/lp_bld_tgsi.h', 'gallivm/lp_bld_tgsi_info.c',