projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Additional error checking for 'return' statements.
[mesa.git] / src / mesa / shader / slang / slang_codegen.c
1 /*
2 * Mesa 3-D graphics library
3 * Version: 6.5.3
4 *
5 * Copyright (C) 2005-2007 Brian Paul All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25 /**
26 * \file slang_codegen.c
27 * Generate IR tree from AST.
28 * \author Brian Paul
29 */
30
31
32 /***
33 *** NOTES:
34 *** The new_() functions return a new instance of a simple IR node.
35 *** The gen_() functions generate larger IR trees from the simple nodes.
36 ***/
37
38
39
40 #include "imports.h"
41 #include "macros.h"
42 #include "mtypes.h"
43 #include "program.h"
44 #include "prog_instruction.h"
45 #include "prog_parameter.h"
46 #include "prog_statevars.h"
47 #include "slang_typeinfo.h"
48 #include "slang_codegen.h"
49 #include "slang_compile.h"
50 #include "slang_label.h"
51 #include "slang_simplify.h"
52 #include "slang_emit.h"
53 #include "slang_vartable.h"
54 #include "slang_ir.h"
55 #include "slang_print.h"
56
57
58 static slang_ir_node *
59 _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper);
60
61
62 static GLboolean
63 is_sampler_type(const slang_fully_specified_type *t)
64 {
65 switch (t->specifier.type) {
66 case SLANG_SPEC_SAMPLER1D:
67 case SLANG_SPEC_SAMPLER2D:
68 case SLANG_SPEC_SAMPLER3D:
69 case SLANG_SPEC_SAMPLERCUBE:
70 case SLANG_SPEC_SAMPLER1DSHADOW:
71 case SLANG_SPEC_SAMPLER2DSHADOW:
72 case SLANG_SPEC_SAMPLER2DRECT:
73 case SLANG_SPEC_SAMPLER2DRECTSHADOW:
74 return GL_TRUE;
75 default:
76 return GL_FALSE;
77 }
78 }
79
80
81 /**
82 * Return the offset (in floats or ints) of the named field within
83 * the given struct. Return -1 if field not found.
84 * If field is NULL, return the size of the struct instead.
85 */
86 static GLint
87 _slang_field_offset(const slang_type_specifier *spec, slang_atom field)
88 {
89 GLint offset = 0;
90 GLuint i;
91 for (i = 0; i < spec->_struct->fields->num_variables; i++) {
92 const slang_variable *v = spec->_struct->fields->variables[i];
93 const GLuint sz = _slang_sizeof_type_specifier(&v->type.specifier);
94 if (sz > 1) {
95 /* types larger than 1 float are register (4-float) aligned */
96 offset = (offset + 3) & ~3;
97 }
98 if (field && v->a_name == field) {
99 return offset;
100 }
101 offset += sz;
102 }
103 if (field)
104 return -1; /* field not found */
105 else
106 return offset; /* struct size */
107 }
108
109
110 GLuint
111 _slang_sizeof_type_specifier(const slang_type_specifier *spec)
112 {
113 switch (spec->type) {
114 case SLANG_SPEC_VOID:
115 return 0;
116 case SLANG_SPEC_BOOL:
117 return 1;
118 case SLANG_SPEC_BVEC2:
119 return 2;
120 case SLANG_SPEC_BVEC3:
121 return 3;
122 case SLANG_SPEC_BVEC4:
123 return 4;
124 case SLANG_SPEC_INT:
125 return 1;
126 case SLANG_SPEC_IVEC2:
127 return 2;
128 case SLANG_SPEC_IVEC3:
129 return 3;
130 case SLANG_SPEC_IVEC4:
131 return 4;
132 case SLANG_SPEC_FLOAT:
133 return 1;
134 case SLANG_SPEC_VEC2:
135 return 2;
136 case SLANG_SPEC_VEC3:
137 return 3;
138 case SLANG_SPEC_VEC4:
139 return 4;
140 case SLANG_SPEC_MAT2:
141 return 2 * 2;
142 case SLANG_SPEC_MAT3:
143 return 3 * 3;
144 case SLANG_SPEC_MAT4:
145 return 4 * 4;
146 case SLANG_SPEC_SAMPLER1D:
147 case SLANG_SPEC_SAMPLER2D:
148 case SLANG_SPEC_SAMPLER3D:
149 case SLANG_SPEC_SAMPLERCUBE:
150 case SLANG_SPEC_SAMPLER1DSHADOW:
151 case SLANG_SPEC_SAMPLER2DSHADOW:
152 case SLANG_SPEC_SAMPLER2DRECT:
153 case SLANG_SPEC_SAMPLER2DRECTSHADOW:
154 return 1; /* a sampler is basically just an integer index */
155 case SLANG_SPEC_STRUCT:
156 return _slang_field_offset(spec, 0); /* special use */
157 case SLANG_SPEC_ARRAY:
158 return _slang_sizeof_type_specifier(spec->_array);
159 default:
160 _mesa_problem(NULL, "Unexpected type in _slang_sizeof_type_specifier()");
161 return 0;
162 }
163 return 0;
164 }
165
166
167 /**
168 * Establish the binding between a slang_ir_node and a slang_variable.
169 * Then, allocate/attach a slang_ir_storage object to the IR node if needed.
170 * The IR node must be a IR_VAR or IR_VAR_DECL node.
171 * \param n the IR node
172 * \param var the variable to associate with the IR node
173 */
174 static void
175 _slang_attach_storage(slang_ir_node *n, slang_variable *var)
176 {
177 assert(n);
178 assert(var);
179 assert(n->Opcode == IR_VAR || n->Opcode == IR_VAR_DECL);
180 assert(!n->Var || n->Var == var);
181
182 n->Var = var;
183
184 if (!n->Store) {
185 /* need to setup storage */
186 if (n->Var && n->Var->aux) {
187 /* node storage info = var storage info */
188 n->Store = (slang_ir_storage *) n->Var->aux;
189 }
190 else {
191 /* alloc new storage info */
192 n->Store = _slang_new_ir_storage(PROGRAM_UNDEFINED, -1, -5);
193 if (n->Var)
194 n->Var->aux = n->Store;
195 assert(n->Var->aux);
196 }
197 }
198 }
199
200
201 /**
202 * Return the TEXTURE_*_INDEX value that corresponds to a sampler type,
203 * or -1 if the type is not a sampler.
204 */
205 static GLint
206 sampler_to_texture_index(const slang_type_specifier_type type)
207 {
208 switch (type) {
209 case SLANG_SPEC_SAMPLER1D:
210 return TEXTURE_1D_INDEX;
211 case SLANG_SPEC_SAMPLER2D:
212 return TEXTURE_2D_INDEX;
213 case SLANG_SPEC_SAMPLER3D:
214 return TEXTURE_3D_INDEX;
215 case SLANG_SPEC_SAMPLERCUBE:
216 return TEXTURE_CUBE_INDEX;
217 case SLANG_SPEC_SAMPLER1DSHADOW:
218 return TEXTURE_1D_INDEX; /* XXX fix */
219 case SLANG_SPEC_SAMPLER2DSHADOW:
220 return TEXTURE_2D_INDEX; /* XXX fix */
221 case SLANG_SPEC_SAMPLER2DRECT:
222 return TEXTURE_RECT_INDEX;
223 case SLANG_SPEC_SAMPLER2DRECTSHADOW:
224 return TEXTURE_RECT_INDEX; /* XXX fix */
225 default:
226 return -1;
227 }
228 }
229
230
231 /**
232 * Return the VERT_ATTRIB_* or FRAG_ATTRIB_* value that corresponds to
233 * a vertex or fragment program input variable. Return -1 if the input
234 * name is invalid.
235 * XXX return size too
236 */
237 static GLint
238 _slang_input_index(const char *name, GLenum target, GLuint *swizzleOut)
239 {
240 struct input_info {
241 const char *Name;
242 GLuint Attrib;
243 GLuint Swizzle;
244 };
245 static const struct input_info vertInputs[] = {
246 { "gl_Vertex", VERT_ATTRIB_POS, SWIZZLE_NOOP },
247 { "gl_Normal", VERT_ATTRIB_NORMAL, SWIZZLE_NOOP },
248 { "gl_Color", VERT_ATTRIB_COLOR0, SWIZZLE_NOOP },
249 { "gl_SecondaryColor", VERT_ATTRIB_COLOR1, SWIZZLE_NOOP },
250 { "gl_FogCoord", VERT_ATTRIB_FOG, SWIZZLE_XXXX },
251 { "gl_MultiTexCoord0", VERT_ATTRIB_TEX0, SWIZZLE_NOOP },
252 { "gl_MultiTexCoord1", VERT_ATTRIB_TEX1, SWIZZLE_NOOP },
253 { "gl_MultiTexCoord2", VERT_ATTRIB_TEX2, SWIZZLE_NOOP },
254 { "gl_MultiTexCoord3", VERT_ATTRIB_TEX3, SWIZZLE_NOOP },
255 { "gl_MultiTexCoord4", VERT_ATTRIB_TEX4, SWIZZLE_NOOP },
256 { "gl_MultiTexCoord5", VERT_ATTRIB_TEX5, SWIZZLE_NOOP },
257 { "gl_MultiTexCoord6", VERT_ATTRIB_TEX6, SWIZZLE_NOOP },
258 { "gl_MultiTexCoord7", VERT_ATTRIB_TEX7, SWIZZLE_NOOP },
259 { NULL, 0, SWIZZLE_NOOP }
260 };
261 static const struct input_info fragInputs[] = {
262 { "gl_FragCoord", FRAG_ATTRIB_WPOS, SWIZZLE_NOOP },
263 { "gl_Color", FRAG_ATTRIB_COL0, SWIZZLE_NOOP },
264 { "gl_SecondaryColor", FRAG_ATTRIB_COL1, SWIZZLE_NOOP },
265 { "gl_FogFragCoord", FRAG_ATTRIB_FOGC, SWIZZLE_XXXX },
266 { "gl_TexCoord", FRAG_ATTRIB_TEX0, SWIZZLE_NOOP },
267 { "gl_FrontFacing", FRAG_ATTRIB_FOGC, SWIZZLE_YYYY }, /*XXX*/
268 { NULL, 0, SWIZZLE_NOOP }
269 };
270 GLuint i;
271 const struct input_info *inputs
272 = (target == GL_VERTEX_PROGRAM_ARB) ? vertInputs : fragInputs;
273
274 ASSERT(MAX_TEXTURE_UNITS == 8); /* if this fails, fix vertInputs above */
275
276 for (i = 0; inputs[i].Name; i++) {
277 if (strcmp(inputs[i].Name, name) == 0) {
278 /* found */
279 *swizzleOut = inputs[i].Swizzle;
280 return inputs[i].Attrib;
281 }
282 }
283 return -1;
284 }
285
286
287 /**
288 * Return the VERT_RESULT_* or FRAG_RESULT_* value that corresponds to
289 * a vertex or fragment program output variable. Return -1 for an invalid
290 * output name.
291 */
292 static GLint
293 _slang_output_index(const char *name, GLenum target)
294 {
295 struct output_info {
296 const char *Name;
297 GLuint Attrib;
298 };
299 static const struct output_info vertOutputs[] = {
300 { "gl_Position", VERT_RESULT_HPOS },
301 { "gl_FrontColor", VERT_RESULT_COL0 },
302 { "gl_BackColor", VERT_RESULT_BFC0 },
303 { "gl_FrontSecondaryColor", VERT_RESULT_COL1 },
304 { "gl_BackSecondaryColor", VERT_RESULT_BFC1 },
305 { "gl_TexCoord", VERT_RESULT_TEX0 },
306 { "gl_FogFragCoord", VERT_RESULT_FOGC },
307 { "gl_PointSize", VERT_RESULT_PSIZ },
308 { NULL, 0 }
309 };
310 static const struct output_info fragOutputs[] = {
311 { "gl_FragColor", FRAG_RESULT_COLR },
312 { "gl_FragDepth", FRAG_RESULT_DEPR },
313 { "gl_FragData", FRAG_RESULT_DATA0 },
314 { NULL, 0 }
315 };
316 GLuint i;
317 const struct output_info *outputs
318 = (target == GL_VERTEX_PROGRAM_ARB) ? vertOutputs : fragOutputs;
319
320 for (i = 0; outputs[i].Name; i++) {
321 if (strcmp(outputs[i].Name, name) == 0) {
322 /* found */
323 return outputs[i].Attrib;
324 }
325 }
326 return -1;
327 }
328
329
330
331 /**********************************************************************/
332
333
334 /**
335 * Map "_asm foo" to IR_FOO, etc.
336 */
337 typedef struct
338 {
339 const char *Name;
340 slang_ir_opcode Opcode;
341 GLuint HaveRetValue, NumParams;
342 } slang_asm_info;
343
344
345 static slang_asm_info AsmInfo[] = {
346 /* vec4 binary op */
347 { "vec4_add", IR_ADD, 1, 2 },
348 { "vec4_subtract", IR_SUB, 1, 2 },
349 { "vec4_multiply", IR_MUL, 1, 2 },
350 { "vec4_dot", IR_DOT4, 1, 2 },
351 { "vec3_dot", IR_DOT3, 1, 2 },
352 { "vec3_cross", IR_CROSS, 1, 2 },
353 { "vec4_lrp", IR_LRP, 1, 3 },
354 { "vec4_min", IR_MIN, 1, 2 },
355 { "vec4_max", IR_MAX, 1, 2 },
356 { "vec4_clamp", IR_CLAMP, 1, 3 },
357 { "vec4_seq", IR_SEQUAL, 1, 2 },
358 { "vec4_sne", IR_SNEQUAL, 1, 2 },
359 { "vec4_sge", IR_SGE, 1, 2 },
360 { "vec4_sgt", IR_SGT, 1, 2 },
361 { "vec4_sle", IR_SLE, 1, 2 },
362 { "vec4_slt", IR_SLT, 1, 2 },
363 /* vec4 unary */
364 { "vec4_floor", IR_FLOOR, 1, 1 },
365 { "vec4_frac", IR_FRAC, 1, 1 },
366 { "vec4_abs", IR_ABS, 1, 1 },
367 { "vec4_negate", IR_NEG, 1, 1 },
368 { "vec4_ddx", IR_DDX, 1, 1 },
369 { "vec4_ddy", IR_DDY, 1, 1 },
370 /* float binary op */
371 { "float_power", IR_POW, 1, 2 },
372 /* texture / sampler */
373 { "vec4_tex1d", IR_TEX, 1, 2 },
374 { "vec4_texb1d", IR_TEXB, 1, 2 }, /* 1d w/ bias */
375 { "vec4_texp1d", IR_TEXP, 1, 2 }, /* 1d w/ projection */
376 { "vec4_tex2d", IR_TEX, 1, 2 },
377 { "vec4_texb2d", IR_TEXB, 1, 2 }, /* 2d w/ bias */
378 { "vec4_texp2d", IR_TEXP, 1, 2 }, /* 2d w/ projection */
379 { "vec4_tex3d", IR_TEX, 1, 2 },
380 { "vec4_texb3d", IR_TEXB, 1, 2 }, /* 3d w/ bias */
381 { "vec4_texp3d", IR_TEXP, 1, 2 }, /* 3d w/ projection */
382 { "vec4_texcube", IR_TEX, 1, 2 }, /* cubemap */
383 { "vec4_tex_rect", IR_TEX, 1, 2 }, /* rectangle */
384 { "vec4_texp_rect", IR_TEX, 1, 2 },/* rectangle w/ projection */
385
386 /* unary op */
387 { "int_to_float", IR_I_TO_F, 1, 1 },
388 { "float_to_int", IR_F_TO_I, 1, 1 },
389 { "float_exp", IR_EXP, 1, 1 },
390 { "float_exp2", IR_EXP2, 1, 1 },
391 { "float_log2", IR_LOG2, 1, 1 },
392 { "float_rsq", IR_RSQ, 1, 1 },
393 { "float_rcp", IR_RCP, 1, 1 },
394 { "float_sine", IR_SIN, 1, 1 },
395 { "float_cosine", IR_COS, 1, 1 },
396 { "float_noise1", IR_NOISE1, 1, 1},
397 { "float_noise2", IR_NOISE2, 1, 1},
398 { "float_noise3", IR_NOISE3, 1, 1},
399 { "float_noise4", IR_NOISE4, 1, 1},
400
401 { NULL, IR_NOP, 0, 0 }
402 };
403
404
405 static slang_ir_node *
406 new_node3(slang_ir_opcode op,
407 slang_ir_node *c0, slang_ir_node *c1, slang_ir_node *c2)
408 {
409 slang_ir_node *n = (slang_ir_node *) calloc(1, sizeof(slang_ir_node));
410 if (n) {
411 n->Opcode = op;
412 n->Children[0] = c0;
413 n->Children[1] = c1;
414 n->Children[2] = c2;
415 n->Writemask = WRITEMASK_XYZW;
416 n->InstLocation = -1;
417 }
418 return n;
419 }
420
421 static slang_ir_node *
422 new_node2(slang_ir_opcode op, slang_ir_node *c0, slang_ir_node *c1)
423 {
424 return new_node3(op, c0, c1, NULL);
425 }
426
427 static slang_ir_node *
428 new_node1(slang_ir_opcode op, slang_ir_node *c0)
429 {
430 return new_node3(op, c0, NULL, NULL);
431 }
432
433 static slang_ir_node *
434 new_node0(slang_ir_opcode op)
435 {
436 return new_node3(op, NULL, NULL, NULL);
437 }
438
439
440 static slang_ir_node *
441 new_seq(slang_ir_node *left, slang_ir_node *right)
442 {
443 if (!left)
444 return right;
445 if (!right)
446 return left;
447 return new_node2(IR_SEQ, left, right);
448 }
449
450 static slang_ir_node *
451 new_label(slang_label *label)
452 {
453 slang_ir_node *n = new_node0(IR_LABEL);
454 assert(label);
455 if (n)
456 n->Label = label;
457 return n;
458 }
459
460 static slang_ir_node *
461 new_float_literal(const float v[4], GLuint size)
462 {
463 slang_ir_node *n = new_node0(IR_FLOAT);
464 assert(size <= 4);
465 COPY_4V(n->Value, v);
466 /* allocate a storage object, but compute actual location (Index) later */
467 n->Store = _slang_new_ir_storage(PROGRAM_CONSTANT, -1, size);
468 return n;
469 }
470
471 /**
472 * Unconditional jump.
473 */
474 static slang_ir_node *
475 new_jump(slang_label *dest)
476 {
477 slang_ir_node *n = new_node0(IR_JUMP);
478 assert(dest);
479 if (n)
480 n->Label = dest;
481 return n;
482 }
483
484
485 static slang_ir_node *
486 new_loop(slang_ir_node *body)
487 {
488 return new_node1(IR_LOOP, body);
489 }
490
491
492 static slang_ir_node *
493 new_break(slang_ir_node *loopNode)
494 {
495 slang_ir_node *n = new_node0(IR_BREAK);
496 assert(loopNode);
497 assert(loopNode->Opcode == IR_LOOP);
498 if (n) {
499 /* insert this node at head of linked list */
500 n->List = loopNode->List;
501 loopNode->List = n;
502 }
503 return n;
504 }
505
506
507 /**
508 * Make new IR_BREAK_IF_TRUE or IR_BREAK_IF_FALSE node.
509 */
510 static slang_ir_node *
511 new_break_if(slang_ir_node *loopNode, slang_ir_node *cond, GLboolean breakTrue)
512 {
513 slang_ir_node *n;
514 assert(loopNode);
515 assert(loopNode->Opcode == IR_LOOP);
516 n = new_node1(breakTrue ? IR_BREAK_IF_TRUE : IR_BREAK_IF_FALSE, cond);
517 if (n) {
518 /* insert this node at head of linked list */
519 n->List = loopNode->List;
520 loopNode->List = n;
521 }
522 return n;
523 }
524
525
526 /**
527 * Make new IR_CONT_IF_TRUE or IR_CONT_IF_FALSE node.
528 */
529 static slang_ir_node *
530 new_cont_if(slang_ir_node *loopNode, slang_ir_node *cond, GLboolean contTrue)
531 {
532 slang_ir_node *n;
533 assert(loopNode);
534 assert(loopNode->Opcode == IR_LOOP);
535 n = new_node1(contTrue ? IR_CONT_IF_TRUE : IR_CONT_IF_FALSE, cond);
536 if (n) {
537 /* insert this node at head of linked list */
538 n->List = loopNode->List;
539 loopNode->List = n;
540 }
541 return n;
542 }
543
544
545 static slang_ir_node *
546 new_cond(slang_ir_node *n)
547 {
548 slang_ir_node *c = new_node1(IR_COND, n);
549 return c;
550 }
551
552
553 static slang_ir_node *
554 new_if(slang_ir_node *cond, slang_ir_node *ifPart, slang_ir_node *elsePart)
555 {
556 return new_node3(IR_IF, cond, ifPart, elsePart);
557 }
558
559
560 /**
561 * New IR_VAR node - a reference to a previously declared variable.
562 */
563 static slang_ir_node *
564 new_var(slang_assemble_ctx *A, slang_operation *oper, slang_atom name)
565 {
566 slang_ir_node *n;
567 slang_variable *var = _slang_locate_variable(oper->locals, name, GL_TRUE);
568 if (!var)
569 return NULL;
570
571 assert(!oper->var || oper->var == var);
572
573 n = new_node0(IR_VAR);
574 if (n) {
575 _slang_attach_storage(n, var);
576 }
577 return n;
578 }
579
580
581 /**
582 * Check if the given function is really just a wrapper for a
583 * basic assembly instruction.
584 */
585 static GLboolean
586 slang_is_asm_function(const slang_function *fun)
587 {
588 if (fun->body->type == SLANG_OPER_BLOCK_NO_NEW_SCOPE &&
589 fun->body->num_children == 1 &&
590 fun->body->children[0].type == SLANG_OPER_ASM) {
591 return GL_TRUE;
592 }
593 return GL_FALSE;
594 }
595
596
597 static GLboolean
598 _slang_is_noop(const slang_operation *oper)
599 {
600 if (!oper ||
601 oper->type == SLANG_OPER_VOID ||
602 (oper->num_children == 1 && oper->children[0].type == SLANG_OPER_VOID))
603 return GL_TRUE;
604 else
605 return GL_FALSE;
606 }
607
608
609 /**
610 * Produce inline code for a call to an assembly instruction.
611 * XXX Note: children are passed as asm args in-order, not by name!
612 */
613 static slang_operation *
614 slang_inline_asm_function(slang_assemble_ctx *A,
615 slang_function *fun, slang_operation *oper)
616 {
617 const GLuint numArgs = oper->num_children;
618 const slang_operation *args = oper->children;
619 GLuint i;
620 slang_operation *inlined = slang_operation_new(1);
621
622 /*assert(oper->type == SLANG_OPER_CALL); or vec4_add, etc */
623 /*
624 printf("Inline asm %s\n", (char*) fun->header.a_name);
625 */
626 inlined->type = fun->body->children[0].type;
627 inlined->a_id = fun->body->children[0].a_id;
628 inlined->num_children = numArgs;
629 inlined->children = slang_operation_new(numArgs);
630 inlined->locals->outer_scope = oper->locals->outer_scope;
631
632 for (i = 0; i < numArgs; i++) {
633 slang_operation_copy(inlined->children + i, args + i);
634 }
635
636 return inlined;
637 }
638
639
640 static void
641 slang_resolve_variable(slang_operation *oper)
642 {
643 if (oper->type == SLANG_OPER_IDENTIFIER && !oper->var) {
644 oper->var = _slang_locate_variable(oper->locals, oper->a_id, GL_TRUE);
645 }
646 }
647
648
649 /**
650 * Replace particular variables (SLANG_OPER_IDENTIFIER) with new expressions.
651 */
652 static void
653 slang_substitute(slang_assemble_ctx *A, slang_operation *oper,
654 GLuint substCount, slang_variable **substOld,
655 slang_operation **substNew, GLboolean isLHS)
656 {
657 switch (oper->type) {
658 case SLANG_OPER_VARIABLE_DECL:
659 {
660 slang_variable *v = _slang_locate_variable(oper->locals,
661 oper->a_id, GL_TRUE);
662 assert(v);
663 if (v->initializer && oper->num_children == 0) {
664 /* set child of oper to copy of initializer */
665 oper->num_children = 1;
666 oper->children = slang_operation_new(1);
667 slang_operation_copy(&oper->children[0], v->initializer);
668 }
669 if (oper->num_children == 1) {
670 /* the initializer */
671 slang_substitute(A, &oper->children[0], substCount,
672 substOld, substNew, GL_FALSE);
673 }
674 }
675 break;
676 case SLANG_OPER_IDENTIFIER:
677 assert(oper->num_children == 0);
678 if (1/**!isLHS XXX FIX */) {
679 slang_atom id = oper->a_id;
680 slang_variable *v;
681 GLuint i;
682 v = _slang_locate_variable(oper->locals, id, GL_TRUE);
683 if (!v) {
684 printf("var %s not found!\n", (char *) oper->a_id);
685 _slang_print_var_scope(oper->locals, 6);
686
687 abort();
688 break;
689 }
690
691 /* look for a substitution */
692 for (i = 0; i < substCount; i++) {
693 if (v == substOld[i]) {
694 /* OK, replace this SLANG_OPER_IDENTIFIER with a new expr */
695 #if 0 /* DEBUG only */
696 if (substNew[i]->type == SLANG_OPER_IDENTIFIER) {
697 assert(substNew[i]->var);
698 assert(substNew[i]->var->a_name);
699 printf("Substitute %s with %s in id node %p\n",
700 (char*)v->a_name, (char*) substNew[i]->var->a_name,
701 (void*) oper);
702 }
703 else {
704 printf("Substitute %s with %f in id node %p\n",
705 (char*)v->a_name, substNew[i]->literal[0],
706 (void*) oper);
707 }
708 #endif
709 slang_operation_copy(oper, substNew[i]);
710 break;
711 }
712 }
713 }
714 break;
715
716 case SLANG_OPER_RETURN:
717 /* do return replacement here too */
718 assert(oper->num_children == 0 || oper->num_children == 1);
719 if (oper->num_children == 1 && !_slang_is_noop(&oper->children[0])) {
720 /* replace:
721 * return expr;
722 * with:
723 * __retVal = expr;
724 * return;
725 * then do substitutions on the assignment.
726 */
727 slang_operation *blockOper, *assignOper, *returnOper;
728
729 /* check if function actually has a return type */
730 assert(A->CurFunction);
731 if (A->CurFunction->header.type.specifier.type == SLANG_SPEC_VOID) {
732 slang_info_log_error(A->log, "illegal return expression");
733 return;
734 }
735
736 blockOper = slang_operation_new(1);
737 blockOper->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE;
738 blockOper->num_children = 2;
739 blockOper->locals->outer_scope = oper->locals->outer_scope;
740 blockOper->children = slang_operation_new(2);
741 assignOper = blockOper->children + 0;
742 returnOper = blockOper->children + 1;
743
744 assignOper->type = SLANG_OPER_ASSIGN;
745 assignOper->num_children = 2;
746 assignOper->locals->outer_scope = blockOper->locals;
747 assignOper->children = slang_operation_new(2);
748 assignOper->children[0].type = SLANG_OPER_IDENTIFIER;
749 assignOper->children[0].a_id = slang_atom_pool_atom(A->atoms, "__retVal");
750 assignOper->children[0].locals->outer_scope = assignOper->locals;
751
752 slang_operation_copy(&assignOper->children[1],
753 &oper->children[0]);
754
755 returnOper->type = SLANG_OPER_RETURN;
756 assert(returnOper->num_children == 0);
757
758 /* do substitutions on the "__retVal = expr" sub-tree */
759 slang_substitute(A, assignOper,
760 substCount, substOld, substNew, GL_FALSE);
761
762 /* install new code */
763 slang_operation_copy(oper, blockOper);
764 slang_operation_destruct(blockOper);
765 }
766 else {
767 /* check if return value was expected */
768 assert(A->CurFunction);
769 if (A->CurFunction->header.type.specifier.type != SLANG_SPEC_VOID) {
770 slang_info_log_error(A->log, "return statement requires an expression");
771 return;
772 }
773 }
774 break;
775
776 case SLANG_OPER_ASSIGN:
777 case SLANG_OPER_SUBSCRIPT:
778 /* special case:
779 * child[0] can't have substitutions but child[1] can.
780 */
781 slang_substitute(A, &oper->children[0],
782 substCount, substOld, substNew, GL_TRUE);
783 slang_substitute(A, &oper->children[1],
784 substCount, substOld, substNew, GL_FALSE);
785 break;
786 case SLANG_OPER_FIELD:
787 /* XXX NEW - test */
788 slang_substitute(A, &oper->children[0],
789 substCount, substOld, substNew, GL_TRUE);
790 break;
791 default:
792 {
793 GLuint i;
794 for (i = 0; i < oper->num_children; i++)
795 slang_substitute(A, &oper->children[i],
796 substCount, substOld, substNew, GL_FALSE);
797 }
798 }
799 }
800
801
802
803 /**
804 * Inline the given function call operation.
805 * Return a new slang_operation that corresponds to the inlined code.
806 */
807 static slang_operation *
808 slang_inline_function_call(slang_assemble_ctx * A, slang_function *fun,
809 slang_operation *oper, slang_operation *returnOper)
810 {
811 typedef enum {
812 SUBST = 1,
813 COPY_IN,
814 COPY_OUT
815 } ParamMode;
816 ParamMode *paramMode;
817 const GLboolean haveRetValue = _slang_function_has_return_value(fun);
818 const GLuint numArgs = oper->num_children;
819 const GLuint totalArgs = numArgs + haveRetValue;
820 slang_operation *args = oper->children;
821 slang_operation *inlined, *top;
822 slang_variable **substOld;
823 slang_operation **substNew;
824 GLuint substCount, numCopyIn, i;
825 slang_function *prevFunction;
826
827 /* save / push */
828 prevFunction = A->CurFunction;
829 A->CurFunction = fun;
830
831 /*assert(oper->type == SLANG_OPER_CALL); (or (matrix) multiply, etc) */
832 assert(fun->param_count == totalArgs);
833
834 /* allocate temporary arrays */
835 paramMode = (ParamMode *)
836 _mesa_calloc(totalArgs * sizeof(ParamMode));
837 substOld = (slang_variable **)
838 _mesa_calloc(totalArgs * sizeof(slang_variable *));
839 substNew = (slang_operation **)
840 _mesa_calloc(totalArgs * sizeof(slang_operation *));
841
842 #if 0
843 printf("Inline call to %s (total vars=%d nparams=%d)\n",
844 (char *) fun->header.a_name,
845 fun->parameters->num_variables, numArgs);
846 #endif
847
848 if (haveRetValue && !returnOper) {
849 /* Create 3-child comma sequence for inlined code:
850 * child[0]: declare __resultTmp
851 * child[1]: inlined function body
852 * child[2]: __resultTmp
853 */
854 slang_operation *commaSeq;
855 slang_operation *declOper = NULL;
856 slang_variable *resultVar;
857
858 commaSeq = slang_operation_new(1);
859 commaSeq->type = SLANG_OPER_SEQUENCE;
860 assert(commaSeq->locals);
861 commaSeq->locals->outer_scope = oper->locals->outer_scope;
862 commaSeq->num_children = 3;
863 commaSeq->children = slang_operation_new(3);
864 /* allocate the return var */
865 resultVar = slang_variable_scope_grow(commaSeq->locals);
866 /*
867 printf("Alloc __resultTmp in scope %p for retval of calling %s\n",
868 (void*)commaSeq->locals, (char *) fun->header.a_name);
869 */
870
871 resultVar->a_name = slang_atom_pool_atom(A->atoms, "__resultTmp");
872 resultVar->type = fun->header.type; /* XXX copy? */
873 resultVar->isTemp = GL_TRUE;
874
875 /* child[0] = __resultTmp declaration */
876 declOper = &commaSeq->children[0];
877 declOper->type = SLANG_OPER_VARIABLE_DECL;
878 declOper->a_id = resultVar->a_name;
879 declOper->locals->outer_scope = commaSeq->locals;
880
881 /* child[1] = function body */
882 inlined = &commaSeq->children[1];
883 inlined->locals->outer_scope = commaSeq->locals;
884
885 /* child[2] = __resultTmp reference */
886 returnOper = &commaSeq->children[2];
887 returnOper->type = SLANG_OPER_IDENTIFIER;
888 returnOper->a_id = resultVar->a_name;
889 returnOper->locals->outer_scope = commaSeq->locals;
890
891 top = commaSeq;
892 }
893 else {
894 top = inlined = slang_operation_new(1);
895 /* XXXX this may be inappropriate!!!! */
896 inlined->locals->outer_scope = oper->locals->outer_scope;
897 }
898
899
900 assert(inlined->locals);
901
902 /* Examine the parameters, look for inout/out params, look for possible
903 * substitutions, etc:
904 * param type behaviour
905 * in copy actual to local
906 * const in substitute param with actual
907 * out copy out
908 */
909 substCount = 0;
910 for (i = 0; i < totalArgs; i++) {
911 slang_variable *p = fun->parameters->variables[i];
912 /*
913 printf("Param %d: %s %s \n", i,
914 slang_type_qual_string(p->type.qualifier),
915 (char *) p->a_name);
916 */
917 if (p->type.qualifier == SLANG_QUAL_INOUT ||
918 p->type.qualifier == SLANG_QUAL_OUT) {
919 /* an output param */
920 slang_operation *arg;
921 if (i < numArgs)
922 arg = &args[i];
923 else
924 arg = returnOper;
925 paramMode[i] = SUBST;
926
927 if (arg->type == SLANG_OPER_IDENTIFIER)
928 slang_resolve_variable(arg);
929
930 /* replace parameter 'p' with argument 'arg' */
931 substOld[substCount] = p;
932 substNew[substCount] = arg; /* will get copied */
933 substCount++;
934 }
935 else if (p->type.qualifier == SLANG_QUAL_CONST) {
936 /* a constant input param */
937 if (args[i].type == SLANG_OPER_IDENTIFIER ||
938 args[i].type == SLANG_OPER_LITERAL_FLOAT) {
939 /* replace all occurances of this parameter variable with the
940 * actual argument variable or a literal.
941 */
942 paramMode[i] = SUBST;
943 slang_resolve_variable(&args[i]);
944 substOld[substCount] = p;
945 substNew[substCount] = &args[i]; /* will get copied */
946 substCount++;
947 }
948 else {
949 paramMode[i] = COPY_IN;
950 }
951 }
952 else {
953 paramMode[i] = COPY_IN;
954 }
955 assert(paramMode[i]);
956 }
957
958 /* actual code inlining: */
959 slang_operation_copy(inlined, fun->body);
960
961 /*** XXX review this */
962 assert(inlined->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE);
963 inlined->type = SLANG_OPER_BLOCK_NEW_SCOPE;
964
965 #if 0
966 printf("======================= orig body code ======================\n");
967 printf("=== params scope = %p\n", (void*) fun->parameters);
968 slang_print_tree(fun->body, 8);
969 printf("======================= copied code =========================\n");
970 slang_print_tree(inlined, 8);
971 #endif
972
973 /* do parameter substitution in inlined code: */
974 slang_substitute(A, inlined, substCount, substOld, substNew, GL_FALSE);
975
976 #if 0
977 printf("======================= subst code ==========================\n");
978 slang_print_tree(inlined, 8);
979 printf("=============================================================\n");
980 #endif
981
982 /* New prolog statements: (inserted before the inlined code)
983 * Copy the 'in' arguments.
984 */
985 numCopyIn = 0;
986 for (i = 0; i < numArgs; i++) {
987 if (paramMode[i] == COPY_IN) {
988 slang_variable *p = fun->parameters->variables[i];
989 /* declare parameter 'p' */
990 slang_operation *decl = slang_operation_insert(&inlined->num_children,
991 &inlined->children,
992 numCopyIn);
993 /*
994 printf("COPY_IN %s from expr\n", (char*)p->a_name);
995 */
996 decl->type = SLANG_OPER_VARIABLE_DECL;
997 assert(decl->locals);
998 decl->locals->outer_scope = inlined->locals;
999 decl->a_id = p->a_name;
1000 decl->num_children = 1;
1001 decl->children = slang_operation_new(1);
1002
1003 /* child[0] is the var's initializer */
1004 slang_operation_copy(&decl->children[0], args + i);
1005
1006 numCopyIn++;
1007 }
1008 }
1009
1010 /* New epilog statements:
1011 * 1. Create end of function label to jump to from return statements.
1012 * 2. Copy the 'out' parameter vars
1013 */
1014 {
1015 slang_operation *lab = slang_operation_insert(&inlined->num_children,
1016 &inlined->children,
1017 inlined->num_children);
1018 lab->type = SLANG_OPER_LABEL;
1019 lab->label = A->curFuncEndLabel;
1020 }
1021
1022 for (i = 0; i < totalArgs; i++) {
1023 if (paramMode[i] == COPY_OUT) {
1024 const slang_variable *p = fun->parameters->variables[i];
1025 /* actualCallVar = outParam */
1026 /*if (i > 0 || !haveRetValue)*/
1027 slang_operation *ass = slang_operation_insert(&inlined->num_children,
1028 &inlined->children,
1029 inlined->num_children);
1030 ass->type = SLANG_OPER_ASSIGN;
1031 ass->num_children = 2;
1032 ass->locals->outer_scope = inlined->locals;
1033 ass->children = slang_operation_new(2);
1034 ass->children[0] = args[i]; /*XXX copy */
1035 ass->children[1].type = SLANG_OPER_IDENTIFIER;
1036 ass->children[1].a_id = p->a_name;
1037 ass->children[1].locals->outer_scope = ass->locals;
1038 }
1039 }
1040
1041 _mesa_free(paramMode);
1042 _mesa_free(substOld);
1043 _mesa_free(substNew);
1044
1045 #if 0
1046 printf("Done Inline call to %s (total vars=%d nparams=%d)\n",
1047 (char *) fun->header.a_name,
1048 fun->parameters->num_variables, numArgs);
1049 slang_print_tree(top, 0);
1050 #endif
1051
1052 /* pop */
1053 A->CurFunction = prevFunction;
1054
1055 return top;
1056 }
1057
1058
1059 static slang_ir_node *
1060 _slang_gen_function_call(slang_assemble_ctx *A, slang_function *fun,
1061 slang_operation *oper, slang_operation *dest)
1062 {
1063 slang_ir_node *n;
1064 slang_operation *inlined;
1065 slang_label *prevFuncEndLabel;
1066 char name[200];
1067
1068 prevFuncEndLabel = A->curFuncEndLabel;
1069 sprintf(name, "__endOfFunc_%s_", (char *) fun->header.a_name);
1070 A->curFuncEndLabel = _slang_label_new(name);
1071 assert(A->curFuncEndLabel);
1072
1073 if (slang_is_asm_function(fun) && !dest) {
1074 /* assemble assembly function - tree style */
1075 inlined = slang_inline_asm_function(A, fun, oper);
1076 }
1077 else {
1078 /* non-assembly function */
1079 inlined = slang_inline_function_call(A, fun, oper, dest);
1080 }
1081
1082 /* Replace the function call with the inlined block */
1083 slang_operation_destruct(oper);
1084 *oper = *inlined;
1085 /* XXX slang_operation_destruct(inlined) ??? */
1086
1087 #if 0
1088 assert(inlined->locals);
1089 printf("*** Inlined code for call to %s:\n",
1090 (char*) fun->header.a_name);
1091 slang_print_tree(oper, 10);
1092 printf("\n");
1093 #endif
1094
1095 n = _slang_gen_operation(A, oper);
1096
1097 /*_slang_label_delete(A->curFuncEndLabel);*/
1098 A->curFuncEndLabel = prevFuncEndLabel;
1099 assert(A->curFuncEndLabel);
1100
1101 return n;
1102 }
1103
1104
1105 static slang_asm_info *
1106 slang_find_asm_info(const char *name)
1107 {
1108 GLuint i;
1109 for (i = 0; AsmInfo[i].Name; i++) {
1110 if (_mesa_strcmp(AsmInfo[i].Name, name) == 0) {
1111 return AsmInfo + i;
1112 }
1113 }
1114 return NULL;
1115 }
1116
1117
1118 static GLuint
1119 make_writemask(const char *field)
1120 {
1121 GLuint mask = 0x0;
1122 while (*field) {
1123 switch (*field) {
1124 case 'x':
1125 mask |= WRITEMASK_X;
1126 break;
1127 case 'y':
1128 mask |= WRITEMASK_Y;
1129 break;
1130 case 'z':
1131 mask |= WRITEMASK_Z;
1132 break;
1133 case 'w':
1134 mask |= WRITEMASK_W;
1135 break;
1136 default:
1137 abort();
1138 }
1139 field++;
1140 }
1141 if (mask == 0x0)
1142 return WRITEMASK_XYZW;
1143 else
1144 return mask;
1145 }
1146
1147
1148 /**
1149 * Generate IR tree for an asm instruction/operation such as:
1150 * __asm vec4_dot __retVal.x, v1, v2;
1151 */
1152 static slang_ir_node *
1153 _slang_gen_asm(slang_assemble_ctx *A, slang_operation *oper,
1154 slang_operation *dest)
1155 {
1156 const slang_asm_info *info;
1157 slang_ir_node *kids[3], *n;
1158 GLuint j, firstOperand;
1159
1160 assert(oper->type == SLANG_OPER_ASM);
1161
1162 info = slang_find_asm_info((char *) oper->a_id);
1163 if (!info) {
1164 _mesa_problem(NULL, "undefined __asm function %s\n",
1165 (char *) oper->a_id);
1166 assert(info);
1167 }
1168 assert(info->NumParams <= 3);
1169
1170 if (info->NumParams == oper->num_children) {
1171 /* Storage for result is not specified.
1172 * Children[0], [1] are the operands.
1173 */
1174 firstOperand = 0;
1175 }
1176 else {
1177 /* Storage for result (child[0]) is specified.
1178 * Children[1], [2] are the operands.
1179 */
1180 firstOperand = 1;
1181 }
1182
1183 /* assemble child(ren) */
1184 kids[0] = kids[1] = kids[2] = NULL;
1185 for (j = 0; j < info->NumParams; j++) {
1186 kids[j] = _slang_gen_operation(A, &oper->children[firstOperand + j]);
1187 if (!kids[j])
1188 return NULL;
1189 }
1190
1191 n = new_node3(info->Opcode, kids[0], kids[1], kids[2]);
1192
1193 if (firstOperand) {
1194 /* Setup n->Store to be a particular location. Otherwise, storage
1195 * for the result (a temporary) will be allocated later.
1196 */
1197 GLuint writemask = WRITEMASK_XYZW;
1198 slang_operation *dest_oper;
1199 slang_ir_node *n0;
1200
1201 dest_oper = &oper->children[0];
1202 while (dest_oper->type == SLANG_OPER_FIELD) {
1203 /* writemask */
1204 writemask &= make_writemask((char*) dest_oper->a_id);
1205 dest_oper = &dest_oper->children[0];
1206 }
1207
1208 n0 = _slang_gen_operation(A, dest_oper);
1209 assert(n0->Var);
1210 assert(n0->Store);
1211 assert(!n->Store);
1212 n->Store = n0->Store;
1213 n->Writemask = writemask;
1214
1215 free(n0);
1216 }
1217
1218 return n;
1219 }
1220
1221
1222 static void
1223 print_funcs(struct slang_function_scope_ *scope, const char *name)
1224 {
1225 GLuint i;
1226 for (i = 0; i < scope->num_functions; i++) {
1227 slang_function *f = &scope->functions[i];
1228 if (!name || strcmp(name, (char*) f->header.a_name) == 0)
1229 printf(" %s (%d args)\n", name, f->param_count);
1230
1231 }
1232 if (scope->outer_scope)
1233 print_funcs(scope->outer_scope, name);
1234 }
1235
1236
1237 /**
1238 * Return first function in the scope that has the given name.
1239 * This is the function we'll try to call when there is no exact match
1240 * between function parameters and call arguments.
1241 *
1242 * XXX we should really create a list of candidate functions and try
1243 * all of them...
1244 */
1245 static slang_function *
1246 _slang_first_function(struct slang_function_scope_ *scope, const char *name)
1247 {
1248 GLuint i;
1249 for (i = 0; i < scope->num_functions; i++) {
1250 slang_function *f = &scope->functions[i];
1251 if (strcmp(name, (char*) f->header.a_name) == 0)
1252 return f;
1253 }
1254 if (scope->outer_scope)
1255 return _slang_first_function(scope->outer_scope, name);
1256 return NULL;
1257 }
1258
1259
1260
1261 /**
1262 * Assemble a function call, given a particular function name.
1263 * \param name the function's name (operators like '*' are possible).
1264 */
1265 static slang_ir_node *
1266 _slang_gen_function_call_name(slang_assemble_ctx *A, const char *name,
1267 slang_operation *oper, slang_operation *dest)
1268 {
1269 slang_operation *params = oper->children;
1270 const GLuint param_count = oper->num_children;
1271 slang_atom atom;
1272 slang_function *fun;
1273
1274 atom = slang_atom_pool_atom(A->atoms, name);
1275 if (atom == SLANG_ATOM_NULL)
1276 return NULL;
1277
1278 /*
1279 * Use 'name' to find the function to call
1280 */
1281 fun = _slang_locate_function(A->space.funcs, atom, params, param_count,
1282 &A->space, A->atoms, A->log);
1283 if (!fun) {
1284 /* A function with exactly the right parameters/types was not found.
1285 * Try adapting the parameters.
1286 */
1287 fun = _slang_first_function(A->space.funcs, name);
1288 if (!_slang_adapt_call(oper, fun, &A->space, A->atoms, A->log)) {
1289 slang_info_log_error(A->log, "Function '%s' not found (check argument types)", name);
1290 return NULL;
1291 }
1292 assert(fun);
1293 }
1294
1295 return _slang_gen_function_call(A, fun, oper, dest);
1296 }
1297
1298
1299 static GLboolean
1300 _slang_is_constant_cond(const slang_operation *oper, GLboolean *value)
1301 {
1302 if (oper->type == SLANG_OPER_LITERAL_FLOAT ||
1303 oper->type == SLANG_OPER_LITERAL_INT ||
1304 oper->type == SLANG_OPER_LITERAL_BOOL) {
1305 if (oper->literal[0])
1306 *value = GL_TRUE;
1307 else
1308 *value = GL_FALSE;
1309 return GL_TRUE;
1310 }
1311 else if (oper->type == SLANG_OPER_EXPRESSION &&
1312 oper->num_children == 1) {
1313 return _slang_is_constant_cond(&oper->children[0], value);
1314 }
1315 return GL_FALSE;
1316 }
1317
1318
1319
1320 /**
1321 * Generate loop code using high-level IR_LOOP instruction
1322 */
1323 static slang_ir_node *
1324 _slang_gen_while(slang_assemble_ctx * A, const slang_operation *oper)
1325 {
1326 /*
1327 * LOOP:
1328 * BREAK if !expr (child[0])
1329 * body code (child[1])
1330 */
1331 slang_ir_node *prevLoop, *loop, *cond, *breakIf, *body;
1332 GLboolean isConst, constTrue;
1333
1334 /* Check if loop condition is a constant */
1335 isConst = _slang_is_constant_cond(&oper->children[0], &constTrue);
1336
1337 if (isConst && !constTrue) {
1338 /* loop is never executed! */
1339 return new_node0(IR_NOP);
1340 }
1341
1342 loop = new_loop(NULL);
1343
1344 /* save old, push new loop */
1345 prevLoop = A->CurLoop;
1346 A->CurLoop = loop;
1347
1348 cond = new_cond(_slang_gen_operation(A, &oper->children[0]));
1349 if (isConst && constTrue) {
1350 /* while(nonzero constant), no conditional break */
1351 breakIf = NULL;
1352 }
1353 else {
1354 breakIf = new_break_if(A->CurLoop, cond, GL_FALSE);
1355 }
1356 body = _slang_gen_operation(A, &oper->children[1]);
1357 loop->Children[0] = new_seq(breakIf, body);
1358
1359 /* Do infinite loop detection */
1360 /* loop->List is head of linked list of break/continue nodes */
1361 if (!loop->List && isConst && constTrue) {
1362 /* infinite loop detected */
1363 A->CurLoop = prevLoop; /* clean-up */
1364 slang_info_log_error(A->log, "Infinite loop detected!");
1365 return NULL;
1366 }
1367
1368 /* pop loop, restore prev */
1369 A->CurLoop = prevLoop;
1370
1371 return loop;
1372 }
1373
1374
1375 /**
1376 * Generate IR tree for a do-while loop using high-level LOOP, IF instructions.
1377 */
1378 static slang_ir_node *
1379 _slang_gen_do(slang_assemble_ctx * A, const slang_operation *oper)
1380 {
1381 /*
1382 * LOOP:
1383 * body code (child[0])
1384 * tail code:
1385 * BREAK if !expr (child[1])
1386 */
1387 slang_ir_node *prevLoop, *loop, *cond;
1388 GLboolean isConst, constTrue;
1389
1390 loop = new_loop(NULL);
1391
1392 /* save old, push new loop */
1393 prevLoop = A->CurLoop;
1394 A->CurLoop = loop;
1395
1396 /* loop body: */
1397 loop->Children[0] = _slang_gen_operation(A, &oper->children[0]);
1398
1399 /* Check if loop condition is a constant */
1400 isConst = _slang_is_constant_cond(&oper->children[1], &constTrue);
1401 if (isConst && constTrue) {
1402 /* do { } while(1) ==> no conditional break */
1403 loop->Children[1] = NULL; /* no tail code */
1404 }
1405 else {
1406 cond = new_cond(_slang_gen_operation(A, &oper->children[1]));
1407 loop->Children[1] = new_break_if(A->CurLoop, cond, GL_FALSE);
1408 }
1409
1410 /* XXX we should do infinite loop detection, as above */
1411
1412 /* pop loop, restore prev */
1413 A->CurLoop = prevLoop;
1414
1415 return loop;
1416 }
1417
1418
1419 /**
1420 * Generate for-loop using high-level IR_LOOP instruction.
1421 */
1422 static slang_ir_node *
1423 _slang_gen_for(slang_assemble_ctx * A, const slang_operation *oper)
1424 {
1425 /*
1426 * init code (child[0])
1427 * LOOP:
1428 * BREAK if !expr (child[1])
1429 * body code (child[3])
1430 * tail code:
1431 * incr code (child[2]) // XXX continue here
1432 */
1433 slang_ir_node *prevLoop, *loop, *cond, *breakIf, *body, *init, *incr;
1434
1435 init = _slang_gen_operation(A, &oper->children[0]);
1436 loop = new_loop(NULL);
1437
1438 /* save old, push new loop */
1439 prevLoop = A->CurLoop;
1440 A->CurLoop = loop;
1441
1442 cond = new_cond(_slang_gen_operation(A, &oper->children[1]));
1443 breakIf = new_break_if(A->CurLoop, cond, GL_FALSE);
1444 body = _slang_gen_operation(A, &oper->children[3]);
1445 incr = _slang_gen_operation(A, &oper->children[2]);
1446
1447 loop->Children[0] = new_seq(breakIf, body);
1448 loop->Children[1] = incr; /* tail code */
1449
1450 /* pop loop, restore prev */
1451 A->CurLoop = prevLoop;
1452
1453 return new_seq(init, loop);
1454 }
1455
1456
1457 static slang_ir_node *
1458 _slang_gen_continue(slang_assemble_ctx * A, const slang_operation *oper)
1459 {
1460 slang_ir_node *n, *loopNode;
1461 assert(oper->type == SLANG_OPER_CONTINUE);
1462 loopNode = A->CurLoop;
1463 assert(loopNode);
1464 assert(loopNode->Opcode == IR_LOOP);
1465 n = new_node0(IR_CONT);
1466 if (n) {
1467 n->Parent = loopNode;
1468 /* insert this node at head of linked list */
1469 n->List = loopNode->List;
1470 loopNode->List = n;
1471 }
1472 return n;
1473 }
1474
1475
1476 /**
1477 * Determine if the given operation is of a specific type.
1478 */
1479 static GLboolean
1480 is_operation_type(const const slang_operation *oper, slang_operation_type type)
1481 {
1482 if (oper->type == type)
1483 return GL_TRUE;
1484 else if ((oper->type == SLANG_OPER_BLOCK_NEW_SCOPE ||
1485 oper->type == SLANG_OPER_BLOCK_NO_NEW_SCOPE) &&
1486 oper->num_children == 1)
1487 return is_operation_type(&oper->children[0], type);
1488 else
1489 return GL_FALSE;
1490 }
1491
1492
1493 /**
1494 * Generate IR tree for an if/then/else conditional using high-level
1495 * IR_IF instruction.
1496 */
1497 static slang_ir_node *
1498 _slang_gen_if(slang_assemble_ctx * A, const slang_operation *oper)
1499 {
1500 /*
1501 * eval expr (child[0])
1502 * IF expr THEN
1503 * if-body code
1504 * ELSE
1505 * else-body code
1506 * ENDIF
1507 */
1508 const GLboolean haveElseClause = !_slang_is_noop(&oper->children[2]);
1509 slang_ir_node *ifNode, *cond, *ifBody, *elseBody;
1510 GLboolean isConst, constTrue;
1511
1512 isConst = _slang_is_constant_cond(&oper->children[0], &constTrue);
1513 if (isConst) {
1514 if (constTrue) {
1515 /* if (true) ... */
1516 return _slang_gen_operation(A, &oper->children[1]);
1517 }
1518 else {
1519 /* if (false) ... */
1520 return _slang_gen_operation(A, &oper->children[2]);
1521 }
1522 }
1523
1524 cond = _slang_gen_operation(A, &oper->children[0]);
1525 cond = new_cond(cond);
1526
1527 if (is_operation_type(&oper->children[1], SLANG_OPER_BREAK)) {
1528 /* Special case: generate a conditional break */
1529 ifBody = new_break_if(A->CurLoop, cond, GL_TRUE);
1530 if (haveElseClause) {
1531 elseBody = _slang_gen_operation(A, &oper->children[2]);
1532 return new_seq(ifBody, elseBody);
1533 }
1534 return ifBody;
1535 }
1536 else if (is_operation_type(&oper->children[1], SLANG_OPER_CONTINUE)) {
1537 /* Special case: generate a conditional break */
1538 ifBody = new_cont_if(A->CurLoop, cond, GL_TRUE);
1539 if (haveElseClause) {
1540 elseBody = _slang_gen_operation(A, &oper->children[2]);
1541 return new_seq(ifBody, elseBody);
1542 }
1543 return ifBody;
1544 }
1545 else {
1546 /* general case */
1547 ifBody = _slang_gen_operation(A, &oper->children[1]);
1548 if (haveElseClause)
1549 elseBody = _slang_gen_operation(A, &oper->children[2]);
1550 else
1551 elseBody = NULL;
1552 ifNode = new_if(cond, ifBody, elseBody);
1553 return ifNode;
1554 }
1555 }
1556
1557
1558
1559 /**
1560 * Generate IR node for storage of a temporary of given size.
1561 */
1562 static slang_ir_node *
1563 _slang_gen_temporary(GLint size)
1564 {
1565 slang_ir_storage *store;
1566 slang_ir_node *n;
1567
1568 store = _slang_new_ir_storage(PROGRAM_TEMPORARY, -1, size);
1569 if (store) {
1570 n = new_node0(IR_VAR_DECL);
1571 if (n) {
1572 n->Store = store;
1573 }
1574 else {
1575 free(store);
1576 }
1577 }
1578 return n;
1579 }
1580
1581
1582 /**
1583 * Generate IR node for allocating/declaring a variable.
1584 */
1585 static slang_ir_node *
1586 _slang_gen_var_decl(slang_assemble_ctx *A, slang_variable *var)
1587 {
1588 slang_ir_node *n;
1589 assert(!is_sampler_type(&var->type));
1590 n = new_node0(IR_VAR_DECL);
1591 if (n) {
1592 _slang_attach_storage(n, var);
1593
1594 assert(var->aux);
1595 assert(n->Store == var->aux);
1596 assert(n->Store);
1597 assert(n->Store->Index < 0);
1598
1599 n->Store->File = PROGRAM_TEMPORARY;
1600 n->Store->Size = _slang_sizeof_type_specifier(&n->Var->type.specifier);
1601 assert(n->Store->Size > 0);
1602 }
1603 return n;
1604 }
1605
1606
1607 /**
1608 * Generate code for a selection expression: b ? x : y
1609 * XXX In some cases we could implement a selection expression
1610 * with an LRP instruction (use the boolean as the interpolant).
1611 * Otherwise, we use an IF/ELSE/ENDIF construct.
1612 */
1613 static slang_ir_node *
1614 _slang_gen_select(slang_assemble_ctx *A, slang_operation *oper)
1615 {
1616 slang_ir_node *cond, *ifNode, *trueExpr, *falseExpr, *trueNode, *falseNode;
1617 slang_ir_node *tmpDecl, *tmpVar, *tree;
1618 slang_typeinfo type;
1619 int size;
1620
1621 assert(oper->type == SLANG_OPER_SELECT);
1622 assert(oper->num_children == 3);
1623
1624 /* size of x or y's type */
1625 slang_typeinfo_construct(&type);
1626 _slang_typeof_operation(A, &oper->children[1], &type);
1627 size = _slang_sizeof_type_specifier(&type.spec);
1628 assert(size > 0);
1629
1630 /* temporary var */
1631 tmpDecl = _slang_gen_temporary(size);
1632
1633 /* the condition (child 0) */
1634 cond = _slang_gen_operation(A, &oper->children[0]);
1635 cond = new_cond(cond);
1636
1637 /* if-true body (child 1) */
1638 tmpVar = new_node0(IR_VAR);
1639 tmpVar->Store = tmpDecl->Store;
1640 trueExpr = _slang_gen_operation(A, &oper->children[1]);
1641 trueNode = new_node2(IR_MOVE, tmpVar, trueExpr);
1642
1643 /* if-false body (child 2) */
1644 tmpVar = new_node0(IR_VAR);
1645 tmpVar->Store = tmpDecl->Store;
1646 falseExpr = _slang_gen_operation(A, &oper->children[2]);
1647 falseNode = new_node2(IR_MOVE, tmpVar, falseExpr);
1648
1649 ifNode = new_if(cond, trueNode, falseNode);
1650
1651 /* tmp var value */
1652 tmpVar = new_node0(IR_VAR);
1653 tmpVar->Store = tmpDecl->Store;
1654
1655 tree = new_seq(ifNode, tmpVar);
1656 tree = new_seq(tmpDecl, tree);
1657
1658 /*_slang_print_ir_tree(tree, 10);*/
1659 return tree;
1660 }
1661
1662
1663 /**
1664 * Generate code for &&.
1665 */
1666 static slang_ir_node *
1667 _slang_gen_logical_and(slang_assemble_ctx *A, slang_operation *oper)
1668 {
1669 /* rewrite "a && b" as "a ? b : false" */
1670 slang_operation *select;
1671 slang_ir_node *n;
1672
1673 select = slang_operation_new(1);
1674 select->type = SLANG_OPER_SELECT;
1675 select->num_children = 3;
1676 select->children = slang_operation_new(3);
1677
1678 slang_operation_copy(&select->children[0], &oper->children[0]);
1679 slang_operation_copy(&select->children[1], &oper->children[1]);
1680 select->children[2].type = SLANG_OPER_LITERAL_BOOL;
1681 ASSIGN_4V(select->children[2].literal, 0, 0, 0, 0); /* false */
1682 select->children[2].literal_size = 1;
1683
1684 n = _slang_gen_select(A, select);
1685
1686 /* xxx wrong */
1687 free(select->children);
1688 free(select);
1689
1690 return n;
1691 }
1692
1693
1694 /**
1695 * Generate code for ||.
1696 */
1697 static slang_ir_node *
1698 _slang_gen_logical_or(slang_assemble_ctx *A, slang_operation *oper)
1699 {
1700 /* rewrite "a || b" as "a ? true : b" */
1701 slang_operation *select;
1702 slang_ir_node *n;
1703
1704 select = slang_operation_new(1);
1705 select->type = SLANG_OPER_SELECT;
1706 select->num_children = 3;
1707 select->children = slang_operation_new(3);
1708
1709 slang_operation_copy(&select->children[0], &oper->children[0]);
1710 select->children[1].type = SLANG_OPER_LITERAL_BOOL;
1711 ASSIGN_4V(select->children[1].literal, 1, 1, 1, 1); /* true */
1712 select->children[1].literal_size = 1;
1713 slang_operation_copy(&select->children[2], &oper->children[1]);
1714
1715 n = _slang_gen_select(A, select);
1716
1717 /* xxx wrong */
1718 free(select->children);
1719 free(select);
1720
1721 return n;
1722 }
1723
1724
1725 /**
1726 * Generate IR tree for a return statement.
1727 */
1728 static slang_ir_node *
1729 _slang_gen_return(slang_assemble_ctx * A, slang_operation *oper)
1730 {
1731 const GLboolean haveReturnValue
1732 = (oper->num_children == 1 &&
1733 oper->children[0].type != SLANG_OPER_VOID);
1734
1735 /* error checking */
1736 assert(A->CurFunction);
1737 if (haveReturnValue &&
1738 A->CurFunction->header.type.specifier.type == SLANG_SPEC_VOID) {
1739 slang_info_log_error(A->log, "illegal return expression");
1740 return NULL;
1741 }
1742 else if (!haveReturnValue &&
1743 A->CurFunction->header.type.specifier.type != SLANG_SPEC_VOID) {
1744 slang_info_log_error(A->log, "return statement requires an expression");
1745 return NULL;
1746 }
1747
1748 if (!haveReturnValue) {
1749 /* Convert from:
1750 * return;
1751 * To:
1752 * goto __endOfFunction;
1753 */
1754 slang_ir_node *n;
1755 slang_operation gotoOp;
1756 slang_operation_construct(&gotoOp);
1757 gotoOp.type = SLANG_OPER_GOTO;
1758 gotoOp.label = A->curFuncEndLabel;
1759 assert(gotoOp.label);
1760
1761 n = _slang_gen_operation(A, &gotoOp);
1762 /* destroy temp code */
1763 slang_operation_destruct(&gotoOp);
1764 return n;
1765 }
1766 else {
1767 /*
1768 * Convert from:
1769 * return expr;
1770 * To:
1771 * __retVal = expr;
1772 * goto __endOfFunction;
1773 */
1774 slang_operation *block, *assign, *jump;
1775 slang_atom a_retVal;
1776 slang_ir_node *n;
1777
1778 a_retVal = slang_atom_pool_atom(A->atoms, "__retVal");
1779 assert(a_retVal);
1780
1781 #if 1 /* DEBUG */
1782 {
1783 slang_variable *v
1784 = _slang_locate_variable(oper->locals, a_retVal, GL_TRUE);
1785 if (!v) {
1786 /* trying to return a value in a void-valued function */
1787 return NULL;
1788 }
1789 }
1790 #endif
1791
1792 block = slang_operation_new(1);
1793 block->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE;
1794 assert(block->locals);
1795 block->locals->outer_scope = oper->locals->outer_scope;
1796 block->num_children = 2;
1797 block->children = slang_operation_new(2);
1798
1799 /* child[0]: __retVal = expr; */
1800 assign = &block->children[0];
1801 assign->type = SLANG_OPER_ASSIGN;
1802 assign->locals->outer_scope = block->locals;
1803 assign->num_children = 2;
1804 assign->children = slang_operation_new(2);
1805 /* lhs (__retVal) */
1806 assign->children[0].type = SLANG_OPER_IDENTIFIER;
1807 assign->children[0].a_id = a_retVal;
1808 assign->children[0].locals->outer_scope = assign->locals;
1809 /* rhs (expr) */
1810 /* XXX we might be able to avoid this copy someday */
1811 slang_operation_copy(&assign->children[1], &oper->children[0]);
1812
1813 /* child[1]: goto __endOfFunction */
1814 jump = &block->children[1];
1815 jump->type = SLANG_OPER_GOTO;
1816 assert(A->curFuncEndLabel);
1817 /* XXX don't call function? */
1818 jump->label = A->curFuncEndLabel;
1819 assert(jump->label);
1820
1821 #if 0 /* debug */
1822 printf("NEW RETURN:\n");
1823 slang_print_tree(block, 0);
1824 #endif
1825
1826 /* assemble the new code */
1827 n = _slang_gen_operation(A, block);
1828 slang_operation_delete(block);
1829 return n;
1830 }
1831 }
1832
1833
1834 /**
1835 * Generate IR tree for a variable declaration.
1836 */
1837 static slang_ir_node *
1838 _slang_gen_declaration(slang_assemble_ctx *A, slang_operation *oper)
1839 {
1840 slang_ir_node *n;
1841 slang_ir_node *varDecl;
1842 slang_variable *v;
1843 const char *varName = (char *) oper->a_id;
1844
1845 assert(oper->num_children == 0 || oper->num_children == 1);
1846
1847 v = _slang_locate_variable(oper->locals, oper->a_id, GL_TRUE);
1848 assert(v);
1849
1850 varDecl = _slang_gen_var_decl(A, v);
1851
1852 if (oper->num_children > 0) {
1853 /* child is initializer */
1854 slang_ir_node *var, *init, *rhs;
1855 assert(oper->num_children == 1);
1856 var = new_var(A, oper, oper->a_id);
1857 if (!var) {
1858 slang_info_log_error(A->log, "undefined variable '%s'", varName);
1859 return NULL;
1860 }
1861 /* XXX make copy of this initializer? */
1862 rhs = _slang_gen_operation(A, &oper->children[0]);
1863 assert(rhs);
1864 init = new_node2(IR_MOVE, var, rhs);
1865 /*assert(rhs->Opcode != IR_SEQ);*/
1866 n = new_seq(varDecl, init);
1867 }
1868 else if (v->initializer) {
1869 slang_ir_node *var, *init, *rhs;
1870 var = new_var(A, oper, oper->a_id);
1871 if (!var) {
1872 slang_info_log_error(A->log, "undefined variable '%s'", varName);
1873 return NULL;
1874 }
1875 #if 0
1876 /* XXX make copy of this initializer? */
1877 {
1878 slang_operation dup;
1879 slang_operation_construct(&dup);
1880 slang_operation_copy(&dup, v->initializer);
1881 _slang_simplify(&dup, &A->space, A->atoms);
1882 rhs = _slang_gen_operation(A, &dup);
1883 }
1884 #else
1885 _slang_simplify(v->initializer, &A->space, A->atoms);
1886 rhs = _slang_gen_operation(A, v->initializer);
1887 #endif
1888 if (!rhs)
1889 return NULL;
1890
1891 assert(rhs);
1892 init = new_node2(IR_MOVE, var, rhs);
1893 /*
1894 assert(rhs->Opcode != IR_SEQ);
1895 */
1896 n = new_seq(varDecl, init);
1897 }
1898 else {
1899 n = varDecl;
1900 }
1901 return n;
1902 }
1903
1904
1905 /**
1906 * Generate IR tree for a variable (such as in an expression).
1907 */
1908 static slang_ir_node *
1909 _slang_gen_variable(slang_assemble_ctx * A, slang_operation *oper)
1910 {
1911 /* If there's a variable associated with this oper (from inlining)
1912 * use it. Otherwise, use the oper's var id.
1913 */
1914 slang_atom aVar = oper->var ? oper->var->a_name : oper->a_id;
1915 slang_ir_node *n = new_var(A, oper, aVar);
1916 if (!n) {
1917 slang_info_log_error(A->log, "undefined variable '%s'", (char *) aVar);
1918 return NULL;
1919 }
1920 return n;
1921 }
1922
1923
1924 /**
1925 * Some write-masked assignments are simple, but others are hard.
1926 * Simple example:
1927 * vec3 v;
1928 * v.xy = vec2(a, b);
1929 * Hard example:
1930 * vec3 v;
1931 * v.zy = vec2(a, b);
1932 * this gets transformed/swizzled into:
1933 * v.zy = vec2(a, b).*yx* (* = don't care)
1934 * This function helps to determine simple vs. non-simple.
1935 */
1936 static GLboolean
1937 _slang_simple_writemask(GLuint writemask, GLuint swizzle)
1938 {
1939 switch (writemask) {
1940 case WRITEMASK_X:
1941 return GET_SWZ(swizzle, 0) == SWIZZLE_X;
1942 case WRITEMASK_Y:
1943 return GET_SWZ(swizzle, 1) == SWIZZLE_Y;
1944 case WRITEMASK_Z:
1945 return GET_SWZ(swizzle, 2) == SWIZZLE_Z;
1946 case WRITEMASK_W:
1947 return GET_SWZ(swizzle, 3) == SWIZZLE_W;
1948 case WRITEMASK_XY:
1949 return (GET_SWZ(swizzle, 0) == SWIZZLE_X)
1950 && (GET_SWZ(swizzle, 1) == SWIZZLE_Y);
1951 case WRITEMASK_XYZ:
1952 return (GET_SWZ(swizzle, 0) == SWIZZLE_X)
1953 && (GET_SWZ(swizzle, 1) == SWIZZLE_Y)
1954 && (GET_SWZ(swizzle, 2) == SWIZZLE_Z);
1955 case WRITEMASK_XYZW:
1956 return swizzle == SWIZZLE_NOOP;
1957 default:
1958 return GL_FALSE;
1959 }
1960 }
1961
1962
1963 /**
1964 * Convert the given swizzle into a writemask. In some cases this
1965 * is trivial, in other cases, we'll need to also swizzle the right
1966 * hand side to put components in the right places.
1967 * \param swizzle the incoming swizzle
1968 * \param writemaskOut returns the writemask
1969 * \param swizzleOut swizzle to apply to the right-hand-side
1970 * \return GL_FALSE for simple writemasks, GL_TRUE for non-simple
1971 */
1972 static GLboolean
1973 swizzle_to_writemask(GLuint swizzle,
1974 GLuint *writemaskOut, GLuint *swizzleOut)
1975 {
1976 GLuint mask = 0x0, newSwizzle[4];
1977 GLint i, size;
1978
1979 /* make new dst writemask, compute size */
1980 for (i = 0; i < 4; i++) {
1981 const GLuint swz = GET_SWZ(swizzle, i);
1982 if (swz == SWIZZLE_NIL) {
1983 /* end */
1984 break;
1985 }
1986 assert(swz >= 0 && swz <= 3);
1987 mask |= (1 << swz);
1988 }
1989 assert(mask <= 0xf);
1990 size = i; /* number of components in mask/swizzle */
1991
1992 *writemaskOut = mask;
1993
1994 /* make new src swizzle, by inversion */
1995 for (i = 0; i < 4; i++) {
1996 newSwizzle[i] = i; /*identity*/
1997 }
1998 for (i = 0; i < size; i++) {
1999 const GLuint swz = GET_SWZ(swizzle, i);
2000 newSwizzle[swz] = i;
2001 }
2002 *swizzleOut = MAKE_SWIZZLE4(newSwizzle[0],
2003 newSwizzle[1],
2004 newSwizzle[2],
2005 newSwizzle[3]);
2006
2007 if (_slang_simple_writemask(mask, *swizzleOut)) {
2008 if (size >= 1)
2009 assert(GET_SWZ(*swizzleOut, 0) == SWIZZLE_X);
2010 if (size >= 2)
2011 assert(GET_SWZ(*swizzleOut, 1) == SWIZZLE_Y);
2012 if (size >= 3)
2013 assert(GET_SWZ(*swizzleOut, 2) == SWIZZLE_Z);
2014 if (size >= 4)
2015 assert(GET_SWZ(*swizzleOut, 3) == SWIZZLE_W);
2016 return GL_TRUE;
2017 }
2018 else
2019 return GL_FALSE;
2020 }
2021
2022
2023 static slang_ir_node *
2024 _slang_gen_swizzle(slang_ir_node *child, GLuint swizzle)
2025 {
2026 slang_ir_node *n = new_node1(IR_SWIZZLE, child);
2027 assert(child);
2028 if (n) {
2029 n->Store = _slang_new_ir_storage(PROGRAM_UNDEFINED, -1, -1);
2030 n->Store->Swizzle = swizzle;
2031 }
2032 return n;
2033 }
2034
2035
2036 /**
2037 * Generate IR tree for an assignment (=).
2038 */
2039 static slang_ir_node *
2040 _slang_gen_assignment(slang_assemble_ctx * A, slang_operation *oper)
2041 {
2042 if (oper->children[0].type == SLANG_OPER_IDENTIFIER &&
2043 oper->children[1].type == SLANG_OPER_CALL) {
2044 /* Special case of: x = f(a, b)
2045 * Replace with f(a, b, x) (where x == hidden __retVal out param)
2046 *
2047 * XXX this could be even more effective if we could accomodate
2048 * cases such as "v.x = f();" - would help with typical vertex
2049 * transformation.
2050 */
2051 slang_ir_node *n;
2052 n = _slang_gen_function_call_name(A,
2053 (const char *) oper->children[1].a_id,
2054 &oper->children[1], &oper->children[0]);
2055 return n;
2056 }
2057 else {
2058 slang_ir_node *n, *lhs, *rhs;
2059 lhs = _slang_gen_operation(A, &oper->children[0]);
2060
2061 if (lhs) {
2062 if (lhs->Store->File != PROGRAM_OUTPUT &&
2063 lhs->Store->File != PROGRAM_TEMPORARY &&
2064 lhs->Store->File != PROGRAM_VARYING &&
2065 lhs->Store->File != PROGRAM_UNDEFINED) {
2066 slang_info_log_error(A->log, "Assignment to read-only variable");
2067 return NULL;
2068 }
2069 }
2070
2071 rhs = _slang_gen_operation(A, &oper->children[1]);
2072 if (lhs && rhs) {
2073 /* convert lhs swizzle into writemask */
2074 GLuint writemask, newSwizzle;
2075 if (!swizzle_to_writemask(lhs->Store->Swizzle,
2076 &writemask, &newSwizzle)) {
2077 /* Non-simple writemask, need to swizzle right hand side in
2078 * order to put components into the right place.
2079 */
2080 rhs = _slang_gen_swizzle(rhs, newSwizzle);
2081 }
2082 n = new_node2(IR_MOVE, lhs, rhs);
2083 n->Writemask = writemask;
2084 return n;
2085 }
2086 else {
2087 return NULL;
2088 }
2089 }
2090 }
2091
2092
2093 /**
2094 * Generate IR tree for referencing a field in a struct (or basic vector type)
2095 */
2096 static slang_ir_node *
2097 _slang_gen_field(slang_assemble_ctx * A, slang_operation *oper)
2098 {
2099 slang_typeinfo ti;
2100
2101 /* type of struct */
2102 slang_typeinfo_construct(&ti);
2103 _slang_typeof_operation(A, &oper->children[0], &ti);
2104
2105 if (_slang_type_is_vector(ti.spec.type)) {
2106 /* the field should be a swizzle */
2107 const GLuint rows = _slang_type_dim(ti.spec.type);
2108 slang_swizzle swz;
2109 slang_ir_node *n;
2110 GLuint swizzle;
2111 if (!_slang_is_swizzle((char *) oper->a_id, rows, &swz)) {
2112 slang_info_log_error(A->log, "Bad swizzle");
2113 }
2114 swizzle = MAKE_SWIZZLE4(swz.swizzle[0],
2115 swz.swizzle[1],
2116 swz.swizzle[2],
2117 swz.swizzle[3]);
2118
2119 n = _slang_gen_operation(A, &oper->children[0]);
2120 /* create new parent node with swizzle */
2121 if (n)
2122 n = _slang_gen_swizzle(n, swizzle);
2123 return n;
2124 }
2125 else if (ti.spec.type == SLANG_SPEC_FLOAT) {
2126 const GLuint rows = 1;
2127 slang_swizzle swz;
2128 slang_ir_node *n;
2129 GLuint swizzle;
2130 if (!_slang_is_swizzle((char *) oper->a_id, rows, &swz)) {
2131 slang_info_log_error(A->log, "Bad swizzle");
2132 }
2133 swizzle = MAKE_SWIZZLE4(swz.swizzle[0],
2134 swz.swizzle[1],
2135 swz.swizzle[2],
2136 swz.swizzle[3]);
2137 n = _slang_gen_operation(A, &oper->children[0]);
2138 /* create new parent node with swizzle */
2139 n = _slang_gen_swizzle(n, swizzle);
2140 return n;
2141 }
2142 else {
2143 /* the field is a structure member (base.field) */
2144 /* oper->children[0] is the base */
2145 /* oper->a_id is the field name */
2146 slang_ir_node *base, *n;
2147 slang_typeinfo field_ti;
2148 GLint fieldSize, fieldOffset;
2149 /* type of field */
2150 slang_typeinfo_construct(&field_ti);
2151 _slang_typeof_operation(A, oper, &field_ti);
2152
2153 fieldSize = _slang_sizeof_type_specifier(&field_ti.spec);
2154 fieldOffset = _slang_field_offset(&ti.spec, oper->a_id);
2155
2156 if (fieldOffset < 0) {
2157 slang_info_log_error(A->log,
2158 "\"%s\" is not a member of struct \"%s\"",
2159 (char *) oper->a_id,
2160 (char *) ti.spec._struct->a_name);
2161 return NULL;
2162 }
2163 assert(fieldSize >= 0);
2164
2165 base = _slang_gen_operation(A, &oper->children[0]);
2166 if (!base) {
2167 /* error msg should have already been logged */
2168 return NULL;
2169 }
2170
2171 n = new_node1(IR_FIELD, base);
2172 if (n) {
2173 n->Field = (char *) oper->a_id;
2174 n->FieldOffset = fieldOffset;
2175 assert(n->FieldOffset >= 0);
2176 n->Store = _slang_new_ir_storage(base->Store->File,
2177 base->Store->Index,
2178 fieldSize);
2179 }
2180 return n;
2181
2182 #if 0
2183 _mesa_problem(NULL, "glsl structs/fields not supported yet");
2184 return NULL;
2185 #endif
2186 }
2187 }
2188
2189
2190 /**
2191 * Gen code for array indexing.
2192 */
2193 static slang_ir_node *
2194 _slang_gen_subscript(slang_assemble_ctx * A, slang_operation *oper)
2195 {
2196 slang_typeinfo array_ti;
2197
2198 /* get array's type info */
2199 slang_typeinfo_construct(&array_ti);
2200 _slang_typeof_operation(A, &oper->children[0], &array_ti);
2201
2202 if (_slang_type_is_vector(array_ti.spec.type)) {
2203 /* indexing a simple vector type: "vec4 v; v[0]=p;" */
2204 /* translate the index into a swizzle/writemask: "v.x=p" */
2205 const GLuint max = _slang_type_dim(array_ti.spec.type);
2206 GLint index;
2207 slang_ir_node *n;
2208
2209 index = (GLint) oper->children[1].literal[0];
2210 if (oper->children[1].type != SLANG_OPER_LITERAL_INT ||
2211 index >= max) {
2212 slang_info_log_error(A->log, "Invalid array index for vector type");
2213 return NULL;
2214 }
2215
2216 n = _slang_gen_operation(A, &oper->children[0]);
2217 if (n) {
2218 /* use swizzle to access the element */
2219 GLuint swizzle = MAKE_SWIZZLE4(SWIZZLE_X + index,
2220 SWIZZLE_NIL,
2221 SWIZZLE_NIL,
2222 SWIZZLE_NIL);
2223 n = _slang_gen_swizzle(n, swizzle);
2224 /*n->Store = _slang_clone_ir_storage_swz(n->Store, */
2225 n->Writemask = WRITEMASK_X << index;
2226 }
2227 return n;
2228 }
2229 else {
2230 /* conventional array */
2231 slang_typeinfo elem_ti;
2232 slang_ir_node *elem, *array, *index;
2233 GLint elemSize, arrayLen;
2234
2235 /* size of array element */
2236 slang_typeinfo_construct(&elem_ti);
2237 _slang_typeof_operation(A, oper, &elem_ti);
2238 elemSize = _slang_sizeof_type_specifier(&elem_ti.spec);
2239
2240 if (_slang_type_is_matrix(array_ti.spec.type))
2241 arrayLen = _slang_type_dim(array_ti.spec.type);
2242 else
2243 arrayLen = array_ti.array_len;
2244
2245 slang_typeinfo_destruct(&array_ti);
2246 slang_typeinfo_destruct(&elem_ti);
2247
2248 if (elemSize <= 0) {
2249 /* unknown var or type */
2250 slang_info_log_error(A->log, "Undefined variable or type");
2251 return NULL;
2252 }
2253
2254 array = _slang_gen_operation(A, &oper->children[0]);
2255 index = _slang_gen_operation(A, &oper->children[1]);
2256 if (array && index) {
2257 /* bounds check */
2258 if (index->Opcode == IR_FLOAT &&
2259 ((int) index->Value[0] < 0 ||
2260 (int) index->Value[0] >= arrayLen)) {
2261 slang_info_log_error(A->log,
2262 "Array index out of bounds (index=%d size=%d)",
2263 (int) index->Value[0], arrayLen);
2264 _slang_free_ir_tree(array);
2265 _slang_free_ir_tree(index);
2266 return NULL;
2267 }
2268
2269 elem = new_node2(IR_ELEMENT, array, index);
2270 elem->Store = _slang_new_ir_storage(array->Store->File,
2271 array->Store->Index,
2272 elemSize);
2273 /* XXX try to do some array bounds checking here */
2274 return elem;
2275 }
2276 else {
2277 _slang_free_ir_tree(array);
2278 _slang_free_ir_tree(index);
2279 return NULL;
2280 }
2281 }
2282 }
2283
2284
2285 /**
2286 * Look for expressions such as: gl_ModelviewMatrix * gl_Vertex
2287 * and replace with this: gl_Vertex * gl_ModelviewMatrixTranpose
2288 * Since matrices are stored in column-major order, the second form of
2289 * multiplication is much more efficient (just 4 dot products).
2290 */
2291 static void
2292 _slang_check_matmul_optimization(slang_assemble_ctx *A, slang_operation *oper)
2293 {
2294 static const struct {
2295 const char *orig;
2296 const char *tranpose;
2297 } matrices[] = {
2298 {"gl_ModelViewMatrix", "gl_ModelViewMatrixTranspose"},
2299 {"gl_ProjectionMatrix", "gl_ProjectionMatrixTranspose"},
2300 {"gl_ModelViewProjectionMatrix", "gl_ModelViewProjectionMatrixTranspose"},
2301 {"gl_TextureMatrix", "gl_TextureMatrixTranspose"},
2302 {"gl_NormalMatrix", "__NormalMatrixTranspose"},
2303 { NULL, NULL }
2304 };
2305
2306 assert(oper->type == SLANG_OPER_MULTIPLY);
2307 if (oper->children[0].type == SLANG_OPER_IDENTIFIER) {
2308 GLuint i;
2309 for (i = 0; matrices[i].orig; i++) {
2310 if (oper->children[0].a_id
2311 == slang_atom_pool_atom(A->atoms, matrices[i].orig)) {
2312 /*
2313 _mesa_printf("Replace %s with %s\n",
2314 matrices[i].orig, matrices[i].tranpose);
2315 */
2316 assert(oper->children[0].type == SLANG_OPER_IDENTIFIER);
2317 oper->children[0].a_id
2318 = slang_atom_pool_atom(A->atoms, matrices[i].tranpose);
2319 /* finally, swap the operands */
2320 _slang_operation_swap(&oper->children[0], &oper->children[1]);
2321 return;
2322 }
2323 }
2324 }
2325 }
2326
2327
2328 /**
2329 * Generate IR tree for a slang_operation (AST node)
2330 */
2331 static slang_ir_node *
2332 _slang_gen_operation(slang_assemble_ctx * A, slang_operation *oper)
2333 {
2334 switch (oper->type) {
2335 case SLANG_OPER_BLOCK_NEW_SCOPE:
2336 {
2337 slang_ir_node *n;
2338
2339 _slang_push_var_table(A->vartable);
2340
2341 oper->type = SLANG_OPER_BLOCK_NO_NEW_SCOPE; /* temp change */
2342 n = _slang_gen_operation(A, oper);
2343 oper->type = SLANG_OPER_BLOCK_NEW_SCOPE; /* restore */
2344
2345 _slang_pop_var_table(A->vartable);
2346
2347 if (n)
2348 n = new_node1(IR_SCOPE, n);
2349 return n;
2350 }
2351 break;
2352
2353 case SLANG_OPER_BLOCK_NO_NEW_SCOPE:
2354 /* list of operations */
2355 if (oper->num_children > 0)
2356 {
2357 slang_ir_node *n, *tree = NULL;
2358 GLuint i;
2359
2360 for (i = 0; i < oper->num_children; i++) {
2361 n = _slang_gen_operation(A, &oper->children[i]);
2362 if (!n) {
2363 _slang_free_ir_tree(tree);
2364 return NULL; /* error must have occured */
2365 }
2366 tree = tree ? new_seq(tree, n) : n;
2367 }
2368
2369 #if 00
2370 if (oper->locals->num_variables > 0) {
2371 int i;
2372 /*
2373 printf("\n****** Deallocate vars in scope!\n");
2374 */
2375 for (i = 0; i < oper->locals->num_variables; i++) {
2376 slang_variable *v = oper->locals->variables + i;
2377 if (v->aux) {
2378 slang_ir_storage *store = (slang_ir_storage *) v->aux;
2379 /*
2380 printf(" Deallocate var %s\n", (char*) v->a_name);
2381 */
2382 assert(store->File == PROGRAM_TEMPORARY);
2383 assert(store->Index >= 0);
2384 _slang_free_temp(A->vartable, store->Index, store->Size);
2385 }
2386 }
2387 }
2388 #endif
2389 return tree;
2390 }
2391 else {
2392 return new_node0(IR_NOP);
2393 }
2394
2395 case SLANG_OPER_EXPRESSION:
2396 return _slang_gen_operation(A, &oper->children[0]);
2397
2398 case SLANG_OPER_FOR:
2399 return _slang_gen_for(A, oper);
2400 case SLANG_OPER_DO:
2401 return _slang_gen_do(A, oper);
2402 case SLANG_OPER_WHILE:
2403 return _slang_gen_while(A, oper);
2404 case SLANG_OPER_BREAK:
2405 if (!A->CurLoop) {
2406 slang_info_log_error(A->log, "'break' not in loop");
2407 }
2408 return new_break(A->CurLoop);
2409 case SLANG_OPER_CONTINUE:
2410 if (!A->CurLoop) {
2411 slang_info_log_error(A->log, "'continue' not in loop");
2412 }
2413 return _slang_gen_continue(A, oper);
2414 case SLANG_OPER_DISCARD:
2415 return new_node0(IR_KILL);
2416
2417 case SLANG_OPER_EQUAL:
2418 return new_node2(IR_EQUAL,
2419 _slang_gen_operation(A, &oper->children[0]),
2420 _slang_gen_operation(A, &oper->children[1]));
2421 case SLANG_OPER_NOTEQUAL:
2422 return new_node2(IR_NOTEQUAL,
2423 _slang_gen_operation(A, &oper->children[0]),
2424 _slang_gen_operation(A, &oper->children[1]));
2425 case SLANG_OPER_GREATER:
2426 return new_node2(IR_SGT,
2427 _slang_gen_operation(A, &oper->children[0]),
2428 _slang_gen_operation(A, &oper->children[1]));
2429 case SLANG_OPER_LESS:
2430 return new_node2(IR_SLT,
2431 _slang_gen_operation(A, &oper->children[0]),
2432 _slang_gen_operation(A, &oper->children[1]));
2433 case SLANG_OPER_GREATEREQUAL:
2434 return new_node2(IR_SGE,
2435 _slang_gen_operation(A, &oper->children[0]),
2436 _slang_gen_operation(A, &oper->children[1]));
2437 case SLANG_OPER_LESSEQUAL:
2438 return new_node2(IR_SLE,
2439 _slang_gen_operation(A, &oper->children[0]),
2440 _slang_gen_operation(A, &oper->children[1]));
2441 case SLANG_OPER_ADD:
2442 {
2443 slang_ir_node *n;
2444 assert(oper->num_children == 2);
2445 n = _slang_gen_function_call_name(A, "+", oper, NULL);
2446 return n;
2447 }
2448 case SLANG_OPER_SUBTRACT:
2449 {
2450 slang_ir_node *n;
2451 assert(oper->num_children == 2);
2452 n = _slang_gen_function_call_name(A, "-", oper, NULL);
2453 return n;
2454 }
2455 case SLANG_OPER_MULTIPLY:
2456 {
2457 slang_ir_node *n;
2458 assert(oper->num_children == 2);
2459 _slang_check_matmul_optimization(A, oper);
2460 n = _slang_gen_function_call_name(A, "*", oper, NULL);
2461 return n;
2462 }
2463 case SLANG_OPER_DIVIDE:
2464 {
2465 slang_ir_node *n;
2466 assert(oper->num_children == 2);
2467 n = _slang_gen_function_call_name(A, "/", oper, NULL);
2468 return n;
2469 }
2470 case SLANG_OPER_MINUS:
2471 {
2472 slang_ir_node *n;
2473 assert(oper->num_children == 1);
2474 n = _slang_gen_function_call_name(A, "-", oper, NULL);
2475 return n;
2476 }
2477 case SLANG_OPER_PLUS:
2478 /* +expr --> do nothing */
2479 return _slang_gen_operation(A, &oper->children[0]);
2480 case SLANG_OPER_VARIABLE_DECL:
2481 return _slang_gen_declaration(A, oper);
2482 case SLANG_OPER_ASSIGN:
2483 return _slang_gen_assignment(A, oper);
2484 case SLANG_OPER_ADDASSIGN:
2485 {
2486 slang_ir_node *n;
2487 assert(oper->num_children == 2);
2488 n = _slang_gen_function_call_name(A, "+=", oper, &oper->children[0]);
2489 return n;
2490 }
2491 case SLANG_OPER_SUBASSIGN:
2492 {
2493 slang_ir_node *n;
2494 assert(oper->num_children == 2);
2495 n = _slang_gen_function_call_name(A, "-=", oper, &oper->children[0]);
2496 return n;
2497 }
2498 break;
2499 case SLANG_OPER_MULASSIGN:
2500 {
2501 slang_ir_node *n;
2502 assert(oper->num_children == 2);
2503 n = _slang_gen_function_call_name(A, "*=", oper, &oper->children[0]);
2504 return n;
2505 }
2506 case SLANG_OPER_DIVASSIGN:
2507 {
2508 slang_ir_node *n;
2509 assert(oper->num_children == 2);
2510 n = _slang_gen_function_call_name(A, "/=", oper, &oper->children[0]);
2511 return n;
2512 }
2513 case SLANG_OPER_LOGICALAND:
2514 {
2515 slang_ir_node *n;
2516 assert(oper->num_children == 2);
2517 n = _slang_gen_logical_and(A, oper);
2518 return n;
2519 }
2520 case SLANG_OPER_LOGICALOR:
2521 {
2522 slang_ir_node *n;
2523 assert(oper->num_children == 2);
2524 n = _slang_gen_logical_or(A, oper);
2525 return n;
2526 }
2527 case SLANG_OPER_LOGICALXOR:
2528 {
2529 slang_ir_node *n;
2530 assert(oper->num_children == 2);
2531 n = _slang_gen_function_call_name(A, "__logicalXor", oper, NULL);
2532 return n;
2533 }
2534 case SLANG_OPER_NOT:
2535 {
2536 slang_ir_node *n;
2537 assert(oper->num_children == 1);
2538 n = _slang_gen_function_call_name(A, "__logicalNot", oper, NULL);
2539 return n;
2540 }
2541
2542 case SLANG_OPER_SELECT: /* b ? x : y */
2543 {
2544 slang_ir_node *n;
2545 assert(oper->num_children == 3);
2546 n = _slang_gen_select(A, oper);
2547 return n;
2548 }
2549
2550 case SLANG_OPER_ASM:
2551 return _slang_gen_asm(A, oper, NULL);
2552 case SLANG_OPER_CALL:
2553 return _slang_gen_function_call_name(A, (const char *) oper->a_id,
2554 oper, NULL);
2555 case SLANG_OPER_RETURN:
2556 return _slang_gen_return(A, oper);
2557 case SLANG_OPER_GOTO:
2558 return new_jump(oper->label);
2559 case SLANG_OPER_LABEL:
2560 return new_label(oper->label);
2561 case SLANG_OPER_IDENTIFIER:
2562 return _slang_gen_variable(A, oper);
2563 case SLANG_OPER_IF:
2564 return _slang_gen_if(A, oper);
2565 case SLANG_OPER_FIELD:
2566 return _slang_gen_field(A, oper);
2567 case SLANG_OPER_SUBSCRIPT:
2568 return _slang_gen_subscript(A, oper);
2569 case SLANG_OPER_LITERAL_FLOAT:
2570 /* fall-through */
2571 case SLANG_OPER_LITERAL_INT:
2572 /* fall-through */
2573 case SLANG_OPER_LITERAL_BOOL:
2574 return new_float_literal(oper->literal, oper->literal_size);
2575
2576 case SLANG_OPER_POSTINCREMENT: /* var++ */
2577 {
2578 slang_ir_node *n;
2579 assert(oper->num_children == 1);
2580 n = _slang_gen_function_call_name(A, "__postIncr", oper, NULL);
2581 return n;
2582 }
2583 case SLANG_OPER_POSTDECREMENT: /* var-- */
2584 {
2585 slang_ir_node *n;
2586 assert(oper->num_children == 1);
2587 n = _slang_gen_function_call_name(A, "__postDecr", oper, NULL);
2588 return n;
2589 }
2590 case SLANG_OPER_PREINCREMENT: /* ++var */
2591 {
2592 slang_ir_node *n;
2593 assert(oper->num_children == 1);
2594 n = _slang_gen_function_call_name(A, "++", oper, NULL);
2595 return n;
2596 }
2597 case SLANG_OPER_PREDECREMENT: /* --var */
2598 {
2599 slang_ir_node *n;
2600 assert(oper->num_children == 1);
2601 n = _slang_gen_function_call_name(A, "--", oper, NULL);
2602 return n;
2603 }
2604
2605 case SLANG_OPER_SEQUENCE:
2606 {
2607 slang_ir_node *tree = NULL;
2608 GLuint i;
2609 for (i = 0; i < oper->num_children; i++) {
2610 slang_ir_node *n = _slang_gen_operation(A, &oper->children[i]);
2611 tree = tree ? new_seq(tree, n) : n;
2612 }
2613 return tree;
2614 }
2615
2616 case SLANG_OPER_NONE:
2617 case SLANG_OPER_VOID:
2618 /* returning NULL here would generate an error */
2619 return new_node0(IR_NOP);
2620
2621 default:
2622 printf("Unhandled node type %d\n", oper->type);
2623 abort();
2624 return new_node0(IR_NOP);
2625 }
2626
2627 return NULL;
2628 }
2629
2630
2631
2632 /**
2633 * Called by compiler when a global variable has been parsed/compiled.
2634 * Here we examine the variable's type to determine what kind of register
2635 * storage will be used.
2636 *
2637 * A uniform such as "gl_Position" will become the register specification
2638 * (PROGRAM_OUTPUT, VERT_RESULT_HPOS). Or, uniform "gl_FogFragCoord"
2639 * will be (PROGRAM_INPUT, FRAG_ATTRIB_FOGC).
2640 *
2641 * Samplers are interesting. For "uniform sampler2D tex;" we'll specify
2642 * (PROGRAM_SAMPLER, index) where index is resolved at link-time to an
2643 * actual texture unit (as specified by the user calling glUniform1i()).
2644 */
2645 GLboolean
2646 _slang_codegen_global_variable(slang_assemble_ctx *A, slang_variable *var,
2647 slang_unit_type type)
2648 {
2649 struct gl_program *prog = A->program;
2650 const char *varName = (char *) var->a_name;
2651 GLboolean success = GL_TRUE;
2652 GLint texIndex;
2653 slang_ir_storage *store = NULL;
2654 int dbg = 0;
2655
2656 texIndex = sampler_to_texture_index(var->type.specifier.type);
2657
2658 if (texIndex != -1) {
2659 /* Texture sampler:
2660 * store->File = PROGRAM_SAMPLER
2661 * store->Index = sampler uniform location
2662 * store->Size = texture type index (1D, 2D, 3D, cube, etc)
2663 */
2664 GLint samplerUniform = _mesa_add_sampler(prog->Parameters, varName);
2665 store = _slang_new_ir_storage(PROGRAM_SAMPLER, samplerUniform, texIndex);
2666 if (dbg) printf("SAMPLER ");
2667 }
2668 else if (var->type.qualifier == SLANG_QUAL_UNIFORM) {
2669 /* Uniform variable */
2670 const GLint size = _slang_sizeof_type_specifier(&var->type.specifier)
2671 * MAX2(var->array_len, 1);
2672 if (prog) {
2673 /* user-defined uniform */
2674 GLint uniformLoc = _mesa_add_uniform(prog->Parameters, varName, size);
2675 store = _slang_new_ir_storage(PROGRAM_UNIFORM, uniformLoc, size);
2676 }
2677 else {
2678 /* pre-defined uniform, like gl_ModelviewMatrix */
2679 /* We know it's a uniform, but don't allocate storage unless
2680 * it's really used.
2681 */
2682 store = _slang_new_ir_storage(PROGRAM_STATE_VAR, -1, size);
2683 }
2684 if (dbg) printf("UNIFORM (sz %d) ", size);
2685 }
2686 else if (var->type.qualifier == SLANG_QUAL_VARYING) {
2687 const GLint size = 4; /* XXX fix */
2688 if (prog) {
2689 /* user-defined varying */
2690 GLint varyingLoc = _mesa_add_varying(prog->Varying, varName, size);
2691 store = _slang_new_ir_storage(PROGRAM_VARYING, varyingLoc, size);
2692 }
2693 else {
2694 /* pre-defined varying, like gl_Color or gl_TexCoord */
2695 if (type == SLANG_UNIT_FRAGMENT_BUILTIN) {
2696 GLuint swizzle;
2697 GLint index = _slang_input_index(varName, GL_FRAGMENT_PROGRAM_ARB,
2698 &swizzle);
2699 assert(index >= 0);
2700 store = _slang_new_ir_storage(PROGRAM_INPUT, index, size);
2701 store->Swizzle = swizzle;
2702 assert(index < FRAG_ATTRIB_MAX);
2703 }
2704 else {
2705 GLint index = _slang_output_index(varName, GL_VERTEX_PROGRAM_ARB);
2706 assert(index >= 0);
2707 assert(type == SLANG_UNIT_VERTEX_BUILTIN);
2708 store = _slang_new_ir_storage(PROGRAM_OUTPUT, index, size);
2709 assert(index < VERT_RESULT_MAX);
2710 }
2711 if (dbg) printf("V/F ");
2712 }
2713 if (dbg) printf("VARYING ");
2714 }
2715 else if (var->type.qualifier == SLANG_QUAL_ATTRIBUTE) {
2716 if (prog) {
2717 /* user-defined vertex attribute */
2718 const GLint size = _slang_sizeof_type_specifier(&var->type.specifier);
2719 const GLint attr = -1; /* unknown */
2720 GLint index = _mesa_add_attribute(prog->Attributes, varName,
2721 size, attr);
2722 assert(index >= 0);
2723 store = _slang_new_ir_storage(PROGRAM_INPUT,
2724 VERT_ATTRIB_GENERIC0 + index, size);
2725 }
2726 else {
2727 /* pre-defined vertex attrib */
2728 GLuint swizzle;
2729 GLint index = _slang_input_index(varName, GL_VERTEX_PROGRAM_ARB,
2730 &swizzle);
2731 GLint size = 4; /* XXX? */
2732 assert(index >= 0);
2733 store = _slang_new_ir_storage(PROGRAM_INPUT, index, size);
2734 store->Swizzle = swizzle;
2735 }
2736 if (dbg) printf("ATTRIB ");
2737 }
2738 else if (var->type.qualifier == SLANG_QUAL_FIXEDINPUT) {
2739 GLuint swizzle;
2740 GLint index = _slang_input_index(varName, GL_FRAGMENT_PROGRAM_ARB,
2741 &swizzle);
2742 GLint size = 4; /* XXX? */
2743 store = _slang_new_ir_storage(PROGRAM_INPUT, index, size);
2744 store->Swizzle = swizzle;
2745 if (dbg) printf("INPUT ");
2746 }
2747 else if (var->type.qualifier == SLANG_QUAL_FIXEDOUTPUT) {
2748 if (type == SLANG_UNIT_VERTEX_BUILTIN) {
2749 GLint index = _slang_output_index(varName, GL_VERTEX_PROGRAM_ARB);
2750 GLint size = 4; /* XXX? */
2751 store = _slang_new_ir_storage(PROGRAM_OUTPUT, index, size);
2752 }
2753 else {
2754 assert(type == SLANG_UNIT_FRAGMENT_BUILTIN);
2755 GLint index = _slang_output_index(varName, GL_FRAGMENT_PROGRAM_ARB);
2756 GLint size = 4; /* XXX? */
2757 store = _slang_new_ir_storage(PROGRAM_OUTPUT, index, size);
2758 }
2759 if (dbg) printf("OUTPUT ");
2760 }
2761 else if (var->type.qualifier == SLANG_QUAL_CONST && !prog) {
2762 /* pre-defined global constant, like gl_MaxLights */
2763 const GLint size = _slang_sizeof_type_specifier(&var->type.specifier);
2764 store = _slang_new_ir_storage(PROGRAM_CONSTANT, -1, size);
2765 if (dbg) printf("CONST ");
2766 }
2767 else {
2768 /* ordinary variable (may be const) */
2769 slang_ir_node *n;
2770
2771 /* IR node to declare the variable */
2772 n = _slang_gen_var_decl(A, var);
2773
2774 /* IR code for the var's initializer, if present */
2775 if (var->initializer) {
2776 slang_ir_node *lhs, *rhs, *init;
2777
2778 /* Generate IR_MOVE instruction to initialize the variable */
2779 lhs = new_node0(IR_VAR);
2780 lhs->Var = var;
2781 lhs->Store = n->Store;
2782
2783 /* constant folding, etc */
2784 _slang_simplify(var->initializer, &A->space, A->atoms);
2785
2786 rhs = _slang_gen_operation(A, var->initializer);
2787 assert(rhs);
2788 init = new_node2(IR_MOVE, lhs, rhs);
2789 n = new_seq(n, init);
2790 }
2791
2792 success = _slang_emit_code(n, A->vartable, A->program, GL_FALSE, A->log);
2793
2794 _slang_free_ir_tree(n);
2795 }
2796
2797 if (dbg) printf("GLOBAL VAR %s idx %d\n", (char*) var->a_name,
2798 store ? store->Index : -2);
2799
2800 if (store)
2801 var->aux = store; /* save var's storage info */
2802
2803 return success;
2804 }
2805
2806
2807 /**
2808 * Produce an IR tree from a function AST (fun->body).
2809 * Then call the code emitter to convert the IR tree into gl_program
2810 * instructions.
2811 */
2812 GLboolean
2813 _slang_codegen_function(slang_assemble_ctx * A, slang_function * fun)
2814 {
2815 slang_ir_node *n;
2816 GLboolean success = GL_TRUE;
2817
2818 if (_mesa_strcmp((char *) fun->header.a_name, "main") != 0) {
2819 /* we only really generate code for main, all other functions get
2820 * inlined.
2821 */
2822 return GL_TRUE; /* not an error */
2823 }
2824
2825 #if 0
2826 printf("\n*********** codegen_function %s\n", (char *) fun->header.a_name);
2827 slang_print_function(fun, 1);
2828 #endif
2829
2830 /* should have been allocated earlier: */
2831 assert(A->program->Parameters );
2832 assert(A->program->Varying);
2833 assert(A->vartable);
2834 A->CurLoop = NULL;
2835 A->CurFunction = fun;
2836
2837 /* fold constant expressions, etc. */
2838 _slang_simplify(fun->body, &A->space, A->atoms);
2839
2840 #if 0
2841 printf("\n*********** simplified %s\n", (char *) fun->header.a_name);
2842 slang_print_function(fun, 1);
2843 #endif
2844
2845 /* Create an end-of-function label */
2846 A->curFuncEndLabel = _slang_label_new("__endOfFunc__main");
2847
2848 /* push new vartable scope */
2849 _slang_push_var_table(A->vartable);
2850
2851 /* Generate IR tree for the function body code */
2852 n = _slang_gen_operation(A, fun->body);
2853 if (n)
2854 n = new_node1(IR_SCOPE, n);
2855
2856 /* pop vartable, restore previous */
2857 _slang_pop_var_table(A->vartable);
2858
2859 if (!n) {
2860 /* XXX record error */
2861 return GL_FALSE;
2862 }
2863
2864 /* append an end-of-function-label to IR tree */
2865 n = new_seq(n, new_label(A->curFuncEndLabel));
2866
2867 /*_slang_label_delete(A->curFuncEndLabel);*/
2868 A->curFuncEndLabel = NULL;
2869
2870 #if 0
2871 printf("************* New AST for %s *****\n", (char*)fun->header.a_name);
2872 slang_print_function(fun, 1);
2873 #endif
2874 #if 0
2875 printf("************* IR for %s *******\n", (char*)fun->header.a_name);
2876 _slang_print_ir_tree(n, 0);
2877 #endif
2878 #if 0
2879 printf("************* End codegen function ************\n\n");
2880 #endif
2881
2882 /* Emit program instructions */
2883 success = _slang_emit_code(n, A->vartable, A->program, GL_TRUE, A->log);
2884 _slang_free_ir_tree(n);
2885
2886 /* free codegen context */
2887 /*
2888 _mesa_free(A->codegen);
2889 */
2890
2891 return success;
2892 }
2893