Lines Matching refs:instructions
66 exec_list *instructions);
68 remove_per_vertex_blocks(exec_list *instructions,
124 _mesa_ast_to_hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)
126 _mesa_glsl_initialize_variables(instructions, state);
132 state->toplevel_ir = instructions;
154 ast->hir(instructions, state);
156 detect_recursion_unlinked(state, instructions);
157 detect_conflicting_assignments(state, instructions);
169 foreach_in_list_safe(ir_instruction, node, instructions) {
176 instructions->push_head(var);
215 remove_per_vertex_blocks(instructions, state, ir_var_shader_in);
216 remove_per_vertex_blocks(instructions, state, ir_var_shader_out);
220 v.run(instructions);
909 do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state,
1008 instructions->push_tail(var);
1009 instructions->push_tail(assign(var, rhs));
1013 instructions->push_tail(new(ctx) ir_assignment(lhs, deref_var));
1021 instructions->push_tail(new(ctx) ir_assignment(lhs, rhs));
1029 get_lvalue_copy(exec_list *instructions, ir_rvalue *lvalue)
1036 instructions->push_tail(var);
1038 instructions->push_tail(new(ctx) ir_assignment(new(ctx) ir_dereference_variable(var),
1046 ast_node::hir(exec_list *instructions, struct _mesa_glsl_parse_state *state)
1048 (void) instructions;
1066 ast_function_expression::hir_no_rvalue(exec_list *instructions,
1069 (void)hir(instructions, state);
1073 ast_aggregate_initializer::hir_no_rvalue(exec_list *instructions,
1076 (void)hir(instructions, state);
1165 get_scalar_boolean_operand(exec_list *instructions,
1174 ir_rvalue *val = expr->hir(instructions, state);
1266 ast_expression::hir(exec_list *instructions,
1269 return do_hir(instructions, state, true);
1273 ast_expression::hir_no_rvalue(exec_list *instructions,
1276 do_hir(instructions, state, false);
1298 ast_expression::do_hir(exec_list *instructions,
1330 * to multiple IR instructions.
1374 op[0] = this->subexpressions[0]->hir(instructions, state);
1375 op[1] = this->subexpressions[1]->hir(instructions, state);
1378 do_assignment(instructions, state,
1386 op[0] = this->subexpressions[0]->hir(instructions, state);
1396 op[0] = this->subexpressions[0]->hir(instructions, state);
1410 op[0] = this->subexpressions[0]->hir(instructions, state);
1411 op[1] = this->subexpressions[1]->hir(instructions, state);
1423 op[0] = this->subexpressions[0]->hir(instructions, state);
1424 op[1] = this->subexpressions[1]->hir(instructions, state);
1441 op[0] = this->subexpressions[0]->hir(instructions, state);
1442 op[1] = this->subexpressions[1]->hir(instructions, state);
1454 op[0] = this->subexpressions[0]->hir(instructions, state);
1455 op[1] = this->subexpressions[1]->hir(instructions, state);
1473 op[0] = this->subexpressions[0]->hir(instructions, state);
1474 op[1] = this->subexpressions[1]->hir(instructions, state);
1523 op[0] = this->subexpressions[0]->hir(instructions, state);
1524 op[1] = this->subexpressions[1]->hir(instructions, state);
1532 op[0] = this->subexpressions[0]->hir(instructions, state);
1549 op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
1561 instructions->push_tail(tmp);
1564 instructions->push_tail(stmt);
1585 op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
1597 instructions->push_tail(tmp);
1600 instructions->push_tail(stmt);
1626 op[0] = get_scalar_boolean_operand(instructions, state, this, 0, "LHS",
1628 op[1] = get_scalar_boolean_operand(instructions, state, this, 1, "RHS",
1636 op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
1648 op[0] = this->subexpressions[0]->hir(instructions, state);
1649 op[1] = this->subexpressions[1]->hir(instructions, state);
1667 do_assignment(instructions, state,
1683 op[0] = this->subexpressions[0]->hir(instructions, state);
1684 op[1] = this->subexpressions[1]->hir(instructions, state);
1703 do_assignment(instructions, state,
1714 op[0] = this->subexpressions[0]->hir(instructions, state);
1715 op[1] = this->subexpressions[1]->hir(instructions, state);
1721 do_assignment(instructions, state,
1733 op[0] = this->subexpressions[0]->hir(instructions, state);
1734 op[1] = this->subexpressions[1]->hir(instructions, state);
1749 do_assignment(instructions, state,
1764 op[0] = get_scalar_boolean_operand(instructions, state, this, 0,
1839 instructions->push_tail(tmp);
1842 instructions->push_tail(stmt);
1868 op[0] = this->subexpressions[0]->hir(instructions, state);
1878 do_assignment(instructions, state,
1890 op[0] = this->subexpressions[0]->hir(instructions, state);
1904 result = get_lvalue_copy(instructions, op[0]->clone(ctx, NULL));
1908 do_assignment(instructions, state,
1918 result = _mesa_ast_field_selection_to_hir(this, instructions, state);
1929 op[0] = subexpressions[0]->hir(instructions, state);
1930 op[1] = subexpressions[1]->hir(instructions, state);
2017 * therefore add instructions to the instruction list), they get dropped
2028 * instructions->get_tail_raw() will point to the last instruction in
2040 if (previous_tail == instructions->get_tail_raw()) {
2051 previous_tail = instructions->get_tail_raw();
2054 result = ast->hir(instructions, state);
2151 ast_expression_statement::hir(exec_list *instructions,
2164 expression->hir_no_rvalue(instructions, state);
2173 ast_compound_statement::hir(exec_list *instructions,
2180 ast->hir(instructions, state);
2247 * it is) then no instructions should have been emitted
2250 * we are emitting unnecessary instructions.
4481 ast_declarator_list::hir(exec_list *instructions,
4582 (void) this->type->specifier->hir(instructions, state);
5156 /* Process the initializer and add its instructions to a temporary
5287 instructions->push_head(var);
5290 instructions->append_list(&initializer_instructions);
5308 ast_parameter_declarator::hir(exec_list *instructions,
5413 instructions->push_tail(var);
5464 ast_function::hir(exec_list *instructions,
5479 (void) instructions;
5759 ast_function_definition::hir(exec_list *instructions,
5763 prototype->hir(instructions, state);
5816 ast_jump_statement::hir(exec_list *instructions,
5827 ir_rvalue *ret = opt_return_value->hir(instructions, state);
5895 instructions->push_tail(inst);
5906 instructions->push_tail(new(ctx) ir_discard);
5932 state->loop_nesting_ast->rest_expression->hir(instructions,
5937 state->loop_nesting_ast->condition_to_hir(instructions, state);
5947 instructions->push_tail(new(ctx) ir_assignment(deref_continue_inside_var,
5954 instructions->push_tail(jump);
5961 instructions->push_tail(jump);
5967 instructions->push_tail(jump);
5974 /* Jump instructions do not have r-values.
5981 ast_selection_statement::hir(exec_list *instructions,
5986 ir_rvalue *const condition = this->condition->hir(instructions, state);
6018 instructions->push_tail(stmt);
6047 ast_switch_statement::hir(exec_list *instructions,
6053 this->test_expression->hir(instructions, state);
6088 instructions->push_tail(state->switch_state.is_fallthru_var);
6092 instructions->push_tail(new(ctx) ir_assignment(deref_is_fallthru_var,
6101 instructions->push_tail(state->switch_state.continue_inside);
6106 instructions->push_tail(new(ctx) ir_assignment(deref_continue_inside_var,
6113 instructions->push_tail(state->switch_state.run_default);
6117 instructions->push_tail(loop);
6149 instructions->push_tail(irif);
6162 ast_switch_statement::test_to_hir(exec_list *instructions,
6173 ir_rvalue *const test_val = test_expression->hir(instructions, state);
6181 instructions->push_tail(state->switch_state.test_var);
6182 instructions->push_tail(new(ctx) ir_assignment(deref_test_var, test_val));
6187 ast_switch_body::hir(exec_list *instructions,
6191 stmts->hir(instructions, state);
6198 ast_case_statement_list::hir(exec_list *instructions,
6216 instructions->append_list(&tmp);
6234 instructions->push_tail(init_var);
6238 instructions->append_list(&default_case);
6259 instructions->push_tail(set_false);
6263 instructions->append_list(&default_case);
6264 instructions->append_list(&after_default);
6272 ast_case_statement::hir(exec_list *instructions,
6275 labels->hir(instructions, state);
6285 instructions->push_tail(test_fallthru);
6293 ast_case_label_list::hir(exec_list *instructions,
6297 label->hir(instructions, state);
6304 ast_case_label::hir(exec_list *instructions,
6319 ir_rvalue *const label_rval = this->test_value->hir(instructions, state);
6402 instructions->push_tail(set_fallthru_on_test);
6426 instructions->push_tail(set_fallthru);
6434 ast_iteration_statement::condition_to_hir(exec_list *instructions,
6441 condition->hir(instructions, state);
6462 instructions->push_tail(if_stmt);
6469 ast_iteration_statement::hir(exec_list *instructions,
6480 init_statement->hir(instructions, state);
6483 instructions->push_tail(stmt);
6563 ast_type_specifier::hir(exec_list *instructions,
6649 return this->structure->hir(instructions, state);
6673 ast_process_struct_or_iface_block_members(exec_list *instructions,
6716 decl_list->type->specifier->hir(instructions, state);
7105 ast_struct_specifier::hir(exec_list *instructions,
7122 ast_process_struct_or_iface_block_members(instructions,
7222 ast_interface_block::hir(exec_list *instructions,
7572 v.run(instructions);
7603 * impossible for the block to generate any instructions.
7779 instructions->push_tail(var);
7891 instructions->push_tail(var);
7916 foreach_in_list_safe(ir_instruction, node, instructions) {
7939 ast_tcs_output_layout::hir(exec_list *instructions,
7970 foreach_in_list (ir_instruction, node, instructions) {
7996 ast_gs_input_layout::hir(exec_list *instructions,
8023 foreach_in_list(ir_instruction, node, instructions) {
8051 ast_cs_input_layout::hir(exec_list *instructions,
8142 instructions->push_tail(var);
8159 exec_list *instructions)
8172 foreach_in_list(ir_instruction, node, instructions) {
8244 remove_per_vertex_blocks(exec_list *instructions,
8277 v.run(instructions);
8284 foreach_in_list_safe(ir_instruction, node, instructions) {
