3 * Dump/print a slang_operation tree
8 #include "slang_compile.h"
9 #include "slang_print.h"
21 print_type(const slang_fully_specified_type
*t
)
23 switch (t
->qualifier
) {
27 case slang_qual_const
:
30 case slang_qual_attribute
:
33 case slang_qual_varying
:
36 case slang_qual_uniform
:
42 case slang_qual_inout
:
45 case slang_qual_fixedoutput
:
46 printf("fixedoutput");
48 case slang_qual_fixedinput
:
52 printf("unknown qualifer!");
55 switch (t
->specifier
.type
) {
62 case slang_spec_bvec2
:
65 case slang_spec_bvec3
:
68 case slang_spec_bvec4
:
74 case slang_spec_ivec2
:
77 case slang_spec_ivec3
:
80 case slang_spec_ivec4
:
83 case slang_spec_float
:
101 case slang_spec_mat4
:
104 case slang_spec_sampler1D
:
107 case slang_spec_sampler2D
:
110 case slang_spec_sampler3D
:
113 case slang_spec_samplerCube
:
114 printf("samplerCube");
116 case slang_spec_sampler1DShadow
:
117 printf("sampler1DShadow");
119 case slang_spec_sampler2DShadow
:
120 printf("sampler2DShadow");
122 case slang_spec_struct
:
125 case slang_spec_array
:
129 printf("unknown type");
136 print_variable(const slang_variable
*v
, int indent
)
140 print_type(&v
->type
);
141 printf(" %s", (char *) v
->a_name
);
142 if (v
->initializer
) {
144 slang_print_tree(v
->initializer
, indent
+ 3);
153 print_binary(const slang_operation
*op
, const char *oper
, int indent
)
155 assert(op
->num_children
== 2);
156 slang_print_tree(&op
->children
[0], indent
+ 3);
158 printf("%s\n", oper
);
159 slang_print_tree(&op
->children
[1], indent
+ 3);
164 print_generic2(const slang_operation
*op
, const char *oper
,
165 const char *s
, int indent
)
170 printf("[%p locals %p] %s %s\n", (void*) op
, (void*) op
->locals
, oper
, s
);
172 for (i
= 0; i
< op
->num_children
; i
++) {
174 printf("//child %d:\n", i
);
175 slang_print_tree(&op
->children
[i
], indent
);
180 print_generic(const slang_operation
*op
, const char *oper
, int indent
)
182 print_generic2(op
, oper
, "", indent
);
186 static const slang_variable_scope
*
187 find_scope(const slang_variable_scope
*s
, slang_atom name
)
190 for (i
= 0; i
< s
->num_variables
; i
++) {
191 if (s
->variables
[i
]->a_name
== name
)
195 return find_scope(s
->outer_scope
, name
);
200 static const slang_variable
*
201 find_var(const slang_variable_scope
*s
, slang_atom name
)
204 for (i
= 0; i
< s
->num_variables
; i
++) {
205 if (s
->variables
[i
]->a_name
== name
)
206 return s
->variables
[i
];
209 return find_var(s
->outer_scope
, name
);
216 slang_print_tree(const slang_operation
*op
, int indent
)
222 case slang_oper_none
:
224 printf("slang_oper_none\n");
227 case slang_oper_block_no_new_scope
:
229 printf("{ locals %p outer %p\n", (void*)op
->locals
, (void*)op
->locals
->outer_scope
);
230 print_generic(op
, NULL
, indent
+3);
235 case slang_oper_block_new_scope
:
237 printf("{{ // new scope locals %p\n", (void*)op
->locals
);
238 print_generic(op
, NULL
, indent
+3);
243 case slang_oper_variable_decl
:
244 assert(op
->num_children
== 0 || op
->num_children
== 1);
247 v
= _slang_locate_variable(op
->locals
, op
->a_id
, GL_TRUE
);
250 printf("DECL (locals=%p outer=%p) ", (void*)op
->locals
, (void*) op
->locals
->outer_scope
);
251 print_type(&v
->type
);
252 printf(" %s (%p)", (char *) op
->a_id
,
253 (void *) find_var(op
->locals
, op
->a_id
));
255 printf(" (in scope %p) ",
256 (void *) find_scope(op
->locals
, op
->a_id
));
257 if (op
->num_children
== 1) {
259 slang_print_tree(&op
->children
[0], indent
+ 3);
261 else if (v
->initializer
) {
262 printf(" := INITIALIZER\n");
263 slang_print_tree(v
->initializer
, indent
+ 3);
271 print_type(&v->type);
273 printf("ADDR: %d size: %d\n", v->address, v->size);
279 printf("DECL %s (anonymous variable!!!!)\n", (char *) op
->a_id
);
287 printf("ASM: %s\n", (char*) op
->a_id
);
288 print_generic(op
, NULL
, indent
+3);
291 case slang_oper_break
:
296 case slang_oper_continue
:
298 printf("CONTINUE\n");
301 case slang_oper_discard
:
306 case slang_oper_return
:
309 if (op
->num_children
> 0)
310 slang_print_tree(&op
->children
[0], indent
+ 3);
313 case slang_oper_goto
:
315 printf("GOTO %s\n", (char *) op
->a_id
);
318 case slang_oper_label
:
320 printf("LABEL %s\n", (char *) op
->a_id
);
323 case slang_oper_expression
:
325 printf("EXPR: locals %p\n", (void*) op
->locals
);
326 /*print_generic(op, "slang_oper_expression", indent);*/
327 slang_print_tree(&op
->children
[0], indent
+ 3);
333 slang_print_tree(&op
->children
[0], indent
+ 3);
336 slang_print_tree(&op
->children
[1], indent
+ 3);
339 slang_print_tree(&op
->children
[2], indent
+ 3);
344 case slang_oper_while
:
345 assert(op
->num_children
== 2);
347 printf("WHILE cond:\n");
348 slang_print_tree(&op
->children
[0], indent
+ 3);
350 printf("WHILE body:\n");
351 slang_print_tree(&op
->children
[1], indent
+ 3);
356 printf("DO body:\n");
357 slang_print_tree(&op
->children
[0], indent
+ 3);
359 printf("DO cond:\n");
360 slang_print_tree(&op
->children
[1], indent
+ 3);
365 printf("FOR init:\n");
366 slang_print_tree(&op
->children
[0], indent
+ 3);
368 printf("FOR while:\n");
369 slang_print_tree(&op
->children
[1], indent
+ 3);
371 printf("FOR step:\n");
372 slang_print_tree(&op
->children
[2], indent
+ 3);
374 printf("FOR body:\n");
375 slang_print_tree(&op
->children
[3], indent
+ 3);
379 print_generic(op, "FOR", indent + 3);
383 case slang_oper_void
:
385 printf("(oper-void)\n");
388 case slang_oper_literal_bool
:
390 /*printf("slang_oper_literal_bool\n");*/
391 printf("%s\n", op
->literal
[0] ? "TRUE" : "FALSE");
394 case slang_oper_literal_int
:
396 /*printf("slang_oper_literal_int\n");*/
397 printf("(%d %d %d %d)\n", (int) op
->literal
[0], (int) op
->literal
[1],
398 (int) op
->literal
[2], (int) op
->literal
[3]);
401 case slang_oper_literal_float
:
403 /*printf("slang_oper_literal_float\n");*/
404 printf("(%f %f %f %f)\n", op
->literal
[0], op
->literal
[1], op
->literal
[2],
408 case slang_oper_identifier
:
410 if (op
->var
&& op
->var
->a_name
)
411 printf("VAR %s (in scope %p)\n", (char *) op
->var
->a_name
,
412 (void *) find_scope(op
->locals
, op
->a_id
));
414 printf("VAR' %s (in scope %p)\n", (char *) op
->a_id
,
415 (void *) find_scope(op
->locals
, op
->a_id
));
418 case slang_oper_sequence
:
419 print_generic(op
, "COMMA-SEQ", indent
+3);
422 case slang_oper_assign
:
424 printf("ASSIGNMENT locals %p\n", (void*)op
->locals
);
425 print_binary(op
, ":=", indent
);
428 case slang_oper_addassign
:
431 print_binary(op
, "+=", indent
);
434 case slang_oper_subassign
:
437 print_binary(op
, "-=", indent
);
440 case slang_oper_mulassign
:
443 print_binary(op
, "*=", indent
);
446 case slang_oper_divassign
:
449 print_binary(op
, "/=", indent
);
452 /*slang_oper_modassign,*/
453 /*slang_oper_lshassign,*/
454 /*slang_oper_rshassign,*/
455 /*slang_oper_orassign,*/
456 /*slang_oper_xorassign,*/
457 /*slang_oper_andassign,*/
458 case slang_oper_select
:
460 printf("slang_oper_select n=%d\n", op
->num_children
);
461 assert(op
->num_children
== 3);
462 slang_print_tree(&op
->children
[0], indent
+3);
465 slang_print_tree(&op
->children
[1], indent
+3);
468 slang_print_tree(&op
->children
[2], indent
+3);
471 case slang_oper_logicalor
:
472 print_binary(op
, "||", indent
);
475 case slang_oper_logicalxor
:
476 print_binary(op
, "^^", indent
);
479 case slang_oper_logicaland
:
480 print_binary(op
, "&&", indent
);
484 /*slang_oper_bitxor*/
485 /*slang_oper_bitand*/
486 case slang_oper_equal
:
487 print_binary(op
, "==", indent
);
490 case slang_oper_notequal
:
491 print_binary(op
, "!=", indent
);
494 case slang_oper_less
:
495 print_binary(op
, "<", indent
);
498 case slang_oper_greater
:
499 print_binary(op
, ">", indent
);
502 case slang_oper_lessequal
:
503 print_binary(op
, "<=", indent
);
506 case slang_oper_greaterequal
:
507 print_binary(op
, ">=", indent
);
510 /*slang_oper_lshift*/
511 /*slang_oper_rshift*/
513 print_binary(op
, "+", indent
);
516 case slang_oper_subtract
:
517 print_binary(op
, "-", indent
);
520 case slang_oper_multiply
:
521 print_binary(op
, "*", indent
);
524 case slang_oper_divide
:
525 print_binary(op
, "/", indent
);
528 /*slang_oper_modulus*/
529 case slang_oper_preincrement
:
532 slang_print_tree(&op
->children
[0], indent
+3);
535 case slang_oper_predecrement
:
538 slang_print_tree(&op
->children
[0], indent
+3);
541 case slang_oper_plus
:
543 printf("slang_oper_plus\n");
546 case slang_oper_minus
:
548 printf("slang_oper_minus\n");
551 /*slang_oper_complement*/
555 slang_print_tree(&op
->children
[0], indent
+3);
558 case slang_oper_subscript
:
560 printf("slang_oper_subscript\n");
561 print_generic(op
, NULL
, indent
+3);
564 case slang_oper_call
:
567 = _slang_locate_function(A
->space
.funcs
, oper
->a_id
,
569 oper
->num_children
, &A
->space
, A
->atoms
);
572 printf("CALL %s(\n", (char *) op
->a_id
);
573 for (i
= 0; i
< op
->num_children
; i
++) {
574 slang_print_tree(&op
->children
[i
], indent
+3);
575 if (i
+ 1 < op
->num_children
) {
584 case slang_oper_field
:
586 printf("FIELD %s of\n", (char*) op
->a_id
);
587 slang_print_tree(&op
->children
[0], indent
+3);
590 case slang_oper_postincrement
:
593 slang_print_tree(&op
->children
[0], indent
+3);
596 case slang_oper_postdecrement
:
599 slang_print_tree(&op
->children
[0], indent
+3);
603 printf("unknown op->type %d\n", (int) op
->type
);
611 slang_print_function(const slang_function
*f
, GLboolean body
)
616 if (_mesa_strcmp((char *) f
->header
.a_name
, "main") != 0)
620 printf("FUNCTION %s (\n",
621 (char *) f
->header
.a_name
);
623 for (i
= 0; i
< f
->param_count
; i
++) {
624 print_variable(f
->parameters
->variables
[i
], 3);
629 slang_print_tree(f
->body
, 0);
637 slang_asm_string(slang_assembly_type t
)
643 case slang_asm_float_copy
:
645 case slang_asm_float_move
:
647 case slang_asm_float_push
:
649 case slang_asm_float_deref
:
650 return "float_deref";
651 case slang_asm_float_add
:
653 case slang_asm_float_multiply
:
654 return "float_multiply";
655 case slang_asm_float_divide
:
656 return "float_divide";
657 case slang_asm_float_negate
:
658 return "float_negate";
659 case slang_asm_float_less
:
661 case slang_asm_float_equal_exp
:
662 return "float_equal";
663 case slang_asm_float_equal_int
:
664 return "float_equal";
665 case slang_asm_float_to_int
:
666 return "float_to_int";
667 case slang_asm_float_sine
:
669 case slang_asm_float_arcsine
:
670 return "float_arcsine";
671 case slang_asm_float_arctan
:
672 return "float_arctan";
673 case slang_asm_float_power
:
674 return "float_power";
675 case slang_asm_float_log2
:
677 case slang_asm_vec4_floor
:
679 case slang_asm_float_ceil
:
681 case slang_asm_float_noise1
:
682 return "float_noise1";
683 case slang_asm_float_noise2
:
684 return "float_noise2";
685 case slang_asm_float_noise3
:
686 return "float_noise3";
687 case slang_asm_float_noise4
:
688 return "float_noise4";
689 case slang_asm_int_copy
:
691 case slang_asm_int_move
:
693 case slang_asm_int_push
:
695 case slang_asm_int_deref
:
697 case slang_asm_int_to_float
:
698 return "int_to_float";
699 case slang_asm_int_to_addr
:
700 return "int_to_addr";
701 case slang_asm_bool_copy
:
703 case slang_asm_bool_move
:
705 case slang_asm_bool_push
:
707 case slang_asm_bool_deref
:
709 case slang_asm_addr_copy
:
711 case slang_asm_addr_push
:
713 case slang_asm_addr_deref
:
715 case slang_asm_addr_add
:
717 case slang_asm_addr_multiply
:
718 return "addr_multiply";
719 case slang_asm_vec4_tex1d
:
721 case slang_asm_vec4_tex2d
:
723 case slang_asm_vec4_tex3d
:
725 case slang_asm_vec4_texcube
:
726 return "vec4_texcube";
727 case slang_asm_vec4_shad1d
:
728 return "vec4_shad1d";
729 case slang_asm_vec4_shad2d
:
730 return "vec4_shad2d";
733 case slang_asm_jump_if_zero
:
734 return "jump_if_zero";
735 case slang_asm_enter
:
737 case slang_asm_leave
:
739 case slang_asm_local_alloc
:
740 return "local_alloc";
741 case slang_asm_local_free
:
743 case slang_asm_local_addr
:
745 case slang_asm_global_addr
:
746 return "global_addr";
749 case slang_asm_return
:
751 case slang_asm_discard
:
755 /* GL_MESA_shader_debug */
756 case slang_asm_float_print
:
757 return "float_print";
758 case slang_asm_int_print
:
760 case slang_asm_bool_print
:
763 case slang_asm_float_to_vec4
:
764 return "float_to_vec4";
765 case slang_asm_vec4_add
:
767 case slang_asm_vec4_subtract
:
768 return "vec4_subtract";
769 case slang_asm_vec4_multiply
:
770 return "vec4_multiply";
771 case slang_asm_vec4_divide
:
772 return "vec4_divide";
773 case slang_asm_vec4_negate
:
774 return "vec4_negate";
775 case slang_asm_vec4_dot
:
777 case slang_asm_vec4_copy
:
779 case slang_asm_vec4_deref
:
781 case slang_asm_vec4_equal_int
:
790 slang_type_qual_string(slang_type_qualifier q
)
793 case slang_qual_none
:
795 case slang_qual_const
:
797 case slang_qual_attribute
:
799 case slang_qual_varying
:
801 case slang_qual_uniform
:
805 case slang_qual_inout
:
807 case slang_qual_fixedoutput
:
808 return "fixedoutput";
809 case slang_qual_fixedinput
:
810 return "fixedinputk";
818 slang_type_string(slang_type_specifier_type t
)
821 case slang_spec_void
:
823 case slang_spec_bool
:
825 case slang_spec_bvec2
:
827 case slang_spec_bvec3
:
829 case slang_spec_bvec4
:
833 case slang_spec_ivec2
:
835 case slang_spec_ivec3
:
837 case slang_spec_ivec4
:
839 case slang_spec_float
:
841 case slang_spec_vec2
:
843 case slang_spec_vec3
:
845 case slang_spec_vec4
:
847 case slang_spec_mat2
:
849 case slang_spec_mat3
:
851 case slang_spec_mat4
:
853 case slang_spec_sampler1D
:
855 case slang_spec_sampler2D
:
857 case slang_spec_sampler3D
:
859 case slang_spec_samplerCube
:
860 return "samplerCube";
861 case slang_spec_sampler1DShadow
:
862 return "sampler1DShadow";
863 case slang_spec_sampler2DShadow
:
864 return "sampler2DShadow";
865 case slang_spec_struct
:
867 case slang_spec_array
:
876 slang_fq_type_string(const slang_fully_specified_type
*t
)
878 static char str
[1000];
879 sprintf(str
, "%s %s", slang_type_qual_string(t
->qualifier
),
880 slang_type_string(t
->specifier
.type
));
886 slang_print_type(const slang_fully_specified_type
*t
)
888 printf("%s %s", slang_type_qual_string(t
->qualifier
),
889 slang_type_string(t
->specifier
.type
));
895 slang_var_string(const slang_variable
*v
)
897 static char str
[1000];
898 sprintf(str
, "%s : %s",
900 slang_fq_type_string(&v
->type
));
907 slang_print_variable(const slang_variable
*v
)
909 printf("Name: %s\n", (char *) v
->a_name
);
910 printf("Type: %s\n", slang_fq_type_string(&v
->type
));
915 _slang_print_var_scope(const slang_variable_scope
*vars
, int indent
)
920 printf("Var scope %p %d vars:\n", (void *) vars
, vars
->num_variables
);
921 for (i
= 0; i
< vars
->num_variables
; i
++) {
923 printf("%s (at %p)\n", (char *) vars
->variables
[i
]->a_name
, (void*) (vars
->variables
+ i
));
926 printf("outer_scope = %p\n", (void*) vars
->outer_scope
);
928 if (vars
->outer_scope
) {
929 /*spaces(indent + 3);*/
930 _slang_print_var_scope(vars
->outer_scope
, indent
+ 3);
937 slang_checksum_tree(const slang_operation
*op
)
939 int s
= op
->num_children
;
942 for (i
= 0; i
< op
->num_children
; i
++) {
943 s
+= slang_checksum_tree(&op
->children
[i
]);