From 38a96f79afbce2945205d2b48a37cc1f9826d9f7 Mon Sep 17 00:00:00 2001 From: M Henning Date: Sun, 16 Jul 2023 18:18:45 -0400 Subject: [PATCH] nouveau: Delete nv50_ir_from_tgsi.cpp Reviewed-by: Karol Herbst Part-of: --- src/nouveau/codegen/meson.build | 1 - src/nouveau/codegen/nv50_ir.cpp | 3 - src/nouveau/codegen/nv50_ir.h | 2 - src/nouveau/codegen/nv50_ir_from_tgsi.cpp | 4417 ----------------------------- 4 files changed, 4423 deletions(-) delete mode 100644 src/nouveau/codegen/nv50_ir_from_tgsi.cpp diff --git a/src/nouveau/codegen/meson.build b/src/nouveau/codegen/meson.build index d67e375..61ce61f 100644 --- a/src/nouveau/codegen/meson.build +++ b/src/nouveau/codegen/meson.build @@ -28,7 +28,6 @@ files_libnouveau_codegen = files( 'nv50_ir_from_common.cpp', 'nv50_ir_from_common.h', 'nv50_ir_from_nir.cpp', - 'nv50_ir_from_tgsi.cpp', 'nv50_ir_graph.cpp', 'nv50_ir_graph.h', 'nv50_ir.h', diff --git a/src/nouveau/codegen/nv50_ir.cpp b/src/nouveau/codegen/nv50_ir.cpp index 29bfcda..eb9d719 100644 --- a/src/nouveau/codegen/nv50_ir.cpp +++ b/src/nouveau/codegen/nv50_ir.cpp @@ -1313,9 +1313,6 @@ nv50_ir_generate_code(struct nv50_ir_prog_info *info, case PIPE_SHADER_IR_NIR: ret = prog->makeFromNIR(info, info_out) ? 0 : -2; break; - case PIPE_SHADER_IR_TGSI: - ret = prog->makeFromTGSI(info, info_out) ? 0 : -2; - break; default: ret = -1; break; diff --git a/src/nouveau/codegen/nv50_ir.h b/src/nouveau/codegen/nv50_ir.h index decc7b9..42acbe2 100644 --- a/src/nouveau/codegen/nv50_ir.h +++ b/src/nouveau/codegen/nv50_ir.h @@ -1340,8 +1340,6 @@ public: bool makeFromNIR(struct nv50_ir_prog_info *, struct nv50_ir_prog_info_out *); - bool makeFromTGSI(struct nv50_ir_prog_info *, - struct nv50_ir_prog_info_out *); bool convertToSSA(); bool optimizeSSA(int level); bool optimizePostRA(int level); diff --git a/src/nouveau/codegen/nv50_ir_from_tgsi.cpp b/src/nouveau/codegen/nv50_ir_from_tgsi.cpp deleted file mode 100644 index 057d7f4..0000000 --- a/src/nouveau/codegen/nv50_ir_from_tgsi.cpp +++ /dev/null @@ -1,4417 +0,0 @@ -/* - * Copyright 2011 Christoph Bumiller - * - * 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, sublicense, - * 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 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 NONINFRINGEMENT. IN NO EVENT SHALL - * THE AUTHORS OR COPYRIGHT HOLDERS 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. - */ - -#include "tgsi/tgsi_build.h" -#include "tgsi/tgsi_dump.h" -#include "tgsi/tgsi_scan.h" -#include "tgsi/tgsi_util.h" - -#include - -#include "nv50_ir.h" -#include "nv50_ir_from_common.h" -#include "nv50_ir_util.h" - -namespace tgsi { - -class Source; - -static nv50_ir::operation translateOpcode(uint opcode); -static nv50_ir::DataFile translateFile(uint file); -static nv50_ir::TexTarget translateTexture(uint texTarg); -static nv50_ir::SVSemantic translateSysVal(uint sysval); -static nv50_ir::CacheMode translateCacheMode(uint qualifier); - -class Instruction -{ -public: - Instruction(const struct tgsi_full_instruction *inst) : insn(inst) { } - - class SrcRegister - { - public: - SrcRegister(const struct tgsi_full_src_register *src) - : reg(src->Register), - fsr(src) - { } - - SrcRegister(const struct tgsi_src_register& src) : reg(src), fsr(NULL) { } - - SrcRegister(const struct tgsi_ind_register& ind) - : reg(tgsi_util_get_src_from_ind(&ind)), - fsr(NULL) - { } - - struct tgsi_src_register offsetToSrc(struct tgsi_texture_offset off) - { - struct tgsi_src_register reg; - memset(®, 0, sizeof(reg)); - reg.Index = off.Index; - reg.File = off.File; - reg.SwizzleX = off.SwizzleX; - reg.SwizzleY = off.SwizzleY; - reg.SwizzleZ = off.SwizzleZ; - return reg; - } - - SrcRegister(const struct tgsi_texture_offset& off) : - reg(offsetToSrc(off)), - fsr(NULL) - { } - - uint getFile() const { return reg.File; } - - bool is2D() const { return reg.Dimension; } - - bool isIndirect(int dim) const - { - return (dim && fsr) ? fsr->Dimension.Indirect : reg.Indirect; - } - - int getIndex(int dim) const - { - return (dim && fsr) ? fsr->Dimension.Index : reg.Index; - } - - int getSwizzle(int chan) const - { - return tgsi_util_get_src_register_swizzle(®, chan); - } - - int getArrayId() const - { - if (isIndirect(0)) - return fsr->Indirect.ArrayID; - return 0; - } - - nv50_ir::Modifier getMod(int chan) const; - - SrcRegister getIndirect(int dim) const - { - assert(fsr && isIndirect(dim)); - if (dim) - return SrcRegister(fsr->DimIndirect); - return SrcRegister(fsr->Indirect); - } - - uint32_t getValueU32(int c, const uint32_t *data) const - { - assert(reg.File == TGSI_FILE_IMMEDIATE); - assert(!reg.Absolute); - assert(!reg.Negate); - return data[reg.Index * 4 + getSwizzle(c)]; - } - - private: - const struct tgsi_src_register reg; - const struct tgsi_full_src_register *fsr; - }; - - class DstRegister - { - public: - DstRegister(const struct tgsi_full_dst_register *dst) - : reg(dst->Register), - fdr(dst) - { } - - DstRegister(const struct tgsi_dst_register& dst) : reg(dst), fdr(NULL) { } - - uint getFile() const { return reg.File; } - - bool is2D() const { return reg.Dimension; } - - bool isIndirect(int dim) const - { - return (dim && fdr) ? fdr->Dimension.Indirect : reg.Indirect; - } - - int getIndex(int dim) const - { - return (dim && fdr) ? fdr->Dimension.Dimension : reg.Index; - } - - unsigned int getMask() const { return reg.WriteMask; } - - bool isMasked(int chan) const { return !(getMask() & (1 << chan)); } - - SrcRegister getIndirect(int dim) const - { - assert(fdr && isIndirect(dim)); - if (dim) - return SrcRegister(fdr->DimIndirect); - return SrcRegister(fdr->Indirect); - } - - struct tgsi_full_src_register asSrc() - { - assert(fdr); - return tgsi_full_src_register_from_dst(fdr); - } - - int getArrayId() const - { - if (isIndirect(0)) - return fdr->Indirect.ArrayID; - return 0; - } - - private: - const struct tgsi_dst_register reg; - const struct tgsi_full_dst_register *fdr; - }; - - inline uint getOpcode() const { return insn->Instruction.Opcode; } - - unsigned int srcCount() const { return insn->Instruction.NumSrcRegs; } - unsigned int dstCount() const { return insn->Instruction.NumDstRegs; } - - // mask of used components of source s - unsigned int srcMask(unsigned int s) const; - unsigned int texOffsetMask() const; - - SrcRegister getSrc(unsigned int s) const - { - assert(s < srcCount()); - return SrcRegister(&insn->Src[s]); - } - - DstRegister getDst(unsigned int d) const - { - assert(d < dstCount()); - return DstRegister(&insn->Dst[d]); - } - - SrcRegister getTexOffset(unsigned int i) const - { - assert(i < TGSI_FULL_MAX_TEX_OFFSETS); - return SrcRegister(insn->TexOffsets[i]); - } - - unsigned int getNumTexOffsets() const { return insn->Texture.NumOffsets; } - - bool checkDstSrcAliasing() const; - - inline nv50_ir::operation getOP() const { - return translateOpcode(getOpcode()); } - - nv50_ir::DataType inferSrcType() const; - nv50_ir::DataType inferDstType() const; - - nv50_ir::CondCode getSetCond() const; - - nv50_ir::TexInstruction::Target getTexture(const Source *, int s) const; - - const nv50_ir::TexInstruction::ImgFormatDesc *getImageFormat() const { - return nv50_ir::TexInstruction::translateImgFormat((enum pipe_format)insn->Memory.Format); - } - - nv50_ir::TexTarget getImageTarget() const { - return translateTexture(insn->Memory.Texture); - } - - nv50_ir::CacheMode getCacheMode() const { - if (!insn->Instruction.Memory) - return nv50_ir::CACHE_CA; - return translateCacheMode(insn->Memory.Qualifier); - } - - inline uint getLabel() { return insn->Label.Label; } - - unsigned getSaturate() const { return insn->Instruction.Saturate; } - - void print() const - { - tgsi_dump_instruction(insn, 1); - } - -private: - const struct tgsi_full_instruction *insn; -}; - -unsigned int Instruction::texOffsetMask() const -{ - const struct tgsi_instruction_texture *tex = &insn->Texture; - assert(insn->Instruction.Texture); - - switch (tex->Texture) { - case TGSI_TEXTURE_BUFFER: - case TGSI_TEXTURE_1D: - case TGSI_TEXTURE_SHADOW1D: - case TGSI_TEXTURE_1D_ARRAY: - case TGSI_TEXTURE_SHADOW1D_ARRAY: - return 0x1; - case TGSI_TEXTURE_2D: - case TGSI_TEXTURE_SHADOW2D: - case TGSI_TEXTURE_2D_ARRAY: - case TGSI_TEXTURE_SHADOW2D_ARRAY: - case TGSI_TEXTURE_RECT: - case TGSI_TEXTURE_SHADOWRECT: - case TGSI_TEXTURE_2D_MSAA: - case TGSI_TEXTURE_2D_ARRAY_MSAA: - return 0x3; - case TGSI_TEXTURE_3D: - return 0x7; - default: - assert(!"Unexpected texture target"); - return 0xf; - } -} - -unsigned int Instruction::srcMask(unsigned int s) const -{ - unsigned int mask = insn->Dst[0].Register.WriteMask; - - switch (insn->Instruction.Opcode) { - case TGSI_OPCODE_COS: - case TGSI_OPCODE_SIN: - return (mask & 0x8) | ((mask & 0x7) ? 0x1 : 0x0); - case TGSI_OPCODE_DP2: - return 0x3; - case TGSI_OPCODE_DP3: - return 0x7; - case TGSI_OPCODE_DP4: - case TGSI_OPCODE_KILL_IF: /* WriteMask ignored */ - return 0xf; - case TGSI_OPCODE_DST: - return mask & (s ? 0xa : 0x6); - case TGSI_OPCODE_EX2: - case TGSI_OPCODE_EXP: - case TGSI_OPCODE_LG2: - case TGSI_OPCODE_LOG: - case TGSI_OPCODE_POW: - case TGSI_OPCODE_RCP: - case TGSI_OPCODE_RSQ: - return 0x1; - case TGSI_OPCODE_IF: - case TGSI_OPCODE_UIF: - return 0x1; - case TGSI_OPCODE_LIT: - return 0xb; - case TGSI_OPCODE_TEX2: - case TGSI_OPCODE_TXB2: - case TGSI_OPCODE_TXL2: - return (s == 0) ? 0xf : 0x3; - case TGSI_OPCODE_TEX: - case TGSI_OPCODE_TXB: - case TGSI_OPCODE_TXD: - case TGSI_OPCODE_TXL: - case TGSI_OPCODE_TXP: - case TGSI_OPCODE_TXF: - case TGSI_OPCODE_TG4: - case TGSI_OPCODE_TEX_LZ: - case TGSI_OPCODE_TXF_LZ: - case TGSI_OPCODE_LODQ: - { - const struct tgsi_instruction_texture *tex = &insn->Texture; - - assert(insn->Instruction.Texture); - - mask = 0x7; - if (insn->Instruction.Opcode != TGSI_OPCODE_TEX && - insn->Instruction.Opcode != TGSI_OPCODE_TEX_LZ && - insn->Instruction.Opcode != TGSI_OPCODE_TXF_LZ && - insn->Instruction.Opcode != TGSI_OPCODE_TXD) - mask |= 0x8; /* bias, lod or proj */ - - switch (tex->Texture) { - case TGSI_TEXTURE_1D: - mask &= 0x9; - break; - case TGSI_TEXTURE_SHADOW1D: - mask &= 0xd; - break; - case TGSI_TEXTURE_1D_ARRAY: - case TGSI_TEXTURE_2D: - case TGSI_TEXTURE_RECT: - mask &= 0xb; - break; - case TGSI_TEXTURE_CUBE_ARRAY: - case TGSI_TEXTURE_SHADOW2D_ARRAY: - case TGSI_TEXTURE_SHADOWCUBE: - case TGSI_TEXTURE_SHADOWCUBE_ARRAY: - mask |= 0x8; - break; - default: - break; - } - } - return mask; - case TGSI_OPCODE_TXQ: - return 1; - case TGSI_OPCODE_D2I: - case TGSI_OPCODE_D2U: - case TGSI_OPCODE_D2F: - case TGSI_OPCODE_DSLT: - case TGSI_OPCODE_DSGE: - case TGSI_OPCODE_DSEQ: - case TGSI_OPCODE_DSNE: - case TGSI_OPCODE_U64SEQ: - case TGSI_OPCODE_U64SNE: - case TGSI_OPCODE_I64SLT: - case TGSI_OPCODE_U64SLT: - case TGSI_OPCODE_I64SGE: - case TGSI_OPCODE_U64SGE: - case TGSI_OPCODE_I642F: - case TGSI_OPCODE_U642F: - switch (util_bitcount(mask)) { - case 1: return 0x3; - case 2: return 0xf; - default: - assert(!"unexpected mask"); - return 0xf; - } - case TGSI_OPCODE_I2D: - case TGSI_OPCODE_U2D: - case TGSI_OPCODE_F2D: { - unsigned int x = 0; - if ((mask & 0x3) == 0x3) - x |= 1; - if ((mask & 0xc) == 0xc) - x |= 2; - return x; - } - case TGSI_OPCODE_PK2H: - return 0x3; - case TGSI_OPCODE_UP2H: - return 0x1; - default: - break; - } - - return mask; -} - -nv50_ir::Modifier Instruction::SrcRegister::getMod(int chan) const -{ - nv50_ir::Modifier m(0); - - if (reg.Absolute) - m = m | nv50_ir::Modifier(NV50_IR_MOD_ABS); - if (reg.Negate) - m = m | nv50_ir::Modifier(NV50_IR_MOD_NEG); - return m; -} - -static nv50_ir::DataFile translateFile(uint file) -{ - switch (file) { - case TGSI_FILE_CONSTANT: return nv50_ir::FILE_MEMORY_CONST; - case TGSI_FILE_INPUT: return nv50_ir::FILE_SHADER_INPUT; - case TGSI_FILE_OUTPUT: return nv50_ir::FILE_SHADER_OUTPUT; - case TGSI_FILE_TEMPORARY: return nv50_ir::FILE_GPR; - case TGSI_FILE_ADDRESS: return nv50_ir::FILE_ADDRESS; - case TGSI_FILE_IMMEDIATE: return nv50_ir::FILE_IMMEDIATE; - case TGSI_FILE_SYSTEM_VALUE: return nv50_ir::FILE_SYSTEM_VALUE; - case TGSI_FILE_BUFFER: return nv50_ir::FILE_MEMORY_BUFFER; - case TGSI_FILE_IMAGE: return nv50_ir::FILE_MEMORY_GLOBAL; - case TGSI_FILE_MEMORY: return nv50_ir::FILE_MEMORY_GLOBAL; - case TGSI_FILE_SAMPLER: - case TGSI_FILE_NULL: - default: - return nv50_ir::FILE_NULL; - } -} - -static nv50_ir::SVSemantic translateSysVal(uint sysval) -{ - switch (sysval) { - case TGSI_SEMANTIC_FACE: return nv50_ir::SV_FACE; - case TGSI_SEMANTIC_PSIZE: return nv50_ir::SV_POINT_SIZE; - case TGSI_SEMANTIC_PRIMID: return nv50_ir::SV_PRIMITIVE_ID; - case TGSI_SEMANTIC_INSTANCEID: return nv50_ir::SV_INSTANCE_ID; - case TGSI_SEMANTIC_VERTEXID: return nv50_ir::SV_VERTEX_ID; - case TGSI_SEMANTIC_GRID_SIZE: return nv50_ir::SV_NCTAID; - case TGSI_SEMANTIC_BLOCK_ID: return nv50_ir::SV_CTAID; - case TGSI_SEMANTIC_BLOCK_SIZE: return nv50_ir::SV_NTID; - case TGSI_SEMANTIC_THREAD_ID: return nv50_ir::SV_TID; - case TGSI_SEMANTIC_SAMPLEID: return nv50_ir::SV_SAMPLE_INDEX; - case TGSI_SEMANTIC_SAMPLEPOS: return nv50_ir::SV_SAMPLE_POS; - case TGSI_SEMANTIC_SAMPLEMASK: return nv50_ir::SV_SAMPLE_MASK; - case TGSI_SEMANTIC_INVOCATIONID: return nv50_ir::SV_INVOCATION_ID; - case TGSI_SEMANTIC_TESSCOORD: return nv50_ir::SV_TESS_COORD; - case TGSI_SEMANTIC_TESSOUTER: return nv50_ir::SV_TESS_OUTER; - case TGSI_SEMANTIC_TESSINNER: return nv50_ir::SV_TESS_INNER; - case TGSI_SEMANTIC_VERTICESIN: return nv50_ir::SV_VERTEX_COUNT; - case TGSI_SEMANTIC_HELPER_INVOCATION: return nv50_ir::SV_THREAD_KILL; - case TGSI_SEMANTIC_BASEVERTEX: return nv50_ir::SV_BASEVERTEX; - case TGSI_SEMANTIC_BASEINSTANCE: return nv50_ir::SV_BASEINSTANCE; - case TGSI_SEMANTIC_DRAWID: return nv50_ir::SV_DRAWID; - case TGSI_SEMANTIC_WORK_DIM: return nv50_ir::SV_WORK_DIM; - case TGSI_SEMANTIC_SUBGROUP_INVOCATION: return nv50_ir::SV_LANEID; - case TGSI_SEMANTIC_SUBGROUP_EQ_MASK: return nv50_ir::SV_LANEMASK_EQ; - case TGSI_SEMANTIC_SUBGROUP_LT_MASK: return nv50_ir::SV_LANEMASK_LT; - case TGSI_SEMANTIC_SUBGROUP_LE_MASK: return nv50_ir::SV_LANEMASK_LE; - case TGSI_SEMANTIC_SUBGROUP_GT_MASK: return nv50_ir::SV_LANEMASK_GT; - case TGSI_SEMANTIC_SUBGROUP_GE_MASK: return nv50_ir::SV_LANEMASK_GE; - default: - assert(0); - return nv50_ir::SV_CLOCK; - } -} - -#define NV50_IR_TEX_TARG_CASE(a, b) \ - case TGSI_TEXTURE_##a: return nv50_ir::TEX_TARGET_##b; - -static nv50_ir::TexTarget translateTexture(uint tex) -{ - switch (tex) { - NV50_IR_TEX_TARG_CASE(1D, 1D); - NV50_IR_TEX_TARG_CASE(2D, 2D); - NV50_IR_TEX_TARG_CASE(2D_MSAA, 2D_MS); - NV50_IR_TEX_TARG_CASE(3D, 3D); - NV50_IR_TEX_TARG_CASE(CUBE, CUBE); - NV50_IR_TEX_TARG_CASE(RECT, RECT); - NV50_IR_TEX_TARG_CASE(1D_ARRAY, 1D_ARRAY); - NV50_IR_TEX_TARG_CASE(2D_ARRAY, 2D_ARRAY); - NV50_IR_TEX_TARG_CASE(2D_ARRAY_MSAA, 2D_MS_ARRAY); - NV50_IR_TEX_TARG_CASE(CUBE_ARRAY, CUBE_ARRAY); - NV50_IR_TEX_TARG_CASE(SHADOW1D, 1D_SHADOW); - NV50_IR_TEX_TARG_CASE(SHADOW2D, 2D_SHADOW); - NV50_IR_TEX_TARG_CASE(SHADOWCUBE, CUBE_SHADOW); - NV50_IR_TEX_TARG_CASE(SHADOWRECT, RECT_SHADOW); - NV50_IR_TEX_TARG_CASE(SHADOW1D_ARRAY, 1D_ARRAY_SHADOW); - NV50_IR_TEX_TARG_CASE(SHADOW2D_ARRAY, 2D_ARRAY_SHADOW); - NV50_IR_TEX_TARG_CASE(SHADOWCUBE_ARRAY, CUBE_ARRAY_SHADOW); - NV50_IR_TEX_TARG_CASE(BUFFER, BUFFER); - - case TGSI_TEXTURE_UNKNOWN: - default: - assert(!"invalid texture target"); - return nv50_ir::TEX_TARGET_2D; - } -} - -static nv50_ir::CacheMode translateCacheMode(uint qualifier) -{ - if (qualifier & TGSI_MEMORY_VOLATILE) - return nv50_ir::CACHE_CV; - if (qualifier & TGSI_MEMORY_COHERENT) - return nv50_ir::CACHE_CG; - return nv50_ir::CACHE_CA; -} - -nv50_ir::DataType Instruction::inferSrcType() const -{ - switch (getOpcode()) { - case TGSI_OPCODE_UIF: - case TGSI_OPCODE_AND: - case TGSI_OPCODE_OR: - case TGSI_OPCODE_XOR: - case TGSI_OPCODE_NOT: - case TGSI_OPCODE_SHL: - case TGSI_OPCODE_U2F: - case TGSI_OPCODE_U2D: - case TGSI_OPCODE_U2I64: - case TGSI_OPCODE_UADD: - case TGSI_OPCODE_UDIV: - case TGSI_OPCODE_UMOD: - case TGSI_OPCODE_UMAD: - case TGSI_OPCODE_UMUL: - case TGSI_OPCODE_UMUL_HI: - case TGSI_OPCODE_UMAX: - case TGSI_OPCODE_UMIN: - case TGSI_OPCODE_USEQ: - case TGSI_OPCODE_USGE: - case TGSI_OPCODE_USLT: - case TGSI_OPCODE_USNE: - case TGSI_OPCODE_USHR: - case TGSI_OPCODE_ATOMUADD: - case TGSI_OPCODE_ATOMXCHG: - case TGSI_OPCODE_ATOMCAS: - case TGSI_OPCODE_ATOMAND: - case TGSI_OPCODE_ATOMOR: - case TGSI_OPCODE_ATOMXOR: - case TGSI_OPCODE_ATOMUMIN: - case TGSI_OPCODE_ATOMUMAX: - case TGSI_OPCODE_ATOMDEC_WRAP: - case TGSI_OPCODE_ATOMINC_WRAP: - case TGSI_OPCODE_UBFE: - case TGSI_OPCODE_UMSB: - case TGSI_OPCODE_UP2H: - case TGSI_OPCODE_VOTE_ALL: - case TGSI_OPCODE_VOTE_ANY: - case TGSI_OPCODE_VOTE_EQ: - return nv50_ir::TYPE_U32; - case TGSI_OPCODE_I2F: - case TGSI_OPCODE_I2D: - case TGSI_OPCODE_I2I64: - case TGSI_OPCODE_IDIV: - case TGSI_OPCODE_IMUL_HI: - case TGSI_OPCODE_IMAX: - case TGSI_OPCODE_IMIN: - case TGSI_OPCODE_IABS: - case TGSI_OPCODE_INEG: - case TGSI_OPCODE_ISGE: - case TGSI_OPCODE_ISHR: - case TGSI_OPCODE_ISLT: - case TGSI_OPCODE_ISSG: - case TGSI_OPCODE_MOD: - case TGSI_OPCODE_UARL: - case TGSI_OPCODE_ATOMIMIN: - case TGSI_OPCODE_ATOMIMAX: - case TGSI_OPCODE_IBFE: - case TGSI_OPCODE_IMSB: - return nv50_ir::TYPE_S32; - case TGSI_OPCODE_D2F: - case TGSI_OPCODE_D2I: - case TGSI_OPCODE_D2U: - case TGSI_OPCODE_D2I64: - case TGSI_OPCODE_D2U64: - case TGSI_OPCODE_DABS: - case TGSI_OPCODE_DNEG: - case TGSI_OPCODE_DADD: - case TGSI_OPCODE_DMUL: - case TGSI_OPCODE_DDIV: - case TGSI_OPCODE_DMAX: - case TGSI_OPCODE_DMIN: - case TGSI_OPCODE_DSLT: - case TGSI_OPCODE_DSGE: - case TGSI_OPCODE_DSEQ: - case TGSI_OPCODE_DSNE: - case TGSI_OPCODE_DRCP: - case TGSI_OPCODE_DSQRT: - case TGSI_OPCODE_DMAD: - case TGSI_OPCODE_DFMA: - case TGSI_OPCODE_DFRAC: - case TGSI_OPCODE_DRSQ: - case TGSI_OPCODE_DTRUNC: - case TGSI_OPCODE_DCEIL: - case TGSI_OPCODE_DFLR: - case TGSI_OPCODE_DROUND: - return nv50_ir::TYPE_F64; - case TGSI_OPCODE_U64SEQ: - case TGSI_OPCODE_U64SNE: - case TGSI_OPCODE_U64SLT: - case TGSI_OPCODE_U64SGE: - case TGSI_OPCODE_U64MIN: - case TGSI_OPCODE_U64MAX: - case TGSI_OPCODE_U64ADD: - case TGSI_OPCODE_U64MUL: - case TGSI_OPCODE_U64SHL: - case TGSI_OPCODE_U64SHR: - case TGSI_OPCODE_U64DIV: - case TGSI_OPCODE_U64MOD: - case TGSI_OPCODE_U642F: - case TGSI_OPCODE_U642D: - return nv50_ir::TYPE_U64; - case TGSI_OPCODE_I64ABS: - case TGSI_OPCODE_I64SSG: - case TGSI_OPCODE_I64NEG: - case TGSI_OPCODE_I64SLT: - case TGSI_OPCODE_I64SGE: - case TGSI_OPCODE_I64MIN: - case TGSI_OPCODE_I64MAX: - case TGSI_OPCODE_I64SHR: - case TGSI_OPCODE_I64DIV: - case TGSI_OPCODE_I64MOD: - case TGSI_OPCODE_I642F: - case TGSI_OPCODE_I642D: - return nv50_ir::TYPE_S64; - default: - return nv50_ir::TYPE_F32; - } -} - -nv50_ir::DataType Instruction::inferDstType() const -{ - switch (getOpcode()) { - case TGSI_OPCODE_D2U: - case TGSI_OPCODE_F2U: return nv50_ir::TYPE_U32; - case TGSI_OPCODE_D2I: - case TGSI_OPCODE_F2I: return nv50_ir::TYPE_S32; - case TGSI_OPCODE_FSEQ: - case TGSI_OPCODE_FSGE: - case TGSI_OPCODE_FSLT: - case TGSI_OPCODE_FSNE: - case TGSI_OPCODE_DSEQ: - case TGSI_OPCODE_DSGE: - case TGSI_OPCODE_DSLT: - case TGSI_OPCODE_DSNE: - case TGSI_OPCODE_I64SLT: - case TGSI_OPCODE_I64SGE: - case TGSI_OPCODE_U64SEQ: - case TGSI_OPCODE_U64SNE: - case TGSI_OPCODE_U64SLT: - case TGSI_OPCODE_U64SGE: - case TGSI_OPCODE_PK2H: - return nv50_ir::TYPE_U32; - case TGSI_OPCODE_I2F: - case TGSI_OPCODE_U2F: - case TGSI_OPCODE_D2F: - case TGSI_OPCODE_I642F: - case TGSI_OPCODE_U642F: - case TGSI_OPCODE_UP2H: - return nv50_ir::TYPE_F32; - case TGSI_OPCODE_I2D: - case TGSI_OPCODE_U2D: - case TGSI_OPCODE_F2D: - case TGSI_OPCODE_I642D: - case TGSI_OPCODE_U642D: - return nv50_ir::TYPE_F64; - case TGSI_OPCODE_I2I64: - case TGSI_OPCODE_U2I64: - case TGSI_OPCODE_F2I64: - case TGSI_OPCODE_D2I64: - return nv50_ir::TYPE_S64; - case TGSI_OPCODE_F2U64: - case TGSI_OPCODE_D2U64: - return nv50_ir::TYPE_U64; - default: - return inferSrcType(); - } -} - -nv50_ir::CondCode Instruction::getSetCond() const -{ - using namespace nv50_ir; - - switch (getOpcode()) { - case TGSI_OPCODE_SLT: - case TGSI_OPCODE_ISLT: - case TGSI_OPCODE_USLT: - case TGSI_OPCODE_FSLT: - case TGSI_OPCODE_DSLT: - case TGSI_OPCODE_I64SLT: - case TGSI_OPCODE_U64SLT: - return CC_LT; - case TGSI_OPCODE_SLE: - return CC_LE; - case TGSI_OPCODE_SGE: - case TGSI_OPCODE_ISGE: - case TGSI_OPCODE_USGE: - case TGSI_OPCODE_FSGE: - case TGSI_OPCODE_DSGE: - case TGSI_OPCODE_I64SGE: - case TGSI_OPCODE_U64SGE: - return CC_GE; - case TGSI_OPCODE_SGT: - return CC_GT; - case TGSI_OPCODE_SEQ: - case TGSI_OPCODE_USEQ: - case TGSI_OPCODE_FSEQ: - case TGSI_OPCODE_DSEQ: - case TGSI_OPCODE_U64SEQ: - return CC_EQ; - case TGSI_OPCODE_SNE: - case TGSI_OPCODE_FSNE: - case TGSI_OPCODE_DSNE: - case TGSI_OPCODE_U64SNE: - return CC_NEU; - case TGSI_OPCODE_USNE: - return CC_NE; - default: - return CC_ALWAYS; - } -} - -#define NV50_IR_OPCODE_CASE(a, b) case TGSI_OPCODE_##a: return nv50_ir::OP_##b - -static nv50_ir::operation translateOpcode(uint opcode) -{ - switch (opcode) { - NV50_IR_OPCODE_CASE(ARL, SHL); - NV50_IR_OPCODE_CASE(MOV, MOV); - - NV50_IR_OPCODE_CASE(RCP, RCP); - NV50_IR_OPCODE_CASE(RSQ, RSQ); - NV50_IR_OPCODE_CASE(SQRT, SQRT); - - NV50_IR_OPCODE_CASE(MUL, MUL); - NV50_IR_OPCODE_CASE(ADD, ADD); - - NV50_IR_OPCODE_CASE(MIN, MIN); - NV50_IR_OPCODE_CASE(MAX, MAX); - NV50_IR_OPCODE_CASE(SLT, SET); - NV50_IR_OPCODE_CASE(SGE, SET); - NV50_IR_OPCODE_CASE(MAD, MAD); - NV50_IR_OPCODE_CASE(FMA, FMA); - - NV50_IR_OPCODE_CASE(FLR, FLOOR); - NV50_IR_OPCODE_CASE(ROUND, CVT); - NV50_IR_OPCODE_CASE(EX2, EX2); - NV50_IR_OPCODE_CASE(LG2, LG2); - NV50_IR_OPCODE_CASE(POW, POW); - - NV50_IR_OPCODE_CASE(COS, COS); - NV50_IR_OPCODE_CASE(DDX, DFDX); - NV50_IR_OPCODE_CASE(DDX_FINE, DFDX); - NV50_IR_OPCODE_CASE(DDY, DFDY); - NV50_IR_OPCODE_CASE(DDY_FINE, DFDY); - NV50_IR_OPCODE_CASE(KILL, DISCARD); - NV50_IR_OPCODE_CASE(DEMOTE, DISCARD); - - NV50_IR_OPCODE_CASE(SEQ, SET); - NV50_IR_OPCODE_CASE(SGT, SET); - NV50_IR_OPCODE_CASE(SIN, SIN); - NV50_IR_OPCODE_CASE(SLE, SET); - NV50_IR_OPCODE_CASE(SNE, SET); - NV50_IR_OPCODE_CASE(TEX, TEX); - NV50_IR_OPCODE_CASE(TXD, TXD); - NV50_IR_OPCODE_CASE(TXP, TEX); - - NV50_IR_OPCODE_CASE(CAL, CALL); - NV50_IR_OPCODE_CASE(RET, RET); - NV50_IR_OPCODE_CASE(CMP, SLCT); - - NV50_IR_OPCODE_CASE(TXB, TXB); - - NV50_IR_OPCODE_CASE(DIV, DIV); - - NV50_IR_OPCODE_CASE(TXL, TXL); - NV50_IR_OPCODE_CASE(TEX_LZ, TXL); - - NV50_IR_OPCODE_CASE(CEIL, CEIL); - NV50_IR_OPCODE_CASE(I2F, CVT); - NV50_IR_OPCODE_CASE(NOT, NOT); - NV50_IR_OPCODE_CASE(TRUNC, TRUNC); - NV50_IR_OPCODE_CASE(SHL, SHL); - - NV50_IR_OPCODE_CASE(AND, AND); - NV50_IR_OPCODE_CASE(OR, OR); - NV50_IR_OPCODE_CASE(MOD, MOD); - NV50_IR_OPCODE_CASE(XOR, XOR); - NV50_IR_OPCODE_CASE(TXF, TXF); - NV50_IR_OPCODE_CASE(TXF_LZ, TXF); - NV50_IR_OPCODE_CASE(TXQ, TXQ); - NV50_IR_OPCODE_CASE(TXQS, TXQ); - NV50_IR_OPCODE_CASE(TG4, TXG); - NV50_IR_OPCODE_CASE(LODQ, TXLQ); - - NV50_IR_OPCODE_CASE(EMIT, EMIT); - NV50_IR_OPCODE_CASE(ENDPRIM, RESTART); - - NV50_IR_OPCODE_CASE(KILL_IF, DISCARD); - - NV50_IR_OPCODE_CASE(F2I, CVT); - NV50_IR_OPCODE_CASE(FSEQ, SET); - NV50_IR_OPCODE_CASE(FSGE, SET); - NV50_IR_OPCODE_CASE(FSLT, SET); - NV50_IR_OPCODE_CASE(FSNE, SET); - NV50_IR_OPCODE_CASE(IDIV, DIV); - NV50_IR_OPCODE_CASE(IMAX, MAX); - NV50_IR_OPCODE_CASE(IMIN, MIN); - NV50_IR_OPCODE_CASE(IABS, ABS); - NV50_IR_OPCODE_CASE(INEG, NEG); - NV50_IR_OPCODE_CASE(ISGE, SET); - NV50_IR_OPCODE_CASE(ISHR, SHR); - NV50_IR_OPCODE_CASE(ISLT, SET); - NV50_IR_OPCODE_CASE(F2U, CVT); - NV50_IR_OPCODE_CASE(U2F, CVT); - NV50_IR_OPCODE_CASE(UADD, ADD); - NV50_IR_OPCODE_CASE(UDIV, DIV); - NV50_IR_OPCODE_CASE(UMAD, MAD); - NV50_IR_OPCODE_CASE(UMAX, MAX); - NV50_IR_OPCODE_CASE(UMIN, MIN); - NV50_IR_OPCODE_CASE(UMOD, MOD); - NV50_IR_OPCODE_CASE(UMUL, MUL); - NV50_IR_OPCODE_CASE(USEQ, SET); - NV50_IR_OPCODE_CASE(USGE, SET); - NV50_IR_OPCODE_CASE(USHR, SHR); - NV50_IR_OPCODE_CASE(USLT, SET); - NV50_IR_OPCODE_CASE(USNE, SET); - - NV50_IR_OPCODE_CASE(DABS, ABS); - NV50_IR_OPCODE_CASE(DNEG, NEG); - NV50_IR_OPCODE_CASE(DADD, ADD); - NV50_IR_OPCODE_CASE(DMUL, MUL); - NV50_IR_OPCODE_CASE(DDIV, DIV); - NV50_IR_OPCODE_CASE(DMAX, MAX); - NV50_IR_OPCODE_CASE(DMIN, MIN); - NV50_IR_OPCODE_CASE(DSLT, SET); - NV50_IR_OPCODE_CASE(DSGE, SET); - NV50_IR_OPCODE_CASE(DSEQ, SET); - NV50_IR_OPCODE_CASE(DSNE, SET); - NV50_IR_OPCODE_CASE(DRCP, RCP); - NV50_IR_OPCODE_CASE(DSQRT, SQRT); - NV50_IR_OPCODE_CASE(DMAD, MAD); - NV50_IR_OPCODE_CASE(DFMA, FMA); - NV50_IR_OPCODE_CASE(D2I, CVT); - NV50_IR_OPCODE_CASE(D2U, CVT); - NV50_IR_OPCODE_CASE(I2D, CVT); - NV50_IR_OPCODE_CASE(U2D, CVT); - NV50_IR_OPCODE_CASE(DRSQ, RSQ); - NV50_IR_OPCODE_CASE(DTRUNC, TRUNC); - NV50_IR_OPCODE_CASE(DCEIL, CEIL); - NV50_IR_OPCODE_CASE(DFLR, FLOOR); - NV50_IR_OPCODE_CASE(DROUND, CVT); - - NV50_IR_OPCODE_CASE(U64SEQ, SET); - NV50_IR_OPCODE_CASE(U64SNE, SET); - NV50_IR_OPCODE_CASE(U64SLT, SET); - NV50_IR_OPCODE_CASE(U64SGE, SET); - NV50_IR_OPCODE_CASE(I64SLT, SET); - NV50_IR_OPCODE_CASE(I64SGE, SET); - NV50_IR_OPCODE_CASE(I2I64, CVT); - NV50_IR_OPCODE_CASE(U2I64, CVT); - NV50_IR_OPCODE_CASE(F2I64, CVT); - NV50_IR_OPCODE_CASE(F2U64, CVT); - NV50_IR_OPCODE_CASE(D2I64, CVT); - NV50_IR_OPCODE_CASE(D2U64, CVT); - NV50_IR_OPCODE_CASE(I642F, CVT); - NV50_IR_OPCODE_CASE(U642F, CVT); - NV50_IR_OPCODE_CASE(I642D, CVT); - NV50_IR_OPCODE_CASE(U642D, CVT); - - NV50_IR_OPCODE_CASE(I64MIN, MIN); - NV50_IR_OPCODE_CASE(U64MIN, MIN); - NV50_IR_OPCODE_CASE(I64MAX, MAX); - NV50_IR_OPCODE_CASE(U64MAX, MAX); - NV50_IR_OPCODE_CASE(I64ABS, ABS); - NV50_IR_OPCODE_CASE(I64NEG, NEG); - NV50_IR_OPCODE_CASE(U64ADD, ADD); - NV50_IR_OPCODE_CASE(U64MUL, MUL); - NV50_IR_OPCODE_CASE(U64SHL, SHL); - NV50_IR_OPCODE_CASE(I64SHR, SHR); - NV50_IR_OPCODE_CASE(U64SHR, SHR); - - NV50_IR_OPCODE_CASE(IMUL_HI, MUL); - NV50_IR_OPCODE_CASE(UMUL_HI, MUL); - - NV50_IR_OPCODE_CASE(SAMPLE, TEX); - NV50_IR_OPCODE_CASE(SAMPLE_B, TXB); - NV50_IR_OPCODE_CASE(SAMPLE_C, TEX); - NV50_IR_OPCODE_CASE(SAMPLE_C_LZ, TEX); - NV50_IR_OPCODE_CASE(SAMPLE_D, TXD); - NV50_IR_OPCODE_CASE(SAMPLE_L, TXL); - NV50_IR_OPCODE_CASE(SAMPLE_I, TXF); - NV50_IR_OPCODE_CASE(SAMPLE_I_MS, TXF); - NV50_IR_OPCODE_CASE(GATHER4, TXG); - NV50_IR_OPCODE_CASE(SVIEWINFO, TXQ); - - NV50_IR_OPCODE_CASE(ATOMUADD, ATOM); - NV50_IR_OPCODE_CASE(ATOMXCHG, ATOM); - NV50_IR_OPCODE_CASE(ATOMCAS, ATOM); - NV50_IR_OPCODE_CASE(ATOMAND, ATOM); - NV50_IR_OPCODE_CASE(ATOMOR, ATOM); - NV50_IR_OPCODE_CASE(ATOMXOR, ATOM); - NV50_IR_OPCODE_CASE(ATOMUMIN, ATOM); - NV50_IR_OPCODE_CASE(ATOMUMAX, ATOM); - NV50_IR_OPCODE_CASE(ATOMIMIN, ATOM); - NV50_IR_OPCODE_CASE(ATOMIMAX, ATOM); - NV50_IR_OPCODE_CASE(ATOMFADD, ATOM); - NV50_IR_OPCODE_CASE(ATOMDEC_WRAP, ATOM); - NV50_IR_OPCODE_CASE(ATOMINC_WRAP, ATOM); - - NV50_IR_OPCODE_CASE(TEX2, TEX); - NV50_IR_OPCODE_CASE(TXB2, TXB); - NV50_IR_OPCODE_CASE(TXL2, TXL); - - NV50_IR_OPCODE_CASE(IBFE, EXTBF); - NV50_IR_OPCODE_CASE(UBFE, EXTBF); - NV50_IR_OPCODE_CASE(BFI, INSBF); - NV50_IR_OPCODE_CASE(BREV, EXTBF); - NV50_IR_OPCODE_CASE(POPC, POPCNT); - NV50_IR_OPCODE_CASE(LSB, BFIND); - NV50_IR_OPCODE_CASE(IMSB, BFIND); - NV50_IR_OPCODE_CASE(UMSB, BFIND); - - NV50_IR_OPCODE_CASE(VOTE_ALL, VOTE); - NV50_IR_OPCODE_CASE(VOTE_ANY, VOTE); - NV50_IR_OPCODE_CASE(VOTE_EQ, VOTE); - - NV50_IR_OPCODE_CASE(BALLOT, VOTE); - NV50_IR_OPCODE_CASE(READ_INVOC, SHFL); - NV50_IR_OPCODE_CASE(READ_FIRST, SHFL); - - NV50_IR_OPCODE_CASE(END, EXIT); - - default: - return nv50_ir::OP_NOP; - } -} - -static uint16_t opcodeToSubOp(uint opcode) -{ - switch (opcode) { - case TGSI_OPCODE_ATOMUADD: return NV50_IR_SUBOP_ATOM_ADD; - case TGSI_OPCODE_ATOMXCHG: return NV50_IR_SUBOP_ATOM_EXCH; - case TGSI_OPCODE_ATOMCAS: return NV50_IR_SUBOP_ATOM_CAS; - case TGSI_OPCODE_ATOMAND: return NV50_IR_SUBOP_ATOM_AND; - case TGSI_OPCODE_ATOMOR: return NV50_IR_SUBOP_ATOM_OR; - case TGSI_OPCODE_ATOMXOR: return NV50_IR_SUBOP_ATOM_XOR; - case TGSI_OPCODE_ATOMUMIN: return NV50_IR_SUBOP_ATOM_MIN; - case TGSI_OPCODE_ATOMIMIN: return NV50_IR_SUBOP_ATOM_MIN; - case TGSI_OPCODE_ATOMUMAX: return NV50_IR_SUBOP_ATOM_MAX; - case TGSI_OPCODE_ATOMIMAX: return NV50_IR_SUBOP_ATOM_MAX; - case TGSI_OPCODE_ATOMFADD: return NV50_IR_SUBOP_ATOM_ADD; - case TGSI_OPCODE_ATOMDEC_WRAP: return NV50_IR_SUBOP_ATOM_DEC; - case TGSI_OPCODE_ATOMINC_WRAP: return NV50_IR_SUBOP_ATOM_INC; - case TGSI_OPCODE_IMUL_HI: - case TGSI_OPCODE_UMUL_HI: - return NV50_IR_SUBOP_MUL_HIGH; - case TGSI_OPCODE_VOTE_ALL: return NV50_IR_SUBOP_VOTE_ALL; - case TGSI_OPCODE_VOTE_ANY: return NV50_IR_SUBOP_VOTE_ANY; - case TGSI_OPCODE_VOTE_EQ: return NV50_IR_SUBOP_VOTE_UNI; - default: - return 0; - } -} - -bool Instruction::checkDstSrcAliasing() const -{ - if (insn->Dst[0].Register.Indirect) // no danger if indirect, using memory - return false; - - for (int s = 0; s < TGSI_FULL_MAX_SRC_REGISTERS; ++s) { - if (insn->Src[s].Register.File == TGSI_FILE_NULL) - break; - if (insn->Src[s].Register.File == insn->Dst[0].Register.File && - insn->Src[s].Register.Index == insn->Dst[0].Register.Index) - return true; - } - return false; -} - -class Source -{ -public: - Source(struct nv50_ir_prog_info *, struct nv50_ir_prog_info_out *, nv50_ir::Program *); - ~Source(); - -public: - bool scanSource(); - unsigned fileSize(unsigned file) const { return scan.file_max[file] + 1; } - -public: - struct tgsi_shader_info scan; - struct tgsi_full_instruction *insns; - const struct tgsi_token *tokens; - struct nv50_ir_prog_info *info; - struct nv50_ir_prog_info_out *info_out; - - nv50_ir::DynArray tempArrays; - nv50_ir::DynArray immdArrays; - - typedef nv50_ir::BuildUtil::Location Location; - // these registers are per-subroutine, cannot be used for parameter passing - std::set locals; - - std::set indirectTempArrays; - std::map indirectTempOffsets; - std::map > tempArrayInfo; - std::vector tempArrayId; - - std::map bufferIds; - std::map imageIds; - - int clipVertexOutput; - - struct TextureView { - uint8_t target; // TGSI_TEXTURE_* - }; - std::vector textureViews; - - /* - struct Resource { - uint8_t target; // TGSI_TEXTURE_* - bool raw; - uint8_t slot; // $surface index - }; - std::vector resources; - */ - - struct MemoryFile { - uint8_t mem_type; // TGSI_MEMORY_TYPE_* - }; - std::vector memoryFiles; - - std::vector bufferAtomics; - - struct { - uint16_t count; /* count of inline immediates */ - uint32_t *data; /* inline immediate data */ - } immd; - -private: - int gmemSlot; - nv50_ir::Program *prog; - int inferSysValDirection(unsigned sn) const; - bool scanDeclaration(const struct tgsi_full_declaration *); - bool scanInstruction(const struct tgsi_full_instruction *); - void scanInstructionSrc(const Instruction& insn, - const Instruction::SrcRegister& src, - unsigned mask); - void scanProperty(const struct tgsi_full_property *); - void scanImmediate(const struct tgsi_full_immediate *); - - inline bool isEdgeFlagPassthrough(const Instruction&) const; -}; - -Source::Source(struct nv50_ir_prog_info *info, struct nv50_ir_prog_info_out *info_out, - nv50_ir::Program *prog) -: insns(NULL), info(info), info_out(info_out), clipVertexOutput(-1), - gmemSlot(0), prog(prog) -{ - tokens = (const struct tgsi_token *)info->bin.source; - - if (info->dbgFlags & NV50_IR_DEBUG_BASIC) - tgsi_dump(tokens, 0); - - tgsi_scan_shader(tokens, &scan); - - immd.count = 0; - immd.data = (uint32_t *)MALLOC(scan.immediate_count * 16); -} - -Source::~Source() -{ - if (insns) - FREE(insns); - - if (immd.data) - FREE(immd.data); -} - -bool Source::scanSource() -{ - unsigned insnCount = 0; - struct tgsi_parse_context parse; - - insns = (struct tgsi_full_instruction *)MALLOC(scan.num_instructions * - sizeof(insns[0])); - if (!insns) - return false; - - textureViews.resize(scan.file_max[TGSI_FILE_SAMPLER_VIEW] + 1); - //resources.resize(scan.file_max[TGSI_FILE_RESOURCE] + 1); - tempArrayId.resize(scan.file_max[TGSI_FILE_TEMPORARY] + 1); - memoryFiles.resize(scan.file_max[TGSI_FILE_MEMORY] + 1); - bufferAtomics.resize(scan.file_max[TGSI_FILE_BUFFER] + 1); - - info_out->numInputs = scan.file_max[TGSI_FILE_INPUT] + 1; - info_out->numOutputs = scan.file_max[TGSI_FILE_OUTPUT] + 1; - info_out->numSysVals = scan.file_max[TGSI_FILE_SYSTEM_VALUE] + 1; - - if (info->type == PIPE_SHADER_FRAGMENT) { - info_out->prop.fp.writesDepth = scan.writes_z; - info_out->prop.fp.usesDiscard = scan.uses_kill || info->io.alphaRefBase; - } else - if (info->type == PIPE_SHADER_GEOMETRY) { - info_out->prop.gp.instanceCount = 1; // default value - } - - info->io.viewportId = -1; - - 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_IMMEDIATE: - scanImmediate(&parse.FullToken.FullImmediate); - break; - case TGSI_TOKEN_TYPE_DECLARATION: - scanDeclaration(&parse.FullToken.FullDeclaration); - break; - case TGSI_TOKEN_TYPE_INSTRUCTION: - insns[insnCount++] = parse.FullToken.FullInstruction; - scanInstruction(&parse.FullToken.FullInstruction); - break; - case TGSI_TOKEN_TYPE_PROPERTY: - scanProperty(&parse.FullToken.FullProperty); - break; - default: - INFO("unknown TGSI token type: %d\n", parse.FullToken.Token.Type); - break; - } - } - tgsi_parse_free(&parse); - - if (indirectTempArrays.size()) { - int tempBase = 0; - for (std::set::const_iterator it = indirectTempArrays.begin(); - it != indirectTempArrays.end(); ++it) { - std::pair& info = tempArrayInfo[*it]; - indirectTempOffsets.insert(std::make_pair(*it, tempBase - info.first)); - tempBase += info.second; - } - info_out->bin.tlsSpace += tempBase * 16; - } - - if (info_out->io.genUserClip > 0) { - info_out->io.clipDistances = info_out->io.genUserClip; - - const unsigned int nOut = (info_out->io.genUserClip + 3) / 4; - - for (unsigned int n = 0; n < nOut; ++n) { - unsigned int i = info_out->numOutputs++; - info_out->out[i].id = i; - info_out->out[i].sn = TGSI_SEMANTIC_CLIPDIST; - info_out->out[i].si = n; - info_out->out[i].mask = ((1 << info_out->io.clipDistances) - 1) >> (n * 4); - } - } - - return info->assignSlots(info_out) == 0; -} - -void Source::scanProperty(const struct tgsi_full_property *prop) -{ - switch (prop->Property.PropertyName) { - case TGSI_PROPERTY_GS_OUTPUT_PRIM: - info_out->prop.gp.outputPrim = prop->u[0].Data; - break; - case TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES: - info_out->prop.gp.maxVertices = prop->u[0].Data; - break; - case TGSI_PROPERTY_GS_INVOCATIONS: - info_out->prop.gp.instanceCount = prop->u[0].Data; - break; - case TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS: - info_out->prop.fp.separateFragData = true; - break; - case TGSI_PROPERTY_FS_COORD_ORIGIN: - case TGSI_PROPERTY_FS_COORD_PIXEL_CENTER: - case TGSI_PROPERTY_FS_DEPTH_LAYOUT: - case TGSI_PROPERTY_GS_INPUT_PRIM: - case TGSI_PROPERTY_FS_BLEND_EQUATION_ADVANCED: - // we don't care - break; - case TGSI_PROPERTY_VS_PROHIBIT_UCPS: - info_out->io.genUserClip = -1; - break; - case TGSI_PROPERTY_TCS_VERTICES_OUT: - info_out->prop.tp.outputPatchSize = prop->u[0].Data; - break; - case TGSI_PROPERTY_TES_PRIM_MODE: - info_out->prop.tp.domain = prop->u[0].Data; - break; - case TGSI_PROPERTY_TES_SPACING: - info_out->prop.tp.partitioning = prop->u[0].Data; - break; - case TGSI_PROPERTY_TES_VERTEX_ORDER_CW: - info_out->prop.tp.winding = prop->u[0].Data; - break; - case TGSI_PROPERTY_TES_POINT_MODE: - if (prop->u[0].Data) - info_out->prop.tp.outputPrim = MESA_PRIM_POINTS; - else - info_out->prop.tp.outputPrim = MESA_PRIM_TRIANGLES; /* anything but points */ - break; - case TGSI_PROPERTY_CS_FIXED_BLOCK_WIDTH: - info->prop.cp.numThreads[0] = prop->u[0].Data; - break; - case TGSI_PROPERTY_CS_FIXED_BLOCK_HEIGHT: - info->prop.cp.numThreads[1] = prop->u[0].Data; - break; - case TGSI_PROPERTY_CS_FIXED_BLOCK_DEPTH: - info->prop.cp.numThreads[2] = prop->u[0].Data; - break; - case TGSI_PROPERTY_NUM_CLIPDIST_ENABLED: - info_out->io.clipDistances = prop->u[0].Data; - break; - case TGSI_PROPERTY_NUM_CULLDIST_ENABLED: - info_out->io.cullDistances = prop->u[0].Data; - break; - case TGSI_PROPERTY_NEXT_SHADER: - /* Do not need to know the next shader stage. */ - break; - case TGSI_PROPERTY_FS_EARLY_DEPTH_STENCIL: - info_out->prop.fp.earlyFragTests = prop->u[0].Data; - break; - case TGSI_PROPERTY_FS_POST_DEPTH_COVERAGE: - info_out->prop.fp.postDepthCoverage = prop->u[0].Data; - break; - case TGSI_PROPERTY_LEGACY_MATH_RULES: - info->io.mul_zero_wins = prop->u[0].Data; - break; - case TGSI_PROPERTY_LAYER_VIEWPORT_RELATIVE: - info_out->io.layer_viewport_relative = prop->u[0].Data; - break; - default: - INFO("unhandled TGSI property %d\n", prop->Property.PropertyName); - break; - } -} - -void Source::scanImmediate(const struct tgsi_full_immediate *imm) -{ - const unsigned n = immd.count++; - - assert(n < scan.immediate_count); - - for (int c = 0; c < 4; ++c) - immd.data[n * 4 + c] = imm->u[c].Uint; -} - -int Source::inferSysValDirection(unsigned sn) const -{ - switch (sn) { - case TGSI_SEMANTIC_INSTANCEID: - case TGSI_SEMANTIC_VERTEXID: - return 1; - case TGSI_SEMANTIC_LAYER: -#if 0 - case TGSI_SEMANTIC_VIEWPORTINDEX: - return 0; -#endif - case TGSI_SEMANTIC_PRIMID: - return (info->type == PIPE_SHADER_FRAGMENT) ? 1 : 0; - default: - return 0; - } -} - -bool Source::scanDeclaration(const struct tgsi_full_declaration *decl) -{ - unsigned i, c; - unsigned sn = TGSI_SEMANTIC_GENERIC; - unsigned si = 0; - const unsigned first = decl->Range.First, last = decl->Range.Last; - const int arrayId = decl->Array.ArrayID; - - if (decl->Declaration.Semantic) { - sn = decl->Semantic.Name; - si = decl->Semantic.Index; - } - - if (decl->Declaration.Local || decl->Declaration.File == TGSI_FILE_ADDRESS) { - for (i = first; i <= last; ++i) { - for (c = 0; c < 4; ++c) { - locals.insert( - Location(decl->Declaration.File, decl->Dim.Index2D, i, c)); - } - } - } - - switch (decl->Declaration.File) { - case TGSI_FILE_INPUT: - if (info->type == PIPE_SHADER_VERTEX) { - // all vertex attributes are equal - for (i = first; i <= last; ++i) { - info_out->in[i].sn = TGSI_SEMANTIC_GENERIC; - info_out->in[i].si = i; - } - } else { - for (i = first; i <= last; ++i, ++si) { - info_out->in[i].id = i; - info_out->in[i].sn = sn; - info_out->in[i].si = si; - if (info->type == PIPE_SHADER_FRAGMENT) { - // translate interpolation mode - switch (decl->Interp.Interpolate) { - case TGSI_INTERPOLATE_CONSTANT: - info_out->in[i].flat = 1; - break; - case TGSI_INTERPOLATE_COLOR: - info_out->in[i].sc = 1; - break; - case TGSI_INTERPOLATE_LINEAR: - info_out->in[i].linear = 1; - break; - default: - break; - } - if (decl->Interp.Location) - info_out->in[i].centroid = 1; - } - - if (sn == TGSI_SEMANTIC_PATCH) - info_out->in[i].patch = 1; - if (sn == TGSI_SEMANTIC_PATCH) - info_out->numPatchConstants = MAX2(info_out->numPatchConstants, si + 1); - } - } - break; - case TGSI_FILE_OUTPUT: - for (i = first; i <= last; ++i, ++si) { - switch (sn) { - case TGSI_SEMANTIC_POSITION: - if (info->type == PIPE_SHADER_FRAGMENT) - info_out->io.fragDepth = i; - else - if (clipVertexOutput < 0) - clipVertexOutput = i; - break; - case TGSI_SEMANTIC_COLOR: - if (info->type == PIPE_SHADER_FRAGMENT) - info_out->prop.fp.numColourResults++; - break; - case TGSI_SEMANTIC_EDGEFLAG: - info_out->io.edgeFlagOut = i; - break; - case TGSI_SEMANTIC_CLIPVERTEX: - clipVertexOutput = i; - break; - case TGSI_SEMANTIC_CLIPDIST: - info_out->io.genUserClip = -1; - break; - case TGSI_SEMANTIC_SAMPLEMASK: - info_out->io.sampleMask = i; - break; - case TGSI_SEMANTIC_VIEWPORT_INDEX: - info->io.viewportId = i; - break; - case TGSI_SEMANTIC_PATCH: - info_out->numPatchConstants = MAX2(info_out->numPatchConstants, si + 1); - FALLTHROUGH; - case TGSI_SEMANTIC_TESSOUTER: - case TGSI_SEMANTIC_TESSINNER: - info_out->out[i].patch = 1; - break; - default: - break; - } - info_out->out[i].id = i; - info_out->out[i].sn = sn; - info_out->out[i].si = si; - } - break; - case TGSI_FILE_SYSTEM_VALUE: - switch (sn) { - case TGSI_SEMANTIC_INSTANCEID: - info_out->io.instanceId = first; - break; - case TGSI_SEMANTIC_VERTEXID: - info_out->io.vertexId = first; - break; - case TGSI_SEMANTIC_BASEVERTEX: - case TGSI_SEMANTIC_BASEINSTANCE: - case TGSI_SEMANTIC_DRAWID: - info_out->prop.vp.usesDrawParameters = true; - break; - case TGSI_SEMANTIC_SAMPLEID: - case TGSI_SEMANTIC_SAMPLEPOS: - prog->persampleInvocation = true; - break; - case TGSI_SEMANTIC_SAMPLEMASK: - info_out->prop.fp.usesSampleMaskIn = true; - break; - default: - break; - } - for (i = first; i <= last; ++i, ++si) { - info_out->sv[i].sn = sn; - info_out->sv[i].si = si; - info_out->sv[i].input = inferSysValDirection(sn); - - switch (sn) { - case TGSI_SEMANTIC_TESSOUTER: - case TGSI_SEMANTIC_TESSINNER: - info_out->sv[i].patch = 1; - break; - } - } - break; -/* - case TGSI_FILE_RESOURCE: - for (i = first; i <= last; ++i) { - resources[i].target = decl->Resource.Resource; - resources[i].raw = decl->Resource.Raw; - resources[i].slot = i; - } - break; -*/ - case TGSI_FILE_SAMPLER_VIEW: - for (i = first; i <= last; ++i) - textureViews[i].target = decl->SamplerView.Resource; - break; - case TGSI_FILE_MEMORY: - for (i = first; i <= last; ++i) - memoryFiles[i].mem_type = decl->Declaration.MemType; - break; - case TGSI_FILE_NULL: - case TGSI_FILE_TEMPORARY: - for (i = first; i <= last; ++i) - tempArrayId[i] = arrayId; - if (arrayId) - tempArrayInfo.insert(std::make_pair(arrayId, std::make_pair( - first, last - first + 1))); - break; - case TGSI_FILE_BUFFER: - for (i = first; i <= last; ++i) - bufferAtomics[i] = decl->Declaration.Atomic; - if (info->type == PIPE_SHADER_COMPUTE && info->target < NVISA_GF100_CHIPSET) { - for (i = first; i <= last; i++) { - bufferIds.insert(std::make_pair(i, gmemSlot)); - info_out->prop.cp.gmem[gmemSlot++] = {.valid = 1, .image = 0, .slot = i}; - assert(gmemSlot < 16); - } - } - break; - case TGSI_FILE_IMAGE: - if (info->type == PIPE_SHADER_COMPUTE && info->target < NVISA_GF100_CHIPSET) { - for (i = first; i <= last; i++) { - imageIds.insert(std::make_pair(i, gmemSlot)); - info_out->prop.cp.gmem[gmemSlot++] = {.valid = 1, .image = 1, .slot = i}; - assert(gmemSlot < 16); - } - } - break; - case TGSI_FILE_ADDRESS: - case TGSI_FILE_CONSTANT: - case TGSI_FILE_IMMEDIATE: - case TGSI_FILE_SAMPLER: - break; - default: - ERROR("unhandled TGSI_FILE %d\n", decl->Declaration.File); - return false; - } - return true; -} - -inline bool Source::isEdgeFlagPassthrough(const Instruction& insn) const -{ - return insn.getOpcode() == TGSI_OPCODE_MOV && - insn.getDst(0).getIndex(0) == info_out->io.edgeFlagOut && - insn.getSrc(0).getFile() == TGSI_FILE_INPUT; -} - -void Source::scanInstructionSrc(const Instruction& insn, - const Instruction::SrcRegister& src, - unsigned mask) -{ - if (src.getFile() == TGSI_FILE_TEMPORARY) { - if (src.isIndirect(0)) - indirectTempArrays.insert(src.getArrayId()); - } else - if (src.getFile() == TGSI_FILE_OUTPUT) { - if (src.isIndirect(0)) { - // We don't know which one is accessed, just mark everything for - // reading. This is an extremely unlikely occurrence. - for (unsigned i = 0; i < info_out->numOutputs; ++i) - info_out->out[i].oread = 1; - } else { - info_out->out[src.getIndex(0)].oread = 1; - } - } - if (src.getFile() == TGSI_FILE_SYSTEM_VALUE) { - if (info_out->sv[src.getIndex(0)].sn == TGSI_SEMANTIC_SAMPLEPOS) - info_out->prop.fp.readsSampleLocations = true; - } - if (src.getFile() != TGSI_FILE_INPUT) - return; - - if (src.isIndirect(0)) { - for (unsigned i = 0; i < info_out->numInputs; ++i) - info_out->in[i].mask = 0xf; - } else { - const int i = src.getIndex(0); - for (unsigned c = 0; c < 4; ++c) { - if (!(mask & (1 << c))) - continue; - int k = src.getSwizzle(c); - if (k <= TGSI_SWIZZLE_W) - info_out->in[i].mask |= 1 << k; - } - switch (info_out->in[i].sn) { - case TGSI_SEMANTIC_PSIZE: - case TGSI_SEMANTIC_PRIMID: - case TGSI_SEMANTIC_FOG: - info_out->in[i].mask &= 0x1; - break; - case TGSI_SEMANTIC_PCOORD: - info_out->in[i].mask &= 0x3; - break; - default: - break; - } - } -} - -bool Source::scanInstruction(const struct tgsi_full_instruction *inst) -{ - Instruction insn(inst); - - if (insn.getOpcode() == TGSI_OPCODE_BARRIER) - info_out->numBarriers = 1; - - if (insn.getOpcode() == TGSI_OPCODE_FBFETCH) - info_out->prop.fp.readsFramebuffer = true; - - if (insn.getOpcode() == TGSI_OPCODE_INTERP_SAMPLE) - info_out->prop.fp.readsSampleLocations = true; - - if (insn.getOpcode() == TGSI_OPCODE_DEMOTE) - info_out->prop.fp.usesDiscard = true; - - if (insn.dstCount()) { - Instruction::DstRegister dst = insn.getDst(0); - - if (insn.getOpcode() == TGSI_OPCODE_STORE && - dst.getFile() != TGSI_FILE_MEMORY) { - info_out->io.globalAccess |= 0x2; - - if (dst.getFile() == TGSI_FILE_INPUT) { - // TODO: Handle indirect somehow? - const int i = dst.getIndex(0); - info_out->in[i].mask |= 1; - } - } - - if (dst.getFile() == TGSI_FILE_OUTPUT) { - if (dst.isIndirect(0)) - for (unsigned i = 0; i < info_out->numOutputs; ++i) - info_out->out[i].mask = 0xf; - else - info_out->out[dst.getIndex(0)].mask |= dst.getMask(); - - if (info_out->out[dst.getIndex(0)].sn == TGSI_SEMANTIC_PSIZE || - info_out->out[dst.getIndex(0)].sn == TGSI_SEMANTIC_PRIMID || - info_out->out[dst.getIndex(0)].sn == TGSI_SEMANTIC_LAYER || - info_out->out[dst.getIndex(0)].sn == TGSI_SEMANTIC_VIEWPORT_INDEX || - info_out->out[dst.getIndex(0)].sn == TGSI_SEMANTIC_FOG) - info_out->out[dst.getIndex(0)].mask &= 1; - - if (isEdgeFlagPassthrough(insn)) - info_out->io.edgeFlagIn = insn.getSrc(0).getIndex(0); - } else - if (dst.getFile() == TGSI_FILE_TEMPORARY) { - if (dst.isIndirect(0)) - indirectTempArrays.insert(dst.getArrayId()); - } else - if (dst.getFile() == TGSI_FILE_BUFFER || - dst.getFile() == TGSI_FILE_IMAGE || - (dst.getFile() == TGSI_FILE_MEMORY && - memoryFiles[dst.getIndex(0)].mem_type == TGSI_MEMORY_TYPE_GLOBAL)) { - info_out->io.globalAccess |= 0x2; - } - } - - if (insn.srcCount() && ( - insn.getSrc(0).getFile() != TGSI_FILE_MEMORY || - memoryFiles[insn.getSrc(0).getIndex(0)].mem_type == - TGSI_MEMORY_TYPE_GLOBAL)) { - switch (insn.getOpcode()) { - case TGSI_OPCODE_ATOMUADD: - case TGSI_OPCODE_ATOMXCHG: - case TGSI_OPCODE_ATOMCAS: - case TGSI_OPCODE_ATOMAND: - case TGSI_OPCODE_ATOMOR: - case TGSI_OPCODE_ATOMXOR: - case TGSI_OPCODE_ATOMUMIN: - case TGSI_OPCODE_ATOMIMIN: - case TGSI_OPCODE_ATOMUMAX: - case TGSI_OPCODE_ATOMIMAX: - case TGSI_OPCODE_ATOMFADD: - case TGSI_OPCODE_ATOMDEC_WRAP: - case TGSI_OPCODE_ATOMINC_WRAP: - case TGSI_OPCODE_LOAD: - info_out->io.globalAccess |= (insn.getOpcode() == TGSI_OPCODE_LOAD) ? - 0x1 : 0x2; - break; - } - } - - - for (unsigned s = 0; s < insn.srcCount(); ++s) - scanInstructionSrc(insn, insn.getSrc(s), insn.srcMask(s)); - - for (unsigned s = 0; s < insn.getNumTexOffsets(); ++s) - scanInstructionSrc(insn, insn.getTexOffset(s), insn.texOffsetMask()); - - return true; -} - -nv50_ir::TexInstruction::Target -Instruction::getTexture(const tgsi::Source *code, int s) const -{ - // XXX: indirect access - unsigned int r; - - switch (getSrc(s).getFile()) { -/* - case TGSI_FILE_RESOURCE: - r = getSrc(s).getIndex(0); - return translateTexture(code->resources.at(r).target); -*/ - case TGSI_FILE_SAMPLER_VIEW: - r = getSrc(s).getIndex(0); - return translateTexture(code->textureViews.at(r).target); - default: - return translateTexture(insn->Texture.Texture); - } -} - -} // namespace tgsi - -namespace { - -using namespace nv50_ir; - -class Converter : public ConverterCommon -{ -public: - Converter(Program *, const tgsi::Source *, nv50_ir_prog_info_out *); - ~Converter(); - - bool run(); - -private: - Value *shiftAddress(Value *); - Value *getVertexBase(int s); - Value *getOutputBase(int s); - DataArray *getArrayForFile(unsigned file, int idx); - Value *fetchSrc(int s, int c); - Value *fetchDst(int d, int c); - Value *acquireDst(int d, int c); - void storeDst(int d, int c, Value *); - - Value *fetchSrc(const tgsi::Instruction::SrcRegister src, int c, Value *ptr); - void storeDst(const tgsi::Instruction::DstRegister dst, int c, - Value *val, Value *ptr); - - void adjustTempIndex(int arrayId, int &idx, int &idx2d) const; - Value *applySrcMod(Value *, int s, int c); - - Symbol *makeSym(uint file, int fileIndex, int idx, int c, uint32_t addr); - Symbol *srcToSym(tgsi::Instruction::SrcRegister, int c); - Symbol *dstToSym(tgsi::Instruction::DstRegister, int c); - - bool isSubGroupMask(uint8_t semantic); - - bool handleInstruction(const struct tgsi_full_instruction *); - void exportOutputs(); - inline bool isEndOfSubroutine(uint ip); - - void loadProjTexCoords(Value *dst[4], Value *src[4], unsigned int mask); - - // R,S,L,C,Dx,Dy encode TGSI sources for respective values (0xSf for auto) - void setTexRS(TexInstruction *, unsigned int& s, int R, int S); - void handleTEX(Value *dst0[4], int R, int S, int L, int C, int Dx, int Dy); - void handleTXF(Value *dst0[4], int R, int L_M); - void handleTXQ(Value *dst0[4], enum TexQuery, int R); - void handleFBFETCH(Value *dst0[4]); - void handleLIT(Value *dst0[4]); - - // Symbol *getResourceBase(int r); - void getImageCoords(std::vector&, int s); - int remapImageId(int); - int remapBufferId(int); - - void handleLOAD(Value *dst0[4]); - void handleSTORE(); - void handleATOM(Value *dst0[4], DataType, uint16_t subOp); - - void handleINTERP(Value *dst0[4]); - - Value *interpolate(tgsi::Instruction::SrcRegister, int c, Value *ptr); - - void insertConvergenceOps(BasicBlock *conv, BasicBlock *fork); - - Value *buildDot(int dim); - - class BindArgumentsPass : public Pass { - public: - BindArgumentsPass(Converter &conv) : conv(conv), sub(NULL) { } - - private: - Converter &conv; - Subroutine *sub; - - inline const Location *getValueLocation(Subroutine *, Value *); - - template inline void - updateCallArgs(Instruction *i, void (Instruction::*setArg)(int, Value *), - T (Function::*proto)); - - template inline void - updatePrototype(BitSet *set, void (Function::*updateSet)(), - T (Function::*proto)); - - protected: - bool visit(Function *); - bool visit(BasicBlock *bb) { return false; } - }; - -private: - const tgsi::Source *code; - - uint ip; // instruction pointer - - tgsi::Instruction tgsi; - - DataType dstTy; - DataType srcTy; - - DataArray tData; // TGSI_FILE_TEMPORARY - DataArray lData; // TGSI_FILE_TEMPORARY, for indirect arrays - DataArray aData; // TGSI_FILE_ADDRESS - DataArray oData; // TGSI_FILE_OUTPUT (if outputs in registers) - - Value *zero; - - Value *vtxBase[5]; // base address of vertex in primitive (for TP/GP) - uint8_t vtxBaseValid; - - Stack condBBs; // fork BB, then else clause BB - Stack joinBBs; // fork BB, for inserting join ops on ENDIF - Stack loopBBs; // loop headers - Stack breakBBs; // end of / after loop - - Value *viewport; -}; - -Symbol * -Converter::srcToSym(tgsi::Instruction::SrcRegister src, int c) -{ - const int swz = src.getSwizzle(c); - - /* TODO: Use Array ID when it's available for the index */ - return makeSym(src.getFile(), - src.is2D() ? src.getIndex(1) : 0, - src.getIndex(0), swz, - src.getIndex(0) * 16 + swz * 4); -} - -Symbol * -Converter::dstToSym(tgsi::Instruction::DstRegister dst, int c) -{ - /* TODO: Use Array ID when it's available for the index */ - return makeSym(dst.getFile(), - dst.is2D() ? dst.getIndex(1) : 0, - dst.getIndex(0), c, - dst.getIndex(0) * 16 + c * 4); -} - -Symbol * -Converter::makeSym(uint tgsiFile, int fileIdx, int idx, int c, uint32_t address) -{ - Symbol *sym = new_Symbol(prog, tgsi::translateFile(tgsiFile)); - - sym->reg.fileIndex = fileIdx; - - if (tgsiFile == TGSI_FILE_MEMORY) { - switch (code->memoryFiles[fileIdx].mem_type) { - case TGSI_MEMORY_TYPE_GLOBAL: - /* No-op this is the default for TGSI_FILE_MEMORY */ - sym->setFile(FILE_MEMORY_GLOBAL); - break; - case TGSI_MEMORY_TYPE_SHARED: - sym->setFile(FILE_MEMORY_SHARED); - address += info->prop.cp.inputOffset; - break; - case TGSI_MEMORY_TYPE_INPUT: - assert(prog->getType() == Program::TYPE_COMPUTE); - assert(idx == -1); - sym->setFile(FILE_SHADER_INPUT); - address += info->prop.cp.inputOffset; - break; - default: - assert(0); /* TODO: Add support for global and private memory */ - } - } - - if (idx >= 0) { - if (sym->reg.file == FILE_SHADER_INPUT) - sym->setOffset(info_out->in[idx].slot[c] * 4); - else - if (sym->reg.file == FILE_SHADER_OUTPUT) - sym->setOffset(info_out->out[idx].slot[c] * 4); - else - if (sym->reg.file == FILE_SYSTEM_VALUE) - sym->setSV(tgsi::translateSysVal(info_out->sv[idx].sn), c); - else - sym->setOffset(address); - } else { - sym->setOffset(address); - } - return sym; -} - -Value * -Converter::interpolate(tgsi::Instruction::SrcRegister src, int c, Value *ptr) -{ - operation op; - - // XXX: no way to know interpolation mode if we don't know what's accessed - const uint8_t mode = translateInterpMode(&info_out->in[ptr ? 0 : - src.getIndex(0)], op); - - Instruction *insn = new_Instruction(func, op, TYPE_F32); - - insn->setDef(0, getScratch()); - insn->setSrc(0, srcToSym(src, c)); - if (op == OP_PINTERP) - insn->setSrc(1, fragCoord[3]); - if (ptr) - insn->setIndirect(0, 0, ptr); - - insn->setInterpolate(mode); - - bb->insertTail(insn); - return insn->getDef(0); -} - -Value * -Converter::applySrcMod(Value *val, int s, int c) -{ - Modifier m = tgsi.getSrc(s).getMod(c); - DataType ty = tgsi.inferSrcType(); - - if (m & Modifier(NV50_IR_MOD_ABS)) - val = mkOp1v(OP_ABS, ty, getScratch(), val); - - if (m & Modifier(NV50_IR_MOD_NEG)) - val = mkOp1v(OP_NEG, ty, getScratch(), val); - - return val; -} - -Value * -Converter::getVertexBase(int s) -{ - assert(s < 5); - if (!(vtxBaseValid & (1 << s))) { - const int index = tgsi.getSrc(s).getIndex(1); - Value *rel = NULL; - if (tgsi.getSrc(s).isIndirect(1)) - rel = fetchSrc(tgsi.getSrc(s).getIndirect(1), 0, NULL); - vtxBaseValid |= 1 << s; - vtxBase[s] = mkOp2v(OP_PFETCH, TYPE_U32, getSSA(4, FILE_ADDRESS), - mkImm(index), rel); - } - return vtxBase[s]; -} - -Value * -Converter::getOutputBase(int s) -{ - assert(s < 5); - if (!(vtxBaseValid & (1 << s))) { - Value *offset = loadImm(NULL, tgsi.getSrc(s).getIndex(1)); - if (tgsi.getSrc(s).isIndirect(1)) - offset = mkOp2v(OP_ADD, TYPE_U32, getSSA(), - fetchSrc(tgsi.getSrc(s).getIndirect(1), 0, NULL), - offset); - vtxBaseValid |= 1 << s; - vtxBase[s] = mkOp2v(OP_ADD, TYPE_U32, getSSA(), outBase, offset); - } - return vtxBase[s]; -} - -Value * -Converter::fetchSrc(int s, int c) -{ - Value *res; - Value *ptr = NULL, *dimRel = NULL; - - tgsi::Instruction::SrcRegister src = tgsi.getSrc(s); - - if (src.isIndirect(0)) - ptr = fetchSrc(src.getIndirect(0), 0, NULL); - - if (src.is2D()) { - switch (src.getFile()) { - case TGSI_FILE_OUTPUT: - dimRel = getOutputBase(s); - break; - case TGSI_FILE_INPUT: - dimRel = getVertexBase(s); - break; - case TGSI_FILE_CONSTANT: - // on NVC0, this is valid and c{I+J}[k] == cI[(J << 16) + k] - if (src.isIndirect(1)) - dimRel = fetchSrc(src.getIndirect(1), 0, 0); - break; - default: - break; - } - } - - res = fetchSrc(src, c, ptr); - - if (dimRel) - res->getInsn()->setIndirect(0, 1, dimRel); - - return applySrcMod(res, s, c); -} - -Value * -Converter::fetchDst(int d, int c) -{ - Value *res; - Value *ptr = NULL, *dimRel = NULL; - - tgsi::Instruction::DstRegister dst = tgsi.getDst(d); - - if (dst.isIndirect(0)) - ptr = fetchSrc(dst.getIndirect(0), 0, NULL); - - if (dst.is2D()) { - switch (dst.getFile()) { - case TGSI_FILE_OUTPUT: - assert(0); // TODO - dimRel = NULL; - break; - case TGSI_FILE_INPUT: - assert(0); // TODO - dimRel = NULL; - break; - case TGSI_FILE_CONSTANT: - // on NVC0, this is valid and c{I+J}[k] == cI[(J << 16) + k] - if (dst.isIndirect(1)) - dimRel = fetchSrc(dst.getIndirect(1), 0, 0); - break; - default: - break; - } - } - - struct tgsi_full_src_register fsr = dst.asSrc(); - tgsi::Instruction::SrcRegister src(&fsr); - res = fetchSrc(src, c, ptr); - - if (dimRel) - res->getInsn()->setIndirect(0, 1, dimRel); - - return res; -} - -Converter::DataArray * -Converter::getArrayForFile(unsigned file, int idx) -{ - switch (file) { - case TGSI_FILE_TEMPORARY: - return idx == 0 ? &tData : &lData; - case TGSI_FILE_ADDRESS: - return &aData; - case TGSI_FILE_OUTPUT: - assert(prog->getType() == Program::TYPE_FRAGMENT); - return &oData; - default: - assert(!"invalid/unhandled TGSI source file"); - return NULL; - } -} - -Value * -Converter::shiftAddress(Value *index) -{ - if (!index) - return NULL; - return mkOp2v(OP_SHL, TYPE_U32, getSSA(4, FILE_ADDRESS), index, mkImm(4)); -} - -void -Converter::adjustTempIndex(int arrayId, int &idx, int &idx2d) const -{ - std::map::const_iterator it = - code->indirectTempOffsets.find(arrayId); - if (it == code->indirectTempOffsets.end()) - return; - - idx2d = 1; - idx += it->second; -} - -bool -Converter::isSubGroupMask(uint8_t semantic) -{ - switch (semantic) { - case TGSI_SEMANTIC_SUBGROUP_EQ_MASK: - case TGSI_SEMANTIC_SUBGROUP_LT_MASK: - case TGSI_SEMANTIC_SUBGROUP_LE_MASK: - case TGSI_SEMANTIC_SUBGROUP_GT_MASK: - case TGSI_SEMANTIC_SUBGROUP_GE_MASK: - return true; - default: - return false; - } -} - -Value * -Converter::fetchSrc(tgsi::Instruction::SrcRegister src, int c, Value *ptr) -{ - int idx2d = src.is2D() ? src.getIndex(1) : 0; - int idx = src.getIndex(0); - const int swz = src.getSwizzle(c); - Instruction *ld; - - switch (src.getFile()) { - case TGSI_FILE_IMMEDIATE: - assert(!ptr); - return loadImm(NULL, code->immd.data[idx * 4 + swz]); - case TGSI_FILE_CONSTANT: - return mkLoadv(TYPE_U32, srcToSym(src, c), shiftAddress(ptr)); - case TGSI_FILE_INPUT: - if (prog->getType() == Program::TYPE_FRAGMENT) { - // don't load masked inputs, won't be assigned a slot - if (!ptr && !(info_out->in[idx].mask & (1 << swz))) - return loadImm(NULL, swz == TGSI_SWIZZLE_W ? 1.0f : 0.0f); - return interpolate(src, c, shiftAddress(ptr)); - } else - if (prog->getType() == Program::TYPE_GEOMETRY) { - if (!ptr && info_out->in[idx].sn == TGSI_SEMANTIC_PRIMID) - return mkOp1v(OP_RDSV, TYPE_U32, getSSA(), mkSysVal(SV_PRIMITIVE_ID, 0)); - // XXX: This is going to be a problem with scalar arrays, i.e. when - // we cannot assume that the address is given in units of vec4. - // - // nv50 and nvc0 need different things here, so let the lowering - // passes decide what to do with the address - if (ptr) - return mkLoadv(TYPE_U32, srcToSym(src, c), ptr); - } - ld = mkLoad(TYPE_U32, getSSA(), srcToSym(src, c), shiftAddress(ptr)); - ld->perPatch = info_out->in[idx].patch; - return ld->getDef(0); - case TGSI_FILE_OUTPUT: - assert(prog->getType() == Program::TYPE_TESSELLATION_CONTROL); - ld = mkLoad(TYPE_U32, getSSA(), srcToSym(src, c), shiftAddress(ptr)); - ld->perPatch = info_out->out[idx].patch; - return ld->getDef(0); - case TGSI_FILE_SYSTEM_VALUE: - assert(!ptr); - if (info_out->sv[idx].sn == TGSI_SEMANTIC_THREAD_ID && - info->prop.cp.numThreads[swz] == 1) - return loadImm(NULL, 0u); - if (isSubGroupMask(info_out->sv[idx].sn) && swz > 0) - return loadImm(NULL, 0u); - if (info_out->sv[idx].sn == TGSI_SEMANTIC_SUBGROUP_SIZE) - return loadImm(NULL, 32u); - ld = mkOp1(OP_RDSV, TYPE_U32, getSSA(), srcToSym(src, c)); - ld->perPatch = info_out->sv[idx].patch; - return ld->getDef(0); - case TGSI_FILE_TEMPORARY: { - int arrayid = src.getArrayId(); - if (!arrayid) - arrayid = code->tempArrayId[idx]; - adjustTempIndex(arrayid, idx, idx2d); - } - FALLTHROUGH; - default: - return getArrayForFile(src.getFile(), idx2d)->load( - sub.cur->values, idx, swz, shiftAddress(ptr)); - } -} - -Value * -Converter::acquireDst(int d, int c) -{ - const tgsi::Instruction::DstRegister dst = tgsi.getDst(d); - const unsigned f = dst.getFile(); - int idx = dst.getIndex(0); - int idx2d = dst.is2D() ? dst.getIndex(1) : 0; - - if (dst.isMasked(c) || f == TGSI_FILE_BUFFER || f == TGSI_FILE_MEMORY || - f == TGSI_FILE_IMAGE) - return NULL; - - if (dst.isIndirect(0) || - f == TGSI_FILE_SYSTEM_VALUE || - (f == TGSI_FILE_OUTPUT && prog->getType() != Program::TYPE_FRAGMENT)) - return getScratch(); - - if (f == TGSI_FILE_TEMPORARY) { - int arrayid = dst.getArrayId(); - if (!arrayid) - arrayid = code->tempArrayId[idx]; - adjustTempIndex(arrayid, idx, idx2d); - } - - return getArrayForFile(f, idx2d)-> acquire(sub.cur->values, idx, c); -} - -void -Converter::storeDst(int d, int c, Value *val) -{ - const tgsi::Instruction::DstRegister dst = tgsi.getDst(d); - - if (tgsi.getSaturate()) { - mkOp1(OP_SAT, dstTy, val, val); - } - - Value *ptr = NULL; - if (dst.isIndirect(0)) - ptr = shiftAddress(fetchSrc(dst.getIndirect(0), 0, NULL)); - - if (info_out->io.genUserClip > 0 && - dst.getFile() == TGSI_FILE_OUTPUT && - !dst.isIndirect(0) && dst.getIndex(0) == code->clipVertexOutput) { - mkMov(clipVtx[c], val); - val = clipVtx[c]; - } - - storeDst(dst, c, val, ptr); -} - -void -Converter::storeDst(const tgsi::Instruction::DstRegister dst, int c, - Value *val, Value *ptr) -{ - const unsigned f = dst.getFile(); - int idx = dst.getIndex(0); - int idx2d = dst.is2D() ? dst.getIndex(1) : 0; - - if (f == TGSI_FILE_SYSTEM_VALUE) { - assert(!ptr); - mkOp2(OP_WRSV, TYPE_U32, NULL, dstToSym(dst, c), val); - } else - if (f == TGSI_FILE_OUTPUT && prog->getType() != Program::TYPE_FRAGMENT) { - - if (ptr || (info_out->out[idx].mask & (1 << c))) { - /* Save the viewport index into a scratch register so that it can be - exported at EMIT time */ - if (info_out->out[idx].sn == TGSI_SEMANTIC_VIEWPORT_INDEX && - prog->getType() == Program::TYPE_GEOMETRY && - viewport != NULL) - mkOp1(OP_MOV, TYPE_U32, viewport, val); - else - mkStore(OP_EXPORT, TYPE_U32, dstToSym(dst, c), ptr, val)->perPatch = - info_out->out[idx].patch; - } - } else - if (f == TGSI_FILE_TEMPORARY || - f == TGSI_FILE_ADDRESS || - f == TGSI_FILE_OUTPUT) { - if (f == TGSI_FILE_TEMPORARY) { - int arrayid = dst.getArrayId(); - if (!arrayid) - arrayid = code->tempArrayId[idx]; - adjustTempIndex(arrayid, idx, idx2d); - } - - getArrayForFile(f, idx2d)->store(sub.cur->values, idx, c, ptr, val); - } else { - assert(!"invalid dst file"); - } -} - -#define FOR_EACH_DST_ENABLED_CHANNEL(d, chan, inst) \ - for (chan = 0; chan < 4; ++chan) \ - if (!inst.getDst(d).isMasked(chan)) - -Value * -Converter::buildDot(int dim) -{ - assert(dim > 0); - - Value *src0 = fetchSrc(0, 0), *src1 = fetchSrc(1, 0); - Value *dotp = getScratch(); - - mkOp2(OP_MUL, TYPE_F32, dotp, src0, src1) - ->dnz = info->io.mul_zero_wins; - - for (int c = 1; c < dim; ++c) { - src0 = fetchSrc(0, c); - src1 = fetchSrc(1, c); - mkOp3(OP_MAD, TYPE_F32, dotp, src0, src1, dotp) - ->dnz = info->io.mul_zero_wins; - } - return dotp; -} - -void -Converter::insertConvergenceOps(BasicBlock *conv, BasicBlock *fork) -{ - FlowInstruction *join = new_FlowInstruction(func, OP_JOIN, NULL); - join->fixed = 1; - conv->insertHead(join); - - assert(!fork->joinAt); - fork->joinAt = new_FlowInstruction(func, OP_JOINAT, conv); - fork->insertBefore(fork->getExit(), fork->joinAt); -} - -void -Converter::setTexRS(TexInstruction *tex, unsigned int& s, int R, int S) -{ - unsigned rIdx = 0, sIdx = 0; - - if (R >= 0 && tgsi.getSrc(R).getFile() != TGSI_FILE_SAMPLER) { - // This is the bindless case. We have to get the actual value and pass - // it in. This will be the complete handle. - tex->tex.rIndirectSrc = s; - tex->setSrc(s++, fetchSrc(R, 0)); - tex->setTexture(tgsi.getTexture(code, R), 0xff, 0x1f); - tex->tex.bindless = true; - return; - } - - if (R >= 0) - rIdx = tgsi.getSrc(R).getIndex(0); - if (S >= 0) - sIdx = tgsi.getSrc(S).getIndex(0); - - tex->setTexture(tgsi.getTexture(code, R), rIdx, sIdx); - - if (tgsi.getSrc(R).isIndirect(0)) { - tex->tex.rIndirectSrc = s; - tex->setSrc(s++, fetchSrc(tgsi.getSrc(R).getIndirect(0), 0, NULL)); - } - if (S >= 0 && tgsi.getSrc(S).isIndirect(0)) { - tex->tex.sIndirectSrc = s; - tex->setSrc(s++, fetchSrc(tgsi.getSrc(S).getIndirect(0), 0, NULL)); - } -} - -void -Converter::handleTXQ(Value *dst0[4], enum TexQuery query, int R) -{ - TexInstruction *tex = new_TexInstruction(func, OP_TXQ); - tex->tex.query = query; - unsigned int c, d; - - for (d = 0, c = 0; c < 4; ++c) { - if (!dst0[c]) - continue; - tex->tex.mask |= 1 << c; - tex->setDef(d++, dst0[c]); - } - if (query == TXQ_DIMS) - tex->setSrc((c = 0), fetchSrc(0, 0)); // mip level - else - tex->setSrc((c = 0), zero); - - setTexRS(tex, ++c, R, -1); - - bb->insertTail(tex); -} - -void -Converter::loadProjTexCoords(Value *dst[4], Value *src[4], unsigned int mask) -{ - Value *proj = fetchSrc(0, 3); - Instruction *insn = proj->getUniqueInsn(); - int c; - - if (insn->op == OP_PINTERP) { - bb->insertTail(insn = cloneForward(func, insn)); - insn->op = OP_LINTERP; - insn->setInterpolate(NV50_IR_INTERP_LINEAR | insn->getSampleMode()); - insn->setSrc(1, NULL); - proj = insn->getDef(0); - } - proj = mkOp1v(OP_RCP, TYPE_F32, getSSA(), proj); - - for (c = 0; c < 4; ++c) { - if (!(mask & (1 << c))) - continue; - if ((insn = src[c]->getUniqueInsn())->op != OP_PINTERP) - continue; - mask &= ~(1 << c); - - bb->insertTail(insn = cloneForward(func, insn)); - insn->setInterpolate(NV50_IR_INTERP_PERSPECTIVE | insn->getSampleMode()); - insn->setSrc(1, proj); - dst[c] = insn->getDef(0); - } - if (!mask) - return; - - proj = mkOp1v(OP_RCP, TYPE_F32, getSSA(), fetchSrc(0, 3)); - - for (c = 0; c < 4; ++c) - if (mask & (1 << c)) - dst[c] = mkOp2v(OP_MUL, TYPE_F32, getSSA(), src[c], proj); -} - -// order of nv50 ir sources: x y z layer lod/bias shadow -// order of TGSI TEX sources: x y z layer shadow lod/bias -// lowering will finally set the hw specific order (like array first on nvc0) -void -Converter::handleTEX(Value *dst[4], int R, int S, int L, int C, int Dx, int Dy) -{ - Value *arg[4], *src[8]; - Value *lod = NULL, *shd = NULL; - unsigned int s, c, d; - TexInstruction *texi = new_TexInstruction(func, tgsi.getOP()); - - TexInstruction::Target tgt = tgsi.getTexture(code, R); - - for (s = 0; s < tgt.getArgCount(); ++s) - arg[s] = src[s] = fetchSrc(0, s); - - if (tgsi.getOpcode() == TGSI_OPCODE_TEX_LZ) - lod = loadImm(NULL, 0); - else if (texi->op == OP_TXL || texi->op == OP_TXB) - lod = fetchSrc(L >> 4, L & 3); - - if (C == 0x0f) - C = 0x00 | MAX2(tgt.getArgCount(), 2); // guess DC src - - if (tgt == TEX_TARGET_CUBE_ARRAY_SHADOW) { - switch (tgsi.getOpcode()) { - case TGSI_OPCODE_TG4: shd = fetchSrc(1, 0); break; - case TGSI_OPCODE_TEX2: shd = fetchSrc(1, 0); break; - case TGSI_OPCODE_TXB2: shd = fetchSrc(1, 1); break; - case TGSI_OPCODE_TXL2: shd = fetchSrc(1, 1); break; - default: assert(!"unexpected opcode with cube array shadow"); break; - } - } - else if (tgt.isShadow()) - shd = fetchSrc(C >> 4, C & 3); - - if (texi->op == OP_TXD) { - for (c = 0; c < tgt.getDim() + tgt.isCube(); ++c) { - texi->dPdx[c].set(fetchSrc(Dx >> 4, (Dx & 3) + c)); - texi->dPdy[c].set(fetchSrc(Dy >> 4, (Dy & 3) + c)); - } - } - - // cube textures don't care about projection value, it's divided out - if (tgsi.getOpcode() == TGSI_OPCODE_TXP && !tgt.isCube() && !tgt.isArray()) { - unsigned int n = tgt.getDim(); - if (shd) { - arg[n] = shd; - ++n; - assert(tgt.getDim() == tgt.getArgCount()); - } - loadProjTexCoords(src, arg, (1 << n) - 1); - if (shd) - shd = src[n - 1]; - } - - for (c = 0, d = 0; c < 4; ++c) { - if (dst[c]) { - texi->setDef(d++, dst[c]); - texi->tex.mask |= 1 << c; - } else { - // NOTE: maybe hook up def too, for CSE - } - } - for (s = 0; s < tgt.getArgCount(); ++s) - texi->setSrc(s, src[s]); - if (lod) - texi->setSrc(s++, lod); - if (shd) - texi->setSrc(s++, shd); - - setTexRS(texi, s, R, S); - - if (tgsi.getOpcode() == TGSI_OPCODE_SAMPLE_C_LZ) - texi->tex.levelZero = true; - if (prog->getType() != Program::TYPE_FRAGMENT && - (tgsi.getOpcode() == TGSI_OPCODE_TEX || - tgsi.getOpcode() == TGSI_OPCODE_TEX2 || - tgsi.getOpcode() == TGSI_OPCODE_TXP)) - texi->tex.levelZero = true; - if (tgsi.getOpcode() == TGSI_OPCODE_TG4 && !tgt.isShadow()) - texi->tex.gatherComp = tgsi.getSrc(1).getValueU32(0, code->immd.data); - - texi->tex.useOffsets = tgsi.getNumTexOffsets(); - for (s = 0; s < tgsi.getNumTexOffsets(); ++s) { - for (c = 0; c < 3; ++c) { - texi->offset[s][c].set(fetchSrc(tgsi.getTexOffset(s), c, NULL)); - texi->offset[s][c].setInsn(texi); - } - } - - bb->insertTail(texi); -} - -// 1st source: xyz = coordinates, w = lod/sample -// 2nd source: offset -void -Converter::handleTXF(Value *dst[4], int R, int L_M) -{ - TexInstruction *texi = new_TexInstruction(func, tgsi.getOP()); - int ms; - unsigned int c, d, s; - - texi->tex.target = tgsi.getTexture(code, R); - - ms = texi->tex.target.isMS() ? 1 : 0; - texi->tex.levelZero = ms; /* MS textures don't have mip-maps */ - - for (c = 0, d = 0; c < 4; ++c) { - if (dst[c]) { - texi->setDef(d++, dst[c]); - texi->tex.mask |= 1 << c; - } - } - for (c = 0; c < (texi->tex.target.getArgCount() - ms); ++c) - texi->setSrc(c, fetchSrc(0, c)); - if (!ms && tgsi.getOpcode() == TGSI_OPCODE_TXF_LZ) - texi->setSrc(c++, loadImm(NULL, 0)); - else - texi->setSrc(c++, fetchSrc(L_M >> 4, L_M & 3)); // lod or ms - - setTexRS(texi, c, R, -1); - - texi->tex.useOffsets = tgsi.getNumTexOffsets(); - for (s = 0; s < tgsi.getNumTexOffsets(); ++s) { - for (c = 0; c < 3; ++c) { - texi->offset[s][c].set(fetchSrc(tgsi.getTexOffset(s), c, NULL)); - texi->offset[s][c].setInsn(texi); - } - } - - bb->insertTail(texi); -} - -void -Converter::handleFBFETCH(Value *dst[4]) -{ - TexInstruction *texi = new_TexInstruction(func, OP_TXF); - unsigned int c, d; - - texi->tex.target = TEX_TARGET_2D_MS_ARRAY; - texi->tex.levelZero = true; - texi->tex.useOffsets = 0; - - for (c = 0, d = 0; c < 4; ++c) { - if (dst[c]) { - texi->setDef(d++, dst[c]); - texi->tex.mask |= 1 << c; - } - } - - Value *x = mkOp1v(OP_RDSV, TYPE_F32, getScratch(), mkSysVal(SV_POSITION, 0)); - Value *y = mkOp1v(OP_RDSV, TYPE_F32, getScratch(), mkSysVal(SV_POSITION, 1)); - Value *z = mkOp1v(OP_RDSV, TYPE_U32, getScratch(), mkSysVal(SV_LAYER, 0)); - Value *ms = mkOp1v(OP_RDSV, TYPE_U32, getScratch(), mkSysVal(SV_SAMPLE_INDEX, 0)); - - mkCvt(OP_CVT, TYPE_U32, x, TYPE_F32, x)->rnd = ROUND_Z; - mkCvt(OP_CVT, TYPE_U32, y, TYPE_F32, y)->rnd = ROUND_Z; - texi->setSrc(0, x); - texi->setSrc(1, y); - texi->setSrc(2, z); - texi->setSrc(3, ms); - - texi->tex.r = texi->tex.s = -1; - - bb->insertTail(texi); -} - -void -Converter::handleLIT(Value *dst0[4]) -{ - Value *val0 = NULL; - unsigned int mask = tgsi.getDst(0).getMask(); - - if (mask & (1 << 0)) - loadImm(dst0[0], 1.0f); - - if (mask & (1 << 3)) - loadImm(dst0[3], 1.0f); - - if (mask & (3 << 1)) { - val0 = getScratch(); - mkOp2(OP_MAX, TYPE_F32, val0, fetchSrc(0, 0), zero); - if (mask & (1 << 1)) - mkMov(dst0[1], val0); - } - - if (mask & (1 << 2)) { - Value *src1 = fetchSrc(0, 1), *src3 = fetchSrc(0, 3); - Value *val1 = getScratch(), *val3 = getScratch(); - - Value *pos128 = loadImm(NULL, +127.999999f); - Value *neg128 = loadImm(NULL, -127.999999f); - - mkOp2(OP_MAX, TYPE_F32, val1, src1, zero); - mkOp2(OP_MAX, TYPE_F32, val3, src3, neg128); - mkOp2(OP_MIN, TYPE_F32, val3, val3, pos128); - mkOp2(OP_POW, TYPE_F32, val3, val1, val3); - - mkCmp(OP_SLCT, CC_GT, TYPE_F32, dst0[2], TYPE_F32, val3, zero, val0); - } -} - -/* Keep this around for now as reference when adding img support -static inline bool -isResourceSpecial(const int r) -{ - return (r == TGSI_RESOURCE_GLOBAL || - r == TGSI_RESOURCE_LOCAL || - r == TGSI_RESOURCE_PRIVATE || - r == TGSI_RESOURCE_INPUT); -} - -static inline bool -isResourceRaw(const tgsi::Source *code, const int r) -{ - return isResourceSpecial(r) || code->resources[r].raw; -} - -static inline nv50_ir::TexTarget -getResourceTarget(const tgsi::Source *code, int r) -{ - if (isResourceSpecial(r)) - return nv50_ir::TEX_TARGET_BUFFER; - return tgsi::translateTexture(code->resources.at(r).target); -} - -Symbol * -Converter::getResourceBase(const int r) -{ - Symbol *sym = NULL; - - switch (r) { - case TGSI_RESOURCE_GLOBAL: - sym = new_Symbol(prog, nv50_ir::FILE_MEMORY_GLOBAL, - info->io.auxCBSlot); - break; - case TGSI_RESOURCE_LOCAL: - assert(prog->getType() == Program::TYPE_COMPUTE); - sym = mkSymbol(nv50_ir::FILE_MEMORY_SHARED, 0, TYPE_U32, - info->prop.cp.sharedOffset); - break; - case TGSI_RESOURCE_PRIVATE: - sym = mkSymbol(nv50_ir::FILE_MEMORY_LOCAL, 0, TYPE_U32, - info->bin.tlsSpace); - break; - case TGSI_RESOURCE_INPUT: - assert(prog->getType() == Program::TYPE_COMPUTE); - sym = mkSymbol(nv50_ir::FILE_SHADER_INPUT, 0, TYPE_U32, - info->prop.cp.inputOffset); - break; - default: - sym = new_Symbol(prog, - nv50_ir::FILE_MEMORY_GLOBAL, code->resources.at(r).slot); - break; - } - return sym; -} - -void -Converter::getResourceCoords(std::vector &coords, int r, int s) -{ - const int arg = - TexInstruction::Target(getResourceTarget(code, r)).getArgCount(); - - for (int c = 0; c < arg; ++c) - coords.push_back(fetchSrc(s, c)); - - // NOTE: TGSI_RESOURCE_GLOBAL needs FILE_GPR; this is an nv50 quirk - if (r == TGSI_RESOURCE_LOCAL || - r == TGSI_RESOURCE_PRIVATE || - r == TGSI_RESOURCE_INPUT) - coords[0] = mkOp1v(OP_MOV, TYPE_U32, getScratch(4, FILE_ADDRESS), - coords[0]); -} - -static inline int -partitionLoadStore(uint8_t comp[2], uint8_t size[2], uint8_t mask) -{ - int n = 0; - - while (mask) { - if (mask & 1) { - size[n]++; - } else { - if (size[n]) - comp[n = 1] = size[0] + 1; - else - comp[n]++; - } - mask >>= 1; - } - if (size[0] == 3) { - n = 1; - size[0] = (comp[0] == 1) ? 1 : 2; - size[1] = 3 - size[0]; - comp[1] = comp[0] + size[0]; - } - return n + 1; -} -*/ -void -Converter::getImageCoords(std::vector &coords, int s) -{ - TexInstruction::Target t = - TexInstruction::Target(tgsi.getImageTarget()); - const int arg = t.getDim() + (t.isArray() || t.isCube()); - - for (int c = 0; c < arg; ++c) - coords.push_back(fetchSrc(s, c)); - - if (t.isMS()) - coords.push_back(fetchSrc(s, 3)); -} - -int -Converter::remapBufferId(int id) -{ - std::map::const_iterator it = code->bufferIds.find(id); - if (it != code->bufferIds.end()) - return it->second; - return id; -} - -int -Converter::remapImageId(int id) -{ - std::map::const_iterator it = code->imageIds.find(id); - if (it != code->imageIds.end()) - return it->second; - return id; -} - -// For raw loads, granularity is 4 byte. -// Usage of the texture read mask on OP_SULDP is not allowed. -void -Converter::handleLOAD(Value *dst0[4]) -{ - int r = tgsi.getSrc(0).getIndex(0); - int c; - std::vector off, src, ldv, def; - Value *ind = NULL; - - if (tgsi.getSrc(0).isIndirect(0)) - ind = fetchSrc(tgsi.getSrc(0).getIndirect(0), 0, 0); - - switch (tgsi.getSrc(0).getFile()) { - case TGSI_FILE_BUFFER: - r = remapBufferId(r); - /* fallthrough */ - case TGSI_FILE_MEMORY: - for (c = 0; c < 4; ++c) { - if (!dst0[c]) - continue; - - Value *off; - Symbol *sym; - uint32_t src0_component_offset = tgsi.getSrc(0).getSwizzle(c) * 4; - - if (tgsi.getSrc(1).getFile() == TGSI_FILE_IMMEDIATE) { - off = NULL; - sym = makeSym(tgsi.getSrc(0).getFile(), r, -1, c, - tgsi.getSrc(1).getValueU32(0, code->immd.data) + - src0_component_offset); - } else { - // yzw are ignored for buffers - off = fetchSrc(1, 0); - sym = makeSym(tgsi.getSrc(0).getFile(), r, -1, c, - src0_component_offset); - } - - Instruction *ld = mkLoad(TYPE_U32, dst0[c], sym, off); - if (tgsi.getSrc(0).getFile() == TGSI_FILE_BUFFER && - code->bufferAtomics[tgsi.getSrc(0).getIndex(0)]) - ld->cache = nv50_ir::CACHE_CG; - else - ld->cache = tgsi.getCacheMode(); - if (ind) - ld->setIndirect(0, 1, ind); - } - break; - default: { - r = remapImageId(r); - getImageCoords(off, 1); - def.resize(4); - - for (c = 0; c < 4; ++c) { - if (!dst0[c] || tgsi.getSrc(0).getSwizzle(c) != (TGSI_SWIZZLE_X + c)) - def[c] = getScratch(); - else - def[c] = dst0[c]; - } - - bool bindless = tgsi.getSrc(0).getFile() != TGSI_FILE_IMAGE; - if (bindless) - ind = fetchSrc(0, 0); - - TexInstruction *ld = - mkTex(OP_SULDP, tgsi.getImageTarget(), 0, 0, def, off); - ld->tex.mask = tgsi.getDst(0).getMask(); - ld->tex.format = tgsi.getImageFormat(); - ld->cache = tgsi.getCacheMode(); - ld->tex.bindless = bindless; - if (!bindless) - ld->tex.r = r; - if (ind) - ld->setIndirectR(ind); - - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) - if (dst0[c] != def[c]) - mkMov(dst0[c], def[tgsi.getSrc(0).getSwizzle(c)]); - break; - } - } - - -/* Keep this around for now as reference when adding img support - getResourceCoords(off, r, 1); - - if (isResourceRaw(code, r)) { - uint8_t mask = 0; - uint8_t comp[2] = { 0, 0 }; - uint8_t size[2] = { 0, 0 }; - - Symbol *base = getResourceBase(r); - - // determine the base and size of the at most 2 load ops - for (c = 0; c < 4; ++c) - if (!tgsi.getDst(0).isMasked(c)) - mask |= 1 << (tgsi.getSrc(0).getSwizzle(c) - TGSI_SWIZZLE_X); - - int n = partitionLoadStore(comp, size, mask); - - src = off; - - def.resize(4); // index by component, the ones we need will be non-NULL - for (c = 0; c < 4; ++c) { - if (dst0[c] && tgsi.getSrc(0).getSwizzle(c) == (TGSI_SWIZZLE_X + c)) - def[c] = dst0[c]; - else - if (mask & (1 << c)) - def[c] = getScratch(); - } - - const bool useLd = isResourceSpecial(r) || - (info->io.nv50styleSurfaces && - code->resources[r].target == TGSI_TEXTURE_BUFFER); - - for (int i = 0; i < n; ++i) { - ldv.assign(def.begin() + comp[i], def.begin() + comp[i] + size[i]); - - if (comp[i]) // adjust x component of source address if necessary - src[0] = mkOp2v(OP_ADD, TYPE_U32, getSSA(4, off[0]->reg.file), - off[0], mkImm(comp[i] * 4)); - else - src[0] = off[0]; - - if (useLd) { - Instruction *ld = - mkLoad(typeOfSize(size[i] * 4), ldv[0], base, src[0]); - for (size_t c = 1; c < ldv.size(); ++c) - ld->setDef(c, ldv[c]); - } else { - mkTex(OP_SULDB, getResourceTarget(code, r), code->resources[r].slot, - 0, ldv, src)->dType = typeOfSize(size[i] * 4); - } - } - } else { - def.resize(4); - for (c = 0; c < 4; ++c) { - if (!dst0[c] || tgsi.getSrc(0).getSwizzle(c) != (TGSI_SWIZZLE_X + c)) - def[c] = getScratch(); - else - def[c] = dst0[c]; - } - - mkTex(OP_SULDP, getResourceTarget(code, r), code->resources[r].slot, 0, - def, off); - } - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) - if (dst0[c] != def[c]) - mkMov(dst0[c], def[tgsi.getSrc(0).getSwizzle(c)]); -*/ -} - -// For formatted stores, the write mask on OP_SUSTP can be used. -// Raw stores have to be split. -void -Converter::handleSTORE() -{ - int r = tgsi.getDst(0).getIndex(0); - int c; - std::vector off, src, dummy; - Value *ind = NULL; - - if (tgsi.getDst(0).isIndirect(0)) - ind = fetchSrc(tgsi.getDst(0).getIndirect(0), 0, 0); - - switch (tgsi.getDst(0).getFile()) { - case TGSI_FILE_BUFFER: - r = remapBufferId(r); - /* fallthrough */ - case TGSI_FILE_MEMORY: - for (c = 0; c < 4; ++c) { - if (!(tgsi.getDst(0).getMask() & (1 << c))) - continue; - - Symbol *sym; - Value *off; - if (tgsi.getSrc(0).getFile() == TGSI_FILE_IMMEDIATE) { - off = NULL; - sym = makeSym(tgsi.getDst(0).getFile(), r, -1, c, - tgsi.getSrc(0).getValueU32(0, code->immd.data) + 4 * c); - } else { - // yzw are ignored for buffers - off = fetchSrc(0, 0); - sym = makeSym(tgsi.getDst(0).getFile(), r, -1, c, 4 * c); - } - - Instruction *st = mkStore(OP_STORE, TYPE_U32, sym, off, fetchSrc(1, c)); - st->cache = tgsi.getCacheMode(); - if (ind) - st->setIndirect(0, 1, ind); - } - break; - default: { - r = remapImageId(r); - getImageCoords(off, 0); - src = off; - - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) - src.push_back(fetchSrc(1, c)); - - bool bindless = tgsi.getDst(0).getFile() != TGSI_FILE_IMAGE; - if (bindless) - ind = fetchDst(0, 0); - - TexInstruction *st = - mkTex(OP_SUSTP, tgsi.getImageTarget(), 0, 0, dummy, src); - st->tex.mask = tgsi.getDst(0).getMask(); - st->tex.format = tgsi.getImageFormat(); - st->cache = tgsi.getCacheMode(); - st->tex.bindless = bindless; - if (!bindless) - st->tex.r = r; - if (ind) - st->setIndirectR(ind); - - break; - } - } - -/* Keep this around for now as reference when adding img support - getResourceCoords(off, r, 0); - src = off; - const int s = src.size(); - - if (isResourceRaw(code, r)) { - uint8_t comp[2] = { 0, 0 }; - uint8_t size[2] = { 0, 0 }; - - int n = partitionLoadStore(comp, size, tgsi.getDst(0).getMask()); - - Symbol *base = getResourceBase(r); - - const bool useSt = isResourceSpecial(r) || - (info->io.nv50styleSurfaces && - code->resources[r].target == TGSI_TEXTURE_BUFFER); - - for (int i = 0; i < n; ++i) { - if (comp[i]) // adjust x component of source address if necessary - src[0] = mkOp2v(OP_ADD, TYPE_U32, getSSA(4, off[0]->reg.file), - off[0], mkImm(comp[i] * 4)); - else - src[0] = off[0]; - - const DataType stTy = typeOfSize(size[i] * 4); - - if (useSt) { - Instruction *st = - mkStore(OP_STORE, stTy, base, NULL, fetchSrc(1, comp[i])); - for (c = 1; c < size[i]; ++c) - st->setSrc(1 + c, fetchSrc(1, comp[i] + c)); - st->setIndirect(0, 0, src[0]); - } else { - // attach values to be stored - src.resize(s + size[i]); - for (c = 0; c < size[i]; ++c) - src[s + c] = fetchSrc(1, comp[i] + c); - mkTex(OP_SUSTB, getResourceTarget(code, r), code->resources[r].slot, - 0, dummy, src)->setType(stTy); - } - } - } else { - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) - src.push_back(fetchSrc(1, c)); - - mkTex(OP_SUSTP, getResourceTarget(code, r), code->resources[r].slot, 0, - dummy, src)->tex.mask = tgsi.getDst(0).getMask(); - } -*/ -} - -// XXX: These only work on resources with the single-component u32/s32 formats. -// Therefore the result is replicated. This might not be intended by TGSI, but -// operating on more than 1 component would produce undefined results because -// they do not exist. -void -Converter::handleATOM(Value *dst0[4], DataType ty, uint16_t subOp) -{ - int r = tgsi.getSrc(0).getIndex(0); - std::vector srcv; - std::vector defv; - LValue *dst = getScratch(); - Value *ind = NULL; - - if (tgsi.getSrc(0).isIndirect(0)) - ind = fetchSrc(tgsi.getSrc(0).getIndirect(0), 0, 0); - - switch (tgsi.getSrc(0).getFile()) { - case TGSI_FILE_BUFFER: - r = remapBufferId(r); - /* fallthrough */ - case TGSI_FILE_MEMORY: - for (int c = 0; c < 4; ++c) { - if (!dst0[c]) - continue; - - Instruction *insn; - Value *off = fetchSrc(1, c); - Value *sym; - if (tgsi.getSrc(1).getFile() == TGSI_FILE_IMMEDIATE) - sym = makeSym(tgsi.getSrc(0).getFile(), r, -1, c, - tgsi.getSrc(1).getValueU32(c, code->immd.data)); - else - sym = makeSym(tgsi.getSrc(0).getFile(), r, -1, c, 0); - if (subOp == NV50_IR_SUBOP_ATOM_CAS) - insn = mkOp3(OP_ATOM, ty, dst, sym, fetchSrc(2, c), fetchSrc(3, c)); - else - insn = mkOp2(OP_ATOM, ty, dst, sym, fetchSrc(2, c)); - if (tgsi.getSrc(1).getFile() != TGSI_FILE_IMMEDIATE) - insn->setIndirect(0, 0, off); - if (ind) - insn->setIndirect(0, 1, ind); - insn->subOp = subOp; - - if (tgsi.getSrc(0).getFile() == TGSI_FILE_BUFFER && - code->bufferAtomics[tgsi.getSrc(0).getIndex(0)]) - insn->cache = nv50_ir::CACHE_CG; - } - for (int c = 0; c < 4; ++c) - if (dst0[c]) - dst0[c] = dst; // not equal to rDst so handleInstruction will do mkMov - break; - default: { - r = remapImageId(r); - getImageCoords(srcv, 1); - defv.push_back(dst); - srcv.push_back(fetchSrc(2, 0)); - - if (subOp == NV50_IR_SUBOP_ATOM_CAS) - srcv.push_back(fetchSrc(3, 0)); - - bool bindless = tgsi.getSrc(0).getFile() != TGSI_FILE_IMAGE; - if (bindless) - ind = fetchSrc(0, 0); - - TexInstruction *tex = mkTex(OP_SUREDP, tgsi.getImageTarget(), - 0, 0, defv, srcv); - tex->subOp = subOp; - tex->tex.mask = 1; - tex->tex.format = tgsi.getImageFormat(); - tex->setType(ty); - tex->tex.bindless = bindless; - if (!bindless) - tex->tex.r = r; - if (ind) - tex->setIndirectR(ind); - - for (int c = 0; c < 4; ++c) - if (dst0[c]) - dst0[c] = dst; // not equal to rDst so handleInstruction will do mkMov - break; - } - } - -/* Keep this around for now as reference when adding img support - getResourceCoords(srcv, r, 1); - - if (isResourceSpecial(r)) { - assert(r != TGSI_RESOURCE_INPUT); - Instruction *insn; - insn = mkOp2(OP_ATOM, ty, dst, getResourceBase(r), fetchSrc(2, 0)); - insn->subOp = subOp; - if (subOp == NV50_IR_SUBOP_ATOM_CAS) - insn->setSrc(2, fetchSrc(3, 0)); - insn->setIndirect(0, 0, srcv.at(0)); - } else { - operation op = isResourceRaw(code, r) ? OP_SUREDB : OP_SUREDP; - TexTarget targ = getResourceTarget(code, r); - int idx = code->resources[r].slot; - defv.push_back(dst); - srcv.push_back(fetchSrc(2, 0)); - if (subOp == NV50_IR_SUBOP_ATOM_CAS) - srcv.push_back(fetchSrc(3, 0)); - TexInstruction *tex = mkTex(op, targ, idx, 0, defv, srcv); - tex->subOp = subOp; - tex->tex.mask = 1; - tex->setType(ty); - } - - for (int c = 0; c < 4; ++c) - if (dst0[c]) - dst0[c] = dst; // not equal to rDst so handleInstruction will do mkMov -*/ -} - -void -Converter::handleINTERP(Value *dst[4]) -{ - // Check whether the input is linear. All other attributes ignored. - Instruction *insn; - Value *offset = NULL, *ptr = NULL, *w = NULL; - Symbol *sym[4] = { NULL }; - bool linear; - operation op = OP_NOP; - int c, mode = 0; - - tgsi::Instruction::SrcRegister src = tgsi.getSrc(0); - - // In some odd cases, in large part due to varying packing, the source - // might not actually be an input. This is illegal TGSI, but it's easier to - // account for it here than it is to fix it where the TGSI is being - // generated. In that case, it's going to be a straight up mov (or sequence - // of mov's) from the input in question. We follow the mov chain to see - // which input we need to use. - if (src.getFile() != TGSI_FILE_INPUT) { - if (src.isIndirect(0)) { - ERROR("Ignoring indirect input interpolation\n"); - return; - } - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - Value *val = fetchSrc(0, c); - assert(val->defs.size() == 1); - insn = val->getInsn(); - while (insn->op == OP_MOV) { - assert(insn->getSrc(0)->defs.size() == 1); - insn = insn->getSrc(0)->getInsn(); - if (!insn) { - ERROR("Miscompiling shader due to unhandled INTERP\n"); - return; - } - } - if (insn->op != OP_LINTERP && insn->op != OP_PINTERP) { - ERROR("Trying to interpolate non-input, this is not allowed.\n"); - return; - } - sym[c] = insn->getSrc(0)->asSym(); - assert(sym[c]); - op = insn->op; - mode = insn->ipa; - ptr = insn->getIndirect(0, 0); - } - } else { - if (src.isIndirect(0)) - ptr = shiftAddress(fetchSrc(src.getIndirect(0), 0, NULL)); - - // We can assume that the fixed index will point to an input of the same - // interpolation type in case of an indirect. - // TODO: Make use of ArrayID. - linear = info_out->in[src.getIndex(0)].linear; - if (linear) { - op = OP_LINTERP; - mode = NV50_IR_INTERP_LINEAR; - } else { - op = OP_PINTERP; - mode = NV50_IR_INTERP_PERSPECTIVE; - } - } - - switch (tgsi.getOpcode()) { - case TGSI_OPCODE_INTERP_CENTROID: - mode |= NV50_IR_INTERP_CENTROID; - break; - case TGSI_OPCODE_INTERP_SAMPLE: { - // When using a non-MS buffer, we're supposed to always use the center - // (i.e. sample 0). This adds a SELP which will be always true or false - // based on a data fixup. - Value *sample = getScratch(); - mkOp3(OP_SELP, TYPE_U32, sample, mkImm(0), fetchSrc(1, 0), mkImm(0)) - ->subOp = 2; - - insn = mkOp1(OP_PIXLD, TYPE_U32, (offset = getScratch()), sample); - insn->subOp = NV50_IR_SUBOP_PIXLD_OFFSET; - mode |= NV50_IR_INTERP_OFFSET; - break; - } - case TGSI_OPCODE_INTERP_OFFSET: { - // The input in src1.xy is float, but we need a single 32-bit value - // where the upper and lower 16 bits are encoded in S0.12 format. We need - // to clamp the input coordinates to (-0.5, 0.4375), multiply by 4096, - // and then convert to s32. - Value *offs[2]; - for (c = 0; c < 2; c++) { - offs[c] = getScratch(); - mkOp2(OP_MIN, TYPE_F32, offs[c], fetchSrc(1, c), loadImm(NULL, 0.4375f)); - mkOp2(OP_MAX, TYPE_F32, offs[c], offs[c], loadImm(NULL, -0.5f)); - mkOp2(OP_MUL, TYPE_F32, offs[c], offs[c], loadImm(NULL, 4096.0f)); - mkCvt(OP_CVT, TYPE_S32, offs[c], TYPE_F32, offs[c]); - } - offset = mkOp3v(OP_INSBF, TYPE_U32, getScratch(), - offs[1], mkImm(0x1010), offs[0]); - mode |= NV50_IR_INTERP_OFFSET; - break; - } - } - - if (op == OP_PINTERP) { - if (offset) { - w = mkOp2v(OP_RDSV, TYPE_F32, getSSA(), mkSysVal(SV_POSITION, 3), offset); - mkOp1(OP_RCP, TYPE_F32, w, w); - } else { - w = fragCoord[3]; - } - } - - - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - insn = mkOp1(op, TYPE_F32, dst[c], sym[c] ? sym[c] : srcToSym(src, c)); - if (op == OP_PINTERP) - insn->setSrc(1, w); - if (offset) - insn->setSrc(op == OP_PINTERP ? 2 : 1, offset); - if (ptr) - insn->setIndirect(0, 0, ptr); - - insn->setInterpolate(mode); - } -} - -bool -Converter::isEndOfSubroutine(uint ip) -{ - assert(ip < code->scan.num_instructions); - tgsi::Instruction insn(&code->insns[ip]); - return (insn.getOpcode() == TGSI_OPCODE_END || - insn.getOpcode() == TGSI_OPCODE_ENDSUB || - // does END occur at end of main or the very end ? - insn.getOpcode() == TGSI_OPCODE_BGNSUB); -} - -bool -Converter::handleInstruction(const struct tgsi_full_instruction *insn) -{ - Instruction *geni; - - Value *dst0[4], *rDst0[4]; - Value *src0, *src1, *src2, *src3; - Value *val0 = NULL, *val1 = NULL; - int c; - - tgsi = tgsi::Instruction(insn); - - bool useScratchDst = tgsi.checkDstSrcAliasing(); - - operation op = tgsi.getOP(); - dstTy = tgsi.inferDstType(); - srcTy = tgsi.inferSrcType(); - - unsigned int mask = tgsi.dstCount() ? tgsi.getDst(0).getMask() : 0; - - if (tgsi.dstCount() && tgsi.getOpcode() != TGSI_OPCODE_STORE) { - for (c = 0; c < 4; ++c) { - rDst0[c] = acquireDst(0, c); - dst0[c] = (useScratchDst && rDst0[c]) ? getScratch() : rDst0[c]; - } - } - - switch (tgsi.getOpcode()) { - case TGSI_OPCODE_ADD: - case TGSI_OPCODE_UADD: - case TGSI_OPCODE_AND: - case TGSI_OPCODE_DIV: - case TGSI_OPCODE_IDIV: - case TGSI_OPCODE_UDIV: - case TGSI_OPCODE_MAX: - case TGSI_OPCODE_MIN: - case TGSI_OPCODE_IMAX: - case TGSI_OPCODE_IMIN: - case TGSI_OPCODE_UMAX: - case TGSI_OPCODE_UMIN: - case TGSI_OPCODE_MOD: - case TGSI_OPCODE_UMOD: - case TGSI_OPCODE_MUL: - case TGSI_OPCODE_UMUL: - case TGSI_OPCODE_IMUL_HI: - case TGSI_OPCODE_UMUL_HI: - case TGSI_OPCODE_OR: - case TGSI_OPCODE_SHL: - case TGSI_OPCODE_ISHR: - case TGSI_OPCODE_USHR: - case TGSI_OPCODE_XOR: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = fetchSrc(0, c); - src1 = fetchSrc(1, c); - geni = mkOp2(op, dstTy, dst0[c], src0, src1); - geni->subOp = tgsi::opcodeToSubOp(tgsi.getOpcode()); - if (op == OP_MUL && dstTy == TYPE_F32) - geni->dnz = info->io.mul_zero_wins; - geni->precise = insn->Instruction.Precise; - } - break; - case TGSI_OPCODE_MAD: - case TGSI_OPCODE_UMAD: - case TGSI_OPCODE_FMA: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = fetchSrc(0, c); - src1 = fetchSrc(1, c); - src2 = fetchSrc(2, c); - geni = mkOp3(op, dstTy, dst0[c], src0, src1, src2); - if (dstTy == TYPE_F32) - geni->dnz = info->io.mul_zero_wins; - geni->precise = insn->Instruction.Precise; - } - break; - case TGSI_OPCODE_MOV: - case TGSI_OPCODE_CEIL: - case TGSI_OPCODE_FLR: - case TGSI_OPCODE_TRUNC: - case TGSI_OPCODE_RCP: - case TGSI_OPCODE_SQRT: - case TGSI_OPCODE_IABS: - case TGSI_OPCODE_INEG: - case TGSI_OPCODE_NOT: - case TGSI_OPCODE_DDX: - case TGSI_OPCODE_DDY: - case TGSI_OPCODE_DDX_FINE: - case TGSI_OPCODE_DDY_FINE: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) - mkOp1(op, dstTy, dst0[c], fetchSrc(0, c)); - break; - case TGSI_OPCODE_RSQ: - src0 = fetchSrc(0, 0); - val0 = getScratch(); - mkOp1(OP_ABS, TYPE_F32, val0, src0); - mkOp1(OP_RSQ, TYPE_F32, val0, val0); - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) - mkMov(dst0[c], val0); - break; - case TGSI_OPCODE_ARL: - case TGSI_OPCODE_ARR: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - const RoundMode rnd = - tgsi.getOpcode() == TGSI_OPCODE_ARR ? ROUND_N : ROUND_M; - src0 = fetchSrc(0, c); - mkCvt(OP_CVT, TYPE_S32, dst0[c], TYPE_F32, src0)->rnd = rnd; - } - break; - case TGSI_OPCODE_UARL: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) - mkOp1(OP_MOV, TYPE_U32, dst0[c], fetchSrc(0, c)); - break; - case TGSI_OPCODE_POW: - val0 = mkOp2v(op, TYPE_F32, getScratch(), fetchSrc(0, 0), fetchSrc(1, 0)); - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) - mkOp1(OP_MOV, TYPE_F32, dst0[c], val0); - break; - case TGSI_OPCODE_EX2: - case TGSI_OPCODE_LG2: - val0 = mkOp1(op, TYPE_F32, getScratch(), fetchSrc(0, 0))->getDef(0); - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) - mkOp1(OP_MOV, TYPE_F32, dst0[c], val0); - break; - case TGSI_OPCODE_COS: - case TGSI_OPCODE_SIN: - val0 = getScratch(); - if (mask & 7) { - mkOp1(OP_PRESIN, TYPE_F32, val0, fetchSrc(0, 0)); - mkOp1(op, TYPE_F32, val0, val0); - for (c = 0; c < 3; ++c) - if (dst0[c]) - mkMov(dst0[c], val0); - } - if (dst0[3]) { - mkOp1(OP_PRESIN, TYPE_F32, val0, fetchSrc(0, 3)); - mkOp1(op, TYPE_F32, dst0[3], val0); - } - break; - case TGSI_OPCODE_EXP: - src0 = fetchSrc(0, 0); - val0 = mkOp1v(OP_FLOOR, TYPE_F32, getSSA(), src0); - if (dst0[1]) - mkOp2(OP_SUB, TYPE_F32, dst0[1], src0, val0); - if (dst0[0]) - mkOp1(OP_EX2, TYPE_F32, dst0[0], val0); - if (dst0[2]) - mkOp1(OP_EX2, TYPE_F32, dst0[2], src0); - if (dst0[3]) - loadImm(dst0[3], 1.0f); - break; - case TGSI_OPCODE_LOG: - src0 = mkOp1v(OP_ABS, TYPE_F32, getSSA(), fetchSrc(0, 0)); - val0 = mkOp1v(OP_LG2, TYPE_F32, dst0[2] ? dst0[2] : getSSA(), src0); - if (dst0[0] || dst0[1]) - val1 = mkOp1v(OP_FLOOR, TYPE_F32, dst0[0] ? dst0[0] : getSSA(), val0); - if (dst0[1]) { - mkOp1(OP_EX2, TYPE_F32, dst0[1], val1); - mkOp1(OP_RCP, TYPE_F32, dst0[1], dst0[1]); - mkOp2(OP_MUL, TYPE_F32, dst0[1], dst0[1], src0) - ->dnz = info->io.mul_zero_wins; - } - if (dst0[3]) - loadImm(dst0[3], 1.0f); - break; - case TGSI_OPCODE_DP2: - val0 = buildDot(2); - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) - mkMov(dst0[c], val0); - break; - case TGSI_OPCODE_DP3: - val0 = buildDot(3); - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) - mkMov(dst0[c], val0); - break; - case TGSI_OPCODE_DP4: - val0 = buildDot(4); - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) - mkMov(dst0[c], val0); - break; - case TGSI_OPCODE_DST: - if (dst0[0]) - loadImm(dst0[0], 1.0f); - if (dst0[1]) { - src0 = fetchSrc(0, 1); - src1 = fetchSrc(1, 1); - mkOp2(OP_MUL, TYPE_F32, dst0[1], src0, src1) - ->dnz = info->io.mul_zero_wins; - } - if (dst0[2]) - mkMov(dst0[2], fetchSrc(0, 2)); - if (dst0[3]) - mkMov(dst0[3], fetchSrc(1, 3)); - break; - case TGSI_OPCODE_LRP: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = fetchSrc(0, c); - src1 = fetchSrc(1, c); - src2 = fetchSrc(2, c); - mkOp3(OP_MAD, TYPE_F32, dst0[c], - mkOp2v(OP_SUB, TYPE_F32, getSSA(), src1, src2), src0, src2) - ->dnz = info->io.mul_zero_wins; - } - break; - case TGSI_OPCODE_LIT: - handleLIT(dst0); - break; - case TGSI_OPCODE_ISSG: - case TGSI_OPCODE_SSG: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = fetchSrc(0, c); - val0 = getScratch(); - val1 = getScratch(); - mkCmp(OP_SET, CC_GT, srcTy, val0, srcTy, src0, zero); - mkCmp(OP_SET, CC_LT, srcTy, val1, srcTy, src0, zero); - if (srcTy == TYPE_F32) - mkOp2(OP_SUB, TYPE_F32, dst0[c], val0, val1); - else - mkOp2(OP_SUB, TYPE_S32, dst0[c], val1, val0); - } - break; - case TGSI_OPCODE_UCMP: - srcTy = TYPE_U32; - FALLTHROUGH; - case TGSI_OPCODE_CMP: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = fetchSrc(0, c); - src1 = fetchSrc(1, c); - src2 = fetchSrc(2, c); - if (src1 == src2) - mkMov(dst0[c], src1); - else - mkCmp(OP_SLCT, (srcTy == TYPE_F32) ? CC_LT : CC_NE, - srcTy, dst0[c], srcTy, src1, src2, src0); - } - break; - case TGSI_OPCODE_FRC: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = fetchSrc(0, c); - val0 = getScratch(); - mkOp1(OP_FLOOR, TYPE_F32, val0, src0); - mkOp2(OP_SUB, TYPE_F32, dst0[c], src0, val0); - } - break; - case TGSI_OPCODE_ROUND: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) - mkCvt(OP_CVT, TYPE_F32, dst0[c], TYPE_F32, fetchSrc(0, c)) - ->rnd = ROUND_NI; - break; - case TGSI_OPCODE_SLT: - case TGSI_OPCODE_SGE: - case TGSI_OPCODE_SEQ: - case TGSI_OPCODE_SGT: - case TGSI_OPCODE_SLE: - case TGSI_OPCODE_SNE: - case TGSI_OPCODE_FSEQ: - case TGSI_OPCODE_FSGE: - case TGSI_OPCODE_FSLT: - case TGSI_OPCODE_FSNE: - case TGSI_OPCODE_ISGE: - case TGSI_OPCODE_ISLT: - case TGSI_OPCODE_USEQ: - case TGSI_OPCODE_USGE: - case TGSI_OPCODE_USLT: - case TGSI_OPCODE_USNE: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = fetchSrc(0, c); - src1 = fetchSrc(1, c); - mkCmp(op, tgsi.getSetCond(), dstTy, dst0[c], srcTy, src0, src1); - } - break; - case TGSI_OPCODE_VOTE_ALL: - case TGSI_OPCODE_VOTE_ANY: - case TGSI_OPCODE_VOTE_EQ: - val0 = new_LValue(func, FILE_PREDICATE); - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - mkCmp(OP_SET, CC_NE, TYPE_U32, val0, TYPE_U32, fetchSrc(0, c), zero); - mkOp1(op, dstTy, val0, val0) - ->subOp = tgsi::opcodeToSubOp(tgsi.getOpcode()); - mkCvt(OP_CVT, TYPE_U32, dst0[c], TYPE_U8, val0); - } - break; - case TGSI_OPCODE_BALLOT: - if (!tgsi.getDst(0).isMasked(0)) { - val0 = new_LValue(func, FILE_PREDICATE); - mkCmp(OP_SET, CC_NE, TYPE_U32, val0, TYPE_U32, fetchSrc(0, 0), zero); - mkOp1(op, TYPE_U32, dst0[0], val0)->subOp = NV50_IR_SUBOP_VOTE_ANY; - } - if (!tgsi.getDst(0).isMasked(1)) - mkMov(dst0[1], zero, TYPE_U32); - break; - case TGSI_OPCODE_READ_FIRST: - // ReadFirstInvocationARB(src) is implemented as - // ReadInvocationARB(src, findLSB(ballot(true))) - val0 = getScratch(); - mkOp1(OP_VOTE, TYPE_U32, val0, mkImm(1))->subOp = NV50_IR_SUBOP_VOTE_ANY; - mkOp1(OP_BREV, TYPE_U32, val0, val0); - mkOp1(OP_BFIND, TYPE_U32, val0, val0)->subOp = NV50_IR_SUBOP_BFIND_SAMT; - src1 = val0; - FALLTHROUGH; - case TGSI_OPCODE_READ_INVOC: - if (tgsi.getOpcode() == TGSI_OPCODE_READ_INVOC) - src1 = fetchSrc(1, 0); - else - src1 = val0; - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - geni = mkOp3(op, dstTy, dst0[c], fetchSrc(0, c), src1, mkImm(0x1f)); - geni->subOp = NV50_IR_SUBOP_SHFL_IDX; - } - break; - case TGSI_OPCODE_CLOCK: - // Stick the 32-bit clock into the high dword of the logical result. - if (!tgsi.getDst(0).isMasked(0)) - mkOp1(OP_MOV, TYPE_U32, dst0[0], zero); - if (!tgsi.getDst(0).isMasked(1)) - mkOp1(OP_RDSV, TYPE_U32, dst0[1], mkSysVal(SV_CLOCK, 0))->fixed = 1; - break; - case TGSI_OPCODE_READ_HELPER: - if (!tgsi.getDst(0).isMasked(0)) - mkOp1(OP_RDSV, TYPE_U32, dst0[0], mkSysVal(SV_THREAD_KILL, 0)) - ->fixed = 1; - break; - case TGSI_OPCODE_KILL_IF: - val0 = new_LValue(func, FILE_PREDICATE); - mask = 0; - for (c = 0; c < 4; ++c) { - const int s = tgsi.getSrc(0).getSwizzle(c); - if (mask & (1 << s)) - continue; - mask |= 1 << s; - mkCmp(OP_SET, CC_LT, TYPE_F32, val0, TYPE_F32, fetchSrc(0, c), zero); - mkOp(OP_DISCARD, TYPE_NONE, NULL)->setPredicate(CC_P, val0); - } - break; - case TGSI_OPCODE_KILL: - case TGSI_OPCODE_DEMOTE: - // TODO: Should we make KILL exit that invocation? Some old shaders - // don't like that. - mkOp(OP_DISCARD, TYPE_NONE, NULL); - break; - case TGSI_OPCODE_TEX: - case TGSI_OPCODE_TEX_LZ: - case TGSI_OPCODE_TXB: - case TGSI_OPCODE_TXL: - case TGSI_OPCODE_TXP: - case TGSI_OPCODE_LODQ: - // R S L C Dx Dy - handleTEX(dst0, 1, 1, 0x03, 0x0f, 0x00, 0x00); - break; - case TGSI_OPCODE_TXD: - handleTEX(dst0, 3, 3, 0x03, 0x0f, 0x10, 0x20); - break; - case TGSI_OPCODE_TG4: - handleTEX(dst0, 2, 2, 0x03, 0x0f, 0x00, 0x00); - break; - case TGSI_OPCODE_TEX2: - handleTEX(dst0, 2, 2, 0x03, 0x10, 0x00, 0x00); - break; - case TGSI_OPCODE_TXB2: - case TGSI_OPCODE_TXL2: - handleTEX(dst0, 2, 2, 0x10, 0x0f, 0x00, 0x00); - break; - case TGSI_OPCODE_SAMPLE: - case TGSI_OPCODE_SAMPLE_B: - case TGSI_OPCODE_SAMPLE_D: - case TGSI_OPCODE_SAMPLE_L: - case TGSI_OPCODE_SAMPLE_C: - case TGSI_OPCODE_SAMPLE_C_LZ: - handleTEX(dst0, 1, 2, 0x30, 0x30, 0x30, 0x40); - break; - case TGSI_OPCODE_TXF_LZ: - case TGSI_OPCODE_TXF: - handleTXF(dst0, 1, 0x03); - break; - case TGSI_OPCODE_SAMPLE_I: - handleTXF(dst0, 1, 0x03); - break; - case TGSI_OPCODE_SAMPLE_I_MS: - handleTXF(dst0, 1, 0x20); - break; - case TGSI_OPCODE_TXQ: - case TGSI_OPCODE_SVIEWINFO: - handleTXQ(dst0, TXQ_DIMS, 1); - break; - case TGSI_OPCODE_TXQS: - // The TXQ_TYPE query returns samples in its 3rd arg, but we need it to - // be in .x - dst0[1] = dst0[2] = dst0[3] = NULL; - std::swap(dst0[0], dst0[2]); - handleTXQ(dst0, TXQ_TYPE, 0); - std::swap(dst0[0], dst0[2]); - break; - case TGSI_OPCODE_FBFETCH: - handleFBFETCH(dst0); - break; - case TGSI_OPCODE_F2I: - case TGSI_OPCODE_F2U: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) - mkCvt(OP_CVT, dstTy, dst0[c], srcTy, fetchSrc(0, c))->rnd = ROUND_Z; - break; - case TGSI_OPCODE_I2F: - case TGSI_OPCODE_U2F: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) - mkCvt(OP_CVT, dstTy, dst0[c], srcTy, fetchSrc(0, c)); - break; - case TGSI_OPCODE_PK2H: - val0 = getScratch(); - val1 = getScratch(); - mkCvt(OP_CVT, TYPE_F16, val0, TYPE_F32, fetchSrc(0, 0)); - mkCvt(OP_CVT, TYPE_F16, val1, TYPE_F32, fetchSrc(0, 1)); - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) - mkOp3(OP_INSBF, TYPE_U32, dst0[c], val1, mkImm(0x1010), val0); - break; - case TGSI_OPCODE_UP2H: - src0 = fetchSrc(0, 0); - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - geni = mkCvt(OP_CVT, TYPE_F32, dst0[c], TYPE_F16, src0); - geni->subOp = c & 1; - } - break; - case TGSI_OPCODE_EMIT: - /* export the saved viewport index */ - if (viewport != NULL) { - Symbol *vpSym = mkSymbol(FILE_SHADER_OUTPUT, 0, TYPE_U32, - info_out->out[info->io.viewportId].slot[0] * 4); - mkStore(OP_EXPORT, TYPE_U32, vpSym, NULL, viewport); - } - /* handle user clip planes for each emitted vertex */ - if (info_out->io.genUserClip > 0) - handleUserClipPlanes(); - FALLTHROUGH; - case TGSI_OPCODE_ENDPRIM: - { - // get vertex stream (must be immediate) - unsigned int stream = tgsi.getSrc(0).getValueU32(0, code->immd.data); - if (stream && op == OP_RESTART) - break; - if (info_out->prop.gp.maxVertices == 0) - break; - src0 = mkImm(stream); - mkOp1(op, TYPE_U32, NULL, src0)->fixed = 1; - break; - } - case TGSI_OPCODE_IF: - case TGSI_OPCODE_UIF: - { - BasicBlock *ifBB = new BasicBlock(func); - - bb->cfg.attach(&ifBB->cfg, Graph::Edge::TREE); - condBBs.push(bb); - joinBBs.push(bb); - - mkFlow(OP_BRA, NULL, CC_NOT_P, fetchSrc(0, 0))->setType(srcTy); - - setPosition(ifBB, true); - } - break; - case TGSI_OPCODE_ELSE: - { - BasicBlock *elseBB = new BasicBlock(func); - BasicBlock *forkBB = reinterpret_cast(condBBs.pop().u.p); - - forkBB->cfg.attach(&elseBB->cfg, Graph::Edge::TREE); - condBBs.push(bb); - - forkBB->getExit()->asFlow()->target.bb = elseBB; - if (!bb->isTerminated()) - mkFlow(OP_BRA, NULL, CC_ALWAYS, NULL); - - setPosition(elseBB, true); - } - break; - case TGSI_OPCODE_ENDIF: - { - BasicBlock *convBB = new BasicBlock(func); - BasicBlock *prevBB = reinterpret_cast(condBBs.pop().u.p); - BasicBlock *forkBB = reinterpret_cast(joinBBs.pop().u.p); - - if (!bb->isTerminated()) { - // we only want join if none of the clauses ended with CONT/BREAK/RET - if (prevBB->getExit()->op == OP_BRA && joinBBs.getSize() < 6) - insertConvergenceOps(convBB, forkBB); - mkFlow(OP_BRA, convBB, CC_ALWAYS, NULL); - bb->cfg.attach(&convBB->cfg, Graph::Edge::FORWARD); - } - - if (prevBB->getExit()->op == OP_BRA) { - prevBB->cfg.attach(&convBB->cfg, Graph::Edge::FORWARD); - prevBB->getExit()->asFlow()->target.bb = convBB; - } - setPosition(convBB, true); - } - break; - case TGSI_OPCODE_BGNLOOP: - { - BasicBlock *lbgnBB = new BasicBlock(func); - BasicBlock *lbrkBB = new BasicBlock(func); - - loopBBs.push(lbgnBB); - breakBBs.push(lbrkBB); - if (loopBBs.getSize() > func->loopNestingBound) - func->loopNestingBound++; - - mkFlow(OP_PREBREAK, lbrkBB, CC_ALWAYS, NULL); - - bb->cfg.attach(&lbgnBB->cfg, Graph::Edge::TREE); - setPosition(lbgnBB, true); - mkFlow(OP_PRECONT, lbgnBB, CC_ALWAYS, NULL); - - info_out->loops++; - } - break; - case TGSI_OPCODE_ENDLOOP: - { - BasicBlock *loopBB = reinterpret_cast(loopBBs.pop().u.p); - - if (!bb->isTerminated()) { - mkFlow(OP_CONT, loopBB, CC_ALWAYS, NULL); - bb->cfg.attach(&loopBB->cfg, Graph::Edge::BACK); - } - setPosition(reinterpret_cast(breakBBs.pop().u.p), true); - - // If the loop never breaks (e.g. only has RET's inside), then there - // will be no way to get to the break bb. However BGNLOOP will have - // already made a PREBREAK to it, so it must be in the CFG. - if (getBB()->cfg.incidentCount() == 0) - loopBB->cfg.attach(&getBB()->cfg, Graph::Edge::TREE); - } - break; - case TGSI_OPCODE_BRK: - { - if (bb->isTerminated()) - break; - BasicBlock *brkBB = reinterpret_cast(breakBBs.peek().u.p); - mkFlow(OP_BREAK, brkBB, CC_ALWAYS, NULL); - bb->cfg.attach(&brkBB->cfg, Graph::Edge::CROSS); - } - break; - case TGSI_OPCODE_CONT: - { - if (bb->isTerminated()) - break; - BasicBlock *contBB = reinterpret_cast(loopBBs.peek().u.p); - mkFlow(OP_CONT, contBB, CC_ALWAYS, NULL); - contBB->explicitCont = true; - bb->cfg.attach(&contBB->cfg, Graph::Edge::BACK); - } - break; - case TGSI_OPCODE_BGNSUB: - { - Subroutine *s = getSubroutine(ip); - BasicBlock *entry = new BasicBlock(s->f); - BasicBlock *leave = new BasicBlock(s->f); - - // multiple entrypoints possible, keep the graph connected - if (prog->getType() == Program::TYPE_COMPUTE) - prog->main->call.attach(&s->f->call, Graph::Edge::TREE); - - sub.cur = s; - s->f->setEntry(entry); - s->f->setExit(leave); - setPosition(entry, true); - return true; - } - case TGSI_OPCODE_ENDSUB: - { - sub.cur = getSubroutine(prog->main); - setPosition(BasicBlock::get(sub.cur->f->cfg.getRoot()), true); - return true; - } - case TGSI_OPCODE_CAL: - { - Subroutine *s = getSubroutine(tgsi.getLabel()); - mkFlow(OP_CALL, s->f, CC_ALWAYS, NULL); - func->call.attach(&s->f->call, Graph::Edge::TREE); - return true; - } - case TGSI_OPCODE_RET: - { - if (bb->isTerminated()) - return true; - BasicBlock *leave = BasicBlock::get(func->cfgExit); - - if (!isEndOfSubroutine(ip + 1)) { - // insert a PRERET at the entry if this is an early return - // (only needed for sharing code in the epilogue) - BasicBlock *root = BasicBlock::get(func->cfg.getRoot()); - if (root->getEntry() == NULL || root->getEntry()->op != OP_PRERET) { - BasicBlock *pos = getBB(); - setPosition(root, false); - mkFlow(OP_PRERET, leave, CC_ALWAYS, NULL)->fixed = 1; - setPosition(pos, true); - } - } - mkFlow(OP_RET, NULL, CC_ALWAYS, NULL)->fixed = 1; - bb->cfg.attach(&leave->cfg, Graph::Edge::CROSS); - } - break; - case TGSI_OPCODE_END: - { - // attach and generate epilogue code - BasicBlock *epilogue = BasicBlock::get(func->cfgExit); - bb->cfg.attach(&epilogue->cfg, Graph::Edge::TREE); - setPosition(epilogue, true); - if (prog->getType() == Program::TYPE_FRAGMENT) - exportOutputs(); - if ((prog->getType() == Program::TYPE_VERTEX || - prog->getType() == Program::TYPE_TESSELLATION_EVAL - ) && info_out->io.genUserClip > 0) - handleUserClipPlanes(); - mkOp(OP_EXIT, TYPE_NONE, NULL)->terminator = 1; - } - break; - case TGSI_OPCODE_SWITCH: - case TGSI_OPCODE_CASE: - ERROR("switch/case opcode encountered, should have been lowered\n"); - abort(); - break; - case TGSI_OPCODE_LOAD: - handleLOAD(dst0); - break; - case TGSI_OPCODE_STORE: - handleSTORE(); - break; - case TGSI_OPCODE_BARRIER: - geni = mkOp2(OP_BAR, TYPE_U32, NULL, mkImm(0), mkImm(0)); - geni->fixed = 1; - geni->subOp = NV50_IR_SUBOP_BAR_SYNC; - break; - case TGSI_OPCODE_MEMBAR: - { - uint32_t level = tgsi.getSrc(0).getValueU32(0, code->immd.data); - geni = mkOp(OP_MEMBAR, TYPE_NONE, NULL); - geni->fixed = 1; - if (!(level & ~(TGSI_MEMBAR_THREAD_GROUP | TGSI_MEMBAR_SHARED))) - geni->subOp = NV50_IR_SUBOP_MEMBAR(M, CTA); - else - geni->subOp = NV50_IR_SUBOP_MEMBAR(M, GL); - } - break; - case TGSI_OPCODE_ATOMUADD: - case TGSI_OPCODE_ATOMXCHG: - case TGSI_OPCODE_ATOMCAS: - case TGSI_OPCODE_ATOMAND: - case TGSI_OPCODE_ATOMOR: - case TGSI_OPCODE_ATOMXOR: - case TGSI_OPCODE_ATOMUMIN: - case TGSI_OPCODE_ATOMIMIN: - case TGSI_OPCODE_ATOMUMAX: - case TGSI_OPCODE_ATOMIMAX: - case TGSI_OPCODE_ATOMFADD: - case TGSI_OPCODE_ATOMDEC_WRAP: - case TGSI_OPCODE_ATOMINC_WRAP: - handleATOM(dst0, dstTy, tgsi::opcodeToSubOp(tgsi.getOpcode())); - break; - case TGSI_OPCODE_RESQ: - if (tgsi.getSrc(0).getFile() == TGSI_FILE_BUFFER) { - Value *ind = NULL; - if (tgsi.getSrc(0).isIndirect(0)) - ind = fetchSrc(tgsi.getSrc(0).getIndirect(0), 0, 0); - geni = mkOp1(OP_BUFQ, TYPE_U32, dst0[0], - makeSym(tgsi.getSrc(0).getFile(), - tgsi.getSrc(0).getIndex(0), -1, 0, 0)); - if (ind) - geni->setIndirect(0, 1, ind); - } else { - TexInstruction *texi = new_TexInstruction(func, OP_SUQ); - for (int c = 0, d = 0; c < 4; ++c) { - if (dst0[c]) { - texi->setDef(d++, dst0[c]); - texi->tex.mask |= 1 << c; - } - } - if (tgsi.getSrc(0).getFile() == TGSI_FILE_IMAGE) { - texi->tex.r = tgsi.getSrc(0).getIndex(0); - if (tgsi.getSrc(0).isIndirect(0)) - texi->setIndirectR(fetchSrc(tgsi.getSrc(0).getIndirect(0), 0, NULL)); - } else { - texi->tex.bindless = true; - texi->setIndirectR(fetchSrc(0, 0)); - } - texi->tex.target = tgsi.getImageTarget(); - - bb->insertTail(texi); - } - break; - case TGSI_OPCODE_IBFE: - case TGSI_OPCODE_UBFE: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = fetchSrc(0, c); - val0 = getScratch(); - if (tgsi.getSrc(1).getFile() == TGSI_FILE_IMMEDIATE && - tgsi.getSrc(2).getFile() == TGSI_FILE_IMMEDIATE) { - loadImm(val0, (tgsi.getSrc(2).getValueU32(c, code->immd.data) << 8) | - tgsi.getSrc(1).getValueU32(c, code->immd.data)); - } else { - src1 = fetchSrc(1, c); - src2 = fetchSrc(2, c); - mkOp3(OP_INSBF, TYPE_U32, val0, src2, mkImm(0x808), src1); - } - mkOp2(OP_EXTBF, dstTy, dst0[c], src0, val0); - } - break; - case TGSI_OPCODE_BFI: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = fetchSrc(0, c); - src1 = fetchSrc(1, c); - src2 = fetchSrc(2, c); - src3 = fetchSrc(3, c); - val0 = getScratch(); - mkOp3(OP_INSBF, TYPE_U32, val0, src3, mkImm(0x808), src2); - mkOp3(OP_INSBF, TYPE_U32, dst0[c], src1, val0, src0); - } - break; - case TGSI_OPCODE_LSB: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = fetchSrc(0, c); - val0 = getScratch(); - mkOp1(OP_BREV, TYPE_U32, val0, src0); - geni = mkOp1(OP_BFIND, TYPE_U32, dst0[c], val0); - geni->subOp = NV50_IR_SUBOP_BFIND_SAMT; - } - break; - case TGSI_OPCODE_IMSB: - case TGSI_OPCODE_UMSB: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = fetchSrc(0, c); - mkOp1(OP_BFIND, srcTy, dst0[c], src0); - } - break; - case TGSI_OPCODE_BREV: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = fetchSrc(0, c); - mkOp1(OP_BREV, TYPE_U32, dst0[c], src0); - } - break; - case TGSI_OPCODE_POPC: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = fetchSrc(0, c); - mkOp2(OP_POPCNT, TYPE_U32, dst0[c], src0, src0); - } - break; - case TGSI_OPCODE_INTERP_CENTROID: - case TGSI_OPCODE_INTERP_SAMPLE: - case TGSI_OPCODE_INTERP_OFFSET: - handleINTERP(dst0); - break; - case TGSI_OPCODE_I642F: - case TGSI_OPCODE_U642F: - case TGSI_OPCODE_D2I: - case TGSI_OPCODE_D2U: - case TGSI_OPCODE_D2F: { - int pos = 0; - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - Value *dreg = getSSA(8); - src0 = fetchSrc(0, pos); - src1 = fetchSrc(0, pos + 1); - mkOp2(OP_MERGE, TYPE_U64, dreg, src0, src1); - Instruction *cvt = mkCvt(OP_CVT, dstTy, dst0[c], srcTy, dreg); - if (!isFloatType(dstTy)) - cvt->rnd = ROUND_Z; - pos += 2; - } - break; - } - case TGSI_OPCODE_I2I64: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - dst0[c] = fetchSrc(0, c / 2); - mkOp2(OP_SHR, TYPE_S32, dst0[c + 1], dst0[c], loadImm(NULL, 31)); - c++; - } - break; - case TGSI_OPCODE_U2I64: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - dst0[c] = fetchSrc(0, c / 2); - dst0[c + 1] = zero; - c++; - } - break; - case TGSI_OPCODE_F2I64: - case TGSI_OPCODE_F2U64: - case TGSI_OPCODE_I2D: - case TGSI_OPCODE_U2D: - case TGSI_OPCODE_F2D: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - Value *dreg = getSSA(8); - Instruction *cvt = mkCvt(OP_CVT, dstTy, dreg, srcTy, fetchSrc(0, c / 2)); - if (!isFloatType(dstTy)) - cvt->rnd = ROUND_Z; - mkSplit(&dst0[c], 4, dreg); - c++; - } - break; - case TGSI_OPCODE_D2I64: - case TGSI_OPCODE_D2U64: - case TGSI_OPCODE_I642D: - case TGSI_OPCODE_U642D: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = getSSA(8); - Value *dst = getSSA(8), *tmp[2]; - tmp[0] = fetchSrc(0, c); - tmp[1] = fetchSrc(0, c + 1); - mkOp2(OP_MERGE, TYPE_U64, src0, tmp[0], tmp[1]); - Instruction *cvt = mkCvt(OP_CVT, dstTy, dst, srcTy, src0); - if (!isFloatType(dstTy)) - cvt->rnd = ROUND_Z; - mkSplit(&dst0[c], 4, dst); - c++; - } - break; - case TGSI_OPCODE_I64NEG: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = getSSA(8); - Value *dst = getSSA(8), *tmp[2]; - tmp[0] = fetchSrc(0, c); - tmp[1] = fetchSrc(0, c + 1); - mkOp2(OP_MERGE, TYPE_U64, src0, tmp[0], tmp[1]); - mkOp2(OP_SUB, dstTy, dst, zero, src0); - mkSplit(&dst0[c], 4, dst); - c++; - } - break; - case TGSI_OPCODE_I64ABS: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = getSSA(8); - Value *neg = getSSA(8), *srcComp[2], *negComp[2]; - srcComp[0] = fetchSrc(0, c); - srcComp[1] = fetchSrc(0, c + 1); - mkOp2(OP_MERGE, TYPE_U64, src0, srcComp[0], srcComp[1]); - mkOp2(OP_SUB, dstTy, neg, zero, src0); - mkSplit(negComp, 4, neg); - mkCmp(OP_SLCT, CC_LT, TYPE_S32, dst0[c], TYPE_S32, - negComp[0], srcComp[0], srcComp[1]); - mkCmp(OP_SLCT, CC_LT, TYPE_S32, dst0[c + 1], TYPE_S32, - negComp[1], srcComp[1], srcComp[1]); - c++; - } - break; - case TGSI_OPCODE_DABS: - case TGSI_OPCODE_DNEG: - case TGSI_OPCODE_DRCP: - case TGSI_OPCODE_DSQRT: - case TGSI_OPCODE_DRSQ: - case TGSI_OPCODE_DTRUNC: - case TGSI_OPCODE_DCEIL: - case TGSI_OPCODE_DFLR: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = getSSA(8); - Value *dst = getSSA(8), *tmp[2]; - tmp[0] = fetchSrc(0, c); - tmp[1] = fetchSrc(0, c + 1); - mkOp2(OP_MERGE, TYPE_U64, src0, tmp[0], tmp[1]); - mkOp1(op, dstTy, dst, src0); - mkSplit(&dst0[c], 4, dst); - c++; - } - break; - case TGSI_OPCODE_DFRAC: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = getSSA(8); - Value *dst = getSSA(8), *tmp[2]; - tmp[0] = fetchSrc(0, c); - tmp[1] = fetchSrc(0, c + 1); - mkOp2(OP_MERGE, TYPE_U64, src0, tmp[0], tmp[1]); - mkOp1(OP_FLOOR, TYPE_F64, dst, src0); - mkOp2(OP_SUB, TYPE_F64, dst, src0, dst); - mkSplit(&dst0[c], 4, dst); - c++; - } - break; - case TGSI_OPCODE_U64SEQ: - case TGSI_OPCODE_U64SNE: - case TGSI_OPCODE_U64SLT: - case TGSI_OPCODE_U64SGE: - case TGSI_OPCODE_I64SLT: - case TGSI_OPCODE_I64SGE: - case TGSI_OPCODE_DSLT: - case TGSI_OPCODE_DSGE: - case TGSI_OPCODE_DSEQ: - case TGSI_OPCODE_DSNE: { - int pos = 0; - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - Value *tmp[2]; - - src0 = getSSA(8); - src1 = getSSA(8); - tmp[0] = fetchSrc(0, pos); - tmp[1] = fetchSrc(0, pos + 1); - mkOp2(OP_MERGE, TYPE_U64, src0, tmp[0], tmp[1]); - tmp[0] = fetchSrc(1, pos); - tmp[1] = fetchSrc(1, pos + 1); - mkOp2(OP_MERGE, TYPE_U64, src1, tmp[0], tmp[1]); - mkCmp(op, tgsi.getSetCond(), dstTy, dst0[c], srcTy, src0, src1); - pos += 2; - } - break; - } - case TGSI_OPCODE_U64MIN: - case TGSI_OPCODE_U64MAX: - case TGSI_OPCODE_I64MIN: - case TGSI_OPCODE_I64MAX: { - dstTy = isSignedIntType(dstTy) ? TYPE_S32 : TYPE_U32; - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - Value *flag = getSSA(1, FILE_FLAGS); - src0 = fetchSrc(0, c + 1); - src1 = fetchSrc(1, c + 1); - geni = mkOp2(op, dstTy, dst0[c + 1], src0, src1); - geni->subOp = NV50_IR_SUBOP_MINMAX_HIGH; - geni->setFlagsDef(1, flag); - - src0 = fetchSrc(0, c); - src1 = fetchSrc(1, c); - geni = mkOp2(op, TYPE_U32, dst0[c], src0, src1); - geni->subOp = NV50_IR_SUBOP_MINMAX_LOW; - geni->setFlagsSrc(2, flag); - - c++; - } - break; - } - case TGSI_OPCODE_U64SHL: - case TGSI_OPCODE_I64SHR: - case TGSI_OPCODE_U64SHR: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = getSSA(8); - Value *dst = getSSA(8), *tmp[2]; - tmp[0] = fetchSrc(0, c); - tmp[1] = fetchSrc(0, c + 1); - mkOp2(OP_MERGE, TYPE_U64, src0, tmp[0], tmp[1]); - // Theoretically src1 is a 64-bit value but in practice only the low - // bits matter. The IR expects this to be a 32-bit value. - src1 = fetchSrc(1, c); - mkOp2(op, dstTy, dst, src0, src1); - mkSplit(&dst0[c], 4, dst); - c++; - } - break; - case TGSI_OPCODE_U64ADD: - case TGSI_OPCODE_U64MUL: - case TGSI_OPCODE_DADD: - case TGSI_OPCODE_DMUL: - case TGSI_OPCODE_DDIV: - case TGSI_OPCODE_DMAX: - case TGSI_OPCODE_DMIN: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = getSSA(8); - src1 = getSSA(8); - Value *dst = getSSA(8), *tmp[2]; - tmp[0] = fetchSrc(0, c); - tmp[1] = fetchSrc(0, c + 1); - mkOp2(OP_MERGE, TYPE_U64, src0, tmp[0], tmp[1]); - tmp[0] = fetchSrc(1, c); - tmp[1] = fetchSrc(1, c + 1); - mkOp2(OP_MERGE, TYPE_U64, src1, tmp[0], tmp[1]); - mkOp2(op, dstTy, dst, src0, src1); - mkSplit(&dst0[c], 4, dst); - c++; - } - break; - case TGSI_OPCODE_DMAD: - case TGSI_OPCODE_DFMA: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = getSSA(8); - src1 = getSSA(8); - src2 = getSSA(8); - Value *dst = getSSA(8), *tmp[2]; - tmp[0] = fetchSrc(0, c); - tmp[1] = fetchSrc(0, c + 1); - mkOp2(OP_MERGE, TYPE_U64, src0, tmp[0], tmp[1]); - tmp[0] = fetchSrc(1, c); - tmp[1] = fetchSrc(1, c + 1); - mkOp2(OP_MERGE, TYPE_U64, src1, tmp[0], tmp[1]); - tmp[0] = fetchSrc(2, c); - tmp[1] = fetchSrc(2, c + 1); - mkOp2(OP_MERGE, TYPE_U64, src2, tmp[0], tmp[1]); - mkOp3(op, dstTy, dst, src0, src1, src2); - mkSplit(&dst0[c], 4, dst); - c++; - } - break; - case TGSI_OPCODE_DROUND: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = getSSA(8); - Value *dst = getSSA(8), *tmp[2]; - tmp[0] = fetchSrc(0, c); - tmp[1] = fetchSrc(0, c + 1); - mkOp2(OP_MERGE, TYPE_U64, src0, tmp[0], tmp[1]); - mkCvt(OP_CVT, TYPE_F64, dst, TYPE_F64, src0) - ->rnd = ROUND_NI; - mkSplit(&dst0[c], 4, dst); - c++; - } - break; - case TGSI_OPCODE_DSSG: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = getSSA(8); - Value *dst = getSSA(8), *dstF32 = getSSA(), *tmp[2]; - tmp[0] = fetchSrc(0, c); - tmp[1] = fetchSrc(0, c + 1); - mkOp2(OP_MERGE, TYPE_U64, src0, tmp[0], tmp[1]); - - val0 = getScratch(); - val1 = getScratch(); - // The zero is wrong here since it's only 32-bit, but it works out in - // the end since it gets replaced with $r63. - mkCmp(OP_SET, CC_GT, TYPE_F32, val0, TYPE_F64, src0, zero); - mkCmp(OP_SET, CC_LT, TYPE_F32, val1, TYPE_F64, src0, zero); - mkOp2(OP_SUB, TYPE_F32, dstF32, val0, val1); - mkCvt(OP_CVT, TYPE_F64, dst, TYPE_F32, dstF32); - mkSplit(&dst0[c], 4, dst); - c++; - } - break; - case TGSI_OPCODE_I64SSG: - FOR_EACH_DST_ENABLED_CHANNEL(0, c, tgsi) { - src0 = getSSA(8); - Value *tmp[2]; - tmp[0] = fetchSrc(0, c); - tmp[1] = fetchSrc(0, c + 1); - mkOp2(OP_MERGE, TYPE_U64, src0, tmp[0], tmp[1]); - - val0 = getScratch(); - val1 = getScratch(); - mkCmp(OP_SET, CC_GT, TYPE_U32, val0, TYPE_S64, src0, zero); - mkCmp(OP_SET, CC_LT, TYPE_U32, val1, TYPE_S64, src0, zero); - mkOp2(OP_SUB, TYPE_S32, dst0[c], val1, val0); - mkOp2(OP_SHR, TYPE_S32, dst0[c + 1], dst0[c], loadImm(0, 31)); - c++; - } - break; - default: - ERROR("unhandled TGSI opcode: %u\n", tgsi.getOpcode()); - assert(0); - break; - } - - if (tgsi.dstCount() && tgsi.getOpcode() != TGSI_OPCODE_STORE) { - for (c = 0; c < 4; ++c) { - if (!dst0[c]) - continue; - if (dst0[c] != rDst0[c]) - mkMov(rDst0[c], dst0[c]); - storeDst(0, c, rDst0[c]); - } - } - vtxBaseValid = 0; - - return true; -} - -void -Converter::exportOutputs() -{ - if (info->io.alphaRefBase) { - for (unsigned int i = 0; i < info_out->numOutputs; ++i) { - if (info_out->out[i].sn != TGSI_SEMANTIC_COLOR || - info_out->out[i].si != 0) - continue; - const unsigned int c = 3; - if (!oData.exists(sub.cur->values, i, c)) - continue; - Value *val = oData.load(sub.cur->values, i, c, NULL); - if (!val) - continue; - - Symbol *ref = mkSymbol(FILE_MEMORY_CONST, info->io.auxCBSlot, - TYPE_U32, info->io.alphaRefBase); - Value *pred = new_LValue(func, FILE_PREDICATE); - mkCmp(OP_SET, CC_TR, TYPE_U32, pred, TYPE_F32, val, - mkLoadv(TYPE_U32, ref, NULL)) - ->subOp = 1; - mkOp(OP_DISCARD, TYPE_NONE, NULL)->setPredicate(CC_NOT_P, pred); - } - } - - for (unsigned int i = 0; i < info_out->numOutputs; ++i) { - for (unsigned int c = 0; c < 4; ++c) { - if (!oData.exists(sub.cur->values, i, c)) - continue; - Symbol *sym = mkSymbol(FILE_SHADER_OUTPUT, 0, TYPE_F32, - info_out->out[i].slot[c] * 4); - Value *val = oData.load(sub.cur->values, i, c, NULL); - if (val) { - if (info_out->out[i].sn == TGSI_SEMANTIC_POSITION) - mkOp1(OP_SAT, TYPE_F32, val, val); - mkStore(OP_EXPORT, TYPE_F32, sym, NULL, val); - } - } - } -} - -Converter::Converter(Program *ir, const tgsi::Source *code, nv50_ir_prog_info_out *info_out) -: ConverterCommon(ir, code->info, info_out), - code(code), - tgsi(NULL), - tData(this), lData(this), aData(this), oData(this) -{ - const unsigned tSize = code->fileSize(TGSI_FILE_TEMPORARY); - const unsigned aSize = code->fileSize(TGSI_FILE_ADDRESS); - const unsigned oSize = code->fileSize(TGSI_FILE_OUTPUT); - - tData.setup(TGSI_FILE_TEMPORARY, 0, 0, tSize, 4, 4, FILE_GPR, 0); - lData.setup(TGSI_FILE_TEMPORARY, 1, 0, tSize, 4, 4, FILE_MEMORY_LOCAL, 0); - aData.setup(TGSI_FILE_ADDRESS, 0, 0, aSize, 4, 4, FILE_GPR, 0); - oData.setup(TGSI_FILE_OUTPUT, 0, 0, oSize, 4, 4, FILE_GPR, 0); - - zero = mkImm((uint32_t)0); - - vtxBaseValid = 0; -} - -Converter::~Converter() -{ -} - -inline const Converter::Location * -Converter::BindArgumentsPass::getValueLocation(Subroutine *s, Value *v) -{ - ValueMap::l_iterator it = s->values.l.find(v); - return it == s->values.l.end() ? NULL : &it->second; -} - -template inline void -Converter::BindArgumentsPass::updateCallArgs( - Instruction *i, void (Instruction::*setArg)(int, Value *), - T (Function::*proto)) -{ - Function *g = i->asFlow()->target.fn; - Subroutine *subg = conv.getSubroutine(g); - - for (unsigned a = 0; a < (g->*proto).size(); ++a) { - Value *v = (g->*proto)[a].get(); - const Converter::Location &l = *getValueLocation(subg, v); - Converter::DataArray *array = conv.getArrayForFile(l.array, l.arrayIdx); - - (i->*setArg)(a, array->acquire(sub->values, l.i, l.c)); - } -} - -template inline void -Converter::BindArgumentsPass::updatePrototype( - BitSet *set, void (Function::*updateSet)(), T (Function::*proto)) -{ - (func->*updateSet)(); - - for (unsigned i = 0; i < set->getSize(); ++i) { - Value *v = func->getLValue(i); - const Converter::Location *l = getValueLocation(sub, v); - - // only include values with a matching TGSI register - if (set->test(i) && l && !conv.code->locals.count(*l)) - (func->*proto).push_back(v); - } -} - -bool -Converter::BindArgumentsPass::visit(Function *f) -{ - sub = conv.getSubroutine(f); - - for (ArrayList::Iterator bi = f->allBBlocks.iterator(); - !bi.end(); bi.next()) { - for (Instruction *i = BasicBlock::get(bi)->getFirst(); - i; i = i->next) { - if (i->op == OP_CALL && !i->asFlow()->builtin) { - updateCallArgs(i, &Instruction::setSrc, &Function::ins); - updateCallArgs(i, &Instruction::setDef, &Function::outs); - } - } - } - - if (func == prog->main /* && prog->getType() != Program::TYPE_COMPUTE */) - return true; - updatePrototype(&BasicBlock::get(f->cfg.getRoot())->liveSet, - &Function::buildLiveSets, &Function::ins); - updatePrototype(&BasicBlock::get(f->cfgExit)->defSet, - &Function::buildDefSets, &Function::outs); - - return true; -} - -bool -Converter::run() -{ - BasicBlock *entry = new BasicBlock(prog->main); - BasicBlock *leave = new BasicBlock(prog->main); - - prog->main->setEntry(entry); - prog->main->setExit(leave); - - setPosition(entry, true); - sub.cur = getSubroutine(prog->main); - - if (info_out->io.genUserClip > 0) { - for (int c = 0; c < 4; ++c) - clipVtx[c] = getScratch(); - } - - switch (prog->getType()) { - case Program::TYPE_TESSELLATION_CONTROL: - outBase = mkOp2v( - OP_SUB, TYPE_U32, getSSA(), - mkOp1v(OP_RDSV, TYPE_U32, getSSA(), mkSysVal(SV_LANEID, 0)), - mkOp1v(OP_RDSV, TYPE_U32, getSSA(), mkSysVal(SV_INVOCATION_ID, 0))); - break; - case Program::TYPE_FRAGMENT: { - Symbol *sv = mkSysVal(SV_POSITION, 3); - fragCoord[3] = mkOp1v(OP_RDSV, TYPE_F32, getSSA(), sv); - mkOp1(OP_RCP, TYPE_F32, fragCoord[3], fragCoord[3]); - break; - } - default: - break; - } - - if (info->io.viewportId >= 0) - viewport = getScratch(); - else - viewport = NULL; - - for (ip = 0; ip < code->scan.num_instructions; ++ip) { - if (!handleInstruction(&code->insns[ip])) - return false; - } - - if (!BindArgumentsPass(*this).run(prog)) - return false; - - return true; -} - -} // unnamed namespace - -namespace nv50_ir { - -bool -Program::makeFromTGSI(struct nv50_ir_prog_info *info, - struct nv50_ir_prog_info_out *info_out) -{ - tgsi::Source src(info, info_out, this); - if (!src.scanSource()) - return false; - tlsSize = info_out->bin.tlsSpace; - - Converter builder(this, &src, info_out); - return builder.run(); -} - -} // namespace nv50_ir -- 2.7.4