projects / mesa.git / blob
? search:


9d42ecd4ea8a100137f1d768ff4412cbd358d822
[mesa.git] / src / gallium / drivers / swr / swr_shader.cpp
1 /****************************************************************************
2 * Copyright (C) 2015 Intel Corporation. All Rights Reserved.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 ***************************************************************************/
23
24 // llvm redefines DEBUG
25 #pragma push_macro("DEBUG")
26 #undef DEBUG
27 #include "JitManager.h"
28 #include "llvm-c/Core.h"
29 #include "llvm/Support/CBindingWrapping.h"
30 #pragma pop_macro("DEBUG")
31
32 #include "state.h"
33 #include "gen_state_llvm.h"
34 #include "builder.h"
35
36 #include "tgsi/tgsi_strings.h"
37 #include "util/u_format.h"
38 #include "util/u_prim.h"
39 #include "gallivm/lp_bld_init.h"
40 #include "gallivm/lp_bld_flow.h"
41 #include "gallivm/lp_bld_struct.h"
42 #include "gallivm/lp_bld_tgsi.h"
43
44 #include "swr_context.h"
45 #include "gen_swr_context_llvm.h"
46 #include "swr_resource.h"
47 #include "swr_state.h"
48 #include "swr_screen.h"
49
50 #if HAVE_LLVM < 0x0500
51 namespace llvm {
52 typedef AttributeSet AttributeList;
53 }
54 #endif
55
56 using namespace SwrJit;
57 using namespace llvm;
58
59 static unsigned
60 locate_linkage(ubyte name, ubyte index, struct tgsi_shader_info *info);
61
62 bool operator==(const swr_jit_fs_key &lhs, const swr_jit_fs_key &rhs)
63 {
64 return !memcmp(&lhs, &rhs, sizeof(lhs));
65 }
66
67 bool operator==(const swr_jit_vs_key &lhs, const swr_jit_vs_key &rhs)
68 {
69 return !memcmp(&lhs, &rhs, sizeof(lhs));
70 }
71
72 bool operator==(const swr_jit_fetch_key &lhs, const swr_jit_fetch_key &rhs)
73 {
74 return !memcmp(&lhs, &rhs, sizeof(lhs));
75 }
76
77 bool operator==(const swr_jit_gs_key &lhs, const swr_jit_gs_key &rhs)
78 {
79 return !memcmp(&lhs, &rhs, sizeof(lhs));
80 }
81
82 static void
83 swr_generate_sampler_key(const struct lp_tgsi_info &info,
84 struct swr_context *ctx,
85 enum pipe_shader_type shader_type,
86 struct swr_jit_sampler_key &key)
87 {
88 key.nr_samplers = info.base.file_max[TGSI_FILE_SAMPLER] + 1;
89
90 for (unsigned i = 0; i < key.nr_samplers; i++) {
91 if (info.base.file_mask[TGSI_FILE_SAMPLER] & (1 << i)) {
92 lp_sampler_static_sampler_state(
93 &key.sampler[i].sampler_state,
94 ctx->samplers[shader_type][i]);
95 }
96 }
97
98 /*
99 * XXX If TGSI_FILE_SAMPLER_VIEW exists assume all texture opcodes
100 * are dx10-style? Can't really have mixed opcodes, at least not
101 * if we want to skip the holes here (without rescanning tgsi).
102 */
103 if (info.base.file_max[TGSI_FILE_SAMPLER_VIEW] != -1) {
104 key.nr_sampler_views =
105 info.base.file_max[TGSI_FILE_SAMPLER_VIEW] + 1;
106 for (unsigned i = 0; i < key.nr_sampler_views; i++) {
107 if (info.base.file_mask[TGSI_FILE_SAMPLER_VIEW] & (1 << i)) {
108 const struct pipe_sampler_view *view =
109 ctx->sampler_views[shader_type][i];
110 lp_sampler_static_texture_state(
111 &key.sampler[i].texture_state, view);
112 if (view) {
113 struct swr_resource *swr_res = swr_resource(view->texture);
114 const struct util_format_description *desc =
115 util_format_description(view->format);
116 if (swr_res->has_depth && swr_res->has_stencil &&
117 !util_format_has_depth(desc))
118 key.sampler[i].texture_state.format = PIPE_FORMAT_S8_UINT;
119 }
120 }
121 }
122 } else {
123 key.nr_sampler_views = key.nr_samplers;
124 for (unsigned i = 0; i < key.nr_sampler_views; i++) {
125 if (info.base.file_mask[TGSI_FILE_SAMPLER] & (1 << i)) {
126 const struct pipe_sampler_view *view =
127 ctx->sampler_views[shader_type][i];
128 lp_sampler_static_texture_state(
129 &key.sampler[i].texture_state, view);
130 if (view) {
131 struct swr_resource *swr_res = swr_resource(view->texture);
132 const struct util_format_description *desc =
133 util_format_description(view->format);
134 if (swr_res->has_depth && swr_res->has_stencil &&
135 !util_format_has_depth(desc))
136 key.sampler[i].texture_state.format = PIPE_FORMAT_S8_UINT;
137 }
138 }
139 }
140 }
141 }
142
143 void
144 swr_generate_fs_key(struct swr_jit_fs_key &key,
145 struct swr_context *ctx,
146 swr_fragment_shader *swr_fs)
147 {
148 memset(&key, 0, sizeof(key));
149
150 key.nr_cbufs = ctx->framebuffer.nr_cbufs;
151 key.light_twoside = ctx->rasterizer->light_twoside;
152 key.sprite_coord_enable = ctx->rasterizer->sprite_coord_enable;
153
154 struct tgsi_shader_info *pPrevShader;
155 if (ctx->gs)
156 pPrevShader = &ctx->gs->info.base;
157 else
158 pPrevShader = &ctx->vs->info.base;
159
160 memcpy(&key.vs_output_semantic_name,
161 &pPrevShader->output_semantic_name,
162 sizeof(key.vs_output_semantic_name));
163 memcpy(&key.vs_output_semantic_idx,
164 &pPrevShader->output_semantic_index,
165 sizeof(key.vs_output_semantic_idx));
166
167 swr_generate_sampler_key(swr_fs->info, ctx, PIPE_SHADER_FRAGMENT, key);
168 }
169
170 void
171 swr_generate_vs_key(struct swr_jit_vs_key &key,
172 struct swr_context *ctx,
173 swr_vertex_shader *swr_vs)
174 {
175 memset(&key, 0, sizeof(key));
176
177 key.clip_plane_mask =
178 swr_vs->info.base.clipdist_writemask ?
179 swr_vs->info.base.clipdist_writemask & ctx->rasterizer->clip_plane_enable :
180 ctx->rasterizer->clip_plane_enable;
181
182 swr_generate_sampler_key(swr_vs->info, ctx, PIPE_SHADER_VERTEX, key);
183 }
184
185 void
186 swr_generate_fetch_key(struct swr_jit_fetch_key &key,
187 struct swr_vertex_element_state *velems)
188 {
189 memset(&key, 0, sizeof(key));
190
191 key.fsState = velems->fsState;
192 }
193
194 void
195 swr_generate_gs_key(struct swr_jit_gs_key &key,
196 struct swr_context *ctx,
197 swr_geometry_shader *swr_gs)
198 {
199 memset(&key, 0, sizeof(key));
200
201 struct tgsi_shader_info *pPrevShader = &ctx->vs->info.base;
202
203 memcpy(&key.vs_output_semantic_name,
204 &pPrevShader->output_semantic_name,
205 sizeof(key.vs_output_semantic_name));
206 memcpy(&key.vs_output_semantic_idx,
207 &pPrevShader->output_semantic_index,
208 sizeof(key.vs_output_semantic_idx));
209
210 swr_generate_sampler_key(swr_gs->info, ctx, PIPE_SHADER_GEOMETRY, key);
211 }
212
213 struct BuilderSWR : public Builder {
214 BuilderSWR(JitManager *pJitMgr, const char *pName)
215 : Builder(pJitMgr)
216 {
217 pJitMgr->SetupNewModule();
218 gallivm = gallivm_create(pName, wrap(&JM()->mContext));
219 pJitMgr->mpCurrentModule = unwrap(gallivm->module);
220 }
221
222 ~BuilderSWR() {
223 gallivm_free_ir(gallivm);
224 }
225
226 struct gallivm_state *gallivm;
227 PFN_VERTEX_FUNC CompileVS(struct swr_context *ctx, swr_jit_vs_key &key);
228 PFN_PIXEL_KERNEL CompileFS(struct swr_context *ctx, swr_jit_fs_key &key);
229 PFN_GS_FUNC CompileGS(struct swr_context *ctx, swr_jit_gs_key &key);
230
231 LLVMValueRef
232 swr_gs_llvm_fetch_input(const struct lp_build_tgsi_gs_iface *gs_iface,
233 struct lp_build_tgsi_context * bld_base,
234 boolean is_vindex_indirect,
235 LLVMValueRef vertex_index,
236 boolean is_aindex_indirect,
237 LLVMValueRef attrib_index,
238 LLVMValueRef swizzle_index);
239 void
240 swr_gs_llvm_emit_vertex(const struct lp_build_tgsi_gs_iface *gs_base,
241 struct lp_build_tgsi_context * bld_base,
242 LLVMValueRef (*outputs)[4],
243 LLVMValueRef emitted_vertices_vec);
244
245 void
246 swr_gs_llvm_end_primitive(const struct lp_build_tgsi_gs_iface *gs_base,
247 struct lp_build_tgsi_context * bld_base,
248 LLVMValueRef verts_per_prim_vec,
249 LLVMValueRef emitted_prims_vec);
250
251 void
252 swr_gs_llvm_epilogue(const struct lp_build_tgsi_gs_iface *gs_base,
253 struct lp_build_tgsi_context * bld_base,
254 LLVMValueRef total_emitted_vertices_vec,
255 LLVMValueRef emitted_prims_vec);
256
257 };
258
259 struct swr_gs_llvm_iface {
260 struct lp_build_tgsi_gs_iface base;
261 struct tgsi_shader_info *info;
262
263 BuilderSWR *pBuilder;
264
265 Value *pGsCtx;
266 SWR_GS_STATE *pGsState;
267 uint32_t num_outputs;
268 uint32_t num_verts_per_prim;
269
270 Value *pVtxAttribMap;
271 };
272
273 // trampoline functions so we can use the builder llvm construction methods
274 static LLVMValueRef
275 swr_gs_llvm_fetch_input(const struct lp_build_tgsi_gs_iface *gs_iface,
276 struct lp_build_tgsi_context * bld_base,
277 boolean is_vindex_indirect,
278 LLVMValueRef vertex_index,
279 boolean is_aindex_indirect,
280 LLVMValueRef attrib_index,
281 LLVMValueRef swizzle_index)
282 {
283 swr_gs_llvm_iface *iface = (swr_gs_llvm_iface*)gs_iface;
284
285 return iface->pBuilder->swr_gs_llvm_fetch_input(gs_iface, bld_base,
286 is_vindex_indirect,
287 vertex_index,
288 is_aindex_indirect,
289 attrib_index,
290 swizzle_index);
291 }
292
293 static void
294 swr_gs_llvm_emit_vertex(const struct lp_build_tgsi_gs_iface *gs_base,
295 struct lp_build_tgsi_context * bld_base,
296 LLVMValueRef (*outputs)[4],
297 LLVMValueRef emitted_vertices_vec)
298 {
299 swr_gs_llvm_iface *iface = (swr_gs_llvm_iface*)gs_base;
300
301 iface->pBuilder->swr_gs_llvm_emit_vertex(gs_base, bld_base,
302 outputs,
303 emitted_vertices_vec);
304 }
305
306 static void
307 swr_gs_llvm_end_primitive(const struct lp_build_tgsi_gs_iface *gs_base,
308 struct lp_build_tgsi_context * bld_base,
309 LLVMValueRef verts_per_prim_vec,
310 LLVMValueRef emitted_prims_vec)
311 {
312 swr_gs_llvm_iface *iface = (swr_gs_llvm_iface*)gs_base;
313
314 iface->pBuilder->swr_gs_llvm_end_primitive(gs_base, bld_base,
315 verts_per_prim_vec,
316 emitted_prims_vec);
317 }
318
319 static void
320 swr_gs_llvm_epilogue(const struct lp_build_tgsi_gs_iface *gs_base,
321 struct lp_build_tgsi_context * bld_base,
322 LLVMValueRef total_emitted_vertices_vec,
323 LLVMValueRef emitted_prims_vec)
324 {
325 swr_gs_llvm_iface *iface = (swr_gs_llvm_iface*)gs_base;
326
327 iface->pBuilder->swr_gs_llvm_epilogue(gs_base, bld_base,
328 total_emitted_vertices_vec,
329 emitted_prims_vec);
330 }
331
332 LLVMValueRef
333 BuilderSWR::swr_gs_llvm_fetch_input(const struct lp_build_tgsi_gs_iface *gs_iface,
334 struct lp_build_tgsi_context * bld_base,
335 boolean is_vindex_indirect,
336 LLVMValueRef vertex_index,
337 boolean is_aindex_indirect,
338 LLVMValueRef attrib_index,
339 LLVMValueRef swizzle_index)
340 {
341 swr_gs_llvm_iface *iface = (swr_gs_llvm_iface*)gs_iface;
342
343 IRB()->SetInsertPoint(unwrap(LLVMGetInsertBlock(gallivm->builder)));
344
345 assert(is_vindex_indirect == false && is_aindex_indirect == false);
346
347 Value *attrib =
348 LOAD(GEP(iface->pVtxAttribMap, {C(0), unwrap(attrib_index)}));
349
350 Value *pInput =
351 LOAD(GEP(iface->pGsCtx,
352 {C(0),
353 C(SWR_GS_CONTEXT_vert),
354 unwrap(vertex_index),
355 C(0),
356 attrib,
357 unwrap(swizzle_index)}));
358
359 return wrap(pInput);
360 }
361
362 void
363 BuilderSWR::swr_gs_llvm_emit_vertex(const struct lp_build_tgsi_gs_iface *gs_base,
364 struct lp_build_tgsi_context * bld_base,
365 LLVMValueRef (*outputs)[4],
366 LLVMValueRef emitted_vertices_vec)
367 {
368 swr_gs_llvm_iface *iface = (swr_gs_llvm_iface*)gs_base;
369 SWR_GS_STATE *pGS = iface->pGsState;
370
371 IRB()->SetInsertPoint(unwrap(LLVMGetInsertBlock(gallivm->builder)));
372
373 const uint32_t simdVertexStride = sizeof(simdvertex);
374 const uint32_t numSimdBatches = (pGS->maxNumVerts + 7) / 8;
375 const uint32_t inputPrimStride = numSimdBatches * simdVertexStride;
376
377 Value *pStream = LOAD(iface->pGsCtx, { 0, SWR_GS_CONTEXT_pStream });
378 Value *vMask = LOAD(iface->pGsCtx, { 0, SWR_GS_CONTEXT_mask });
379 Value *vMask1 = TRUNC(vMask, VectorType::get(mInt1Ty, 8));
380
381 Value *vOffsets = C({
382 inputPrimStride * 0,
383 inputPrimStride * 1,
384 inputPrimStride * 2,
385 inputPrimStride * 3,
386 inputPrimStride * 4,
387 inputPrimStride * 5,
388 inputPrimStride * 6,
389 inputPrimStride * 7 } );
390
391 Value *vVertexSlot = ASHR(unwrap(emitted_vertices_vec), 3);
392 Value *vSimdSlot = AND(unwrap(emitted_vertices_vec), 7);
393
394 for (uint32_t attrib = 0; attrib < iface->num_outputs; ++attrib) {
395 uint32_t attribSlot = attrib;
396 if (iface->info->output_semantic_name[attrib] == TGSI_SEMANTIC_PSIZE)
397 attribSlot = VERTEX_POINT_SIZE_SLOT;
398 else if (iface->info->output_semantic_name[attrib] == TGSI_SEMANTIC_PRIMID)
399 attribSlot = VERTEX_PRIMID_SLOT;
400 else if (iface->info->output_semantic_name[attrib] == TGSI_SEMANTIC_LAYER)
401 attribSlot = VERTEX_RTAI_SLOT;
402
403 Value *vOffsetsAttrib =
404 ADD(vOffsets, MUL(vVertexSlot, VIMMED1((uint32_t)sizeof(simdvertex))));
405 vOffsetsAttrib =
406 ADD(vOffsetsAttrib, VIMMED1((uint32_t)(attribSlot*sizeof(simdvector))));
407 vOffsetsAttrib =
408 ADD(vOffsetsAttrib, MUL(vSimdSlot, VIMMED1((uint32_t)sizeof(float))));
409
410 for (uint32_t channel = 0; channel < 4; ++channel) {
411 Value *vData = LOAD(unwrap(outputs[attrib][channel]));
412 Value *vPtrs = GEP(pStream, vOffsetsAttrib);
413
414 vPtrs = BITCAST(vPtrs,
415 VectorType::get(PointerType::get(mFP32Ty, 0), 8));
416
417 MASKED_SCATTER(vData, vPtrs, 32, vMask1);
418
419 vOffsetsAttrib =
420 ADD(vOffsetsAttrib, VIMMED1((uint32_t)sizeof(simdscalar)));
421 }
422 }
423 }
424
425 void
426 BuilderSWR::swr_gs_llvm_end_primitive(const struct lp_build_tgsi_gs_iface *gs_base,
427 struct lp_build_tgsi_context * bld_base,
428 LLVMValueRef verts_per_prim_vec,
429 LLVMValueRef emitted_prims_vec)
430 {
431 swr_gs_llvm_iface *iface = (swr_gs_llvm_iface*)gs_base;
432 SWR_GS_STATE *pGS = iface->pGsState;
433
434 IRB()->SetInsertPoint(unwrap(LLVMGetInsertBlock(gallivm->builder)));
435
436 Value *pCutBuffer =
437 LOAD(iface->pGsCtx, {0, SWR_GS_CONTEXT_pCutOrStreamIdBuffer});
438 Value *vMask = LOAD(iface->pGsCtx, { 0, SWR_GS_CONTEXT_mask });
439 Value *vMask1 = TRUNC(vMask, VectorType::get(mInt1Ty, 8));
440
441 uint32_t vertsPerPrim = iface->num_verts_per_prim;
442
443 Value *vCount =
444 ADD(MUL(unwrap(emitted_prims_vec), VIMMED1(vertsPerPrim)),
445 unwrap(verts_per_prim_vec));
446
447 struct lp_build_tgsi_soa_context *bld = lp_soa_context(bld_base);
448 vCount = LOAD(unwrap(bld->total_emitted_vertices_vec_ptr));
449
450 struct lp_exec_mask *exec_mask = &bld->exec_mask;
451 Value *mask = unwrap(lp_build_mask_value(bld->mask));
452 if (exec_mask->has_mask)
453 mask = AND(mask, unwrap(exec_mask->exec_mask));
454
455 Value *cmpMask = VMASK(ICMP_NE(unwrap(verts_per_prim_vec), VIMMED1(0)));
456 mask = AND(mask, cmpMask);
457 vMask1 = TRUNC(mask, VectorType::get(mInt1Ty, 8));
458
459 const uint32_t cutPrimStride =
460 (pGS->maxNumVerts + JM()->mVWidth - 1) / JM()->mVWidth;
461 Value *vOffsets = C({
462 (uint32_t)(cutPrimStride * 0),
463 (uint32_t)(cutPrimStride * 1),
464 (uint32_t)(cutPrimStride * 2),
465 (uint32_t)(cutPrimStride * 3),
466 (uint32_t)(cutPrimStride * 4),
467 (uint32_t)(cutPrimStride * 5),
468 (uint32_t)(cutPrimStride * 6),
469 (uint32_t)(cutPrimStride * 7) } );
470
471 vCount = SUB(vCount, VIMMED1(1));
472 Value *vOffset = ADD(UDIV(vCount, VIMMED1(8)), vOffsets);
473 Value *vValue = SHL(VIMMED1(1), UREM(vCount, VIMMED1(8)));
474
475 vValue = TRUNC(vValue, VectorType::get(mInt8Ty, 8));
476
477 Value *vPtrs = GEP(pCutBuffer, vOffset);
478 vPtrs =
479 BITCAST(vPtrs, VectorType::get(PointerType::get(mInt8Ty, 0), JM()->mVWidth));
480
481 Value *vGather = MASKED_GATHER(vPtrs, 32, vMask1);
482 vValue = OR(vGather, vValue);
483 MASKED_SCATTER(vValue, vPtrs, 32, vMask1);
484 }
485
486 void
487 BuilderSWR::swr_gs_llvm_epilogue(const struct lp_build_tgsi_gs_iface *gs_base,
488 struct lp_build_tgsi_context * bld_base,
489 LLVMValueRef total_emitted_vertices_vec,
490 LLVMValueRef emitted_prims_vec)
491 {
492 swr_gs_llvm_iface *iface = (swr_gs_llvm_iface*)gs_base;
493 SWR_GS_STATE *pGS = iface->pGsState;
494
495 IRB()->SetInsertPoint(unwrap(LLVMGetInsertBlock(gallivm->builder)));
496
497 STORE(unwrap(total_emitted_vertices_vec), iface->pGsCtx, {0, SWR_GS_CONTEXT_vertexCount});
498 }
499
500 PFN_GS_FUNC
501 BuilderSWR::CompileGS(struct swr_context *ctx, swr_jit_gs_key &key)
502 {
503 SWR_GS_STATE *pGS = &ctx->gs->gsState;
504 struct tgsi_shader_info *info = &ctx->gs->info.base;
505
506 pGS->gsEnable = true;
507
508 pGS->numInputAttribs = info->num_inputs;
509 pGS->outputTopology =
510 swr_convert_prim_topology(info->properties[TGSI_PROPERTY_GS_OUTPUT_PRIM]);
511 pGS->maxNumVerts = info->properties[TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES];
512 pGS->instanceCount = info->properties[TGSI_PROPERTY_GS_INVOCATIONS];
513
514 pGS->emitsRenderTargetArrayIndex = info->writes_layer;
515 pGS->emitsPrimitiveID = info->writes_primid;
516 pGS->emitsViewportArrayIndex = info->writes_viewport_index;
517
518 // XXX: single stream for now...
519 pGS->isSingleStream = true;
520 pGS->singleStreamID = 0;
521
522 struct swr_geometry_shader *gs = ctx->gs;
523
524 LLVMValueRef inputs[PIPE_MAX_SHADER_INPUTS][TGSI_NUM_CHANNELS];
525 LLVMValueRef outputs[PIPE_MAX_SHADER_OUTPUTS][TGSI_NUM_CHANNELS];
526
527 memset(outputs, 0, sizeof(outputs));
528
529 AttrBuilder attrBuilder;
530 attrBuilder.addStackAlignmentAttr(JM()->mVWidth * sizeof(float));
531 AttributeList attrSet = AttributeList::get(
532 JM()->mContext, AttributeList::FunctionIndex, attrBuilder);
533
534 std::vector<Type *> gsArgs{PointerType::get(Gen_swr_draw_context(JM()), 0),
535 PointerType::get(Gen_SWR_GS_CONTEXT(JM()), 0)};
536 FunctionType *vsFuncType =
537 FunctionType::get(Type::getVoidTy(JM()->mContext), gsArgs, false);
538
539 // create new vertex shader function
540 auto pFunction = Function::Create(vsFuncType,
541 GlobalValue::ExternalLinkage,
542 "GS",
543 JM()->mpCurrentModule);
544 pFunction->addAttributes(AttributeList::FunctionIndex, attrSet);
545
546 BasicBlock *block = BasicBlock::Create(JM()->mContext, "entry", pFunction);
547 IRB()->SetInsertPoint(block);
548 LLVMPositionBuilderAtEnd(gallivm->builder, wrap(block));
549
550 auto argitr = pFunction->arg_begin();
551 Value *hPrivateData = &*argitr++;
552 hPrivateData->setName("hPrivateData");
553 Value *pGsCtx = &*argitr++;
554 pGsCtx->setName("gsCtx");
555
556 Value *consts_ptr =
557 GEP(hPrivateData, {C(0), C(swr_draw_context_constantGS)});
558 consts_ptr->setName("gs_constants");
559 Value *const_sizes_ptr =
560 GEP(hPrivateData, {0, swr_draw_context_num_constantsGS});
561 const_sizes_ptr->setName("num_gs_constants");
562
563 struct lp_build_sampler_soa *sampler =
564 swr_sampler_soa_create(key.sampler, PIPE_SHADER_GEOMETRY);
565
566 struct lp_bld_tgsi_system_values system_values;
567 memset(&system_values, 0, sizeof(system_values));
568 system_values.prim_id = wrap(LOAD(pGsCtx, {0, SWR_GS_CONTEXT_PrimitiveID}));
569 system_values.instance_id = wrap(LOAD(pGsCtx, {0, SWR_GS_CONTEXT_InstanceID}));
570
571 std::vector<Constant*> mapConstants;
572 Value *vtxAttribMap = ALLOCA(ArrayType::get(mInt32Ty, PIPE_MAX_SHADER_INPUTS));
573 for (unsigned slot = 0; slot < info->num_inputs; slot++) {
574 ubyte semantic_name = info->input_semantic_name[slot];
575 ubyte semantic_idx = info->input_semantic_index[slot];
576
577 unsigned vs_slot =
578 locate_linkage(semantic_name, semantic_idx, &ctx->vs->info.base) + 1;
579
580 STORE(C(vs_slot), vtxAttribMap, {0, slot});
581 mapConstants.push_back(C(vs_slot));
582 }
583
584 struct lp_build_mask_context mask;
585 Value *mask_val = LOAD(pGsCtx, {0, SWR_GS_CONTEXT_mask}, "gsMask");
586 lp_build_mask_begin(&mask, gallivm,
587 lp_type_float_vec(32, 32 * 8), wrap(mask_val));
588
589 // zero out cut buffer so we can load/modify/store bits
590 MEMSET(LOAD(pGsCtx, {0, SWR_GS_CONTEXT_pCutOrStreamIdBuffer}),
591 C((char)0),
592 pGS->instanceCount * ((pGS->maxNumVerts + 7) / 8) * JM()->mVWidth,
593 sizeof(float) * KNOB_SIMD_WIDTH);
594
595 struct swr_gs_llvm_iface gs_iface;
596 gs_iface.base.fetch_input = ::swr_gs_llvm_fetch_input;
597 gs_iface.base.emit_vertex = ::swr_gs_llvm_emit_vertex;
598 gs_iface.base.end_primitive = ::swr_gs_llvm_end_primitive;
599 gs_iface.base.gs_epilogue = ::swr_gs_llvm_epilogue;
600 gs_iface.pBuilder = this;
601 gs_iface.pGsCtx = pGsCtx;
602 gs_iface.pGsState = pGS;
603 gs_iface.num_outputs = gs->info.base.num_outputs;
604 gs_iface.num_verts_per_prim =
605 u_vertices_per_prim((pipe_prim_type)info->properties[TGSI_PROPERTY_GS_OUTPUT_PRIM]);
606 gs_iface.info = info;
607 gs_iface.pVtxAttribMap = vtxAttribMap;
608
609 lp_build_tgsi_soa(gallivm,
610 gs->pipe.tokens,
611 lp_type_float_vec(32, 32 * 8),
612 &mask,
613 wrap(consts_ptr),
614 wrap(const_sizes_ptr),
615 &system_values,
616 inputs,
617 outputs,
618 wrap(hPrivateData), // (sampler context)
619 NULL, // thread data
620 sampler,
621 &gs->info.base,
622 &gs_iface.base);
623
624 lp_build_mask_end(&mask);
625
626 sampler->destroy(sampler);
627
628 IRB()->SetInsertPoint(unwrap(LLVMGetInsertBlock(gallivm->builder)));
629
630 RET_VOID();
631
632 gallivm_verify_function(gallivm, wrap(pFunction));
633 gallivm_compile_module(gallivm);
634
635 PFN_GS_FUNC pFunc =
636 (PFN_GS_FUNC)gallivm_jit_function(gallivm, wrap(pFunction));
637
638 debug_printf("geom shader %p\n", pFunc);
639 assert(pFunc && "Error: GeomShader = NULL");
640
641 JM()->mIsModuleFinalized = true;
642
643 return pFunc;
644 }
645
646 PFN_GS_FUNC
647 swr_compile_gs(struct swr_context *ctx, swr_jit_gs_key &key)
648 {
649 BuilderSWR builder(
650 reinterpret_cast<JitManager *>(swr_screen(ctx->pipe.screen)->hJitMgr),
651 "GS");
652 PFN_GS_FUNC func = builder.CompileGS(ctx, key);
653
654 ctx->gs->map.insert(std::make_pair(key, make_unique<VariantGS>(builder.gallivm, func)));
655 return func;
656 }
657
658 PFN_VERTEX_FUNC
659 BuilderSWR::CompileVS(struct swr_context *ctx, swr_jit_vs_key &key)
660 {
661 struct swr_vertex_shader *swr_vs = ctx->vs;
662
663 LLVMValueRef inputs[PIPE_MAX_SHADER_INPUTS][TGSI_NUM_CHANNELS];
664 LLVMValueRef outputs[PIPE_MAX_SHADER_OUTPUTS][TGSI_NUM_CHANNELS];
665
666 memset(outputs, 0, sizeof(outputs));
667
668 AttrBuilder attrBuilder;
669 attrBuilder.addStackAlignmentAttr(JM()->mVWidth * sizeof(float));
670 AttributeList attrSet = AttributeList::get(
671 JM()->mContext, AttributeList::FunctionIndex, attrBuilder);
672
673 std::vector<Type *> vsArgs{PointerType::get(Gen_swr_draw_context(JM()), 0),
674 PointerType::get(Gen_SWR_VS_CONTEXT(JM()), 0)};
675 FunctionType *vsFuncType =
676 FunctionType::get(Type::getVoidTy(JM()->mContext), vsArgs, false);
677
678 // create new vertex shader function
679 auto pFunction = Function::Create(vsFuncType,
680 GlobalValue::ExternalLinkage,
681 "VS",
682 JM()->mpCurrentModule);
683 pFunction->addAttributes(AttributeList::FunctionIndex, attrSet);
684
685 BasicBlock *block = BasicBlock::Create(JM()->mContext, "entry", pFunction);
686 IRB()->SetInsertPoint(block);
687 LLVMPositionBuilderAtEnd(gallivm->builder, wrap(block));
688
689 auto argitr = pFunction->arg_begin();
690 Value *hPrivateData = &*argitr++;
691 hPrivateData->setName("hPrivateData");
692 Value *pVsCtx = &*argitr++;
693 pVsCtx->setName("vsCtx");
694
695 Value *consts_ptr = GEP(hPrivateData, {C(0), C(swr_draw_context_constantVS)});
696
697 consts_ptr->setName("vs_constants");
698 Value *const_sizes_ptr =
699 GEP(hPrivateData, {0, swr_draw_context_num_constantsVS});
700 const_sizes_ptr->setName("num_vs_constants");
701
702 Value *vtxInput = LOAD(pVsCtx, {0, SWR_VS_CONTEXT_pVin});
703
704 for (uint32_t attrib = 0; attrib < PIPE_MAX_SHADER_INPUTS; attrib++) {
705 const unsigned mask = swr_vs->info.base.input_usage_mask[attrib];
706 for (uint32_t channel = 0; channel < TGSI_NUM_CHANNELS; channel++) {
707 if (mask & (1 << channel)) {
708 inputs[attrib][channel] =
709 wrap(LOAD(vtxInput, {0, 0, attrib, channel}));
710 }
711 }
712 }
713
714 struct lp_build_sampler_soa *sampler =
715 swr_sampler_soa_create(key.sampler, PIPE_SHADER_VERTEX);
716
717 struct lp_bld_tgsi_system_values system_values;
718 memset(&system_values, 0, sizeof(system_values));
719 system_values.instance_id = wrap(LOAD(pVsCtx, {0, SWR_VS_CONTEXT_InstanceID}));
720 system_values.vertex_id = wrap(LOAD(pVsCtx, {0, SWR_VS_CONTEXT_VertexID}));
721
722 lp_build_tgsi_soa(gallivm,
723 swr_vs->pipe.tokens,
724 lp_type_float_vec(32, 32 * 8),
725 NULL, // mask
726 wrap(consts_ptr),
727 wrap(const_sizes_ptr),
728 &system_values,
729 inputs,
730 outputs,
731 wrap(hPrivateData), // (sampler context)
732 NULL, // thread data
733 sampler, // sampler
734 &swr_vs->info.base,
735 NULL); // geometry shader face
736
737 sampler->destroy(sampler);
738
739 IRB()->SetInsertPoint(unwrap(LLVMGetInsertBlock(gallivm->builder)));
740
741 Value *vtxOutput = LOAD(pVsCtx, {0, SWR_VS_CONTEXT_pVout});
742
743 for (uint32_t channel = 0; channel < TGSI_NUM_CHANNELS; channel++) {
744 for (uint32_t attrib = 0; attrib < PIPE_MAX_SHADER_OUTPUTS; attrib++) {
745 if (!outputs[attrib][channel])
746 continue;
747
748 Value *val = LOAD(unwrap(outputs[attrib][channel]));
749
750 uint32_t outSlot = attrib;
751 if (swr_vs->info.base.output_semantic_name[attrib] == TGSI_SEMANTIC_PSIZE)
752 outSlot = VERTEX_POINT_SIZE_SLOT;
753 STORE(val, vtxOutput, {0, 0, outSlot, channel});
754 }
755 }
756
757 if (ctx->rasterizer->clip_plane_enable ||
758 swr_vs->info.base.culldist_writemask) {
759 unsigned clip_mask = ctx->rasterizer->clip_plane_enable;
760
761 unsigned cv = 0;
762 if (swr_vs->info.base.writes_clipvertex) {
763 cv = 1 + locate_linkage(TGSI_SEMANTIC_CLIPVERTEX, 0,
764 &swr_vs->info.base);
765 } else {
766 for (int i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
767 if (swr_vs->info.base.output_semantic_name[i] == TGSI_SEMANTIC_POSITION &&
768 swr_vs->info.base.output_semantic_index[i] == 0) {
769 cv = i;
770 break;
771 }
772 }
773 }
774 LLVMValueRef cx = LLVMBuildLoad(gallivm->builder, outputs[cv][0], "");
775 LLVMValueRef cy = LLVMBuildLoad(gallivm->builder, outputs[cv][1], "");
776 LLVMValueRef cz = LLVMBuildLoad(gallivm->builder, outputs[cv][2], "");
777 LLVMValueRef cw = LLVMBuildLoad(gallivm->builder, outputs[cv][3], "");
778
779 for (unsigned val = 0; val < PIPE_MAX_CLIP_PLANES; val++) {
780 // clip distance overrides user clip planes
781 if ((swr_vs->info.base.clipdist_writemask & clip_mask & (1 << val)) ||
782 ((swr_vs->info.base.culldist_writemask << swr_vs->info.base.num_written_clipdistance) & (1 << val))) {
783 unsigned cv = 1 + locate_linkage(TGSI_SEMANTIC_CLIPDIST, val < 4 ? 0 : 1,
784 &swr_vs->info.base);
785 if (val < 4) {
786 LLVMValueRef dist = LLVMBuildLoad(gallivm->builder, outputs[cv][val], "");
787 STORE(unwrap(dist), vtxOutput, {0, 0, VERTEX_CLIPCULL_DIST_LO_SLOT, val});
788 } else {
789 LLVMValueRef dist = LLVMBuildLoad(gallivm->builder, outputs[cv][val - 4], "");
790 STORE(unwrap(dist), vtxOutput, {0, 0, VERTEX_CLIPCULL_DIST_HI_SLOT, val - 4});
791 }
792 continue;
793 }
794
795 if (!(clip_mask & (1 << val)))
796 continue;
797
798 Value *px = LOAD(GEP(hPrivateData, {0, swr_draw_context_userClipPlanes, val, 0}));
799 Value *py = LOAD(GEP(hPrivateData, {0, swr_draw_context_userClipPlanes, val, 1}));
800 Value *pz = LOAD(GEP(hPrivateData, {0, swr_draw_context_userClipPlanes, val, 2}));
801 Value *pw = LOAD(GEP(hPrivateData, {0, swr_draw_context_userClipPlanes, val, 3}));
802 Value *dist = FADD(FMUL(unwrap(cx), VBROADCAST(px)),
803 FADD(FMUL(unwrap(cy), VBROADCAST(py)),
804 FADD(FMUL(unwrap(cz), VBROADCAST(pz)),
805 FMUL(unwrap(cw), VBROADCAST(pw)))));
806
807 if (val < 4)
808 STORE(dist, vtxOutput, {0, 0, VERTEX_CLIPCULL_DIST_LO_SLOT, val});
809 else
810 STORE(dist, vtxOutput, {0, 0, VERTEX_CLIPCULL_DIST_HI_SLOT, val - 4});
811 }
812 }
813
814 RET_VOID();
815
816 gallivm_verify_function(gallivm, wrap(pFunction));
817 gallivm_compile_module(gallivm);
818
819 // lp_debug_dump_value(func);
820
821 PFN_VERTEX_FUNC pFunc =
822 (PFN_VERTEX_FUNC)gallivm_jit_function(gallivm, wrap(pFunction));
823
824 debug_printf("vert shader %p\n", pFunc);
825 assert(pFunc && "Error: VertShader = NULL");
826
827 JM()->mIsModuleFinalized = true;
828
829 return pFunc;
830 }
831
832 PFN_VERTEX_FUNC
833 swr_compile_vs(struct swr_context *ctx, swr_jit_vs_key &key)
834 {
835 if (!ctx->vs->pipe.tokens)
836 return NULL;
837
838 BuilderSWR builder(
839 reinterpret_cast<JitManager *>(swr_screen(ctx->pipe.screen)->hJitMgr),
840 "VS");
841 PFN_VERTEX_FUNC func = builder.CompileVS(ctx, key);
842
843 ctx->vs->map.insert(std::make_pair(key, make_unique<VariantVS>(builder.gallivm, func)));
844 return func;
845 }
846
847 static unsigned
848 locate_linkage(ubyte name, ubyte index, struct tgsi_shader_info *info)
849 {
850 for (int i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
851 if ((info->output_semantic_name[i] == name)
852 && (info->output_semantic_index[i] == index)) {
853 return i - 1; // position is not part of the linkage
854 }
855 }
856
857 return 0xFFFFFFFF;
858 }
859
860 PFN_PIXEL_KERNEL
861 BuilderSWR::CompileFS(struct swr_context *ctx, swr_jit_fs_key &key)
862 {
863 struct swr_fragment_shader *swr_fs = ctx->fs;
864
865 struct tgsi_shader_info *pPrevShader;
866 if (ctx->gs)
867 pPrevShader = &ctx->gs->info.base;
868 else
869 pPrevShader = &ctx->vs->info.base;
870
871 LLVMValueRef inputs[PIPE_MAX_SHADER_INPUTS][TGSI_NUM_CHANNELS];
872 LLVMValueRef outputs[PIPE_MAX_SHADER_OUTPUTS][TGSI_NUM_CHANNELS];
873
874 memset(inputs, 0, sizeof(inputs));
875 memset(outputs, 0, sizeof(outputs));
876
877 struct lp_build_sampler_soa *sampler = NULL;
878
879 AttrBuilder attrBuilder;
880 attrBuilder.addStackAlignmentAttr(JM()->mVWidth * sizeof(float));
881 AttributeList attrSet = AttributeList::get(
882 JM()->mContext, AttributeList::FunctionIndex, attrBuilder);
883
884 std::vector<Type *> fsArgs{PointerType::get(Gen_swr_draw_context(JM()), 0),
885 PointerType::get(Gen_SWR_PS_CONTEXT(JM()), 0)};
886 FunctionType *funcType =
887 FunctionType::get(Type::getVoidTy(JM()->mContext), fsArgs, false);
888
889 auto pFunction = Function::Create(funcType,
890 GlobalValue::ExternalLinkage,
891 "FS",
892 JM()->mpCurrentModule);
893 pFunction->addAttributes(AttributeList::FunctionIndex, attrSet);
894
895 BasicBlock *block = BasicBlock::Create(JM()->mContext, "entry", pFunction);
896 IRB()->SetInsertPoint(block);
897 LLVMPositionBuilderAtEnd(gallivm->builder, wrap(block));
898
899 auto args = pFunction->arg_begin();
900 Value *hPrivateData = &*args++;
901 hPrivateData->setName("hPrivateData");
902 Value *pPS = &*args++;
903 pPS->setName("psCtx");
904
905 Value *consts_ptr = GEP(hPrivateData, {0, swr_draw_context_constantFS});
906 consts_ptr->setName("fs_constants");
907 Value *const_sizes_ptr =
908 GEP(hPrivateData, {0, swr_draw_context_num_constantsFS});
909 const_sizes_ptr->setName("num_fs_constants");
910
911 // load *pAttribs, *pPerspAttribs
912 Value *pRawAttribs = LOAD(pPS, {0, SWR_PS_CONTEXT_pAttribs}, "pRawAttribs");
913 Value *pPerspAttribs =
914 LOAD(pPS, {0, SWR_PS_CONTEXT_pPerspAttribs}, "pPerspAttribs");
915
916 swr_fs->constantMask = 0;
917 swr_fs->flatConstantMask = 0;
918 swr_fs->pointSpriteMask = 0;
919
920 for (int attrib = 0; attrib < PIPE_MAX_SHADER_INPUTS; attrib++) {
921 const unsigned mask = swr_fs->info.base.input_usage_mask[attrib];
922 const unsigned interpMode = swr_fs->info.base.input_interpolate[attrib];
923 const unsigned interpLoc = swr_fs->info.base.input_interpolate_loc[attrib];
924
925 if (!mask)
926 continue;
927
928 // load i,j
929 Value *vi = nullptr, *vj = nullptr;
930 switch (interpLoc) {
931 case TGSI_INTERPOLATE_LOC_CENTER:
932 vi = LOAD(pPS, {0, SWR_PS_CONTEXT_vI, PixelPositions_center}, "i");
933 vj = LOAD(pPS, {0, SWR_PS_CONTEXT_vJ, PixelPositions_center}, "j");
934 break;
935 case TGSI_INTERPOLATE_LOC_CENTROID:
936 vi = LOAD(pPS, {0, SWR_PS_CONTEXT_vI, PixelPositions_centroid}, "i");
937 vj = LOAD(pPS, {0, SWR_PS_CONTEXT_vJ, PixelPositions_centroid}, "j");
938 break;
939 case TGSI_INTERPOLATE_LOC_SAMPLE:
940 vi = LOAD(pPS, {0, SWR_PS_CONTEXT_vI, PixelPositions_sample}, "i");
941 vj = LOAD(pPS, {0, SWR_PS_CONTEXT_vJ, PixelPositions_sample}, "j");
942 break;
943 }
944
945 // load/compute w
946 Value *vw = nullptr, *pAttribs;
947 if (interpMode == TGSI_INTERPOLATE_PERSPECTIVE ||
948 interpMode == TGSI_INTERPOLATE_COLOR) {
949 pAttribs = pPerspAttribs;
950 switch (interpLoc) {
951 case TGSI_INTERPOLATE_LOC_CENTER:
952 vw = VRCP(LOAD(pPS, {0, SWR_PS_CONTEXT_vOneOverW, PixelPositions_center}));
953 break;
954 case TGSI_INTERPOLATE_LOC_CENTROID:
955 vw = VRCP(LOAD(pPS, {0, SWR_PS_CONTEXT_vOneOverW, PixelPositions_centroid}));
956 break;
957 case TGSI_INTERPOLATE_LOC_SAMPLE:
958 vw = VRCP(LOAD(pPS, {0, SWR_PS_CONTEXT_vOneOverW, PixelPositions_sample}));
959 break;
960 }
961 } else {
962 pAttribs = pRawAttribs;
963 vw = VIMMED1(1.f);
964 }
965
966 vw->setName("w");
967
968 ubyte semantic_name = swr_fs->info.base.input_semantic_name[attrib];
969 ubyte semantic_idx = swr_fs->info.base.input_semantic_index[attrib];
970
971 if (semantic_name == TGSI_SEMANTIC_FACE) {
972 Value *ff =
973 UI_TO_FP(LOAD(pPS, {0, SWR_PS_CONTEXT_frontFace}), mFP32Ty);
974 ff = FSUB(FMUL(ff, C(2.0f)), C(1.0f));
975 ff = VECTOR_SPLAT(JM()->mVWidth, ff, "vFrontFace");
976
977 inputs[attrib][0] = wrap(ff);
978 inputs[attrib][1] = wrap(VIMMED1(0.0f));
979 inputs[attrib][2] = wrap(VIMMED1(0.0f));
980 inputs[attrib][3] = wrap(VIMMED1(1.0f));
981 continue;
982 } else if (semantic_name == TGSI_SEMANTIC_POSITION) { // gl_FragCoord
983 if (swr_fs->info.base.properties[TGSI_PROPERTY_FS_COORD_PIXEL_CENTER] ==
984 TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER) {
985 inputs[attrib][0] = wrap(LOAD(pPS, {0, SWR_PS_CONTEXT_vX, PixelPositions_center}, "vX"));
986 inputs[attrib][1] = wrap(LOAD(pPS, {0, SWR_PS_CONTEXT_vY, PixelPositions_center}, "vY"));
987 } else {
988 inputs[attrib][0] = wrap(LOAD(pPS, {0, SWR_PS_CONTEXT_vX, PixelPositions_UL}, "vX"));
989 inputs[attrib][1] = wrap(LOAD(pPS, {0, SWR_PS_CONTEXT_vY, PixelPositions_UL}, "vY"));
990 }
991 inputs[attrib][2] = wrap(LOAD(pPS, {0, SWR_PS_CONTEXT_vZ}, "vZ"));
992 inputs[attrib][3] =
993 wrap(LOAD(pPS, {0, SWR_PS_CONTEXT_vOneOverW, PixelPositions_center}, "vOneOverW"));
994 continue;
995 } else if (semantic_name == TGSI_SEMANTIC_PRIMID) {
996 Value *primID = LOAD(pPS, {0, SWR_PS_CONTEXT_primID}, "primID");
997 inputs[attrib][0] = wrap(VECTOR_SPLAT(JM()->mVWidth, primID));
998 inputs[attrib][1] = wrap(VIMMED1(0));
999 inputs[attrib][2] = wrap(VIMMED1(0));
1000 inputs[attrib][3] = wrap(VIMMED1(0));
1001 continue;
1002 }
1003
1004 unsigned linkedAttrib =
1005 locate_linkage(semantic_name, semantic_idx, pPrevShader);
1006
1007 if (semantic_name == TGSI_SEMANTIC_GENERIC &&
1008 key.sprite_coord_enable & (1 << semantic_idx)) {
1009 /* we add an extra attrib to the backendState in swr_update_derived. */
1010 linkedAttrib = pPrevShader->num_outputs - 1;
1011 swr_fs->pointSpriteMask |= (1 << linkedAttrib);
1012 } else if (linkedAttrib == 0xFFFFFFFF) {
1013 inputs[attrib][0] = wrap(VIMMED1(0.0f));
1014 inputs[attrib][1] = wrap(VIMMED1(0.0f));
1015 inputs[attrib][2] = wrap(VIMMED1(0.0f));
1016 inputs[attrib][3] = wrap(VIMMED1(1.0f));
1017 /* If we're reading in color and 2-sided lighting is enabled, we have
1018 * to keep going.
1019 */
1020 if (semantic_name != TGSI_SEMANTIC_COLOR || !key.light_twoside)
1021 continue;
1022 } else {
1023 if (interpMode == TGSI_INTERPOLATE_CONSTANT) {
1024 swr_fs->constantMask |= 1 << linkedAttrib;
1025 } else if (interpMode == TGSI_INTERPOLATE_COLOR) {
1026 swr_fs->flatConstantMask |= 1 << linkedAttrib;
1027 }
1028 }
1029
1030 unsigned bcolorAttrib = 0xFFFFFFFF;
1031 Value *offset = NULL;
1032 if (semantic_name == TGSI_SEMANTIC_COLOR && key.light_twoside) {
1033 bcolorAttrib = locate_linkage(
1034 TGSI_SEMANTIC_BCOLOR, semantic_idx, pPrevShader);
1035 /* Neither front nor back colors were available. Nothing to load. */
1036 if (bcolorAttrib == 0xFFFFFFFF && linkedAttrib == 0xFFFFFFFF)
1037 continue;
1038 /* If there is no front color, just always use the back color. */
1039 if (linkedAttrib == 0xFFFFFFFF)
1040 linkedAttrib = bcolorAttrib;
1041
1042 if (bcolorAttrib != 0xFFFFFFFF) {
1043 if (interpMode == TGSI_INTERPOLATE_CONSTANT) {
1044 swr_fs->constantMask |= 1 << bcolorAttrib;
1045 } else if (interpMode == TGSI_INTERPOLATE_COLOR) {
1046 swr_fs->flatConstantMask |= 1 << bcolorAttrib;
1047 }
1048
1049 unsigned diff = 12 * (bcolorAttrib - linkedAttrib);
1050
1051 if (diff) {
1052 Value *back =
1053 XOR(C(1), LOAD(pPS, {0, SWR_PS_CONTEXT_frontFace}), "backFace");
1054
1055 offset = MUL(back, C(diff));
1056 offset->setName("offset");
1057 }
1058 }
1059 }
1060
1061 for (int channel = 0; channel < TGSI_NUM_CHANNELS; channel++) {
1062 if (mask & (1 << channel)) {
1063 Value *indexA = C(linkedAttrib * 12 + channel);
1064 Value *indexB = C(linkedAttrib * 12 + channel + 4);
1065 Value *indexC = C(linkedAttrib * 12 + channel + 8);
1066
1067 if (offset) {
1068 indexA = ADD(indexA, offset);
1069 indexB = ADD(indexB, offset);
1070 indexC = ADD(indexC, offset);
1071 }
1072
1073 Value *va = VBROADCAST(LOAD(GEP(pAttribs, indexA)));
1074 Value *vb = VBROADCAST(LOAD(GEP(pAttribs, indexB)));
1075 Value *vc = VBROADCAST(LOAD(GEP(pAttribs, indexC)));
1076
1077 if (interpMode == TGSI_INTERPOLATE_CONSTANT) {
1078 inputs[attrib][channel] = wrap(va);
1079 } else {
1080 Value *vk = FSUB(FSUB(VIMMED1(1.0f), vi), vj);
1081
1082 vc = FMUL(vk, vc);
1083
1084 Value *interp = FMUL(va, vi);
1085 Value *interp1 = FMUL(vb, vj);
1086 interp = FADD(interp, interp1);
1087 interp = FADD(interp, vc);
1088 if (interpMode == TGSI_INTERPOLATE_PERSPECTIVE ||
1089 interpMode == TGSI_INTERPOLATE_COLOR)
1090 interp = FMUL(interp, vw);
1091 inputs[attrib][channel] = wrap(interp);
1092 }
1093 }
1094 }
1095 }
1096
1097 sampler = swr_sampler_soa_create(key.sampler, PIPE_SHADER_FRAGMENT);
1098
1099 struct lp_bld_tgsi_system_values system_values;
1100 memset(&system_values, 0, sizeof(system_values));
1101
1102 struct lp_build_mask_context mask;
1103
1104 if (swr_fs->info.base.uses_kill) {
1105 Value *mask_val = LOAD(pPS, {0, SWR_PS_CONTEXT_activeMask}, "activeMask");
1106 lp_build_mask_begin(
1107 &mask, gallivm, lp_type_float_vec(32, 32 * 8), wrap(mask_val));
1108 }
1109
1110 lp_build_tgsi_soa(gallivm,
1111 swr_fs->pipe.tokens,
1112 lp_type_float_vec(32, 32 * 8),
1113 swr_fs->info.base.uses_kill ? &mask : NULL, // mask
1114 wrap(consts_ptr),
1115 wrap(const_sizes_ptr),
1116 &system_values,
1117 inputs,
1118 outputs,
1119 wrap(hPrivateData),
1120 NULL, // thread data
1121 sampler, // sampler
1122 &swr_fs->info.base,
1123 NULL); // geometry shader face
1124
1125 sampler->destroy(sampler);
1126
1127 IRB()->SetInsertPoint(unwrap(LLVMGetInsertBlock(gallivm->builder)));
1128
1129 for (uint32_t attrib = 0; attrib < swr_fs->info.base.num_outputs;
1130 attrib++) {
1131 switch (swr_fs->info.base.output_semantic_name[attrib]) {
1132 case TGSI_SEMANTIC_POSITION: {
1133 // write z
1134 LLVMValueRef outZ =
1135 LLVMBuildLoad(gallivm->builder, outputs[attrib][2], "");
1136 STORE(unwrap(outZ), pPS, {0, SWR_PS_CONTEXT_vZ});
1137 break;
1138 }
1139 case TGSI_SEMANTIC_COLOR: {
1140 for (uint32_t channel = 0; channel < TGSI_NUM_CHANNELS; channel++) {
1141 if (!outputs[attrib][channel])
1142 continue;
1143
1144 LLVMValueRef out =
1145 LLVMBuildLoad(gallivm->builder, outputs[attrib][channel], "");
1146 if (swr_fs->info.base.properties[TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS] &&
1147 swr_fs->info.base.output_semantic_index[attrib] == 0) {
1148 for (uint32_t rt = 0; rt < key.nr_cbufs; rt++) {
1149 STORE(unwrap(out),
1150 pPS,
1151 {0, SWR_PS_CONTEXT_shaded, rt, channel});
1152 }
1153 } else {
1154 STORE(unwrap(out),
1155 pPS,
1156 {0,
1157 SWR_PS_CONTEXT_shaded,
1158 swr_fs->info.base.output_semantic_index[attrib],
1159 channel});
1160 }
1161 }
1162 break;
1163 }
1164 default: {
1165 fprintf(stderr,
1166 "unknown output from FS %s[%d]\n",
1167 tgsi_semantic_names[swr_fs->info.base
1168 .output_semantic_name[attrib]],
1169 swr_fs->info.base.output_semantic_index[attrib]);
1170 break;
1171 }
1172 }
1173 }
1174
1175 LLVMValueRef mask_result = 0;
1176 if (swr_fs->info.base.uses_kill) {
1177 mask_result = lp_build_mask_end(&mask);
1178 }
1179
1180 IRB()->SetInsertPoint(unwrap(LLVMGetInsertBlock(gallivm->builder)));
1181
1182 if (swr_fs->info.base.uses_kill) {
1183 STORE(unwrap(mask_result), pPS, {0, SWR_PS_CONTEXT_activeMask});
1184 }
1185
1186 RET_VOID();
1187
1188 gallivm_verify_function(gallivm, wrap(pFunction));
1189
1190 gallivm_compile_module(gallivm);
1191
1192 PFN_PIXEL_KERNEL kernel =
1193 (PFN_PIXEL_KERNEL)gallivm_jit_function(gallivm, wrap(pFunction));
1194 debug_printf("frag shader %p\n", kernel);
1195 assert(kernel && "Error: FragShader = NULL");
1196
1197 JM()->mIsModuleFinalized = true;
1198
1199 return kernel;
1200 }
1201
1202 PFN_PIXEL_KERNEL
1203 swr_compile_fs(struct swr_context *ctx, swr_jit_fs_key &key)
1204 {
1205 if (!ctx->fs->pipe.tokens)
1206 return NULL;
1207
1208 BuilderSWR builder(
1209 reinterpret_cast<JitManager *>(swr_screen(ctx->pipe.screen)->hJitMgr),
1210 "FS");
1211 PFN_PIXEL_KERNEL func = builder.CompileFS(ctx, key);
1212
1213 ctx->fs->map.insert(std::make_pair(key, make_unique<VariantFS>(builder.gallivm, func)));
1214 return func;
1215 }