projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
draw: cliptest and viewport done in a single loop in vertex shader
[mesa.git] / src / gallium / auxiliary / draw / draw_llvm.c
1 /**************************************************************************
2 *
3 * Copyright 2010 VMware, Inc.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 #include "draw_llvm.h"
29
30 #include "draw_context.h"
31 #include "draw_vs.h"
32
33 #include "gallivm/lp_bld_arit.h"
34 #include "gallivm/lp_bld_logic.h"
35 #include "gallivm/lp_bld_const.h"
36 #include "gallivm/lp_bld_swizzle.h"
37 #include "gallivm/lp_bld_struct.h"
38 #include "gallivm/lp_bld_type.h"
39 #include "gallivm/lp_bld_flow.h"
40 #include "gallivm/lp_bld_debug.h"
41 #include "gallivm/lp_bld_tgsi.h"
42 #include "gallivm/lp_bld_printf.h"
43 #include "gallivm/lp_bld_intr.h"
44 #include "gallivm/lp_bld_init.h"
45
46 #include "tgsi/tgsi_exec.h"
47 #include "tgsi/tgsi_dump.h"
48
49 #include "util/u_cpu_detect.h"
50 #include "util/u_pointer.h"
51 #include "util/u_string.h"
52
53 #include <llvm-c/Transforms/Scalar.h>
54
55 #define DEBUG_STORE 0
56
57 /* generates the draw jit function */
58 static void
59 draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *var);
60 static void
61 draw_llvm_generate_elts(struct draw_llvm *llvm, struct draw_llvm_variant *var);
62
63 static void
64 init_globals(struct draw_llvm *llvm)
65 {
66 LLVMTypeRef texture_type;
67
68 /* struct draw_jit_texture */
69 {
70 LLVMTypeRef elem_types[DRAW_JIT_TEXTURE_NUM_FIELDS];
71
72 elem_types[DRAW_JIT_TEXTURE_WIDTH] = LLVMInt32Type();
73 elem_types[DRAW_JIT_TEXTURE_HEIGHT] = LLVMInt32Type();
74 elem_types[DRAW_JIT_TEXTURE_DEPTH] = LLVMInt32Type();
75 elem_types[DRAW_JIT_TEXTURE_LAST_LEVEL] = LLVMInt32Type();
76 elem_types[DRAW_JIT_TEXTURE_ROW_STRIDE] =
77 LLVMArrayType(LLVMInt32Type(), DRAW_MAX_TEXTURE_LEVELS);
78 elem_types[DRAW_JIT_TEXTURE_IMG_STRIDE] =
79 LLVMArrayType(LLVMInt32Type(), DRAW_MAX_TEXTURE_LEVELS);
80 elem_types[DRAW_JIT_TEXTURE_DATA] =
81 LLVMArrayType(LLVMPointerType(LLVMInt8Type(), 0),
82 DRAW_MAX_TEXTURE_LEVELS);
83 elem_types[DRAW_JIT_TEXTURE_MIN_LOD] = LLVMFloatType();
84 elem_types[DRAW_JIT_TEXTURE_MAX_LOD] = LLVMFloatType();
85 elem_types[DRAW_JIT_TEXTURE_LOD_BIAS] = LLVMFloatType();
86 elem_types[DRAW_JIT_TEXTURE_BORDER_COLOR] =
87 LLVMArrayType(LLVMFloatType(), 4);
88
89 texture_type = LLVMStructType(elem_types, Elements(elem_types), 0);
90
91 LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, width,
92 llvm->target, texture_type,
93 DRAW_JIT_TEXTURE_WIDTH);
94 LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, height,
95 llvm->target, texture_type,
96 DRAW_JIT_TEXTURE_HEIGHT);
97 LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, depth,
98 llvm->target, texture_type,
99 DRAW_JIT_TEXTURE_DEPTH);
100 LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, last_level,
101 llvm->target, texture_type,
102 DRAW_JIT_TEXTURE_LAST_LEVEL);
103 LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, row_stride,
104 llvm->target, texture_type,
105 DRAW_JIT_TEXTURE_ROW_STRIDE);
106 LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, img_stride,
107 llvm->target, texture_type,
108 DRAW_JIT_TEXTURE_IMG_STRIDE);
109 LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, data,
110 llvm->target, texture_type,
111 DRAW_JIT_TEXTURE_DATA);
112 LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, min_lod,
113 llvm->target, texture_type,
114 DRAW_JIT_TEXTURE_MIN_LOD);
115 LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, max_lod,
116 llvm->target, texture_type,
117 DRAW_JIT_TEXTURE_MAX_LOD);
118 LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, lod_bias,
119 llvm->target, texture_type,
120 DRAW_JIT_TEXTURE_LOD_BIAS);
121 LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, border_color,
122 llvm->target, texture_type,
123 DRAW_JIT_TEXTURE_BORDER_COLOR);
124 LP_CHECK_STRUCT_SIZE(struct draw_jit_texture,
125 llvm->target, texture_type);
126
127 LLVMAddTypeName(llvm->module, "texture", texture_type);
128 }
129
130
131 /* struct draw_jit_context */
132 {
133 LLVMTypeRef elem_types[3];
134 LLVMTypeRef context_type;
135
136 elem_types[0] = LLVMPointerType(LLVMFloatType(), 0); /* vs_constants */
137 elem_types[1] = LLVMPointerType(LLVMFloatType(), 0); /* vs_constants */
138 elem_types[2] = LLVMArrayType(texture_type,
139 PIPE_MAX_VERTEX_SAMPLERS); /* textures */
140
141 context_type = LLVMStructType(elem_types, Elements(elem_types), 0);
142
143 LP_CHECK_MEMBER_OFFSET(struct draw_jit_context, vs_constants,
144 llvm->target, context_type, 0);
145 LP_CHECK_MEMBER_OFFSET(struct draw_jit_context, gs_constants,
146 llvm->target, context_type, 1);
147 LP_CHECK_MEMBER_OFFSET(struct draw_jit_context, textures,
148 llvm->target, context_type,
149 DRAW_JIT_CTX_TEXTURES);
150 LP_CHECK_STRUCT_SIZE(struct draw_jit_context,
151 llvm->target, context_type);
152
153 LLVMAddTypeName(llvm->module, "draw_jit_context", context_type);
154
155 llvm->context_ptr_type = LLVMPointerType(context_type, 0);
156 }
157 {
158 LLVMTypeRef buffer_ptr = LLVMPointerType(LLVMIntType(8), 0);
159 llvm->buffer_ptr_type = LLVMPointerType(buffer_ptr, 0);
160 }
161 /* struct pipe_vertex_buffer */
162 {
163 LLVMTypeRef elem_types[4];
164 LLVMTypeRef vb_type;
165
166 elem_types[0] = LLVMInt32Type();
167 elem_types[1] = LLVMInt32Type();
168 elem_types[2] = LLVMInt32Type();
169 elem_types[3] = LLVMPointerType(LLVMOpaqueType(), 0); /* vs_constants */
170
171 vb_type = LLVMStructType(elem_types, Elements(elem_types), 0);
172
173 LP_CHECK_MEMBER_OFFSET(struct pipe_vertex_buffer, stride,
174 llvm->target, vb_type, 0);
175 LP_CHECK_MEMBER_OFFSET(struct pipe_vertex_buffer, buffer_offset,
176 llvm->target, vb_type, 2);
177 LP_CHECK_STRUCT_SIZE(struct pipe_vertex_buffer,
178 llvm->target, vb_type);
179
180 LLVMAddTypeName(llvm->module, "pipe_vertex_buffer", vb_type);
181
182 llvm->vb_ptr_type = LLVMPointerType(vb_type, 0);
183 }
184 }
185
186 static LLVMTypeRef
187 create_vertex_header(struct draw_llvm *llvm, int data_elems)
188 {
189 /* struct vertex_header */
190 LLVMTypeRef elem_types[3];
191 LLVMTypeRef vertex_header;
192 char struct_name[24];
193
194 util_snprintf(struct_name, 23, "vertex_header%d", data_elems);
195
196 elem_types[0] = LLVMIntType(32);
197 elem_types[1] = LLVMArrayType(LLVMFloatType(), 4);
198 elem_types[2] = LLVMArrayType(elem_types[1], data_elems);
199
200 vertex_header = LLVMStructType(elem_types, Elements(elem_types), 0);
201
202 /* these are bit-fields and we can't take address of them
203 LP_CHECK_MEMBER_OFFSET(struct vertex_header, clipmask,
204 llvm->target, vertex_header,
205 DRAW_JIT_VERTEX_CLIPMASK);
206 LP_CHECK_MEMBER_OFFSET(struct vertex_header, edgeflag,
207 llvm->target, vertex_header,
208 DRAW_JIT_VERTEX_EDGEFLAG);
209 LP_CHECK_MEMBER_OFFSET(struct vertex_header, pad,
210 llvm->target, vertex_header,
211 DRAW_JIT_VERTEX_PAD);
212 LP_CHECK_MEMBER_OFFSET(struct vertex_header, vertex_id,
213 llvm->target, vertex_header,
214 DRAW_JIT_VERTEX_VERTEX_ID);
215 */
216 LP_CHECK_MEMBER_OFFSET(struct vertex_header, clip,
217 llvm->target, vertex_header,
218 DRAW_JIT_VERTEX_CLIP);
219 LP_CHECK_MEMBER_OFFSET(struct vertex_header, data,
220 llvm->target, vertex_header,
221 DRAW_JIT_VERTEX_DATA);
222
223 LLVMAddTypeName(llvm->module, struct_name, vertex_header);
224
225 return LLVMPointerType(vertex_header, 0);
226 }
227
228 struct draw_llvm *
229 draw_llvm_create(struct draw_context *draw)
230 {
231 struct draw_llvm *llvm;
232
233 llvm = CALLOC_STRUCT( draw_llvm );
234 if (!llvm)
235 return NULL;
236
237 llvm->draw = draw;
238 llvm->engine = draw->engine;
239
240 debug_assert(llvm->engine);
241
242 llvm->module = LLVMModuleCreateWithName("draw_llvm");
243 llvm->provider = LLVMCreateModuleProviderForExistingModule(llvm->module);
244
245 LLVMAddModuleProvider(llvm->engine, llvm->provider);
246
247 llvm->target = LLVMGetExecutionEngineTargetData(llvm->engine);
248
249 llvm->pass = LLVMCreateFunctionPassManager(llvm->provider);
250 LLVMAddTargetData(llvm->target, llvm->pass);
251
252 if ((gallivm_debug & GALLIVM_DEBUG_NO_OPT) == 0) {
253 /* These are the passes currently listed in llvm-c/Transforms/Scalar.h,
254 * but there are more on SVN. */
255 /* TODO: Add more passes */
256
257 LLVMAddCFGSimplificationPass(llvm->pass);
258
259 if (HAVE_LLVM >= 0x207 && sizeof(void*) == 4) {
260 /* For LLVM >= 2.7 and 32-bit build, use this order of passes to
261 * avoid generating bad code.
262 * Test with piglit glsl-vs-sqrt-zero test.
263 */
264 LLVMAddConstantPropagationPass(llvm->pass);
265 LLVMAddPromoteMemoryToRegisterPass(llvm->pass);
266 }
267 else {
268 LLVMAddPromoteMemoryToRegisterPass(llvm->pass);
269 LLVMAddConstantPropagationPass(llvm->pass);
270 }
271
272 if(util_cpu_caps.has_sse4_1) {
273 /* FIXME: There is a bug in this pass, whereby the combination of fptosi
274 * and sitofp (necessary for trunc/floor/ceil/round implementation)
275 * somehow becomes invalid code.
276 */
277 LLVMAddInstructionCombiningPass(llvm->pass);
278 }
279 LLVMAddGVNPass(llvm->pass);
280 } else {
281 /* We need at least this pass to prevent the backends to fail in
282 * unexpected ways.
283 */
284 LLVMAddPromoteMemoryToRegisterPass(llvm->pass);
285 }
286
287 init_globals(llvm);
288
289 if (gallivm_debug & GALLIVM_DEBUG_IR) {
290 LLVMDumpModule(llvm->module);
291 }
292
293 llvm->nr_variants = 0;
294 make_empty_list(&llvm->vs_variants_list);
295
296 return llvm;
297 }
298
299 void
300 draw_llvm_destroy(struct draw_llvm *llvm)
301 {
302 LLVMDisposePassManager(llvm->pass);
303
304 FREE(llvm);
305 }
306
307 struct draw_llvm_variant *
308 draw_llvm_create_variant(struct draw_llvm *llvm,
309 unsigned num_inputs,
310 const struct draw_llvm_variant_key *key)
311 {
312 struct draw_llvm_variant *variant;
313 struct llvm_vertex_shader *shader =
314 llvm_vertex_shader(llvm->draw->vs.vertex_shader);
315
316 variant = MALLOC(sizeof *variant +
317 shader->variant_key_size -
318 sizeof variant->key);
319 if (variant == NULL)
320 return NULL;
321
322 variant->llvm = llvm;
323
324 memcpy(&variant->key, key, shader->variant_key_size);
325
326 llvm->vertex_header_ptr_type = create_vertex_header(llvm, num_inputs);
327
328 draw_llvm_generate(llvm, variant);
329 draw_llvm_generate_elts(llvm, variant);
330
331 variant->shader = shader;
332 variant->list_item_global.base = variant;
333 variant->list_item_local.base = variant;
334 /*variant->no = */shader->variants_created++;
335 variant->list_item_global.base = variant;
336
337 return variant;
338 }
339
340 static void
341 generate_vs(struct draw_llvm *llvm,
342 LLVMBuilderRef builder,
343 LLVMValueRef (*outputs)[NUM_CHANNELS],
344 const LLVMValueRef (*inputs)[NUM_CHANNELS],
345 LLVMValueRef context_ptr,
346 struct lp_build_sampler_soa *draw_sampler)
347 {
348 const struct tgsi_token *tokens = llvm->draw->vs.vertex_shader->state.tokens;
349 struct lp_type vs_type;
350 LLVMValueRef consts_ptr = draw_jit_context_vs_constants(builder, context_ptr);
351 struct lp_build_sampler_soa *sampler = 0;
352
353 memset(&vs_type, 0, sizeof vs_type);
354 vs_type.floating = TRUE; /* floating point values */
355 vs_type.sign = TRUE; /* values are signed */
356 vs_type.norm = FALSE; /* values are not limited to [0,1] or [-1,1] */
357 vs_type.width = 32; /* 32-bit float */
358 vs_type.length = 4; /* 4 elements per vector */
359 #if 0
360 num_vs = 4; /* number of vertices per block */
361 #endif
362
363 if (gallivm_debug & GALLIVM_DEBUG_IR) {
364 tgsi_dump(tokens, 0);
365 }
366
367 if (llvm->draw->num_sampler_views &&
368 llvm->draw->num_samplers)
369 sampler = draw_sampler;
370
371 lp_build_tgsi_soa(builder,
372 tokens,
373 vs_type,
374 NULL /*struct lp_build_mask_context *mask*/,
375 consts_ptr,
376 NULL /*pos*/,
377 inputs,
378 outputs,
379 sampler,
380 &llvm->draw->vs.vertex_shader->info);
381 }
382
383 #if DEBUG_STORE
384 static void print_vectorf(LLVMBuilderRef builder,
385 LLVMValueRef vec)
386 {
387 LLVMValueRef val[4];
388 val[0] = LLVMBuildExtractElement(builder, vec,
389 LLVMConstInt(LLVMInt32Type(), 0, 0), "");
390 val[1] = LLVMBuildExtractElement(builder, vec,
391 LLVMConstInt(LLVMInt32Type(), 1, 0), "");
392 val[2] = LLVMBuildExtractElement(builder, vec,
393 LLVMConstInt(LLVMInt32Type(), 2, 0), "");
394 val[3] = LLVMBuildExtractElement(builder, vec,
395 LLVMConstInt(LLVMInt32Type(), 3, 0), "");
396 lp_build_printf(builder, "vector = [%f, %f, %f, %f]\n",
397 val[0], val[1], val[2], val[3]);
398 }
399 #endif
400
401 static void
402 generate_fetch(LLVMBuilderRef builder,
403 LLVMValueRef vbuffers_ptr,
404 LLVMValueRef *res,
405 struct pipe_vertex_element *velem,
406 LLVMValueRef vbuf,
407 LLVMValueRef index,
408 LLVMValueRef instance_id)
409 {
410 LLVMValueRef indices = LLVMConstInt(LLVMInt64Type(), velem->vertex_buffer_index, 0);
411 LLVMValueRef vbuffer_ptr = LLVMBuildGEP(builder, vbuffers_ptr,
412 &indices, 1, "");
413 LLVMValueRef vb_stride = draw_jit_vbuffer_stride(builder, vbuf);
414 LLVMValueRef vb_max_index = draw_jit_vbuffer_max_index(builder, vbuf);
415 LLVMValueRef vb_buffer_offset = draw_jit_vbuffer_offset(builder, vbuf);
416 LLVMValueRef cond;
417 LLVMValueRef stride;
418
419 if (velem->instance_divisor) {
420 /* array index = instance_id / instance_divisor */
421 index = LLVMBuildUDiv(builder, instance_id,
422 LLVMConstInt(LLVMInt32Type(), velem->instance_divisor, 0),
423 "instance_divisor");
424 }
425
426 /* limit index to min(inex, vb_max_index) */
427 cond = LLVMBuildICmp(builder, LLVMIntULE, index, vb_max_index, "");
428 index = LLVMBuildSelect(builder, cond, index, vb_max_index, "");
429
430 stride = LLVMBuildMul(builder, vb_stride, index, "");
431
432 vbuffer_ptr = LLVMBuildLoad(builder, vbuffer_ptr, "vbuffer");
433
434 stride = LLVMBuildAdd(builder, stride,
435 vb_buffer_offset,
436 "");
437 stride = LLVMBuildAdd(builder, stride,
438 LLVMConstInt(LLVMInt32Type(), velem->src_offset, 0),
439 "");
440
441 /*lp_build_printf(builder, "vbuf index = %d, stride is %d\n", indices, stride);*/
442 vbuffer_ptr = LLVMBuildGEP(builder, vbuffer_ptr, &stride, 1, "");
443
444 *res = draw_llvm_translate_from(builder, vbuffer_ptr, velem->src_format);
445 }
446
447 static LLVMValueRef
448 aos_to_soa(LLVMBuilderRef builder,
449 LLVMValueRef val0,
450 LLVMValueRef val1,
451 LLVMValueRef val2,
452 LLVMValueRef val3,
453 LLVMValueRef channel)
454 {
455 LLVMValueRef ex, res;
456
457 ex = LLVMBuildExtractElement(builder, val0,
458 channel, "");
459 res = LLVMBuildInsertElement(builder,
460 LLVMConstNull(LLVMTypeOf(val0)),
461 ex,
462 LLVMConstInt(LLVMInt32Type(), 0, 0),
463 "");
464
465 ex = LLVMBuildExtractElement(builder, val1,
466 channel, "");
467 res = LLVMBuildInsertElement(builder,
468 res, ex,
469 LLVMConstInt(LLVMInt32Type(), 1, 0),
470 "");
471
472 ex = LLVMBuildExtractElement(builder, val2,
473 channel, "");
474 res = LLVMBuildInsertElement(builder,
475 res, ex,
476 LLVMConstInt(LLVMInt32Type(), 2, 0),
477 "");
478
479 ex = LLVMBuildExtractElement(builder, val3,
480 channel, "");
481 res = LLVMBuildInsertElement(builder,
482 res, ex,
483 LLVMConstInt(LLVMInt32Type(), 3, 0),
484 "");
485
486 return res;
487 }
488
489 static void
490 soa_to_aos(LLVMBuilderRef builder,
491 LLVMValueRef soa[NUM_CHANNELS],
492 LLVMValueRef aos[NUM_CHANNELS])
493 {
494 LLVMValueRef comp;
495 int i = 0;
496
497 debug_assert(NUM_CHANNELS == 4);
498
499 aos[0] = LLVMConstNull(LLVMTypeOf(soa[0]));
500 aos[1] = aos[2] = aos[3] = aos[0];
501
502 for (i = 0; i < NUM_CHANNELS; ++i) {
503 LLVMValueRef channel = LLVMConstInt(LLVMInt32Type(), i, 0);
504
505 comp = LLVMBuildExtractElement(builder, soa[i],
506 LLVMConstInt(LLVMInt32Type(), 0, 0), "");
507 aos[0] = LLVMBuildInsertElement(builder, aos[0], comp, channel, "");
508
509 comp = LLVMBuildExtractElement(builder, soa[i],
510 LLVMConstInt(LLVMInt32Type(), 1, 0), "");
511 aos[1] = LLVMBuildInsertElement(builder, aos[1], comp, channel, "");
512
513 comp = LLVMBuildExtractElement(builder, soa[i],
514 LLVMConstInt(LLVMInt32Type(), 2, 0), "");
515 aos[2] = LLVMBuildInsertElement(builder, aos[2], comp, channel, "");
516
517 comp = LLVMBuildExtractElement(builder, soa[i],
518 LLVMConstInt(LLVMInt32Type(), 3, 0), "");
519 aos[3] = LLVMBuildInsertElement(builder, aos[3], comp, channel, "");
520
521 }
522 }
523
524 static void
525 convert_to_soa(LLVMBuilderRef builder,
526 LLVMValueRef (*aos)[NUM_CHANNELS],
527 LLVMValueRef (*soa)[NUM_CHANNELS],
528 int num_attribs)
529 {
530 int i;
531
532 debug_assert(NUM_CHANNELS == 4);
533
534 for (i = 0; i < num_attribs; ++i) {
535 LLVMValueRef val0 = aos[i][0];
536 LLVMValueRef val1 = aos[i][1];
537 LLVMValueRef val2 = aos[i][2];
538 LLVMValueRef val3 = aos[i][3];
539
540 soa[i][0] = aos_to_soa(builder, val0, val1, val2, val3,
541 LLVMConstInt(LLVMInt32Type(), 0, 0));
542 soa[i][1] = aos_to_soa(builder, val0, val1, val2, val3,
543 LLVMConstInt(LLVMInt32Type(), 1, 0));
544 soa[i][2] = aos_to_soa(builder, val0, val1, val2, val3,
545 LLVMConstInt(LLVMInt32Type(), 2, 0));
546 soa[i][3] = aos_to_soa(builder, val0, val1, val2, val3,
547 LLVMConstInt(LLVMInt32Type(), 3, 0));
548 }
549 }
550
551 static void
552 store_aos(LLVMBuilderRef builder,
553 LLVMValueRef io_ptr,
554 LLVMValueRef index,
555 LLVMValueRef value,
556 LLVMValueRef clipmask)
557 {
558 LLVMValueRef id_ptr = draw_jit_header_id(builder, io_ptr);
559 LLVMValueRef data_ptr = draw_jit_header_data(builder, io_ptr);
560 LLVMValueRef indices[3];
561 LLVMValueRef val, shift;
562
563 indices[0] = LLVMConstInt(LLVMInt32Type(), 0, 0);
564 indices[1] = index;
565 indices[2] = LLVMConstInt(LLVMInt32Type(), 0, 0);
566
567 /* initialize vertex id:16 = 0xffff, pad:3 = 0, edgeflag:1 = 1 */
568 val = LLVMConstInt(LLVMInt32Type(), 0xffff1, 0);
569 shift = LLVMConstInt(LLVMInt32Type(), 12, 0);
570 val = LLVMBuildShl(builder, val, shift, "");
571 /* add clipmask:12 */
572 val = LLVMBuildOr(builder, val, clipmask, "");
573
574 /* store vertex header */
575 LLVMBuildStore(builder, val, id_ptr);
576
577
578 #if DEBUG_STORE
579 lp_build_printf(builder, " ---- %p storing attribute %d (io = %p)\n", data_ptr, index, io_ptr);
580 #endif
581 #if 0
582 /*lp_build_printf(builder, " ---- %p storing at %d (%p) ", io_ptr, index, data_ptr);
583 print_vectorf(builder, value);*/
584 data_ptr = LLVMBuildBitCast(builder, data_ptr,
585 LLVMPointerType(LLVMArrayType(LLVMVectorType(LLVMFloatType(), 4), 0), 0),
586 "datavec");
587 data_ptr = LLVMBuildGEP(builder, data_ptr, indices, 2, "");
588
589 LLVMBuildStore(builder, value, data_ptr);
590 #else
591 {
592 LLVMValueRef x, y, z, w;
593 LLVMValueRef idx0, idx1, idx2, idx3;
594 LLVMValueRef gep0, gep1, gep2, gep3;
595 data_ptr = LLVMBuildGEP(builder, data_ptr, indices, 3, "");
596
597 idx0 = LLVMConstInt(LLVMInt32Type(), 0, 0);
598 idx1 = LLVMConstInt(LLVMInt32Type(), 1, 0);
599 idx2 = LLVMConstInt(LLVMInt32Type(), 2, 0);
600 idx3 = LLVMConstInt(LLVMInt32Type(), 3, 0);
601
602 x = LLVMBuildExtractElement(builder, value,
603 idx0, "");
604 y = LLVMBuildExtractElement(builder, value,
605 idx1, "");
606 z = LLVMBuildExtractElement(builder, value,
607 idx2, "");
608 w = LLVMBuildExtractElement(builder, value,
609 idx3, "");
610
611 gep0 = LLVMBuildGEP(builder, data_ptr, &idx0, 1, "");
612 gep1 = LLVMBuildGEP(builder, data_ptr, &idx1, 1, "");
613 gep2 = LLVMBuildGEP(builder, data_ptr, &idx2, 1, "");
614 gep3 = LLVMBuildGEP(builder, data_ptr, &idx3, 1, "");
615
616 /*lp_build_printf(builder, "##### x = %f (%p), y = %f (%p), z = %f (%p), w = %f (%p)\n",
617 x, gep0, y, gep1, z, gep2, w, gep3);*/
618 LLVMBuildStore(builder, x, gep0);
619 LLVMBuildStore(builder, y, gep1);
620 LLVMBuildStore(builder, z, gep2);
621 LLVMBuildStore(builder, w, gep3);
622 }
623 #endif
624 }
625
626 static void
627 store_aos_array(LLVMBuilderRef builder,
628 LLVMValueRef io_ptr,
629 LLVMValueRef aos[NUM_CHANNELS],
630 int attrib,
631 int num_outputs,
632 LLVMValueRef clipmask)
633 {
634 LLVMValueRef attr_index = LLVMConstInt(LLVMInt32Type(), attrib, 0);
635 LLVMValueRef ind0 = LLVMConstInt(LLVMInt32Type(), 0, 0);
636 LLVMValueRef ind1 = LLVMConstInt(LLVMInt32Type(), 1, 0);
637 LLVMValueRef ind2 = LLVMConstInt(LLVMInt32Type(), 2, 0);
638 LLVMValueRef ind3 = LLVMConstInt(LLVMInt32Type(), 3, 0);
639 LLVMValueRef io0_ptr, io1_ptr, io2_ptr, io3_ptr;
640 LLVMValueRef clipmask0, clipmask1, clipmask2, clipmask3;
641
642 debug_assert(NUM_CHANNELS == 4);
643
644 io0_ptr = LLVMBuildGEP(builder, io_ptr,
645 &ind0, 1, "");
646 io1_ptr = LLVMBuildGEP(builder, io_ptr,
647 &ind1, 1, "");
648 io2_ptr = LLVMBuildGEP(builder, io_ptr,
649 &ind2, 1, "");
650 io3_ptr = LLVMBuildGEP(builder, io_ptr,
651 &ind3, 1, "");
652
653 clipmask0 = LLVMBuildExtractElement(builder, clipmask,
654 ind0, "");
655 clipmask1 = LLVMBuildExtractElement(builder, clipmask,
656 ind1, "");
657 clipmask2 = LLVMBuildExtractElement(builder, clipmask,
658 ind2, "");
659 clipmask3 = LLVMBuildExtractElement(builder, clipmask,
660 ind3, "");
661
662 #if DEBUG_STORE
663 lp_build_printf(builder, "io = %p, indexes[%d, %d, %d, %d]\n, clipmask0 = %x, clipmask1 = %x, clipmask2 = %x, clipmask3 = %x\n",
664 io_ptr, ind0, ind1, ind2, ind3, clipmask0, clipmask1, clipmask2, clipmask3);
665 #endif
666 /* store for each of the 4 vertices */
667 store_aos(builder, io0_ptr, attr_index, aos[0], clipmask0);
668 store_aos(builder, io1_ptr, attr_index, aos[1], clipmask1);
669 store_aos(builder, io2_ptr, attr_index, aos[2], clipmask2);
670 store_aos(builder, io3_ptr, attr_index, aos[3], clipmask3);
671 }
672
673 static void
674 convert_to_aos(LLVMBuilderRef builder,
675 LLVMValueRef io,
676 LLVMValueRef (*outputs)[NUM_CHANNELS],
677 LLVMValueRef clipmask,
678 int num_outputs,
679 int max_vertices)
680 {
681 unsigned chan, attrib;
682
683 #if DEBUG_STORE
684 lp_build_printf(builder, " # storing begin\n");
685 #endif
686 for (attrib = 0; attrib < num_outputs; ++attrib) {
687 LLVMValueRef soa[4];
688 LLVMValueRef aos[4];
689 for(chan = 0; chan < NUM_CHANNELS; ++chan) {
690 if(outputs[attrib][chan]) {
691 LLVMValueRef out = LLVMBuildLoad(builder, outputs[attrib][chan], "");
692 lp_build_name(out, "output%u.%c", attrib, "xyzw"[chan]);
693 /*lp_build_printf(builder, "output %d : %d ",
694 LLVMConstInt(LLVMInt32Type(), attrib, 0),
695 LLVMConstInt(LLVMInt32Type(), chan, 0));
696 print_vectorf(builder, out);*/
697 soa[chan] = out;
698 } else
699 soa[chan] = 0;
700 }
701 soa_to_aos(builder, soa, aos);
702 store_aos_array(builder,
703 io,
704 aos,
705 attrib,
706 num_outputs,
707 clipmask);
708 }
709 #if DEBUG_STORE
710 lp_build_printf(builder, " # storing end\n");
711 #endif
712 }
713
714 /*
715 * Stores original vertex positions in clip coordinates
716 * There is probably a more efficient way to do this, 4 floats at once
717 * rather than extracting each element one by one.
718 */
719 static void
720 store_clip(LLVMBuilderRef builder,
721 LLVMValueRef io_ptr,
722 LLVMValueRef (*outputs)[NUM_CHANNELS])
723 {
724 LLVMValueRef out[4];
725 LLVMValueRef indices[2];
726 LLVMValueRef io0_ptr, io1_ptr, io2_ptr, io3_ptr;
727 LLVMValueRef clip_ptr0, clip_ptr1, clip_ptr2, clip_ptr3;
728 LLVMValueRef clip0_ptr, clip1_ptr, clip2_ptr, clip3_ptr;
729 LLVMValueRef out0elem, out1elem, out2elem, out3elem;
730
731 LLVMValueRef ind0 = LLVMConstInt(LLVMInt32Type(), 0, 0);
732 LLVMValueRef ind1 = LLVMConstInt(LLVMInt32Type(), 1, 0);
733 LLVMValueRef ind2 = LLVMConstInt(LLVMInt32Type(), 2, 0);
734 LLVMValueRef ind3 = LLVMConstInt(LLVMInt32Type(), 3, 0);
735
736 indices[0] = LLVMConstInt(LLVMInt32Type(), 0, 0);
737 indices[1] = LLVMConstInt(LLVMInt32Type(), 0, 0);
738
739 out[0] = LLVMBuildLoad(builder, outputs[0][0], ""); /*x0 y0 z0 w0*/
740 out[1] = LLVMBuildLoad(builder, outputs[0][1], ""); /*x1 y1 z1 w1*/
741 out[2] = LLVMBuildLoad(builder, outputs[0][2], ""); /*x2 y2 z2 w2*/
742 out[3] = LLVMBuildLoad(builder, outputs[0][3], ""); /*x3 y3 z3 w3*/
743
744 io0_ptr = LLVMBuildGEP(builder, io_ptr, &ind0, 1, "");
745 io1_ptr = LLVMBuildGEP(builder, io_ptr, &ind1, 1, "");
746 io2_ptr = LLVMBuildGEP(builder, io_ptr, &ind2, 1, "");
747 io3_ptr = LLVMBuildGEP(builder, io_ptr, &ind3, 1, "");
748
749 clip_ptr0 = draw_jit_header_clip(builder, io0_ptr);
750 clip_ptr1 = draw_jit_header_clip(builder, io1_ptr);
751 clip_ptr2 = draw_jit_header_clip(builder, io2_ptr);
752 clip_ptr3 = draw_jit_header_clip(builder, io3_ptr);
753
754 for (int i = 0; i<4; i++){
755 clip0_ptr = LLVMBuildGEP(builder, clip_ptr0,
756 indices, 2, ""); //x1
757 clip1_ptr = LLVMBuildGEP(builder, clip_ptr1,
758 indices, 2, ""); //y1
759 clip2_ptr = LLVMBuildGEP(builder, clip_ptr2,
760 indices, 2, ""); //z1
761 clip3_ptr = LLVMBuildGEP(builder, clip_ptr3,
762 indices, 2, ""); //w1
763
764 out0elem = LLVMBuildExtractElement(builder, out[0],
765 indices[1], ""); //x1
766 out1elem = LLVMBuildExtractElement(builder, out[1],
767 indices[1], ""); //y1
768 out2elem = LLVMBuildExtractElement(builder, out[2],
769 indices[1], ""); //z1
770 out3elem = LLVMBuildExtractElement(builder, out[3],
771 indices[1], ""); //w1
772
773 LLVMBuildStore(builder, out0elem, clip0_ptr);
774 LLVMBuildStore(builder, out1elem, clip1_ptr);
775 LLVMBuildStore(builder, out2elem, clip2_ptr);
776 LLVMBuildStore(builder, out3elem, clip3_ptr);
777
778 indices[1]= LLVMBuildAdd(builder, indices[1], ind1, "");
779 }
780
781 }
782
783 /*
784 * Transforms the outputs for viewport mapping
785 */
786 static void
787 generate_viewport(struct draw_llvm *llvm,
788 LLVMBuilderRef builder,
789 LLVMValueRef (*outputs)[NUM_CHANNELS])
790 {
791 int i;
792 const float *scaleA = llvm->draw->viewport.scale;
793 const float *transA = llvm->draw->viewport.translate;
794 struct lp_type f32_type = lp_type_float_vec(32);
795 LLVMValueRef out3 = LLVMBuildLoad(builder, outputs[0][3], ""); /*w0 w1 w2 w3*/
796 LLVMValueRef const1 = lp_build_const_vec(f32_type, 1.0); /*1.0 1.0 1.0 1.0*/
797
798 /* for 1/w convention*/
799 out3 = LLVMBuildFDiv(builder, const1, out3, "");
800
801 /* Viewport Mapping */
802 for (i=0; i<4; i++){
803 LLVMValueRef out = LLVMBuildLoad(builder, outputs[0][i], ""); /*x0 x1 x2 x3*/
804 LLVMValueRef scale = lp_build_const_vec(f32_type, scaleA[i]); /*sx sx sx sx*/
805 LLVMValueRef trans = lp_build_const_vec(f32_type, transA[i]); /*tx tx tx tx*/
806
807 /* divide by w */
808 out = LLVMBuildMul(builder, out, out3, "");
809 /* mult by scale */
810 out = LLVMBuildMul(builder, out, scale, "");
811 /* add translation */
812 out = LLVMBuildAdd(builder, out, trans, "");
813
814 /* store transformed outputs */
815 LLVMBuildStore(builder, out, outputs[0][i]);
816 }
817
818 }
819
820 /*
821 * Returns clipmask as 4xi32 bitmask for the 4 vertices
822 */
823 static LLVMValueRef
824 generate_clipmask(LLVMBuilderRef builder,
825 LLVMValueRef (*outputs)[NUM_CHANNELS])
826 {
827 LLVMValueRef mask; /* stores the <4xi32> clipmasks */
828 LLVMValueRef test, temp;
829 LLVMValueRef zero, shift;
830 LLVMValueRef pos_x, pos_y, pos_z, pos_w;
831
832 struct lp_type f32_type = lp_type_float_vec(32);
833
834 zero = lp_build_const_vec(f32_type, 0); /* 0.0f 0.0f 0.0f 0.0f */
835 shift = lp_build_const_int_vec(lp_type_int_vec(32), 1); /* 1 1 1 1 */
836
837 /* Assuming position stored at output[0] */
838 pos_x = LLVMBuildLoad(builder, outputs[0][0], ""); /*x0 x1 x2 x3*/
839 pos_y = LLVMBuildLoad(builder, outputs[0][1], ""); /*y0 y1 y2 y3*/
840 pos_z = LLVMBuildLoad(builder, outputs[0][2], ""); /*z0 z1 z2 z3*/
841 pos_w = LLVMBuildLoad(builder, outputs[0][3], ""); /*w0 w1 w2 w3*/
842
843 /* Cliptest, for hardwired planes */
844 /* plane 1 */
845 test = lp_build_compare(builder, f32_type, PIPE_FUNC_GREATER, pos_x , pos_w);
846 temp = shift;
847 test = LLVMBuildAnd(builder, test, temp, "");
848 mask = test;
849
850 /* plane 2 */
851 test = LLVMBuildFAdd(builder, pos_x, pos_w, "");
852 test = lp_build_compare(builder, f32_type, PIPE_FUNC_GREATER, zero, test);
853 temp = LLVMBuildShl(builder, temp, shift, "");
854 test = LLVMBuildAnd(builder, test, temp, "");
855 mask = LLVMBuildOr(builder, mask, test, "");
856
857 /* plane 3 */
858 test = lp_build_compare(builder, f32_type, PIPE_FUNC_GREATER, pos_y, pos_w);
859 temp = LLVMBuildShl(builder, temp, shift, "");
860 test = LLVMBuildAnd(builder, test, temp, "");
861 mask = LLVMBuildOr(builder, mask, test, "");
862
863 /* plane 4 */
864 test = LLVMBuildFAdd(builder, pos_y, pos_w, "");
865 test = lp_build_compare(builder, f32_type, PIPE_FUNC_GREATER, zero, test);
866 temp = LLVMBuildShl(builder, temp, shift, "");
867 test = LLVMBuildAnd(builder, test, temp, "");
868 mask = LLVMBuildOr(builder, mask, test, "");
869
870 /* plane 5 */
871 test = LLVMBuildFAdd(builder, pos_z, pos_w, "");
872 test = lp_build_compare(builder, f32_type, PIPE_FUNC_GREATER, zero, test);
873 temp = LLVMBuildShl(builder, temp, shift, "");
874 test = LLVMBuildAnd(builder, test, temp, "");
875 mask = LLVMBuildOr(builder, mask, test, "");
876
877 /* plane 6 */
878 test = lp_build_compare(builder, f32_type, PIPE_FUNC_GREATER, pos_z, pos_w);
879 temp = LLVMBuildShl(builder, temp, shift, "");
880 test = LLVMBuildAnd(builder, test, temp, "");
881 mask = LLVMBuildOr(builder, mask, test, "");
882
883 return mask;
884
885 }
886
887 /*
888 * Returns boolean if any clipping has occurred
889 * Used zero/non-zero i32 value to represent boolean
890 */
891 static void
892 clipmask_bool(LLVMBuilderRef builder,
893 LLVMValueRef clipmask,
894 LLVMValueRef ret_ptr)
895 {
896 LLVMValueRef ret = LLVMBuildLoad(builder, ret_ptr, "");
897 LLVMValueRef temp;
898 int i;
899
900 LLVMDumpValue(clipmask);
901
902 for (i=0; i<4; i++){
903 temp = LLVMBuildExtractElement(builder, clipmask,
904 LLVMConstInt(LLVMInt32Type(), i, 0) , "");
905 ret = LLVMBuildOr(builder, ret, temp, "");
906 LLVMDumpValue(ret);
907 }
908
909 LLVMBuildStore(builder, ret, ret_ptr);
910 LLVMDumpValue(ret_ptr);
911
912 }
913
914 static void
915 draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant)
916 {
917 LLVMTypeRef arg_types[8];
918 LLVMTypeRef func_type;
919 LLVMValueRef context_ptr;
920 LLVMBasicBlockRef block;
921 LLVMBuilderRef builder;
922 LLVMValueRef start, end, count, stride, step, io_itr;
923 LLVMValueRef io_ptr, vbuffers_ptr, vb_ptr;
924 LLVMValueRef instance_id;
925 struct draw_context *draw = llvm->draw;
926 unsigned i, j;
927 struct lp_build_context bld;
928 struct lp_build_loop_state lp_loop;
929 const int max_vertices = 4;
930 LLVMValueRef outputs[PIPE_MAX_SHADER_OUTPUTS][NUM_CHANNELS];
931 void *code;
932 struct lp_build_sampler_soa *sampler = 0;
933
934 LLVMValueRef ret, ret_ptr;
935
936 arg_types[0] = llvm->context_ptr_type; /* context */
937 arg_types[1] = llvm->vertex_header_ptr_type; /* vertex_header */
938 arg_types[2] = llvm->buffer_ptr_type; /* vbuffers */
939 arg_types[3] = LLVMInt32Type(); /* start */
940 arg_types[4] = LLVMInt32Type(); /* count */
941 arg_types[5] = LLVMInt32Type(); /* stride */
942 arg_types[6] = llvm->vb_ptr_type; /* pipe_vertex_buffer's */
943 arg_types[7] = LLVMInt32Type(); /* instance_id */
944
945 func_type = LLVMFunctionType(LLVMInt32Type(), arg_types, Elements(arg_types), 0);
946
947 variant->function = LLVMAddFunction(llvm->module, "draw_llvm_shader", func_type);
948 LLVMSetFunctionCallConv(variant->function, LLVMCCallConv);
949 for(i = 0; i < Elements(arg_types); ++i)
950 if(LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind)
951 LLVMAddAttribute(LLVMGetParam(variant->function, i), LLVMNoAliasAttribute);
952
953 context_ptr = LLVMGetParam(variant->function, 0);
954 io_ptr = LLVMGetParam(variant->function, 1);
955 vbuffers_ptr = LLVMGetParam(variant->function, 2);
956 start = LLVMGetParam(variant->function, 3);
957 count = LLVMGetParam(variant->function, 4);
958 stride = LLVMGetParam(variant->function, 5);
959 vb_ptr = LLVMGetParam(variant->function, 6);
960 instance_id = LLVMGetParam(variant->function, 7);
961
962 lp_build_name(context_ptr, "context");
963 lp_build_name(io_ptr, "io");
964 lp_build_name(vbuffers_ptr, "vbuffers");
965 lp_build_name(start, "start");
966 lp_build_name(count, "count");
967 lp_build_name(stride, "stride");
968 lp_build_name(vb_ptr, "vb");
969 lp_build_name(instance_id, "instance_id");
970
971 /*
972 * Function body
973 */
974
975 block = LLVMAppendBasicBlock(variant->function, "entry");
976 builder = LLVMCreateBuilder();
977 LLVMPositionBuilderAtEnd(builder, block);
978
979 lp_build_context_init(&bld, builder, lp_type_int(32));
980
981 end = lp_build_add(&bld, start, count);
982
983 step = LLVMConstInt(LLVMInt32Type(), max_vertices, 0);
984
985 /* function will return non-zero i32 value if any clipped vertices */
986 ret_ptr = lp_build_alloca(builder, LLVMInt32Type(), "");
987 LLVMBuildStore(builder, LLVMConstInt(LLVMInt32Type(), 0, 0), ret_ptr);
988
989 /* code generated texture sampling */
990 sampler = draw_llvm_sampler_soa_create(
991 draw_llvm_variant_key_samplers(&variant->key),
992 context_ptr);
993
994 #if DEBUG_STORE
995 lp_build_printf(builder, "start = %d, end = %d, step = %d\n",
996 start, end, step);
997 #endif
998 lp_build_loop_begin(builder, start, &lp_loop);
999 {
1000 LLVMValueRef inputs[PIPE_MAX_SHADER_INPUTS][NUM_CHANNELS];
1001 LLVMValueRef aos_attribs[PIPE_MAX_SHADER_INPUTS][NUM_CHANNELS] = { { 0 } };
1002 LLVMValueRef io;
1003 LLVMValueRef clipmask; /* holds the clipmask value */
1004 const LLVMValueRef (*ptr_aos)[NUM_CHANNELS];
1005
1006 io_itr = LLVMBuildSub(builder, lp_loop.counter, start, "");
1007 io = LLVMBuildGEP(builder, io_ptr, &io_itr, 1, "");
1008 #if DEBUG_STORE
1009 lp_build_printf(builder, " --- io %d = %p, loop counter %d\n",
1010 io_itr, io, lp_loop.counter);
1011 #endif
1012 for (i = 0; i < NUM_CHANNELS; ++i) {
1013 LLVMValueRef true_index = LLVMBuildAdd(
1014 builder,
1015 lp_loop.counter,
1016 LLVMConstInt(LLVMInt32Type(), i, 0), "");
1017 for (j = 0; j < draw->pt.nr_vertex_elements; ++j) {
1018 struct pipe_vertex_element *velem = &draw->pt.vertex_element[j];
1019 LLVMValueRef vb_index = LLVMConstInt(LLVMInt32Type(),
1020 velem->vertex_buffer_index,
1021 0);
1022 LLVMValueRef vb = LLVMBuildGEP(builder, vb_ptr,
1023 &vb_index, 1, "");
1024 generate_fetch(builder, vbuffers_ptr,
1025 &aos_attribs[j][i], velem, vb, true_index,
1026 instance_id);
1027 }
1028 }
1029 convert_to_soa(builder, aos_attribs, inputs,
1030 draw->pt.nr_vertex_elements);
1031
1032 ptr_aos = (const LLVMValueRef (*)[NUM_CHANNELS]) inputs;
1033 generate_vs(llvm,
1034 builder,
1035 outputs,
1036 ptr_aos,
1037 context_ptr,
1038 sampler);
1039
1040 /* store original positions in clip before further manipulation */
1041 store_clip(builder, io, outputs);
1042
1043 /* allocate clipmask, assign it integer type */
1044 clipmask = generate_clipmask(builder, outputs);
1045 clipmask_bool(builder, clipmask, ret_ptr);
1046
1047 /* do viewport mapping */
1048 generate_viewport(llvm, builder, outputs);
1049
1050 /* store clipmask in vertex header and positions in data */
1051 convert_to_aos(builder, io, outputs, clipmask,
1052 draw->vs.vertex_shader->info.num_outputs,
1053 max_vertices);
1054 }
1055
1056 lp_build_loop_end_cond(builder, end, step, LLVMIntUGE, &lp_loop);
1057
1058 sampler->destroy(sampler);
1059
1060 #ifdef PIPE_ARCH_X86
1061 /* Avoid corrupting the FPU stack on 32bit OSes. */
1062 lp_build_intrinsic(builder, "llvm.x86.mmx.emms", LLVMVoidType(), NULL, 0);
1063 #endif
1064
1065 ret = LLVMBuildLoad(builder, ret_ptr,"");
1066 LLVMBuildRet(builder, ret);
1067
1068 LLVMDisposeBuilder(builder);
1069
1070 /*
1071 * Translate the LLVM IR into machine code.
1072 */
1073 #ifdef DEBUG
1074 if(LLVMVerifyFunction(variant->function, LLVMPrintMessageAction)) {
1075 lp_debug_dump_value(variant->function);
1076 assert(0);
1077 }
1078 #endif
1079
1080 LLVMRunFunctionPassManager(llvm->pass, variant->function);
1081
1082 if (gallivm_debug & GALLIVM_DEBUG_IR) {
1083 lp_debug_dump_value(variant->function);
1084 debug_printf("\n");
1085 }
1086
1087 code = LLVMGetPointerToGlobal(llvm->draw->engine, variant->function);
1088 variant->jit_func = (draw_jit_vert_func)pointer_to_func(code);
1089
1090 if (gallivm_debug & GALLIVM_DEBUG_ASM) {
1091 lp_disassemble(code);
1092 }
1093 lp_func_delete_body(variant->function);
1094 }
1095
1096
1097 static void
1098 draw_llvm_generate_elts(struct draw_llvm *llvm, struct draw_llvm_variant *variant)
1099 {
1100 LLVMTypeRef arg_types[8];
1101 LLVMTypeRef func_type;
1102 LLVMValueRef context_ptr;
1103 LLVMBasicBlockRef block;
1104 LLVMBuilderRef builder;
1105 LLVMValueRef fetch_elts, fetch_count, stride, step, io_itr;
1106 LLVMValueRef io_ptr, vbuffers_ptr, vb_ptr;
1107 LLVMValueRef instance_id;
1108 struct draw_context *draw = llvm->draw;
1109 unsigned i, j;
1110 struct lp_build_context bld;
1111 struct lp_build_loop_state lp_loop;
1112 const int max_vertices = 4;
1113 LLVMValueRef outputs[PIPE_MAX_SHADER_OUTPUTS][NUM_CHANNELS];
1114 LLVMValueRef fetch_max;
1115 void *code;
1116 struct lp_build_sampler_soa *sampler = 0;
1117 LLVMValueRef ret, ret_ptr;
1118
1119 arg_types[0] = llvm->context_ptr_type; /* context */
1120 arg_types[1] = llvm->vertex_header_ptr_type; /* vertex_header */
1121 arg_types[2] = llvm->buffer_ptr_type; /* vbuffers */
1122 arg_types[3] = LLVMPointerType(LLVMInt32Type(), 0); /* fetch_elts * */
1123 arg_types[4] = LLVMInt32Type(); /* fetch_count */
1124 arg_types[5] = LLVMInt32Type(); /* stride */
1125 arg_types[6] = llvm->vb_ptr_type; /* pipe_vertex_buffer's */
1126 arg_types[7] = LLVMInt32Type(); /* instance_id */
1127
1128 func_type = LLVMFunctionType(LLVMInt32Type(), arg_types, Elements(arg_types), 0);
1129
1130 variant->function_elts = LLVMAddFunction(llvm->module, "draw_llvm_shader_elts", func_type);
1131 LLVMSetFunctionCallConv(variant->function_elts, LLVMCCallConv);
1132 for(i = 0; i < Elements(arg_types); ++i)
1133 if(LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind)
1134 LLVMAddAttribute(LLVMGetParam(variant->function_elts, i),
1135 LLVMNoAliasAttribute);
1136
1137 context_ptr = LLVMGetParam(variant->function_elts, 0);
1138 io_ptr = LLVMGetParam(variant->function_elts, 1);
1139 vbuffers_ptr = LLVMGetParam(variant->function_elts, 2);
1140 fetch_elts = LLVMGetParam(variant->function_elts, 3);
1141 fetch_count = LLVMGetParam(variant->function_elts, 4);
1142 stride = LLVMGetParam(variant->function_elts, 5);
1143 vb_ptr = LLVMGetParam(variant->function_elts, 6);
1144 instance_id = LLVMGetParam(variant->function_elts, 7);
1145
1146 lp_build_name(context_ptr, "context");
1147 lp_build_name(io_ptr, "io");
1148 lp_build_name(vbuffers_ptr, "vbuffers");
1149 lp_build_name(fetch_elts, "fetch_elts");
1150 lp_build_name(fetch_count, "fetch_count");
1151 lp_build_name(stride, "stride");
1152 lp_build_name(vb_ptr, "vb");
1153 lp_build_name(instance_id, "instance_id");
1154
1155 /*
1156 * Function body
1157 */
1158
1159 block = LLVMAppendBasicBlock(variant->function_elts, "entry");
1160 builder = LLVMCreateBuilder();
1161 LLVMPositionBuilderAtEnd(builder, block);
1162
1163 lp_build_context_init(&bld, builder, lp_type_int(32));
1164
1165 step = LLVMConstInt(LLVMInt32Type(), max_vertices, 0);
1166
1167 /* code generated texture sampling */
1168 sampler = draw_llvm_sampler_soa_create(
1169 draw_llvm_variant_key_samplers(&variant->key),
1170 context_ptr);
1171
1172 fetch_max = LLVMBuildSub(builder, fetch_count,
1173 LLVMConstInt(LLVMInt32Type(), 1, 0),
1174 "fetch_max");
1175
1176 /* function returns non-zero i32 value if any clipped vertices */
1177 ret_ptr = lp_build_alloca(builder, LLVMInt32Type(), "");
1178 LLVMBuildStore(builder, LLVMConstInt(LLVMInt32Type(), 0, 0), ret_ptr);
1179
1180 lp_build_loop_begin(builder, LLVMConstInt(LLVMInt32Type(), 0, 0), &lp_loop);
1181 {
1182 LLVMValueRef inputs[PIPE_MAX_SHADER_INPUTS][NUM_CHANNELS];
1183 LLVMValueRef aos_attribs[PIPE_MAX_SHADER_INPUTS][NUM_CHANNELS] = { { 0 } };
1184 LLVMValueRef io;
1185 LLVMValueRef clipmask; /* holds the clipmask value */
1186 const LLVMValueRef (*ptr_aos)[NUM_CHANNELS];
1187
1188 io_itr = lp_loop.counter;
1189 io = LLVMBuildGEP(builder, io_ptr, &io_itr, 1, "");
1190 #if DEBUG_STORE
1191 lp_build_printf(builder, " --- io %d = %p, loop counter %d\n",
1192 io_itr, io, lp_loop.counter);
1193 #endif
1194 for (i = 0; i < NUM_CHANNELS; ++i) {
1195 LLVMValueRef true_index = LLVMBuildAdd(
1196 builder,
1197 lp_loop.counter,
1198 LLVMConstInt(LLVMInt32Type(), i, 0), "");
1199 LLVMValueRef fetch_ptr;
1200
1201 /* make sure we're not out of bounds which can happen
1202 * if fetch_count % 4 != 0, because on the last iteration
1203 * a few of the 4 vertex fetches will be out of bounds */
1204 true_index = lp_build_min(&bld, true_index, fetch_max);
1205
1206 fetch_ptr = LLVMBuildGEP(builder, fetch_elts,
1207 &true_index, 1, "");
1208 true_index = LLVMBuildLoad(builder, fetch_ptr, "fetch_elt");
1209 for (j = 0; j < draw->pt.nr_vertex_elements; ++j) {
1210 struct pipe_vertex_element *velem = &draw->pt.vertex_element[j];
1211 LLVMValueRef vb_index = LLVMConstInt(LLVMInt32Type(),
1212 velem->vertex_buffer_index,
1213 0);
1214 LLVMValueRef vb = LLVMBuildGEP(builder, vb_ptr,
1215 &vb_index, 1, "");
1216 generate_fetch(builder, vbuffers_ptr,
1217 &aos_attribs[j][i], velem, vb, true_index,
1218 instance_id);
1219 }
1220 }
1221 convert_to_soa(builder, aos_attribs, inputs,
1222 draw->pt.nr_vertex_elements);
1223
1224 ptr_aos = (const LLVMValueRef (*)[NUM_CHANNELS]) inputs;
1225 generate_vs(llvm,
1226 builder,
1227 outputs,
1228 ptr_aos,
1229 context_ptr,
1230 sampler);
1231
1232 /* store original positions in clip before further manipulation */
1233 store_clip(builder, io, outputs);
1234
1235 /* allocate clipmask, assign it integer type */
1236 clipmask = generate_clipmask(builder, outputs);
1237 clipmask_bool(builder, clipmask, ret_ptr);
1238
1239 /* do viewport mapping */
1240 generate_viewport(llvm, builder, outputs);
1241
1242 /* store clipmask in vertex header,
1243 * original positions in clip
1244 * and transformed positions in data
1245 */
1246 convert_to_aos(builder, io, outputs, clipmask,
1247 draw->vs.vertex_shader->info.num_outputs,
1248 max_vertices);
1249 }
1250
1251 lp_build_loop_end_cond(builder, fetch_count, step, LLVMIntUGE, &lp_loop);
1252
1253 sampler->destroy(sampler);
1254
1255 #ifdef PIPE_ARCH_X86
1256 /* Avoid corrupting the FPU stack on 32bit OSes. */
1257 lp_build_intrinsic(builder, "llvm.x86.mmx.emms", LLVMVoidType(), NULL, 0);
1258 #endif
1259
1260 ret = LLVMBuildLoad(builder, ret_ptr,"");
1261 LLVMBuildRet(builder, ret);
1262
1263 LLVMDisposeBuilder(builder);
1264
1265 /*
1266 * Translate the LLVM IR into machine code.
1267 */
1268 #ifdef DEBUG
1269 if(LLVMVerifyFunction(variant->function_elts, LLVMPrintMessageAction)) {
1270 lp_debug_dump_value(variant->function_elts);
1271 assert(0);
1272 }
1273 #endif
1274
1275 LLVMRunFunctionPassManager(llvm->pass, variant->function_elts);
1276
1277 if (gallivm_debug & GALLIVM_DEBUG_IR) {
1278 lp_debug_dump_value(variant->function_elts);
1279 debug_printf("\n");
1280 }
1281
1282 code = LLVMGetPointerToGlobal(llvm->draw->engine, variant->function_elts);
1283 variant->jit_func_elts = (draw_jit_vert_func_elts)pointer_to_func(code);
1284
1285 if (gallivm_debug & GALLIVM_DEBUG_ASM) {
1286 lp_disassemble(code);
1287 }
1288 lp_func_delete_body(variant->function_elts);
1289 }
1290
1291
1292 struct draw_llvm_variant_key *
1293 draw_llvm_make_variant_key(struct draw_llvm *llvm, char *store)
1294 {
1295 unsigned i;
1296 struct draw_llvm_variant_key *key;
1297 struct lp_sampler_static_state *sampler;
1298
1299 key = (struct draw_llvm_variant_key *)store;
1300
1301 /* Presumably all variants of the shader should have the same
1302 * number of vertex elements - ie the number of shader inputs.
1303 */
1304 key->nr_vertex_elements = llvm->draw->pt.nr_vertex_elements;
1305
1306 /* All variants of this shader will have the same value for
1307 * nr_samplers. Not yet trying to compact away holes in the
1308 * sampler array.
1309 */
1310 key->nr_samplers = llvm->draw->vs.vertex_shader->info.file_max[TGSI_FILE_SAMPLER] + 1;
1311
1312 sampler = draw_llvm_variant_key_samplers(key);
1313
1314 memcpy(key->vertex_element,
1315 llvm->draw->pt.vertex_element,
1316 sizeof(struct pipe_vertex_element) * key->nr_vertex_elements);
1317
1318 memset(sampler, 0, key->nr_samplers * sizeof *sampler);
1319
1320 for (i = 0 ; i < key->nr_samplers; i++) {
1321 lp_sampler_static_state(&sampler[i],
1322 llvm->draw->sampler_views[i],
1323 llvm->draw->samplers[i]);
1324 }
1325
1326 return key;
1327 }
1328
1329 void
1330 draw_llvm_set_mapped_texture(struct draw_context *draw,
1331 unsigned sampler_idx,
1332 uint32_t width, uint32_t height, uint32_t depth,
1333 uint32_t last_level,
1334 uint32_t row_stride[DRAW_MAX_TEXTURE_LEVELS],
1335 uint32_t img_stride[DRAW_MAX_TEXTURE_LEVELS],
1336 const void *data[DRAW_MAX_TEXTURE_LEVELS])
1337 {
1338 unsigned j;
1339 struct draw_jit_texture *jit_tex;
1340
1341 assert(sampler_idx < PIPE_MAX_VERTEX_SAMPLERS);
1342
1343
1344 jit_tex = &draw->llvm->jit_context.textures[sampler_idx];
1345
1346 jit_tex->width = width;
1347 jit_tex->height = height;
1348 jit_tex->depth = depth;
1349 jit_tex->last_level = last_level;
1350
1351 for (j = 0; j <= last_level; j++) {
1352 jit_tex->data[j] = data[j];
1353 jit_tex->row_stride[j] = row_stride[j];
1354 jit_tex->img_stride[j] = img_stride[j];
1355 }
1356 }
1357
1358 void
1359 draw_llvm_destroy_variant(struct draw_llvm_variant *variant)
1360 {
1361 struct draw_llvm *llvm = variant->llvm;
1362 struct draw_context *draw = llvm->draw;
1363
1364 if (variant->function_elts) {
1365 if (variant->function_elts)
1366 LLVMFreeMachineCodeForFunction(draw->engine,
1367 variant->function_elts);
1368 LLVMDeleteFunction(variant->function_elts);
1369 }
1370
1371 if (variant->function) {
1372 if (variant->function)
1373 LLVMFreeMachineCodeForFunction(draw->engine,
1374 variant->function);
1375 LLVMDeleteFunction(variant->function);
1376 }
1377
1378 remove_from_list(&variant->list_item_local);
1379 variant->shader->variants_cached--;
1380 remove_from_list(&variant->list_item_global);
1381 llvm->nr_variants--;
1382 FREE(variant);
1383 }