diff options
| -rw-r--r-- | ast.h | 19 | ||||
| -rw-r--r-- | ast_function.cpp | 88 | ||||
| -rw-r--r-- | ast_to_hir.cpp | 191 | ||||
| -rw-r--r-- | glsl_lexer.lpp | 4 | ||||
| -rw-r--r-- | glsl_parser.ypp | 297 | ||||
| -rw-r--r-- | glsl_symbol_table.h | 33 | ||||
| -rw-r--r-- | glsl_types.cpp | 160 | ||||
| -rw-r--r-- | glsl_types.h | 28 | ||||
| -rw-r--r-- | hir_field_selection.cpp | 7 | ||||
| -rw-r--r-- | ir.cpp | 19 | ||||
| -rw-r--r-- | ir.h | 8 | ||||
| -rw-r--r-- | ir_clone.cpp | 52 | ||||
| -rw-r--r-- | ir_constant_expression.cpp | 11 | ||||
| -rw-r--r-- | ir_copy_propagation.cpp | 3 | ||||
| -rw-r--r-- | ir_dead_code.cpp | 3 | ||||
| -rw-r--r-- | ir_dead_code_local.cpp | 3 | ||||
| -rw-r--r-- | ir_expression_flattening.cpp | 11 | ||||
| -rw-r--r-- | ir_function_inlining.cpp | 20 | ||||
| -rw-r--r-- | ir_reader.cpp | 52 | ||||
| -rw-r--r-- | ir_variable.cpp | 19 | ||||
| -rw-r--r-- | ir_vec_index_to_swizzle.cpp | 4 | ||||
| -rw-r--r-- | list.h | 25 | ||||
| -rw-r--r-- | main.cpp | 97 | ||||
| -rw-r--r-- | s_expression.cpp | 35 | ||||
| -rw-r--r-- | s_expression.h | 12 |
25 files changed, 737 insertions, 464 deletions
@@ -36,6 +36,25 @@ struct YYLTYPE; class ast_node { public: + /* Callers of this talloc-based new need not call delete. It's + * easier to just talloc_free 'ctx' (or any of its ancestors). */ + static void* operator new(size_t size, void *ctx) + { + void *node; + + node = talloc_size(ctx, size); + assert(node != NULL); + + return node; + } + + /* If the user *does* call delete, that's OK, we will just + * talloc_free in that case. */ + static void operator delete(void *table) + { + talloc_free(table); + } + virtual void print(void) const; virtual ir_rvalue *hir(exec_list *instructions, struct _mesa_glsl_parse_state *state); diff --git a/ast_function.cpp b/ast_function.cpp index ff2dfa502f..761af00b95 100644 --- a/ast_function.cpp +++ b/ast_function.cpp @@ -54,6 +54,8 @@ process_call(exec_list *instructions, ir_function *f, YYLTYPE *loc, exec_list *actual_parameters, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); + const ir_function_signature *sig = f->matching_signature(actual_parameters); @@ -93,7 +95,7 @@ process_call(exec_list *instructions, ir_function *f, /* FINISHME: The list of actual parameters needs to be modified to * FINISHME: include any necessary conversions. */ - return new ir_call(sig, actual_parameters); + return new(ctx) ir_call(sig, actual_parameters); } else { /* FINISHME: Log a better error message here. G++ will show the types * FINISHME: of the actual parameters and the set of candidate @@ -102,7 +104,7 @@ process_call(exec_list *instructions, ir_function *f, */ _mesa_glsl_error(loc, state, "no matching function for call to `%s'", f->name); - return ir_call::get_error_instruction(); + return ir_call::get_error_instruction(ctx); } } @@ -112,11 +114,12 @@ match_function_by_name(exec_list *instructions, const char *name, YYLTYPE *loc, exec_list *actual_parameters, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); ir_function *f = state->symbols->get_function(name); if (f == NULL) { _mesa_glsl_error(loc, state, "function `%s' undeclared", name); - return ir_call::get_error_instruction(); + return ir_call::get_error_instruction(ctx); } /* Once we've determined that the function being called might exist, try @@ -132,6 +135,7 @@ match_function_by_name(exec_list *instructions, const char *name, static ir_rvalue * convert_component(ir_rvalue *src, const glsl_type *desired_type) { + void *ctx = talloc_parent(src); const unsigned a = desired_type->base_type; const unsigned b = src->type->base_type; ir_expression *result = NULL; @@ -149,22 +153,22 @@ convert_component(ir_rvalue *src, const glsl_type *desired_type) case GLSL_TYPE_UINT: case GLSL_TYPE_INT: if (b == GLSL_TYPE_FLOAT) - result = new ir_expression(ir_unop_f2i, desired_type, src, NULL); + result = new(ctx) ir_expression(ir_unop_f2i, desired_type, src, NULL); else { assert(b == GLSL_TYPE_BOOL); - result = new ir_expression(ir_unop_b2i, desired_type, src, NULL); + result = new(ctx) ir_expression(ir_unop_b2i, desired_type, src, NULL); } break; case GLSL_TYPE_FLOAT: switch (b) { case GLSL_TYPE_UINT: - result = new ir_expression(ir_unop_u2f, desired_type, src, NULL); + result = new(ctx) ir_expression(ir_unop_u2f, desired_type, src, NULL); break; case GLSL_TYPE_INT: - result = new ir_expression(ir_unop_i2f, desired_type, src, NULL); + result = new(ctx) ir_expression(ir_unop_i2f, desired_type, src, NULL); break; case GLSL_TYPE_BOOL: - result = new ir_expression(ir_unop_b2f, desired_type, src, NULL); + result = new(ctx) ir_expression(ir_unop_b2f, desired_type, src, NULL); break; } break; @@ -172,12 +176,12 @@ convert_component(ir_rvalue *src, const glsl_type *desired_type) ir_constant *zero = NULL; switch (b) { - case GLSL_TYPE_UINT: zero = new ir_constant(unsigned(0)); break; - case GLSL_TYPE_INT: zero = new ir_constant(int(0)); break; - case GLSL_TYPE_FLOAT: zero = new ir_constant(0.0f); break; + case GLSL_TYPE_UINT: zero = new(ctx) ir_constant(unsigned(0)); break; + case GLSL_TYPE_INT: zero = new(ctx) ir_constant(int(0)); break; + case GLSL_TYPE_FLOAT: zero = new(ctx) ir_constant(0.0f); break; } - result = new ir_expression(ir_binop_nequal, desired_type, src, zero); + result = new(ctx) ir_expression(ir_binop_nequal, desired_type, src, zero); } } @@ -194,6 +198,7 @@ convert_component(ir_rvalue *src, const glsl_type *desired_type) static ir_rvalue * dereference_component(ir_rvalue *src, unsigned component) { + void *ctx = talloc_parent(src); assert(component < src->type->components()); /* If the source is a constant, just create a new constant instead of a @@ -201,12 +206,12 @@ dereference_component(ir_rvalue *src, unsigned component) */ ir_constant *constant = src->as_constant(); if (constant) - return new ir_constant(constant, component); + return new(ctx) ir_constant(constant, component); if (src->type->is_scalar()) { return src; } else if (src->type->is_vector()) { - return new ir_swizzle(src, component, 0, 0, 0, 1); + return new(ctx) ir_swizzle(src, component, 0, 0, 0, 1); } else { assert(src->type->is_matrix()); @@ -215,8 +220,8 @@ dereference_component(ir_rvalue *src, unsigned component) */ const int c = component / src->type->column_type()->vector_elements; const int r = component % src->type->column_type()->vector_elements; - ir_constant *const col_index = new ir_constant(c); - ir_dereference *const col = new ir_dereference_array(src, col_index); + ir_constant *const col_index = new(ctx) ir_constant(c); + ir_dereference *const col = new(ctx) ir_dereference_array(src, col_index); col->type = src->type->column_type(); @@ -234,6 +239,7 @@ process_array_constructor(exec_list *instructions, YYLTYPE *loc, exec_list *parameters, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); /* Array constructors come in two forms: sized and unsized. Sized array * constructors look like 'vec4[2](a, b)', where 'a' and 'b' are vec4 * variables. In this case the number of parameters must exactly match the @@ -268,12 +274,13 @@ process_array_constructor(exec_list *instructions, "parameter%s", (constructor_type->length != 0) ? "at least" : "exactly", min_param, (min_param <= 1) ? "" : "s"); - return ir_call::get_error_instruction(); + return ir_call::get_error_instruction(ctx); } if (constructor_type->length == 0) { constructor_type = - glsl_type::get_array_instance(constructor_type->element_type(), + glsl_type::get_array_instance(state, + constructor_type->element_type(), parameter_count); assert(constructor_type != NULL); assert(constructor_type->length == parameter_count); @@ -306,6 +313,7 @@ constant_record_constructor(const glsl_type *constructor_type, YYLTYPE *loc, exec_list *parameters, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); bool all_parameters_are_constant = true; exec_node *node = parameters->head; @@ -338,7 +346,7 @@ constant_record_constructor(const glsl_type *constructor_type, if (!all_parameters_are_constant) return NULL; - return new ir_constant(constructor_type, parameters); + return new(ctx) ir_constant(constructor_type, parameters); } @@ -440,6 +448,7 @@ ir_rvalue * ast_function_expression::hir(exec_list *instructions, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); /* There are three sorts of function calls. * * 1. contstructors - The first subexpression is an ast_type_specifier. @@ -462,14 +471,14 @@ ast_function_expression::hir(exec_list *instructions, if (constructor_type->is_sampler()) { _mesa_glsl_error(& loc, state, "cannot construct sampler type `%s'", constructor_type->name); - return ir_call::get_error_instruction(); + return ir_call::get_error_instruction(ctx); } if (constructor_type->is_array()) { if (state->language_version <= 110) { _mesa_glsl_error(& loc, state, "array constructors forbidden in GLSL 1.10"); - return ir_call::get_error_instruction(); + return ir_call::get_error_instruction(ctx); } return process_array_constructor(instructions, constructor_type, @@ -519,7 +528,7 @@ ast_function_expression::hir(exec_list *instructions, _mesa_glsl_error(& loc, state, "too few components to construct " "`%s'", constructor_type->name); - return ir_call::get_error_instruction(); + return ir_call::get_error_instruction(ctx); } foreach_list (n, &this->expressions) { @@ -549,14 +558,14 @@ ast_function_expression::hir(exec_list *instructions, _mesa_glsl_error(& loc, state, "too many parameters to `%s' " "constructor", constructor_type->name); - return ir_call::get_error_instruction(); + return ir_call::get_error_instruction(ctx); } if (!result->type->is_numeric() && !result->type->is_boolean()) { _mesa_glsl_error(& loc, state, "cannot construct `%s' from a " "non-numeric data type", constructor_type->name); - return ir_call::get_error_instruction(); + return ir_call::get_error_instruction(ctx); } /* Count the number of matrix and nonmatrix parameters. This @@ -574,11 +583,13 @@ ast_function_expression::hir(exec_list *instructions, * glsl-vs-constructor-call.shader_test. */ if (result->type->components() >= 1 && !result->as_constant()) { - result_var = new ir_variable(result->type, "constructor_tmp"); + result_var = new(ctx) ir_variable(result->type, + "constructor_tmp"); ir_dereference_variable *lhs; - lhs = new ir_dereference_variable(result_var); - instructions->push_tail(new ir_assignment(lhs, result, NULL)); + lhs = new(ctx) ir_dereference_variable(result_var); + instructions->push_tail(new(ctx) ir_assignment(lhs, + result, NULL)); } /* Process each of the components of the parameter. Dereference @@ -592,7 +603,7 @@ ast_function_expression::hir(exec_list *instructions, ir_rvalue *component; if (result_var) { - ir_dereference *d = new ir_dereference_variable(result_var); + ir_dereference *d = new(ctx) ir_dereference_variable(result_var); component = dereference_component(d, i); } else { component = dereference_component(result, i); @@ -629,7 +640,7 @@ ast_function_expression::hir(exec_list *instructions, _mesa_glsl_error(& loc, state, "cannot construct `%s' from a " "matrix in GLSL 1.10", constructor_type->name); - return ir_call::get_error_instruction(); + return ir_call::get_error_instruction(ctx); } /* From page 50 (page 56 of the PDF) of the GLSL 1.50 spec: @@ -643,7 +654,7 @@ ast_function_expression::hir(exec_list *instructions, _mesa_glsl_error(& loc, state, "for matrix `%s' constructor, " "matrix must be only parameter", constructor_type->name); - return ir_call::get_error_instruction(); + return ir_call::get_error_instruction(ctx); } /* From page 28 (page 34 of the PDF) of the GLSL 1.10 spec: @@ -656,14 +667,14 @@ ast_function_expression::hir(exec_list *instructions, _mesa_glsl_error(& loc, state, "too few components to construct " "`%s'", constructor_type->name); - return ir_call::get_error_instruction(); + return ir_call::get_error_instruction(ctx); } ir_function *f = state->symbols->get_function(constructor_type->name); if (f == NULL) { _mesa_glsl_error(& loc, state, "no constructor for type `%s'", constructor_type->name); - return ir_call::get_error_instruction(); + return ir_call::get_error_instruction(ctx); } const ir_function_signature *sig = @@ -674,7 +685,8 @@ ast_function_expression::hir(exec_list *instructions, */ if (all_parameters_are_constant) { if (components_used >= type_components) - return new ir_constant(sig->return_type, & actual_parameters); + return new(ctx) ir_constant(sig->return_type, + & actual_parameters); assert(sig->return_type->is_vector() || sig->return_type->is_matrix()); @@ -695,9 +707,9 @@ ast_function_expression::hir(exec_list *instructions, generate_constructor_vector(sig->return_type, initializer, &data); - return new ir_constant(sig->return_type, &data); + return new(ctx) ir_constant(sig->return_type, &data); } else - return new ir_call(sig, & actual_parameters); + return new(ctx) ir_call(sig, & actual_parameters); } else { /* FINISHME: Log a better error message here. G++ will show the * FINSIHME: types of the actual parameters and the set of @@ -706,11 +718,11 @@ ast_function_expression::hir(exec_list *instructions, */ _mesa_glsl_error(& loc, state, "no matching constructor for `%s'", constructor_type->name); - return ir_call::get_error_instruction(); + return ir_call::get_error_instruction(ctx); } } - return ir_call::get_error_instruction(); + return ir_call::get_error_instruction(ctx); } else { const ast_expression *id = subexpressions[0]; YYLTYPE loc = id->get_location(); @@ -735,5 +747,5 @@ ast_function_expression::hir(exec_list *instructions, &actual_parameters, state); } - return ir_call::get_error_instruction(); + return ir_call::get_error_instruction(ctx); } diff --git a/ast_to_hir.cpp b/ast_to_hir.cpp index 25bbe2f2de..33eb27533f 100644 --- a/ast_to_hir.cpp +++ b/ast_to_hir.cpp @@ -87,6 +87,7 @@ static bool apply_implicit_conversion(const glsl_type *to, ir_rvalue * &from, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); if (to->base_type == from->type->base_type) return true; @@ -111,13 +112,13 @@ apply_implicit_conversion(const glsl_type *to, ir_rvalue * &from, switch (from->type->base_type) { case GLSL_TYPE_INT: - from = new ir_expression(ir_unop_i2f, to, from, NULL); + from = new(ctx) ir_expression(ir_unop_i2f, to, from, NULL); break; case GLSL_TYPE_UINT: - from = new ir_expression(ir_unop_u2f, to, from, NULL); + from = new(ctx) ir_expression(ir_unop_u2f, to, from, NULL); break; case GLSL_TYPE_BOOL: - from = new ir_expression(ir_unop_b2f, to, from, NULL); + from = new(ctx) ir_expression(ir_unop_b2f, to, from, NULL); break; default: assert(0); @@ -467,6 +468,7 @@ do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state, ir_rvalue *lhs, ir_rvalue *rhs, YYLTYPE lhs_loc) { + void *ctx = talloc_parent(state); bool error_emitted = (lhs->type->is_error() || rhs->type->is_error()); if (!error_emitted) { @@ -504,7 +506,8 @@ do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state, var->max_array_access); } - var->type = glsl_type::get_array_instance(lhs->type->element_type(), + var->type = glsl_type::get_array_instance(state, + lhs->type->element_type(), rhs->type->array_size()); } } @@ -519,17 +522,19 @@ do_assignment(exec_list *instructions, struct _mesa_glsl_parse_state *state, * temporary and return a deref of that temporary. If the rvalue * ends up not being used, the temp will get copy-propagated out. */ - ir_variable *var = new ir_variable(rhs->type, "assignment_tmp"); + ir_variable *var = new(ctx) ir_variable(rhs->type, "assignment_tmp"); + ir_dereference_variable *deref_var = new(ctx) ir_dereference_variable(var); instructions->push_tail(var); - instructions->push_tail(new ir_assignment(new ir_dereference_variable(var), - rhs, - NULL)); + instructions->push_tail(new(ctx) ir_assignment(deref_var, + rhs, + NULL)); + deref_var = new(ctx) ir_dereference_variable(var); - instructions->push_tail(new ir_assignment(lhs, - new ir_dereference_variable(var), - NULL)); + instructions->push_tail(new(ctx) ir_assignment(lhs, + deref_var, + NULL)); - return new ir_dereference_variable(var); + return new(ctx) ir_dereference_variable(var); } @@ -540,12 +545,13 @@ static ir_variable * generate_temporary(const glsl_type *type, exec_list *instructions, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); char *name = (char *) malloc(sizeof(char) * 13); snprintf(name, 13, "tmp_%08X", state->temp_index); state->temp_index++; - ir_variable *const var = new ir_variable(type, name); + ir_variable *const var = new(ctx) ir_variable(type, name); instructions->push_tail(var); return var; @@ -555,21 +561,22 @@ generate_temporary(const glsl_type *type, exec_list *instructions, static ir_rvalue * get_lvalue_copy(exec_list *instructions, ir_rvalue *lvalue) { + void *ctx = talloc_parent(lvalue); ir_variable *var; /* FINISHME: Give unique names to the temporaries. */ - var = new ir_variable(lvalue->type, "_post_incdec_tmp"); + var = new(ctx) ir_variable(lvalue->type, "_post_incdec_tmp"); var->mode = ir_var_auto; - instructions->push_tail(new ir_assignment(new ir_dereference_variable(var), - lvalue, NULL)); + instructions->push_tail(new(ctx) ir_assignment(new(ctx) ir_dereference_variable(var), + lvalue, NULL)); /* Once we've created this temporary, mark it read only so it's no * longer considered an lvalue. */ var->read_only = true; - return new ir_dereference_variable(var); + return new(ctx) ir_dereference_variable(var); } @@ -588,6 +595,7 @@ ir_rvalue * ast_expression::hir(exec_list *instructions, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); static const int operations[AST_NUM_OPERATORS] = { -1, /* ast_assign doesn't convert to ir_expression. */ -1, /* ast_plus doesn't convert to ir_expression. */ @@ -680,8 +688,8 @@ ast_expression::hir(exec_list *instructions, error_emitted = type->is_error(); - result = new ir_expression(operations[this->oper], type, - op[0], NULL); + result = new(ctx) ir_expression(operations[this->oper], type, + op[0], NULL); break; case ast_add: @@ -696,8 +704,8 @@ ast_expression::hir(exec_list *instructions, state, & loc); error_emitted = type->is_error(); - result = new ir_expression(operations[this->oper], type, - op[0], op[1]); + result = new(ctx) ir_expression(operations[this->oper], type, + op[0], op[1]); break; case ast_mod: @@ -708,8 +716,8 @@ ast_expression::hir(exec_list *instructions, assert(operations[this->oper] == ir_binop_mod); - result = new ir_expression(operations[this->oper], type, - op[0], op[1]); + result = new(ctx) ir_expression(operations[this->oper], type, + op[0], op[1]); error_emitted = type->is_error(); break; @@ -735,8 +743,8 @@ ast_expression::hir(exec_list *instructions, || ((type->base_type == GLSL_TYPE_BOOL) && type->is_scalar())); - result = new ir_expression(operations[this->oper], type, - op[0], op[1]); + result = new(ctx) ir_expression(operations[this->oper], type, + op[0], op[1]); error_emitted = type->is_error(); break; @@ -767,8 +775,8 @@ ast_expression::hir(exec_list *instructions, error_emitted = true; } - result = new ir_expression(operations[this->oper], glsl_type::bool_type, - op[0], op[1]); + result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type, + op[0], op[1]); type = glsl_type::bool_type; assert(result->type == glsl_type::bool_type); @@ -812,7 +820,7 @@ ast_expression::hir(exec_list *instructions, } type = glsl_type::bool_type; } else { - ir_if *const stmt = new ir_if(op[0]); + ir_if *const stmt = new(ctx) ir_if(op[0]); instructions->push_tail(stmt); op[1] = this->subexpressions[1]->hir(&stmt->then_instructions, state); @@ -829,17 +837,17 @@ ast_expression::hir(exec_list *instructions, ir_variable *const tmp = generate_temporary(glsl_type::bool_type, instructions, state); - ir_dereference *const then_deref = new ir_dereference_variable(tmp); + ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp); ir_assignment *const then_assign = - new ir_assignment(then_deref, op[1], NULL); + new(ctx) ir_assignment(then_deref, op[1], NULL); stmt->then_instructions.push_tail(then_assign); - ir_dereference *const else_deref = new ir_dereference_variable(tmp); + ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp); ir_assignment *const else_assign = - new ir_assignment(else_deref, new ir_constant(false), NULL); + new(ctx) ir_assignment(else_deref, new(ctx) ir_constant(false), NULL); stmt->else_instructions.push_tail(else_assign); - result = new ir_dereference_variable(tmp); + result = new(ctx) ir_dereference_variable(tmp); type = tmp->type; } break; @@ -875,7 +883,7 @@ ast_expression::hir(exec_list *instructions, } type = glsl_type::bool_type; } else { - ir_if *const stmt = new ir_if(op[0]); + ir_if *const stmt = new(ctx) ir_if(op[0]); instructions->push_tail(stmt); ir_variable *const tmp = generate_temporary(glsl_type::bool_type, @@ -891,17 +899,17 @@ ast_expression::hir(exec_list *instructions, error_emitted = true; } - ir_dereference *const then_deref = new ir_dereference_variable(tmp); + ir_dereference *const then_deref = new(ctx) ir_dereference_variable(tmp); ir_assignment *const then_assign = - new ir_assignment(then_deref, new ir_constant(true), NULL); + new(ctx) ir_assignment(then_deref, new(ctx) ir_constant(true), NULL); stmt->then_instructions.push_tail(then_assign); - ir_dereference *const else_deref = new ir_dereference_variable(tmp); + ir_dereference *const else_deref = new(ctx) ir_dereference_variable(tmp); ir_assignment *const else_assign = - new ir_assignment(else_deref, op[1], NULL); + new(ctx) ir_assignment(else_deref, op[1], NULL); stmt->else_instructions.push_tail(else_assign); - result = new ir_dereference_variable(tmp); + result = new(ctx) ir_dereference_variable(tmp); type = tmp->type; } break; @@ -912,8 +920,8 @@ ast_expression::hir(exec_list *instructions, op[1] = this->subexpressions[1]->hir(instructions, state); - result = new ir_expression(operations[this->oper], glsl_type::bool_type, - op[0], op[1]); + result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type, + op[0], op[1]); type = glsl_type::bool_type; break; @@ -928,8 +936,8 @@ ast_expression::hir(exec_list *instructions, error_emitted = true; } - result = new ir_expression(operations[this->oper], glsl_type::bool_type, - op[0], NULL); + result = new(ctx) ir_expression(operations[this->oper], glsl_type::bool_type, + op[0], NULL); type = glsl_type::bool_type; break; @@ -944,8 +952,8 @@ ast_expression::hir(exec_list *instructions, (this->oper == ast_mul_assign), state, & loc); - ir_rvalue *temp_rhs = new ir_expression(operations[this->oper], type, - op[0], op[1]); + ir_rvalue *temp_rhs = new(ctx) ir_expression(operations[this->oper], type, + op[0], op[1]); result = do_assignment(instructions, state, (ir_rvalue *)op[0]->clone(NULL), temp_rhs, @@ -970,8 +978,8 @@ ast_expression::hir(exec_list *instructions, assert(operations[this->oper] == ir_binop_mod); struct ir_rvalue *temp_rhs; - temp_rhs = new ir_expression(operations[this->oper], type, - op[0], op[1]); + temp_rhs = new(ctx) ir_expression(operations[this->oper], type, + op[0], op[1]); result = do_assignment(instructions, state, (ir_rvalue *)op[0]->clone(NULL), temp_rhs, @@ -1057,22 +1065,24 @@ ast_expression::hir(exec_list *instructions, ir_variable *const tmp = generate_temporary(type, instructions, state); - ir_if *const stmt = new ir_if(op[0]); + ir_if *const stmt = new(ctx) ir_if(op[0]); instructions->push_tail(stmt); then_instructions.move_nodes_to(& stmt->then_instructions); - ir_dereference *const then_deref = new ir_dereference_variable(tmp); + ir_dereference *const then_deref = + new(ctx) ir_dereference_variable(tmp); ir_assignment *const then_assign = - new ir_assignment(then_deref, op[1], NULL); + new(ctx) ir_assignment(then_deref, op[1], NULL); stmt->then_instructions.push_tail(then_assign); else_instructions.move_nodes_to(& stmt->else_instructions); - ir_dereference *const else_deref = new ir_dereference_variable(tmp); + ir_dereference *const else_deref = + new(ctx) ir_dereference_variable(tmp); ir_assignment *const else_assign = - new ir_assignment(else_deref, op[2], NULL); + new(ctx) ir_assignment(else_deref, op[2], NULL); stmt->else_instructions.push_tail(else_assign); - result = new ir_dereference_variable(tmp); + result = new(ctx) ir_dereference_variable(tmp); } break; } @@ -1081,15 +1091,15 @@ ast_expression::hir(exec_list *instructions, case ast_pre_dec: { op[0] = this->subexpressions[0]->hir(instructions, state); if (op[0]->type->base_type == GLSL_TYPE_FLOAT) - op[1] = new ir_constant(1.0f); + op[1] = new(ctx) ir_constant(1.0f); else - op[1] = new ir_constant(1); + op[1] = new(ctx) ir_constant(1); type = arithmetic_result_type(op[0], op[1], false, state, & loc); struct ir_rvalue *temp_rhs; - temp_rhs = new ir_expression(operations[this->oper], type, - op[0], op[1]); + temp_rhs = new(ctx) ir_expression(operations[this->oper], type, + op[0], op[1]); result = do_assignment(instructions, state, (ir_rvalue *)op[0]->clone(NULL), temp_rhs, @@ -1103,17 +1113,17 @@ ast_expression::hir(exec_list *instructions, case ast_post_dec: { op[0] = this->subexpressions[0]->hir(instructions, state); if (op[0]->type->base_type == GLSL_TYPE_FLOAT) - op[1] = new ir_constant(1.0f); + op[1] = new(ctx) ir_constant(1.0f); else - op[1] = new ir_constant(1); + op[1] = new(ctx) ir_constant(1); error_emitted = op[0]->type->is_error() || op[1]->type->is_error(); type = arithmetic_result_type(op[0], op[1], false, state, & loc); struct ir_rvalue *temp_rhs; - temp_rhs = new ir_expression(operations[this->oper], type, - op[0], op[1]); + temp_rhs = new(ctx) ir_expression(operations[this->oper], type, + op[0], op[1]); /* Get a temporary of a copy of the lvalue before it's modified. * This may get thrown away later. @@ -1144,7 +1154,7 @@ ast_expression::hir(exec_list *instructions, ir_rvalue *const array = op[0]; - result = new ir_dereference_array(op[0], op[1]); + result = new(ctx) ir_dereference_array(op[0], op[1]); /* Do not use op[0] after this point. Use array. */ @@ -1260,7 +1270,7 @@ ast_expression::hir(exec_list *instructions, ir_variable *var = state->symbols->get_variable(this->primary_expression.identifier); - result = new ir_dereference_variable(var); + result = new(ctx) ir_dereference_variable(var); if (var != NULL) { type = result->type; @@ -1275,22 +1285,22 @@ ast_expression::hir(exec_list *instructions, case ast_int_constant: type = glsl_type::int_type; - result = new ir_constant(this->primary_expression.int_constant); + result = new(ctx) ir_constant(this->primary_expression.int_constant); break; case ast_uint_constant: type = glsl_type::uint_type; - result = new ir_constant(this->primary_expression.uint_constant); + result = new(ctx) ir_constant(this->primary_expression.uint_constant); break; case ast_float_constant: type = glsl_type::float_type; - result = new ir_constant(this->primary_expression.float_constant); + result = new(ctx) ir_constant(this->primary_expression.float_constant); break; case ast_bool_constant: type = glsl_type::bool_type; - result = new ir_constant(bool(this->primary_expression.bool_constant)); + result = new(ctx) ir_constant(bool(this->primary_expression.bool_constant)); break; case ast_sequence: { @@ -1403,7 +1413,7 @@ process_array_type(const glsl_type *base, ast_node *array_size, } } - return glsl_type::get_array_instance(base, length); + return glsl_type::get_array_instance(state, base, length); } @@ -1529,6 +1539,7 @@ ir_rvalue * ast_declarator_list::hir(exec_list *instructions, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); const struct glsl_type *decl_type; const char *type_name = NULL; ir_rvalue *result = NULL; @@ -1589,7 +1600,7 @@ ast_declarator_list::hir(exec_list *instructions, var_type = decl_type; } - var = new ir_variable(var_type, decl->identifier); + var = new(ctx) ir_variable(var_type, decl->identifier); /* From page 22 (page 28 of the PDF) of the GLSL 1.10 specification; * @@ -1789,7 +1800,7 @@ ast_declarator_list::hir(exec_list *instructions, ? "attribute" : "varying"); } - ir_dereference *const lhs = new ir_dereference_variable(var); + ir_dereference *const lhs = new(ctx) ir_dereference_variable(var); ir_rvalue *rhs = decl->initializer->hir(instructions, state); /* Calculate the constant value if this is a const or uniform @@ -1867,6 +1878,7 @@ ir_rvalue * ast_parameter_declarator::hir(exec_list *instructions, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); const struct glsl_type *type; const char *name = NULL; YYLTYPE loc = this->get_location(); @@ -1914,7 +1926,7 @@ ast_parameter_declarator::hir(exec_list *instructions, } is_void = false; - ir_variable *var = new ir_variable(type, this->identifier); + ir_variable *var = new(ctx) ir_variable(type, this->identifier); /* FINISHME: Handle array declarations. Note that this requires * FINISHME: complete handling of constant expressions. @@ -1967,6 +1979,7 @@ ir_rvalue * ast_function::hir(exec_list *instructions, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); ir_function *f = NULL; ir_function_signature *sig = NULL; exec_list hir_parameters; @@ -2026,7 +2039,7 @@ ast_function::hir(exec_list *instructions, "non-function", name); sig = NULL; } else { - f = new ir_function(name); + f = new(ctx) ir_function(name); state->symbols->add_function(f->name, f); /* Emit the new function header */ @@ -2051,7 +2064,7 @@ ast_function::hir(exec_list *instructions, /* Finish storing the information about this new function in its signature. */ if (sig == NULL) { - sig = new ir_function_signature(return_type); + sig = new(ctx) ir_function_signature(return_type); f->add_signature(sig); } @@ -2116,6 +2129,7 @@ ir_rvalue * ast_jump_statement::hir(exec_list *instructions, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); switch (mode) { case ast_return: { @@ -2141,7 +2155,7 @@ ast_jump_statement::hir(exec_list *instructions, * FINISHME: type of the enclosing function. */ - inst = new ir_return(ret); + inst = new(ctx) ir_return(ret); } else { if (state->current_function->return_type->base_type != GLSL_TYPE_VOID) { @@ -2152,7 +2166,7 @@ ast_jump_statement::hir(exec_list *instructions, "non-void", state->current_function->function_name()); } - inst = new ir_return; + inst = new(ctx) ir_return; } instructions->push_tail(inst); @@ -2189,9 +2203,9 @@ ast_jump_statement::hir(exec_list *instructions, if (loop != NULL) { ir_loop_jump *const jump = - new ir_loop_jump((mode == ast_break) - ? ir_loop_jump::jump_break - : ir_loop_jump::jump_continue); + new(ctx) ir_loop_jump((mode == ast_break) + ? ir_loop_jump::jump_break + : ir_loop_jump::jump_continue); instructions->push_tail(jump); } } @@ -2209,6 +2223,8 @@ ir_rvalue * ast_selection_statement::hir(exec_list *instructions, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); + ir_rvalue *const condition = this->condition->hir(instructions, state); /* From page 66 (page 72 of the PDF) of the GLSL 1.50 spec: @@ -2227,7 +2243,7 @@ ast_selection_statement::hir(exec_list *instructions, "boolean"); } - ir_if *const stmt = new ir_if(condition); + ir_if *const stmt = new(ctx) ir_if(condition); if (then_statement != NULL) then_statement->hir(& stmt->then_instructions, state); @@ -2247,6 +2263,8 @@ void ast_iteration_statement::condition_to_hir(ir_loop *stmt, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); + if (condition != NULL) { ir_rvalue *const cond = condition->hir(& stmt->body_instructions, state); @@ -2262,13 +2280,13 @@ ast_iteration_statement::condition_to_hir(ir_loop *stmt, * like 'if (!condition) break;' as the loop termination condition. */ ir_rvalue *const not_cond = - new ir_expression(ir_unop_logic_not, glsl_type::bool_type, cond, - NULL); + new(ctx) ir_expression(ir_unop_logic_not, glsl_type::bool_type, cond, + NULL); - ir_if *const if_stmt = new ir_if(not_cond); + ir_if *const if_stmt = new(ctx) ir_if(not_cond); ir_jump *const break_stmt = - new ir_loop_jump(ir_loop_jump::jump_break); + new(ctx) ir_loop_jump(ir_loop_jump::jump_break); if_stmt->then_instructions.push_tail(break_stmt); stmt->body_instructions.push_tail(if_stmt); @@ -2281,6 +2299,8 @@ ir_rvalue * ast_iteration_statement::hir(exec_list *instructions, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); + /* For-loops and while-loops start a new scope, but do-while loops do not. */ if (mode != ast_do_while) @@ -2289,7 +2309,7 @@ ast_iteration_statement::hir(exec_list *instructions, if (init_statement != NULL) init_statement->hir(instructions, state); - ir_loop *const stmt = new ir_loop(); + ir_loop *const stmt = new(ctx) ir_loop(); instructions->push_tail(stmt); /* Track the current loop and / or switch-statement nesting. @@ -2337,6 +2357,7 @@ ir_rvalue * ast_struct_specifier::hir(exec_list *instructions, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); unsigned decl_count = 0; /* Make an initial pass over the list of structure fields to determine how @@ -2399,7 +2420,7 @@ ast_struct_specifier::hir(exec_list *instructions, name = this->name; } - glsl_type *t = new glsl_type(fields, decl_count, name); + glsl_type *t = new(ctx) glsl_type(fields, decl_count, name); YYLTYPE loc = this->get_location(); if (!state->symbols->add_type(name, t)) { diff --git a/glsl_lexer.lpp b/glsl_lexer.lpp index c15c99c4b0..fa439f1278 100644 --- a/glsl_lexer.lpp +++ b/glsl_lexer.lpp @@ -312,7 +312,9 @@ highp return HIGHP; precision return PRECISION; [_a-zA-Z][_a-zA-Z0-9]* { - yylval->identifier = strdup(yytext); + struct _mesa_glsl_parse_state *state = yyextra; + void *ctx = talloc_parent(state); + yylval->identifier = talloc_strdup(ctx, yytext); return IDENTIFIER; } diff --git a/glsl_parser.ypp b/glsl_parser.ypp index ae009ed20c..4132495f40 100644 --- a/glsl_parser.ypp +++ b/glsl_parser.ypp @@ -255,31 +255,36 @@ variable_identifier: primary_expression: variable_identifier { - $$ = new ast_expression(ast_identifier, NULL, NULL, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression(ast_identifier, NULL, NULL, NULL); $$->set_location(yylloc); $$->primary_expression.identifier = $1; } | INTCONSTANT { - $$ = new ast_expression(ast_int_constant, NULL, NULL, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression(ast_int_constant, NULL, NULL, NULL); $$->set_location(yylloc); $$->primary_expression.int_constant = $1; } | UINTCONSTANT { - $$ = new ast_expression(ast_uint_constant, NULL, NULL, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression(ast_uint_constant, NULL, NULL, NULL); $$->set_location(yylloc); $$->primary_expression.uint_constant = $1; } | FLOATCONSTANT { - $$ = new ast_expression(ast_float_constant, NULL, NULL, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression(ast_float_constant, NULL, NULL, NULL); $$->set_location(yylloc); $$->primary_expression.float_constant = $1; } | BOOLCONSTANT { - $$ = new ast_expression(ast_bool_constant, NULL, NULL, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression(ast_bool_constant, NULL, NULL, NULL); $$->set_location(yylloc); $$->primary_expression.bool_constant = $1; } @@ -293,7 +298,8 @@ postfix_expression: primary_expression | postfix_expression '[' integer_expression ']' { - $$ = new ast_expression(ast_array_index, $1, $3, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression(ast_array_index, $1, $3, NULL); $$->set_location(yylloc); } | function_call @@ -308,18 +314,21 @@ postfix_expression: } | postfix_expression '.' IDENTIFIER { - $$ = new ast_expression(ast_field_selection, $1, NULL, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression(ast_field_selection, $1, NULL, NULL); $$->set_location(yylloc); $$->primary_expression.identifier = $3; } | postfix_expression INC_OP { - $$ = new ast_expression(ast_post_inc, $1, NULL, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression(ast_post_inc, $1, NULL, NULL); $$->set_location(yylloc); } | postfix_expression DEC_OP { - $$ = new ast_expression(ast_post_dec, $1, NULL, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression(ast_post_dec, $1, NULL, NULL); $$->set_location(yylloc); } ; @@ -336,7 +345,8 @@ function_call_or_method: function_call_generic | postfix_expression '.' function_call_generic { - $$ = new ast_expression(ast_field_selection, $1, $3, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression(ast_field_selection, $1, $3, NULL); $$->set_location(yylloc); } ; @@ -376,19 +386,22 @@ function_call_header: function_identifier: type_specifier { - $$ = new ast_function_expression($1); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_function_expression($1); $$->set_location(yylloc); } | IDENTIFIER { - ast_expression *callee = new ast_expression($1); - $$ = new ast_function_expression(callee); + void *ctx = talloc_parent(state); + ast_expression *callee = new(ctx) ast_expression($1); + $$ = new(ctx) ast_function_expression(callee); $$->set_location(yylloc); } | FIELD_SELECTION { - ast_expression *callee = new ast_expression($1); - $$ = new ast_function_expression(callee); + void *ctx = talloc_parent(state); + ast_expression *callee = new(ctx) ast_expression($1); + $$ = new(ctx) ast_function_expression(callee); $$->set_location(yylloc); } ; @@ -398,17 +411,20 @@ unary_expression: postfix_expression | INC_OP unary_expression { - $$ = new ast_expression(ast_pre_inc, $2, NULL, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression(ast_pre_inc, $2, NULL, NULL); $$->set_location(yylloc); } | DEC_OP unary_expression { - $$ = new ast_expression(ast_pre_dec, $2, NULL, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression(ast_pre_dec, $2, NULL, NULL); $$->set_location(yylloc); } | unary_operator unary_expression { - $$ = new ast_expression($1, $2, NULL, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression($1, $2, NULL, NULL); $$->set_location(yylloc); } ; @@ -425,17 +441,20 @@ multiplicative_expression: unary_expression | multiplicative_expression '*' unary_expression { - $$ = new ast_expression_bin(ast_mul, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_mul, $1, $3); $$->set_location(yylloc); } | multiplicative_expression '/' unary_expression { - $$ = new ast_expression_bin(ast_div, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_div, $1, $3); $$->set_location(yylloc); } | multiplicative_expression '%' unary_expression { - $$ = new ast_expression_bin(ast_mod, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_mod, $1, $3); $$->set_location(yylloc); } ; @@ -444,12 +463,14 @@ additive_expression: multiplicative_expression | additive_expression '+' multiplicative_expression { - $$ = new ast_expression_bin(ast_add, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_add, $1, $3); $$->set_location(yylloc); } | additive_expression '-' multiplicative_expression { - $$ = new ast_expression_bin(ast_sub, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_sub, $1, $3); $$->set_location(yylloc); } ; @@ -458,12 +479,14 @@ shift_expression: additive_expression | shift_expression LEFT_OP additive_expression { - $$ = new ast_expression_bin(ast_lshift, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_lshift, $1, $3); $$->set_location(yylloc); } | shift_expression RIGHT_OP additive_expression { - $$ = new ast_expression_bin(ast_rshift, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_rshift, $1, $3); $$->set_location(yylloc); } ; @@ -472,22 +495,26 @@ relational_expression: shift_expression | relational_expression '<' shift_expression { - $$ = new ast_expression_bin(ast_less, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_less, $1, $3); $$->set_location(yylloc); } | relational_expression '>' shift_expression { - $$ = new ast_expression_bin(ast_greater, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_greater, $1, $3); $$->set_location(yylloc); } | relational_expression LE_OP shift_expression { - $$ = new ast_expression_bin(ast_lequal, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_lequal, $1, $3); $$->set_location(yylloc); } | relational_expression GE_OP shift_expression { - $$ = new ast_expression_bin(ast_gequal, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_gequal, $1, $3); $$->set_location(yylloc); } ; @@ -496,12 +523,14 @@ equality_expression: relational_expression | equality_expression EQ_OP relational_expression { - $$ = new ast_expression_bin(ast_equal, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_equal, $1, $3); $$->set_location(yylloc); } | equality_expression NE_OP relational_expression { - $$ = new ast_expression_bin(ast_nequal, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_nequal, $1, $3); $$->set_location(yylloc); } ; @@ -510,7 +539,8 @@ and_expression: equality_expression | and_expression '&' equality_expression { - $$ = new ast_expression_bin(ast_bit_or, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_bit_or, $1, $3); $$->set_location(yylloc); } ; @@ -519,7 +549,8 @@ exclusive_or_expression: and_expression | exclusive_or_expression '^' and_expression { - $$ = new ast_expression_bin(ast_bit_xor, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_bit_xor, $1, $3); $$->set_location(yylloc); } ; @@ -528,7 +559,8 @@ inclusive_or_expression: exclusive_or_expression | inclusive_or_expression '|' exclusive_or_expression { - $$ = new ast_expression_bin(ast_bit_or, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_bit_or, $1, $3); $$->set_location(yylloc); } ; @@ -537,7 +569,8 @@ logical_and_expression: inclusive_or_expression | logical_and_expression AND_OP inclusive_or_expression { - $$ = new ast_expression_bin(ast_logic_and, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_logic_and, $1, $3); $$->set_location(yylloc); } ; @@ -546,7 +579,8 @@ logical_xor_expression: logical_and_expression | logical_xor_expression XOR_OP logical_and_expression { - $$ = new ast_expression_bin(ast_logic_xor, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_logic_xor, $1, $3); $$->set_location(yylloc); } ; @@ -555,7 +589,8 @@ logical_or_expression: logical_xor_expression | logical_or_expression OR_OP logical_xor_expression { - $$ = new ast_expression_bin(ast_logic_or, $1, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_bin(ast_logic_or, $1, $3); $$->set_location(yylloc); } ; @@ -564,7 +599,8 @@ conditional_expression: logical_or_expression | logical_or_expression '?' expression ':' assignment_expression { - $$ = new ast_expression(ast_conditional, $1, $3, $5); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression(ast_conditional, $1, $3, $5); $$->set_location(yylloc); } ; @@ -573,7 +609,8 @@ assignment_expression: conditional_expression | unary_expression assignment_operator assignment_expression { - $$ = new ast_expression($2, $1, $3, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression($2, $1, $3, NULL); $$->set_location(yylloc); } ; @@ -599,8 +636,9 @@ expression: } | expression ',' assignment_expression { + void *ctx = talloc_parent(state); if ($1->oper != ast_sequence) { - $$ = new ast_expression(ast_sequence, NULL, NULL, NULL); + $$ = new(ctx) ast_expression(ast_sequence, NULL, NULL, NULL); $$->set_location(yylloc); $$->expressions.push_tail(& $1->link); } else { @@ -662,7 +700,8 @@ function_header_with_parameters: function_header: fully_specified_type IDENTIFIER '(' { - $$ = new ast_function(); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_function(); $$->set_location(yylloc); $$->return_type = $1; $$->identifier = $2; @@ -672,18 +711,20 @@ function_header: parameter_declarator: type_specifier IDENTIFIER { - $$ = new ast_parameter_declarator(); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_parameter_declarator(); $$->set_location(yylloc); - $$->type = new ast_fully_specified_type(); + $$->type = new(ctx) ast_fully_specified_type(); $$->type->set_location(yylloc); $$->type->specifier = $1; $$->identifier = $2; } | type_specifier IDENTIFIER '[' constant_expression ']' { - $$ = new ast_parameter_declarator(); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_parameter_declarator(); $$->set_location(yylloc); - $$->type = new ast_fully_specified_type(); + $$->type = new(ctx) ast_fully_specified_type(); $$->type->set_location(yylloc); $$->type->specifier = $1; $$->identifier = $2; @@ -707,19 +748,21 @@ parameter_declaration: } | parameter_type_qualifier parameter_qualifier parameter_type_specifier { + void *ctx = talloc_parent(state); $1.i |= $2.i; - $$ = new ast_parameter_declarator(); + $$ = new(ctx) ast_parameter_declarator(); $$->set_location(yylloc); - $$->type = new ast_fully_specified_type(); + $$->type = new(ctx) ast_fully_specified_type(); $$->type->qualifier = $1.q; $$->type->specifier = $3; } | parameter_qualifier parameter_type_specifier { - $$ = new ast_parameter_declarator(); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_parameter_declarator(); $$->set_location(yylloc); - $$->type = new ast_fully_specified_type(); + $$->type = new(ctx) ast_fully_specified_type(); $$->type->qualifier = $1.q; $$->type->specifier = $2; } @@ -740,7 +783,8 @@ init_declarator_list: single_declaration | init_declarator_list ',' IDENTIFIER { - ast_declaration *decl = new ast_declaration($3, false, NULL, NULL); + void *ctx = talloc_parent(state); + ast_declaration *decl = new(ctx) ast_declaration($3, false, NULL, NULL); decl->set_location(yylloc); $$ = $1; @@ -748,7 +792,8 @@ init_declarator_list: } | init_declarator_list ',' IDENTIFIER '[' ']' { - ast_declaration *decl = new ast_declaration($3, true, NULL, NULL); + void *ctx = talloc_parent(state); + ast_declaration *decl = new(ctx) ast_declaration($3, true, NULL, NULL); decl->set_location(yylloc); $$ = $1; @@ -756,7 +801,8 @@ init_declarator_list: } | init_declarator_list ',' IDENTIFIER '[' constant_expression ']' { - ast_declaration *decl = new ast_declaration($3, true, $5, NULL); + void *ctx = talloc_parent(state); + ast_declaration *decl = new(ctx) ast_declaration($3, true, $5, NULL); decl->set_location(yylloc); $$ = $1; @@ -764,7 +810,8 @@ init_declarator_list: } | init_declarator_list ',' IDENTIFIER '[' ']' '=' initializer { - ast_declaration *decl = new ast_declaration($3, true, NULL, $7); + void *ctx = talloc_parent(state); + ast_declaration *decl = new(ctx) ast_declaration($3, true, NULL, $7); decl->set_location(yylloc); $$ = $1; @@ -772,7 +819,8 @@ init_declarator_list: } | init_declarator_list ',' IDENTIFIER '[' constant_expression ']' '=' initializer { - ast_declaration *decl = new ast_declaration($3, true, $5, $8); + void *ctx = talloc_parent(state); + ast_declaration *decl = new(ctx) ast_declaration($3, true, $5, $8); decl->set_location(yylloc); $$ = $1; @@ -780,7 +828,8 @@ init_declarator_list: } | init_declarator_list ',' IDENTIFIER '=' initializer { - ast_declaration *decl = new ast_declaration($3, false, NULL, $5); + void *ctx = talloc_parent(state); + ast_declaration *decl = new(ctx) ast_declaration($3, false, NULL, $5); decl->set_location(yylloc); $$ = $1; @@ -792,67 +841,75 @@ init_declarator_list: single_declaration: fully_specified_type { + void *ctx = talloc_parent(state); if ($1->specifier->type_specifier != ast_struct) { _mesa_glsl_error(& @1, state, "empty declaration list\n"); YYERROR; } else { - $$ = new ast_declarator_list($1); + $$ = new(ctx) ast_declarator_list($1); $$->set_location(yylloc); } } | fully_specified_type IDENTIFIER { - ast_declaration *decl = new ast_declaration($2, false, NULL, NULL); + void *ctx = talloc_parent(state); + ast_declaration *decl = new(ctx) ast_declaration($2, false, NULL, NULL); - $$ = new ast_declarator_list($1); + $$ = new(ctx) ast_declarator_list($1); $$->set_location(yylloc); $$->declarations.push_tail(&decl->link); } | fully_specified_type IDENTIFIER '[' ']' { - ast_declaration *decl = new ast_declaration($2, true, NULL, NULL); + void *ctx = talloc_parent(state); + ast_declaration *decl = new(ctx) ast_declaration($2, true, NULL, NULL); - $$ = new ast_declarator_list($1); + $$ = new(ctx) ast_declarator_list($1); $$->set_location(yylloc); $$->declarations.push_tail(&decl->link); } | fully_specified_type IDENTIFIER '[' constant_expression ']' { - ast_declaration *decl = new ast_declaration($2, true, $4, NULL); + void *ctx = talloc_parent(state); + ast_declaration *decl = new(ctx) ast_declaration($2, true, $4, NULL); - $$ = new ast_declarator_list($1); + $$ = new(ctx) ast_declarator_list($1); $$->set_location(yylloc); $$->declarations.push_tail(&decl->link); } | fully_specified_type IDENTIFIER '[' ']' '=' initializer { - ast_declaration *decl = new ast_declaration($2, true, NULL, $6); + void *ctx = talloc_parent(state); + ast_declaration *decl = new(ctx) ast_declaration($2, true, NULL, $6); - $$ = new ast_declarator_list($1); + $$ = new(ctx) ast_declarator_list($1); $$->set_location(yylloc); $$->declarations.push_tail(&decl->link); } | fully_specified_type IDENTIFIER '[' constant_expression ']' '=' initializer { - ast_declaration *decl = new ast_declaration($2, true, $4, $7); + void *ctx = talloc_parent(state); + ast_declaration *decl = new(ctx) ast_declaration($2, true, $4, $7); - $$ = new ast_declarator_list($1); + $$ = new(ctx) ast_declarator_list($1); $$->set_location(yylloc); $$->declarations.push_tail(&decl->link); } | fully_specified_type IDENTIFIER '=' initializer { - ast_declaration *decl = new ast_declaration($2, false, NULL, $4); + void *ctx = talloc_parent(state); + ast_declaration *decl = new(ctx) ast_declaration($2, false, NULL, $4); - $$ = new ast_declarator_list($1); + $$ = new(ctx) ast_declarator_list($1); $$->set_location(yylloc); $$->declarations.push_tail(&decl->link); } | INVARIANT IDENTIFIER // Vertex only. { - ast_declaration *decl = new ast_declaration($2, false, NULL, NULL); + void *ctx = talloc_parent(state); + ast_declaration *decl = new(ctx) ast_declaration($2, false, NULL, NULL); - $$ = new ast_declarator_list(NULL); + $$ = new(ctx) ast_declarator_list(NULL); $$->set_location(yylloc); $$->invariant = true; @@ -863,13 +920,15 @@ single_declaration: fully_specified_type: type_specifier { - $$ = new ast_fully_specified_type(); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_fully_specified_type(); $$->set_location(yylloc); $$->specifier = $1; } | type_qualifier type_specifier { - $$ = new ast_fully_specified_type(); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_fully_specified_type(); $$->set_location(yylloc); $$->qualifier = $1.q; $$->specifier = $2; @@ -939,17 +998,20 @@ type_specifier_no_prec: type_specifier_nonarray: basic_type_specifier_nonarray { - $$ = new ast_type_specifier($1); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_type_specifier($1); $$->set_location(yylloc); } | struct_specifier { - $$ = new ast_type_specifier($1); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_type_specifier($1); $$->set_location(yylloc); } | IDENTIFIER { - $$ = new ast_type_specifier($1); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_type_specifier($1); $$->set_location(yylloc); } ; @@ -1050,12 +1112,14 @@ precision_qualifier: struct_specifier: STRUCT IDENTIFIER '{' struct_declaration_list '}' { - $$ = new ast_struct_specifier($2, $4); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_struct_specifier($2, $4); $$->set_location(yylloc); } | STRUCT '{' struct_declaration_list '}' { - $$ = new ast_struct_specifier(NULL, $3); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_struct_specifier(NULL, $3); $$->set_location(yylloc); } ; @@ -1076,11 +1140,12 @@ struct_declaration_list: struct_declaration: type_specifier struct_declarator_list ';' { - ast_fully_specified_type *type = new ast_fully_specified_type(); + void *ctx = talloc_parent(state); + ast_fully_specified_type *type = new(ctx) ast_fully_specified_type(); type->set_location(yylloc); type->specifier = $1; - $$ = new ast_declarator_list(type); + $$ = new(ctx) ast_declarator_list(type); $$->set_location(yylloc); $$->declarations.push_degenerate_list_at_head(& $2->link); @@ -1103,12 +1168,14 @@ struct_declarator_list: struct_declarator: IDENTIFIER { - $$ = new ast_declaration($1, false, NULL, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_declaration($1, false, NULL, NULL); $$->set_location(yylloc); } | IDENTIFIER '[' constant_expression ']' { - $$ = new ast_declaration($1, true, $3, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_declaration($1, true, $3, NULL); $$->set_location(yylloc); } ; @@ -1150,12 +1217,14 @@ simple_statement: compound_statement: '{' '}' { - $$ = new ast_compound_statement(true, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_compound_statement(true, NULL); $$->set_location(yylloc); } | '{' statement_list '}' { - $$ = new ast_compound_statement(true, $2); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_compound_statement(true, $2); $$->set_location(yylloc); } ; @@ -1168,12 +1237,14 @@ statement_no_new_scope: compound_statement_no_new_scope: '{' '}' { - $$ = new ast_compound_statement(false, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_compound_statement(false, NULL); $$->set_location(yylloc); } | '{' statement_list '}' { - $$ = new ast_compound_statement(false, $2); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_compound_statement(false, $2); $$->set_location(yylloc); } ; @@ -1203,12 +1274,14 @@ statement_list: expression_statement: ';' { - $$ = new ast_expression_statement(NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_statement(NULL); $$->set_location(yylloc); } | expression ';' { - $$ = new ast_expression_statement($1); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_expression_statement($1); $$->set_location(yylloc); } ; @@ -1216,7 +1289,8 @@ expression_statement: selection_statement_matched: IF '(' expression ')' statement_matched ELSE statement_matched { - $$ = new ast_selection_statement($3, $5, $7); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_selection_statement($3, $5, $7); $$->set_location(yylloc); } ; @@ -1224,17 +1298,20 @@ selection_statement_matched: selection_statement_unmatched: IF '(' expression ')' statement_matched { - $$ = new ast_selection_statement($3, $5, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_selection_statement($3, $5, NULL); $$->set_location(yylloc); } | IF '(' expression ')' statement_unmatched { - $$ = new ast_selection_statement($3, $5, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_selection_statement($3, $5, NULL); $$->set_location(yylloc); } | IF '(' expression ')' statement_matched ELSE statement_unmatched { - $$ = new ast_selection_statement($3, $5, $7); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_selection_statement($3, $5, $7); $$->set_location(yylloc); } ; @@ -1246,8 +1323,9 @@ condition: } | fully_specified_type IDENTIFIER '=' initializer { - ast_declaration *decl = new ast_declaration($2, false, NULL, $4); - ast_declarator_list *declarator = new ast_declarator_list($1); + void *ctx = talloc_parent(state); + ast_declaration *decl = new(ctx) ast_declaration($2, false, NULL, $4); + ast_declarator_list *declarator = new(ctx) ast_declarator_list($1); decl->set_location(yylloc); declarator->set_location(yylloc); @@ -1268,20 +1346,23 @@ case_label: iteration_statement: WHILE '(' condition ')' statement_no_new_scope { - $$ = new ast_iteration_statement(ast_iteration_statement::ast_while, - NULL, $3, NULL, $5); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_while, + NULL, $3, NULL, $5); $$->set_location(yylloc); } | DO statement WHILE '(' expression ')' ';' { - $$ = new ast_iteration_statement(ast_iteration_statement::ast_do_while, - NULL, $5, NULL, $2); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_do_while, + NULL, $5, NULL, $2); $$->set_location(yylloc); } | FOR '(' for_init_statement for_rest_statement ')' statement_no_new_scope { - $$ = new ast_iteration_statement(ast_iteration_statement::ast_for, - $3, $4.cond, $4.rest, $6); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_for, + $3, $4.cond, $4.rest, $6); $$->set_location(yylloc); } ; @@ -1316,27 +1397,32 @@ for_rest_statement: jump_statement: CONTINUE ';' { - $$ = new ast_jump_statement(ast_jump_statement::ast_continue, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_continue, NULL); $$->set_location(yylloc); } | BREAK ';' { - $$ = new ast_jump_statement(ast_jump_statement::ast_break, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_break, NULL); $$->set_location(yylloc); } | RETURN ';' { - $$ = new ast_jump_statement(ast_jump_statement::ast_return, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, NULL); $$->set_location(yylloc); } | RETURN expression ';' { - $$ = new ast_jump_statement(ast_jump_statement::ast_return, $2); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, $2); $$->set_location(yylloc); } | DISCARD ';' // Fragment shader only. { - $$ = new ast_jump_statement(ast_jump_statement::ast_discard, NULL); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_discard, NULL); $$->set_location(yylloc); } ; @@ -1349,7 +1435,8 @@ external_declaration: function_definition: function_prototype compound_statement_no_new_scope { - $$ = new ast_function_definition(); + void *ctx = talloc_parent(state); + $$ = new(ctx) ast_function_definition(); $$->set_location(yylloc); $$->prototype = $1; $$->body = $2; diff --git a/glsl_symbol_table.h b/glsl_symbol_table.h index 26b90fdb7c..ae2fd3f4f1 100644 --- a/glsl_symbol_table.h +++ b/glsl_symbol_table.h @@ -26,6 +26,8 @@ #ifndef GLSL_SYMBOL_TABLE #define GLSL_SYMBOL_TABLE +#include <new> + #include "symbol_table.h" #include "ir.h" #include "glsl_types.h" @@ -44,7 +46,38 @@ private: glsl_function_name_space = 2 }; + static int + _glsl_symbol_table_destructor (glsl_symbol_table *table) + { + table->~glsl_symbol_table(); + + return 0; + } + public: + /* Callers of this talloc-based new need not call delete. It's + * easier to just talloc_free 'ctx' (or any of its ancestors). */ + static void* operator new(size_t size, void *ctx) + { + void *table; + + table = talloc_size(ctx, size); + assert(table != NULL); + + talloc_set_destructor(table, (int (*)(void*)) _glsl_symbol_table_destructor); + + return table; + } + + /* If the user *does* call delete, that's OK, we will just + * talloc_free in that case. Here, C++ will have already called the + * destructor so tell talloc not to do that again. */ + static void operator delete(void *table) + { + talloc_set_destructor(table, NULL); + talloc_free(table); + } + glsl_symbol_table() { table = _mesa_symbol_table_ctor(); diff --git a/glsl_types.cpp b/glsl_types.cpp index ca19de6bec..bef267fa6b 100644 --- a/glsl_types.cpp +++ b/glsl_types.cpp @@ -150,14 +150,16 @@ const glsl_type *glsl_type::get_base_type() const ir_function * glsl_type::generate_constructor(glsl_symbol_table *symtab) const { + void *ctx = symtab; + /* Generate the function name and add it to the symbol table. */ - ir_function *const f = new ir_function(name); + ir_function *const f = new(ctx) ir_function(name); bool added = symtab->add_function(name, f); assert(added); - ir_function_signature *const sig = new ir_function_signature(this); + ir_function_signature *const sig = new(ctx) ir_function_signature(this); f->add_signature(sig); ir_variable **declarations = @@ -168,8 +170,8 @@ glsl_type::generate_constructor(glsl_symbol_table *symtab) const snprintf(param_name, 10, "p%08X", i); ir_variable *var = (this->base_type == GLSL_TYPE_ARRAY) - ? new ir_variable(fields.array, param_name) - : new ir_variable(fields.structure[i].type, param_name); + ? new(ctx) ir_variable(fields.array, param_name) + : new(ctx) ir_variable(fields.structure[i].type, param_name); var->mode = ir_var_in; declarations[i] = var; @@ -181,24 +183,26 @@ glsl_type::generate_constructor(glsl_symbol_table *symtab) const * the same type as the constructor. After initializing __retval, * __retval is returned. */ - ir_variable *retval = new ir_variable(this, "__retval"); + ir_variable *retval = new(ctx) ir_variable(this, "__retval"); sig->body.push_tail(retval); for (unsigned i = 0; i < length; i++) { ir_dereference *const lhs = (this->base_type == GLSL_TYPE_ARRAY) - ? (ir_dereference *) new ir_dereference_array(retval, new ir_constant(i)) - : (ir_dereference *) new ir_dereference_record(retval, fields.structure[i].name); + ? (ir_dereference *) new(ctx) ir_dereference_array(retval, + new(ctx) ir_constant(i)) + : (ir_dereference *) new(ctx) ir_dereference_record(retval, + fields.structure[i].name); - ir_dereference *const rhs = new ir_dereference_variable(declarations[i]); - ir_instruction *const assign = new ir_assignment(lhs, rhs, NULL); + ir_dereference *const rhs = new(ctx) ir_dereference_variable(declarations[i]); + ir_instruction *const assign = new(ctx) ir_assignment(lhs, rhs, NULL); sig->body.push_tail(assign); } free(declarations); - ir_dereference *const retref = new ir_dereference_variable(retval); - ir_instruction *const inst = new ir_return(retref); + ir_dereference *const retref = new(ctx) ir_dereference_variable(retval); + ir_instruction *const inst = new(ctx) ir_return(retref); sig->body.push_tail(inst); return f; @@ -220,7 +224,8 @@ glsl_type::generate_constructor(glsl_symbol_table *symtab) const * the symbol table. */ static ir_function_signature * -generate_constructor_intro(const glsl_type *type, unsigned parameter_count, +generate_constructor_intro(void *ctx, + const glsl_type *type, unsigned parameter_count, ir_variable **declarations) { /* Names of parameters used in vector and matrix constructors @@ -234,10 +239,10 @@ generate_constructor_intro(const glsl_type *type, unsigned parameter_count, const glsl_type *const parameter_type = type->get_base_type(); - ir_function_signature *const signature = new ir_function_signature(type); + ir_function_signature *const signature = new(ctx) ir_function_signature(type); for (unsigned i = 0; i < parameter_count; i++) { - ir_variable *var = new ir_variable(parameter_type, names[i]); + ir_variable *var = new(ctx) ir_variable(parameter_type, names[i]); var->mode = ir_var_in; signature->parameters.push_tail(var); @@ -245,7 +250,7 @@ generate_constructor_intro(const glsl_type *type, unsigned parameter_count, declarations[i] = var; } - ir_variable *retval = new ir_variable(type, "__retval"); + ir_variable *retval = new(ctx) ir_variable(type, "__retval"); signature->body.push_tail(retval); declarations[16] = retval; @@ -257,7 +262,8 @@ generate_constructor_intro(const glsl_type *type, unsigned parameter_count, * Generate the body of a vector constructor that takes a single scalar */ static void -generate_vec_body_from_scalar(exec_list *instructions, +generate_vec_body_from_scalar(void *ctx, + exec_list *instructions, ir_variable **declarations) { ir_instruction *inst; @@ -266,20 +272,20 @@ generate_vec_body_from_scalar(exec_list *instructions, * __retval.xxxx for however many vector components there are. */ ir_dereference *const lhs_ref = - new ir_dereference_variable(declarations[16]); - ir_dereference *const rhs = new ir_dereference_variable(declarations[0]); + new(ctx) ir_dereference_variable(declarations[16]); + ir_dereference *const rhs = new(ctx) ir_dereference_variable(declarations[0]); - ir_swizzle *lhs = new ir_swizzle(lhs_ref, 0, 0, 0, 0, 1); + ir_swizzle *lhs = new(ctx) ir_swizzle(lhs_ref, 0, 0, 0, 0, 1); - inst = new ir_assignment(lhs, rhs, NULL); + inst = new(ctx) ir_assignment(lhs, rhs, NULL); instructions->push_tail(inst); - ir_dereference *const retref = new ir_dereference_variable(declarations[16]); + ir_dereference *const retref = new(ctx) ir_dereference_variable(declarations[16]); - ir_swizzle *retval = new ir_swizzle(retref, 0, 0, 0, 0, - declarations[16]->type->vector_elements); + ir_swizzle *retval = new(ctx) ir_swizzle(retref, 0, 0, 0, 0, + declarations[16]->type->vector_elements); - inst = new ir_return(retval); + inst = new(ctx) ir_return(retval); instructions->push_tail(inst); } @@ -288,30 +294,30 @@ generate_vec_body_from_scalar(exec_list *instructions, * Generate the body of a vector constructor that takes multiple scalars */ static void -generate_vec_body_from_N_scalars(exec_list *instructions, +generate_vec_body_from_N_scalars(void *ctx, + exec_list *instructions, ir_variable **declarations) { ir_instruction *inst; const glsl_type *const vec_type = declarations[16]->type; - /* Generate an assignment of each parameter to a single component of * __retval.x and return __retval. */ for (unsigned i = 0; i < vec_type->vector_elements; i++) { ir_dereference *const lhs_ref = - new ir_dereference_variable(declarations[16]); - ir_dereference *const rhs = new ir_dereference_variable(declarations[i]); + new(ctx) ir_dereference_variable(declarations[16]); + ir_dereference *const rhs = new(ctx) ir_dereference_variable(declarations[i]); - ir_swizzle *lhs = new ir_swizzle(lhs_ref, i, 0, 0, 0, 1); + ir_swizzle *lhs = new(ctx) ir_swizzle(lhs_ref, i, 0, 0, 0, 1); - inst = new ir_assignment(lhs, rhs, NULL); + inst = new(ctx) ir_assignment(lhs, rhs, NULL); instructions->push_tail(inst); } - ir_dereference *retval = new ir_dereference_variable(declarations[16]); + ir_dereference *retval = new(ctx) ir_dereference_variable(declarations[16]); - inst = new ir_return(retval); + inst = new(ctx) ir_return(retval); instructions->push_tail(inst); } @@ -320,7 +326,8 @@ generate_vec_body_from_N_scalars(exec_list *instructions, * Generate the body of a matrix constructor that takes a single scalar */ static void -generate_mat_body_from_scalar(exec_list *instructions, +generate_mat_body_from_scalar(void *ctx, + exec_list *instructions, ir_variable **declarations) { ir_instruction *inst; @@ -347,49 +354,50 @@ generate_mat_body_from_scalar(exec_list *instructions, */ const glsl_type *const column_type = declarations[16]->type->column_type(); const glsl_type *const row_type = declarations[16]->type->row_type(); - ir_variable *const column = new ir_variable(column_type, "v"); + + ir_variable *const column = new(ctx) ir_variable(column_type, "v"); instructions->push_tail(column); - ir_dereference *const lhs_ref = new ir_dereference_variable(column); - ir_dereference *const rhs = new ir_dereference_variable(declarations[0]); + ir_dereference *const lhs_ref = new(ctx) ir_dereference_variable(column); + ir_dereference *const rhs = new(ctx) ir_dereference_variable(declarations[0]); - ir_swizzle *lhs = new ir_swizzle(lhs_ref, 0, 0, 0, 0, 1); + ir_swizzle *lhs = new(ctx) ir_swizzle(lhs_ref, 0, 0, 0, 0, 1); - inst = new ir_assignment(lhs, rhs, NULL); + inst = new(ctx) ir_assignment(lhs, rhs, NULL); instructions->push_tail(inst); for (unsigned i = 1; i < column_type->vector_elements; i++) { - ir_dereference *const lhs_ref = new ir_dereference_variable(column); - ir_constant *const zero = new ir_constant(0.0f); + ir_dereference *const lhs_ref = new(ctx) ir_dereference_variable(column); + ir_constant *const zero = new(ctx) ir_constant(0.0f); - ir_swizzle *lhs = new ir_swizzle(lhs_ref, i, 0, 0, 0, 1); + ir_swizzle *lhs = new(ctx) ir_swizzle(lhs_ref, i, 0, 0, 0, 1); - inst = new ir_assignment(lhs, zero, NULL); + inst = new(ctx) ir_assignment(lhs, zero, NULL); instructions->push_tail(inst); } for (unsigned i = 0; i < row_type->vector_elements; i++) { static const unsigned swiz[] = { 1, 1, 1, 0, 1, 1, 1 }; - ir_dereference *const rhs_ref = new ir_dereference_variable(column); + ir_dereference *const rhs_ref = new(ctx) ir_dereference_variable(column); /* This will be .xyyy when i=0, .yxyy when i=1, etc. */ - ir_swizzle *rhs = new ir_swizzle(rhs_ref, swiz[3 - i], swiz[4 - i], - swiz[5 - i], swiz[6 - i], - column_type->vector_elements); + ir_swizzle *rhs = new(ctx) ir_swizzle(rhs_ref, swiz[3 - i], swiz[4 - i], + swiz[5 - i], swiz[6 - i], + column_type->vector_elements); - ir_constant *const idx = new ir_constant(int(i)); + ir_constant *const idx = new(ctx) ir_constant(int(i)); ir_dereference *const lhs = - new ir_dereference_array(declarations[16], idx); + new(ctx) ir_dereference_array(declarations[16], idx); - inst = new ir_assignment(lhs, rhs, NULL); + inst = new(ctx) ir_assignment(lhs, rhs, NULL); instructions->push_tail(inst); } - ir_dereference *const retval = new ir_dereference_variable(declarations[16]); - inst = new ir_return(retval); + ir_dereference *const retval = new(ctx) ir_dereference_variable(declarations[16]); + inst = new(ctx) ir_return(retval); instructions->push_tail(inst); } @@ -398,38 +406,38 @@ generate_mat_body_from_scalar(exec_list *instructions, * Generate the body of a vector constructor that takes multiple scalars */ static void -generate_mat_body_from_N_scalars(exec_list *instructions, +generate_mat_body_from_N_scalars(void *ctx, + exec_list *instructions, ir_variable **declarations) { ir_instruction *inst; const glsl_type *const row_type = declarations[16]->type->row_type(); const glsl_type *const column_type = declarations[16]->type->column_type(); - /* Generate an assignment of each parameter to a single component of * of a particular column of __retval and return __retval. */ for (unsigned i = 0; i < column_type->vector_elements; i++) { for (unsigned j = 0; j < row_type->vector_elements; j++) { - ir_constant *row_index = new ir_constant(int(i)); + ir_constant *row_index = new(ctx) ir_constant(int(i)); ir_dereference *const row_access = - new ir_dereference_array(declarations[16], row_index); + new(ctx) ir_dereference_array(declarations[16], row_index); - ir_swizzle *component_access = new ir_swizzle(row_access, - j, 0, 0, 0, 1); + ir_swizzle *component_access = new(ctx) ir_swizzle(row_access, + j, 0, 0, 0, 1); const unsigned param = (i * row_type->vector_elements) + j; ir_dereference *const rhs = - new ir_dereference_variable(declarations[param]); + new(ctx) ir_dereference_variable(declarations[param]); - inst = new ir_assignment(component_access, rhs, NULL); + inst = new(ctx) ir_assignment(component_access, rhs, NULL); instructions->push_tail(inst); } } - ir_dereference *retval = new ir_dereference_variable(declarations[16]); + ir_dereference *retval = new(ctx) ir_dereference_variable(declarations[16]); - inst = new ir_return(retval); + inst = new(ctx) ir_return(retval); instructions->push_tail(inst); } @@ -444,6 +452,7 @@ static void generate_constructor(glsl_symbol_table *symtab, const struct glsl_type *types, unsigned num_types, exec_list *instructions) { + void *ctx = symtab; ir_variable *declarations[17]; for (unsigned i = 0; i < num_types; i++) { @@ -459,7 +468,7 @@ generate_constructor(glsl_symbol_table *symtab, const struct glsl_type *types, /* Generate the function block, add it to the symbol table, and emit it. */ - ir_function *const f = new ir_function(types[i].name); + ir_function *const f = new(ctx) ir_function(types[i].name); bool added = symtab->add_function(types[i].name, f); assert(added); @@ -484,31 +493,33 @@ generate_constructor(glsl_symbol_table *symtab, const struct glsl_type *types, * appropriate from-scalars constructor. */ ir_function_signature *const sig = - generate_constructor_intro(&types[i], 1, declarations); + generate_constructor_intro(ctx, &types[i], 1, declarations); f->add_signature(sig); if (types[i].is_vector()) { - generate_vec_body_from_scalar(&sig->body, declarations); + generate_vec_body_from_scalar(ctx, &sig->body, declarations); ir_function_signature *const vec_sig = - generate_constructor_intro(&types[i], types[i].vector_elements, + generate_constructor_intro(ctx, + &types[i], types[i].vector_elements, declarations); f->add_signature(vec_sig); - generate_vec_body_from_N_scalars(&vec_sig->body, declarations); + generate_vec_body_from_N_scalars(ctx, &vec_sig->body, declarations); } else { assert(types[i].is_matrix()); - generate_mat_body_from_scalar(&sig->body, declarations); + generate_mat_body_from_scalar(ctx, &sig->body, declarations); ir_function_signature *const mat_sig = - generate_constructor_intro(&types[i], + generate_constructor_intro(ctx, + &types[i], (types[i].vector_elements * types[i].matrix_columns), declarations); f->add_signature(mat_sig); - generate_mat_body_from_N_scalars(&mat_sig->body, declarations); + generate_mat_body_from_N_scalars(ctx, &mat_sig->body, declarations); } } } @@ -563,7 +574,7 @@ _mesa_glsl_initialize_constructors(exec_list *instructions, } -glsl_type::glsl_type(const glsl_type *array, unsigned length) : +glsl_type::glsl_type(void *ctx, const glsl_type *array, unsigned length) : base_type(GLSL_TYPE_ARRAY), sampler_dimensionality(0), sampler_shadow(0), sampler_array(0), sampler_type(0), @@ -577,7 +588,7 @@ glsl_type::glsl_type(const glsl_type *array, unsigned length) : * NUL. */ const unsigned name_length = strlen(array->name) + 10 + 3; - char *const n = (char *) malloc(name_length); + char *const n = (char *) talloc_size(ctx, name_length); if (length == 0) snprintf(n, name_length, "%s[]", array->name); @@ -680,9 +691,10 @@ glsl_type::array_key_hash(const void *a) const glsl_type * -glsl_type::get_array_instance(const glsl_type *base, unsigned array_size) +glsl_type::get_array_instance(void *ctx, const glsl_type *base, + unsigned array_size) { - const glsl_type key(base, array_size); + const glsl_type key(ctx, base, array_size); if (array_types == NULL) { array_types = hash_table_ctor(64, array_key_hash, array_key_compare); @@ -690,7 +702,7 @@ glsl_type::get_array_instance(const glsl_type *base, unsigned array_size) const glsl_type *t = (glsl_type *) hash_table_find(array_types, & key); if (t == NULL) { - t = new glsl_type(base, array_size); + t = new(ctx) glsl_type(ctx, base, array_size); hash_table_insert(array_types, (void *) t, t); } diff --git a/glsl_types.h b/glsl_types.h index 939c173fd4..39e6ac970a 100644 --- a/glsl_types.h +++ b/glsl_types.h @@ -29,6 +29,10 @@ #include <cstring> #include <cassert> +extern "C" { +#include <talloc.h> +} + #define GLSL_TYPE_UINT 0 #define GLSL_TYPE_INT 1 #define GLSL_TYPE_FLOAT 2 @@ -61,6 +65,25 @@ struct glsl_type { * and \c GLSL_TYPE_UINT are valid. */ + /* Callers of this talloc-based new need not call delete. It's + * easier to just talloc_free 'ctx' (or any of its ancestors). */ + static void* operator new(size_t size, void *ctx) + { + void *type; + + type = talloc_size(ctx, size); + assert(type != NULL); + + return type; + } + + /* If the user *does* call delete, that's OK, we will just + * talloc_free in that case. */ + static void operator delete(void *type) + { + talloc_free(type); + } + /** * \name Vector and matrix element counts * @@ -198,7 +221,8 @@ struct glsl_type { /** * Get the instance of an array type */ - static const glsl_type *get_array_instance(const glsl_type *base, + static const glsl_type *get_array_instance(void *ctx, + const glsl_type *base, unsigned elements); /** @@ -387,7 +411,7 @@ private: /** * Constructor for array types */ - glsl_type(const glsl_type *array, unsigned length); + glsl_type(void *ctx, const glsl_type *array, unsigned length); /** Hash table containing the known array types. */ static struct hash_table *array_types; diff --git a/hir_field_selection.cpp b/hir_field_selection.cpp index e60ea30d7f..e2efff60d3 100644 --- a/hir_field_selection.cpp +++ b/hir_field_selection.cpp @@ -33,6 +33,7 @@ _mesa_ast_field_selection_to_hir(const ast_expression *expr, exec_list *instructions, struct _mesa_glsl_parse_state *state) { + void *ctx = talloc_parent(state); ir_rvalue *result = NULL; ir_rvalue *op; @@ -62,8 +63,8 @@ _mesa_ast_field_selection_to_hir(const ast_expression *expr, expr->primary_expression.identifier); } } else if (op->type->base_type == GLSL_TYPE_STRUCT) { - result = new ir_dereference_record(op, - expr->primary_expression.identifier); + result = new(ctx) ir_dereference_record(op, + expr->primary_expression.identifier); if (result->type->is_error()) { _mesa_glsl_error(& loc, state, "Cannot access field `%s' of " @@ -76,5 +77,5 @@ _mesa_ast_field_selection_to_hir(const ast_expression *expr, expr->primary_expression.identifier); } - return result ? result : ir_call::get_error_instruction(); + return result ? result : ir_call::get_error_instruction(ctx); } @@ -466,8 +466,10 @@ ir_dereference_array::ir_dereference_array(ir_rvalue *value, ir_dereference_array::ir_dereference_array(ir_variable *var, ir_rvalue *array_index) { + void *ctx = talloc_parent(var); + this->array_index = array_index; - this->set_array(new ir_dereference_variable(var)); + this->set_array(new(ctx) ir_dereference_variable(var)); } @@ -504,7 +506,9 @@ ir_dereference_record::ir_dereference_record(ir_rvalue *value, ir_dereference_record::ir_dereference_record(ir_variable *var, const char *field) { - this->record = new ir_dereference_variable(var); + void *ctx = talloc_parent(var); + + this->record = new(ctx) ir_dereference_variable(var); this->field = field; this->type = (this->record != NULL) ? this->record->type->field_type(field) : glsl_type::error_type; @@ -615,6 +619,8 @@ ir_swizzle::ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask) ir_swizzle * ir_swizzle::create(ir_rvalue *val, const char *str, unsigned vector_length) { + void *ctx = talloc_parent(val); + /* For each possible swizzle character, this table encodes the value in * \c idx_map that represents the 0th element of the vector. For invalid * swizzle characters (e.g., 'k'), a special value is used that will allow @@ -679,8 +685,8 @@ ir_swizzle::create(ir_rvalue *val, const char *str, unsigned vector_length) if (str[i] != '\0') return NULL; - return new ir_swizzle(val, swiz_idx[0], swiz_idx[1], swiz_idx[2], - swiz_idx[3], i); + return new(ctx) ir_swizzle(val, swiz_idx[0], swiz_idx[1], swiz_idx[2], + swiz_idx[3], i); } #undef X @@ -780,7 +786,6 @@ ir_function_signature::replace_parameters(exec_list *new_params) assert(((ir_instruction *) iter.get())->as_variable() != NULL); iter.remove(); - delete (ir_instruction*) iter.get(); } new_params->move_nodes_to(¶meters); @@ -795,9 +800,9 @@ ir_function::ir_function(const char *name) ir_call * -ir_call::get_error_instruction() +ir_call::get_error_instruction(void *ctx) { - ir_call *call = new ir_call; + ir_call *call = new(ctx) ir_call; call->type = glsl_type::error_type; return call; @@ -29,6 +29,10 @@ #include <cstdio> #include <cstdlib> +extern "C" { +#include <talloc.h> +} + #include "list.h" #include "ir_visitor.h" #include "ir_hierarchical_visitor.h" @@ -641,8 +645,10 @@ public: /** * Get a generic ir_call object when an error occurs + * + * Any allocation will be performed with 'ctx' as talloc owner. */ - static ir_call *get_error_instruction(); + static ir_call *get_error_instruction(void *ctx); /** * Get an iterator for the set of acutal parameters diff --git a/ir_clone.cpp b/ir_clone.cpp index 6db5073f75..84176383fc 100644 --- a/ir_clone.cpp +++ b/ir_clone.cpp @@ -36,7 +36,8 @@ ir_instruction * ir_variable::clone(struct hash_table *ht) const { - ir_variable *var = new ir_variable(type, name); + void *ctx = talloc_parent(this); + ir_variable *var = new(ctx) ir_variable(type, name); var->max_array_access = this->max_array_access; var->read_only = this->read_only; @@ -55,32 +56,36 @@ ir_variable::clone(struct hash_table *ht) const ir_instruction * ir_swizzle::clone(struct hash_table *ht) const { - return new ir_swizzle((ir_rvalue *)this->val->clone(ht), this->mask); + void *ctx = talloc_parent(this); + return new(ctx) ir_swizzle((ir_rvalue *)this->val->clone(ht), this->mask); } ir_instruction * ir_return::clone(struct hash_table *ht) const { + void *ctx = talloc_parent(this); ir_rvalue *new_value = NULL; if (this->value) new_value = (ir_rvalue *)this->value->clone(ht); - return new ir_return(new_value); + return new(ctx) ir_return(new_value); } ir_instruction * ir_loop_jump::clone(struct hash_table *ht) const { + void *ctx = talloc_parent(this); (void)ht; - return new ir_loop_jump(this->mode); + return new(ctx) ir_loop_jump(this->mode); } ir_instruction * ir_if::clone(struct hash_table *ht) const { - ir_if *new_if = new ir_if((ir_rvalue *)this->condition->clone(ht)); + void *ctx = talloc_parent(this); + ir_if *new_if = new(ctx) ir_if((ir_rvalue *)this->condition->clone(ht)); foreach_iter(exec_list_iterator, iter, this->then_instructions) { ir_instruction *ir = (ir_instruction *)iter.get(); @@ -98,7 +103,8 @@ ir_if::clone(struct hash_table *ht) const ir_instruction * ir_loop::clone(struct hash_table *ht) const { - ir_loop *new_loop = new ir_loop(); + void *ctx = talloc_parent(this); + ir_loop *new_loop = new(ctx) ir_loop(); if (this->from) new_loop->from = (ir_rvalue *)this->from->clone(ht); @@ -119,6 +125,7 @@ ir_loop::clone(struct hash_table *ht) const ir_instruction * ir_call::clone(struct hash_table *ht) const { + void *ctx = talloc_parent(this); exec_list new_parameters; foreach_iter(exec_list_iterator, iter, this->actual_parameters) { @@ -126,12 +133,13 @@ ir_call::clone(struct hash_table *ht) const new_parameters.push_tail(ir->clone(ht)); } - return new ir_call(this->callee, &new_parameters); + return new(ctx) ir_call(this->callee, &new_parameters); } ir_instruction * ir_expression::clone(struct hash_table *ht) const { + void *ctx = talloc_parent(this); ir_rvalue *op[2] = {NULL, NULL}; unsigned int i; @@ -139,12 +147,13 @@ ir_expression::clone(struct hash_table *ht) const op[i] = (ir_rvalue *)this->operands[i]->clone(ht); } - return new ir_expression(this->operation, this->type, op[0], op[1]); + return new(ctx) ir_expression(this->operation, this->type, op[0], op[1]); } ir_instruction * ir_dereference_variable::clone(struct hash_table *ht) const { + void *ctx = talloc_parent(this); ir_variable *new_var; if (ht) { @@ -155,27 +164,30 @@ ir_dereference_variable::clone(struct hash_table *ht) const new_var = this->var; } - return new ir_dereference_variable(new_var); + return new(ctx) ir_dereference_variable(new_var); } ir_instruction * ir_dereference_array::clone(struct hash_table *ht) const { - return new ir_dereference_array((ir_rvalue *)this->array->clone(ht), - (ir_rvalue *)this->array_index->clone(ht)); + void *ctx = talloc_parent(this); + return new(ctx) ir_dereference_array((ir_rvalue *)this->array->clone(ht), + (ir_rvalue *)this->array_index->clone(ht)); } ir_instruction * ir_dereference_record::clone(struct hash_table *ht) const { - return new ir_dereference_record((ir_rvalue *)this->record->clone(ht), - this->field); + void *ctx = talloc_parent(this); + return new(ctx) ir_dereference_record((ir_rvalue *)this->record->clone(ht), + this->field); } ir_instruction * ir_texture::clone(struct hash_table *ht) const { - ir_texture *new_tex = new ir_texture(this->op); + void *ctx = talloc_parent(this); + ir_texture *new_tex = new(ctx) ir_texture(this->op); new_tex->sampler = (ir_dereference *)this->sampler->clone(ht); new_tex->coordinate = (ir_rvalue *)this->coordinate->clone(ht); @@ -218,9 +230,10 @@ ir_assignment::clone(struct hash_table *ht) const if (this->condition) new_condition = (ir_rvalue *)this->condition->clone(ht); - return new ir_assignment((ir_rvalue *)this->lhs->clone(ht), - (ir_rvalue *)this->rhs->clone(ht), - new_condition); + void *ctx = talloc_parent(this); + return new(ctx) ir_assignment((ir_rvalue *)this->lhs->clone(ht), + (ir_rvalue *)this->rhs->clone(ht), + new_condition); } ir_instruction * @@ -242,6 +255,7 @@ ir_function_signature::clone(struct hash_table *ht) const ir_instruction * ir_constant::clone(struct hash_table *ht) const { + void *ctx = talloc_parent(this); (void)ht; switch (this->type->base_type) { @@ -249,10 +263,10 @@ ir_constant::clone(struct hash_table *ht) const case GLSL_TYPE_INT: case GLSL_TYPE_FLOAT: case GLSL_TYPE_BOOL: - return new ir_constant(this->type, &this->value); + return new(ctx) ir_constant(this->type, &this->value); case GLSL_TYPE_STRUCT: { - ir_constant *c = new ir_constant; + ir_constant *c = new(ctx) ir_constant; c->type = this->type; for (exec_node *node = this->components.head diff --git a/ir_constant_expression.cpp b/ir_constant_expression.cpp index effb88844e..4010e46267 100644 --- a/ir_constant_expression.cpp +++ b/ir_constant_expression.cpp @@ -127,6 +127,7 @@ ir_constant_visitor::visit(ir_function *ir) void ir_constant_visitor::visit(ir_expression *ir) { + void *ctx = talloc_parent(ir); value = NULL; ir_constant *op[2]; unsigned int operand, c; @@ -497,7 +498,7 @@ ir_constant_visitor::visit(ir_expression *ir) return; } - this->value = new ir_constant(ir->type, &data); + this->value = new(ctx) ir_constant(ir->type, &data); } @@ -513,6 +514,7 @@ ir_constant_visitor::visit(ir_texture *ir) void ir_constant_visitor::visit(ir_swizzle *ir) { + void *ctx = talloc_parent(ir); ir_constant *v = ir->val->constant_expression_value(); this->value = NULL; @@ -534,7 +536,7 @@ ir_constant_visitor::visit(ir_swizzle *ir) } } - this->value = new ir_constant(ir->type, &data); + this->value = new(ctx) ir_constant(ir->type, &data); } } @@ -553,6 +555,7 @@ ir_constant_visitor::visit(ir_dereference_variable *ir) void ir_constant_visitor::visit(ir_dereference_array *ir) { + void *ctx = talloc_parent(ir); ir_constant *array = ir->array->constant_expression_value(); ir_constant *idx = ir->array_index->constant_expression_value(); @@ -592,11 +595,11 @@ ir_constant_visitor::visit(ir_dereference_array *ir) break; } - this->value = new ir_constant(column_type, &data); + this->value = new(ctx) ir_constant(column_type, &data); } else if (array->type->is_vector()) { const unsigned component = idx->value.u[0]; - this->value = new ir_constant(array, component); + this->value = new(ctx) ir_constant(array, component); } else { /* FINISHME: Handle access of constant arrays. */ } diff --git a/ir_copy_propagation.cpp b/ir_copy_propagation.cpp index 16a2ba79bf..46ef6679d9 100644 --- a/ir_copy_propagation.cpp +++ b/ir_copy_propagation.cpp @@ -197,6 +197,7 @@ kill_invalidated_copies(ir_assignment *ir, exec_list *acp) static void add_copy(ir_assignment *ir, exec_list *acp) { + void *ctx = talloc_parent(ir); acp_entry *entry; if (ir->condition) { @@ -209,7 +210,7 @@ add_copy(ir_assignment *ir, exec_list *acp) ir_variable *rhs_var = ir->rhs->whole_variable_referenced(); if ((lhs_var != NULL) && (rhs_var != NULL)) { - entry = new acp_entry(lhs_var, rhs_var); + entry = new(ctx) acp_entry(lhs_var, rhs_var); acp->push_tail(entry); } } diff --git a/ir_dead_code.cpp b/ir_dead_code.cpp index 8465d863aa..01b7d2d832 100644 --- a/ir_dead_code.cpp +++ b/ir_dead_code.cpp @@ -77,6 +77,7 @@ public: variable_entry * ir_dead_code_visitor::get_variable_entry(ir_variable *var) { + void *ctx = talloc_parent(var); assert(var); foreach_iter(exec_list_iterator, iter, this->variable_list) { variable_entry *entry = (variable_entry *)iter.get(); @@ -84,7 +85,7 @@ ir_dead_code_visitor::get_variable_entry(ir_variable *var) return entry; } - variable_entry *entry = new variable_entry(var); + variable_entry *entry = new(ctx) variable_entry(var); this->variable_list.push_tail(entry); return entry; } diff --git a/ir_dead_code_local.cpp b/ir_dead_code_local.cpp index d3b3858617..e01877077c 100644 --- a/ir_dead_code_local.cpp +++ b/ir_dead_code_local.cpp @@ -113,6 +113,7 @@ public: static bool process_assignment(ir_assignment *ir, exec_list *assignments) { + void *ctx = talloc_parent(ir); ir_variable *var = NULL; bool progress = false; kill_for_derefs_visitor v(assignments); @@ -157,7 +158,7 @@ process_assignment(ir_assignment *ir, exec_list *assignments) } /* Add this instruction to the assignment list. */ - assignment_entry *entry = new assignment_entry(var, ir); + assignment_entry *entry = new(ctx) assignment_entry(var, ir); assignments->push_tail(entry); if (debug) { diff --git a/ir_expression_flattening.cpp b/ir_expression_flattening.cpp index 3089f17ae1..5ba24e390b 100644 --- a/ir_expression_flattening.cpp +++ b/ir_expression_flattening.cpp @@ -80,18 +80,19 @@ do_expression_flattening(exec_list *instructions, static ir_rvalue * operand_to_temp(ir_instruction *base_ir, ir_rvalue *ir) { + void *ctx = talloc_parent(base_ir); ir_variable *var; ir_assignment *assign; - var = new ir_variable(ir->type, "flattening_tmp"); + var = new(ctx) ir_variable(ir->type, "flattening_tmp"); base_ir->insert_before(var); - assign = new ir_assignment(new ir_dereference_variable(var), - ir, - NULL); + assign = new(ctx) ir_assignment(new(ctx) ir_dereference_variable(var), + ir, + NULL); base_ir->insert_before(assign); - return new ir_dereference_variable(var); + return new(ctx) ir_dereference_variable(var); } ir_visitor_status diff --git a/ir_function_inlining.cpp b/ir_function_inlining.cpp index 851c0dd9f7..e55780c940 100644 --- a/ir_function_inlining.cpp +++ b/ir_function_inlining.cpp @@ -94,13 +94,14 @@ do_function_inlining(exec_list *instructions) static void replace_return_with_assignment(ir_instruction *ir, void *data) { + void *ctx = talloc_parent(ir); ir_variable *retval = (ir_variable *)data; ir_return *ret = ir->as_return(); if (ret) { if (ret->value) { - ir_rvalue *lhs = new ir_dereference_variable(retval); - ret->insert_before(new ir_assignment(lhs, ret->value, NULL)); + ir_rvalue *lhs = new(ctx) ir_dereference_variable(retval); + ret->insert_before(new(ctx) ir_assignment(lhs, ret->value, NULL)); ret->remove(); } else { /* un-valued return has to be the last return, or we shouldn't @@ -114,6 +115,7 @@ replace_return_with_assignment(ir_instruction *ir, void *data) ir_rvalue * ir_call::generate_inline(ir_instruction *next_ir) { + void *ctx = talloc_parent(this); ir_variable **parameters; int num_parameters; int i; @@ -130,7 +132,7 @@ ir_call::generate_inline(ir_instruction *next_ir) /* Generate storage for the return value. */ if (this->callee->return_type) { - retval = new ir_variable(this->callee->return_type, "__retval"); + retval = new(ctx) ir_variable(this->callee->return_type, "__retval"); next_ir->insert_before(retval); } @@ -154,8 +156,8 @@ ir_call::generate_inline(ir_instruction *next_ir) sig_param->mode == ir_var_inout) { ir_assignment *assign; - assign = new ir_assignment(new ir_dereference_variable(parameters[i]), - param, NULL); + assign = new(ctx) ir_assignment(new(ctx) ir_dereference_variable(parameters[i]), + param, NULL); next_ir->insert_before(assign); } @@ -185,9 +187,9 @@ ir_call::generate_inline(ir_instruction *next_ir) parameters[i]->mode == ir_var_inout) { ir_assignment *assign; - assign = new ir_assignment(param->as_rvalue(), - new ir_dereference_variable(parameters[i]), - NULL); + assign = new(ctx) ir_assignment(param->as_rvalue(), + new(ctx) ir_dereference_variable(parameters[i]), + NULL); next_ir->insert_before(assign); } @@ -199,7 +201,7 @@ ir_call::generate_inline(ir_instruction *next_ir) hash_table_dtor(ht); if (retval) - return new ir_dereference_variable(retval); + return new(ctx) ir_dereference_variable(retval); else return NULL; } diff --git a/ir_reader.cpp b/ir_reader.cpp index ee320ddac2..7383c42cbc 100644 --- a/ir_reader.cpp +++ b/ir_reader.cpp @@ -70,7 +70,8 @@ void _mesa_glsl_read_ir(_mesa_glsl_parse_state *state, exec_list *instructions, const char *src) { - s_expression *expr = s_expression::read_expression(src); + void *ctx = talloc_parent(state); + s_expression *expr = s_expression::read_expression(ctx, src); if (expr == NULL) { ir_read_error(state, NULL, "couldn't parse S-Expression."); return; @@ -137,7 +138,7 @@ read_type(_mesa_glsl_parse_state *st, s_expression *expr) return NULL; } - return glsl_type::get_array_instance(base_type, size->value()); + return glsl_type::get_array_instance(st, base_type, size->value()); } else if (strcmp(type_sym->value(), "struct") == 0) { assert(false); // FINISHME } else { @@ -190,6 +191,7 @@ scan_for_prototypes(_mesa_glsl_parse_state *st, exec_list *instructions, static ir_function * read_function(_mesa_glsl_parse_state *st, s_list *list, bool skip_body) { + void *ctx = talloc_parent(st); if (list->length() < 3) { ir_read_error(st, list, "Expected (function <name> (signature ...) ...)"); return NULL; @@ -203,7 +205,7 @@ read_function(_mesa_glsl_parse_state *st, s_list *list, bool skip_body) ir_function *f = st->symbols->get_function(name->value()); if (f == NULL) { - f = new ir_function(name->value()); + f = new(ctx) ir_function(name->value()); bool added = st->symbols->add_function(name->value(), f); assert(added); } @@ -233,6 +235,7 @@ static void read_function_sig(_mesa_glsl_parse_state *st, ir_function *f, s_list *list, bool skip_body) { + void *ctx = talloc_parent(st); if (list->length() != 4) { ir_read_error(st, list, "Expected (signature <type> (parameters ...) " "(<instruction> ...))"); @@ -286,7 +289,7 @@ read_function_sig(_mesa_glsl_parse_state *st, ir_function *f, s_list *list, return; } } else { - sig = new ir_function_signature(return_type); + sig = new(ctx) ir_function_signature(return_type); f->add_signature(sig); } @@ -331,12 +334,13 @@ static ir_instruction * read_instruction(_mesa_glsl_parse_state *st, s_expression *expr, ir_loop *loop_ctx) { + void *ctx = talloc_parent(st); s_symbol *symbol = SX_AS_SYMBOL(expr); if (symbol != NULL) { if (strcmp(symbol->value(), "break") == 0 && loop_ctx != NULL) - return new ir_loop_jump(ir_loop_jump::jump_break); + return new(ctx) ir_loop_jump(ir_loop_jump::jump_break); if (strcmp(symbol->value(), "continue") == 0 && loop_ctx != NULL) - return new ir_loop_jump(ir_loop_jump::jump_continue); + return new(ctx) ir_loop_jump(ir_loop_jump::jump_continue); } s_list *list = SX_AS_LIST(expr); @@ -372,6 +376,7 @@ read_instruction(_mesa_glsl_parse_state *st, s_expression *expr, static ir_variable * read_declaration(_mesa_glsl_parse_state *st, s_list *list) { + void *ctx = talloc_parent(st); if (list->length() != 4) { ir_read_error(st, list, "expected (declare (<qualifiers>) <type> " "<name>)"); @@ -395,7 +400,7 @@ read_declaration(_mesa_glsl_parse_state *st, s_list *list) return NULL; } - ir_variable *var = new ir_variable(type, var_name->value()); + ir_variable *var = new(ctx) ir_variable(type, var_name->value()); foreach_iter(exec_list_iterator, it, quals->subexpressions) { s_symbol *qualifier = SX_AS_SYMBOL(it.get()); @@ -443,6 +448,7 @@ read_declaration(_mesa_glsl_parse_state *st, s_list *list) static ir_if * read_if(_mesa_glsl_parse_state *st, s_list *list, ir_loop *loop_ctx) { + void *ctx = talloc_parent(st); if (list->length() != 4) { ir_read_error(st, list, "expected (if <condition> (<then> ...) " "(<else> ...))"); @@ -459,7 +465,7 @@ read_if(_mesa_glsl_parse_state *st, s_list *list, ir_loop *loop_ctx) s_expression *then_expr = (s_expression*) cond_expr->next; s_expression *else_expr = (s_expression*) then_expr->next; - ir_if *iff = new ir_if(condition); + ir_if *iff = new(ctx) ir_if(condition); read_instructions(st, &iff->then_instructions, then_expr, loop_ctx); read_instructions(st, &iff->else_instructions, else_expr, loop_ctx); @@ -474,6 +480,7 @@ read_if(_mesa_glsl_parse_state *st, s_list *list, ir_loop *loop_ctx) static ir_loop * read_loop(_mesa_glsl_parse_state *st, s_list *list) { + void *ctx = talloc_parent(st); if (list->length() != 6) { ir_read_error(st, list, "expected (loop <counter> <from> <to> " "<increment> <body>)"); @@ -488,7 +495,7 @@ read_loop(_mesa_glsl_parse_state *st, s_list *list) // FINISHME: actually read the count/from/to fields. - ir_loop *loop = new ir_loop; + ir_loop *loop = new(ctx) ir_loop; read_instructions(st, &loop->body_instructions, body_expr, loop); if (st->error) { delete loop; @@ -501,6 +508,7 @@ read_loop(_mesa_glsl_parse_state *st, s_list *list) static ir_return * read_return(_mesa_glsl_parse_state *st, s_list *list) { + void *ctx = talloc_parent(st); if (list->length() != 2) { ir_read_error(st, list, "expected (return <rvalue>)"); return NULL; @@ -514,7 +522,7 @@ read_return(_mesa_glsl_parse_state *st, s_list *list) return NULL; } - return new ir_return(retval); + return new(ctx) ir_return(retval); } @@ -556,6 +564,7 @@ read_rvalue(_mesa_glsl_parse_state *st, s_expression *expr) static ir_assignment * read_assignment(_mesa_glsl_parse_state *st, s_list *list) { + void *ctx = talloc_parent(st); if (list->length() != 4) { ir_read_error(st, list, "expected (assign <condition> <lhs> <rhs>)"); return NULL; @@ -584,12 +593,13 @@ read_assignment(_mesa_glsl_parse_state *st, s_list *list) return NULL; } - return new ir_assignment(lhs, rhs, condition); + return new(ctx) ir_assignment(lhs, rhs, condition); } static ir_call * read_call(_mesa_glsl_parse_state *st, s_list *list) { + void *ctx = talloc_parent(st); if (list->length() != 3) { ir_read_error(st, list, "expected (call <name> (<param> ...))"); return NULL; @@ -628,12 +638,13 @@ read_call(_mesa_glsl_parse_state *st, s_list *list) return NULL; } - return new ir_call(callee, ¶meters); + return new(ctx) ir_call(callee, ¶meters); } static ir_expression * read_expression(_mesa_glsl_parse_state *st, s_list *list) { + void *ctx = talloc_parent(st); const unsigned list_length = list->length(); if (list_length < 4) { ir_read_error(st, list, "expected (expression <type> <operator> " @@ -693,7 +704,7 @@ read_expression(_mesa_glsl_parse_state *st, s_list *list) } } - return new ir_expression(op, type, arg1, arg2); + return new(ctx) ir_expression(op, type, arg1, arg2); } static ir_swizzle * @@ -738,6 +749,7 @@ read_swizzle(_mesa_glsl_parse_state *st, s_list *list) static ir_constant * read_constant(_mesa_glsl_parse_state *st, s_list *list) { + void *ctx = talloc_parent(st); if (list->length() != 3) { ir_read_error(st, list, "expected (constant <type> (<num> ... <num>))"); return NULL; @@ -803,7 +815,7 @@ read_constant(_mesa_glsl_parse_state *st, s_list *list) ++k; } - return new ir_constant(type, &data); + return new(ctx) ir_constant(type, &data); } static ir_dereference * @@ -828,6 +840,7 @@ read_dereference(_mesa_glsl_parse_state *st, s_expression *expr) static ir_dereference * read_var_ref(_mesa_glsl_parse_state *st, s_list *list) { + void *ctx = talloc_parent(st); if (list->length() != 2) { ir_read_error(st, list, "expected (var_ref <variable name>)"); return NULL; @@ -844,12 +857,13 @@ read_var_ref(_mesa_glsl_parse_state *st, s_list *list) return NULL; } - return new ir_dereference_variable(var); + return new(ctx) ir_dereference_variable(var); } static ir_dereference * read_array_ref(_mesa_glsl_parse_state *st, s_list *list) { + void *ctx = talloc_parent(st); if (list->length() != 3) { ir_read_error(st, list, "expected (array_ref <rvalue> <index>)"); return NULL; @@ -864,12 +878,13 @@ read_array_ref(_mesa_glsl_parse_state *st, s_list *list) s_expression *idx_expr = (s_expression*) subj_expr->next; ir_rvalue *idx = read_rvalue(st, idx_expr); - return new ir_dereference_array(subject, idx); + return new(ctx) ir_dereference_array(subject, idx); } static ir_dereference * read_record_ref(_mesa_glsl_parse_state *st, s_list *list) { + void *ctx = talloc_parent(st); if (list->length() != 3) { ir_read_error(st, list, "expected (record_ref <rvalue> <field>)"); return NULL; @@ -887,7 +902,7 @@ read_record_ref(_mesa_glsl_parse_state *st, s_list *list) ir_read_error(st, list, "expected (record_ref ... <field name>)"); return NULL; } - return new ir_dereference_record(subject, field->value()); + return new(ctx) ir_dereference_record(subject, field->value()); } static bool @@ -905,6 +920,7 @@ valid_texture_list_length(ir_texture_opcode op, s_list *list) static ir_texture * read_texture(_mesa_glsl_parse_state *st, s_list *list) { + void *ctx = talloc_parent(st); s_symbol *tag = SX_AS_SYMBOL(list->subexpressions.head); assert(tag != NULL); @@ -917,7 +933,7 @@ read_texture(_mesa_glsl_parse_state *st, s_list *list) return NULL; } - ir_texture *tex = new ir_texture(op); + ir_texture *tex = new(ctx) ir_texture(op); // Read sampler (must be a deref) s_expression *sampler_expr = (s_expression *) tag->next; diff --git a/ir_variable.cpp b/ir_variable.cpp index efebe9199f..15a4a92f62 100644 --- a/ir_variable.cpp +++ b/ir_variable.cpp @@ -35,7 +35,7 @@ add_variable(const char *name, enum ir_variable_mode mode, int slot, const glsl_type *type, exec_list *instructions, glsl_symbol_table *symtab) { - ir_variable *var = new ir_variable(type, name); + ir_variable *var = new(symtab) ir_variable(type, name); var->mode = mode; switch (var->mode) { @@ -104,7 +104,7 @@ generate_110_uniforms(exec_list *instructions, * FINISHME: for now. */ const glsl_type *const mat4_array_type = - glsl_type::get_array_instance(glsl_type::mat4_type, 4); + glsl_type::get_array_instance(symtab, glsl_type::mat4_type, 4); add_variable("gl_TextureMatrix", ir_var_uniform, -1, mat4_array_type, instructions, symtab); @@ -122,7 +122,8 @@ generate_110_uniforms(exec_list *instructions, * FINISHME: at least 8, so hard-code 8 for now. */ const glsl_type *const light_source_array_type = - glsl_type::get_array_instance(symtab->get_type("gl_LightSourceParameters"), 8); + glsl_type::get_array_instance(symtab, + symtab->get_type("gl_LightSourceParameters"), 8); add_variable("gl_LightSource", ir_var_uniform, -1, light_source_array_type, instructions, symtab); @@ -157,7 +158,7 @@ generate_110_vs_variables(exec_list *instructions, * FINISHME: for now. */ const glsl_type *const vec4_array_type = - glsl_type::get_array_instance(glsl_type::vec4_type, 4); + glsl_type::get_array_instance(symtab, glsl_type::vec4_type, 4); add_variable("gl_TexCoord", ir_var_out, VERT_RESULT_TEX0, vec4_array_type, instructions, symtab); @@ -179,6 +180,7 @@ static void generate_130_vs_variables(exec_list *instructions, glsl_symbol_table *symtab) { + void *ctx = symtab; generate_120_vs_variables(instructions, symtab); for (unsigned i = 0; i < Elements(builtin_130_vs_variables); i++) { @@ -190,7 +192,7 @@ generate_130_vs_variables(exec_list *instructions, * FINISHME: the value of GL_MAX_CLIP_DISTANCES. */ const glsl_type *const clip_distance_array_type = - glsl_type::get_array_instance(glsl_type::float_type, 8); + glsl_type::get_array_instance(ctx, glsl_type::float_type, 8); /* FINISHME: gl_ClipDistance needs a real location assigned. */ add_variable("gl_ClipDistance", ir_var_out, -1, clip_distance_array_type, @@ -240,7 +242,7 @@ generate_110_fs_variables(exec_list *instructions, * FINISHME: for now. */ const glsl_type *const vec4_array_type = - glsl_type::get_array_instance(glsl_type::vec4_type, 4); + glsl_type::get_array_instance(symtab, glsl_type::vec4_type, 4); add_variable("gl_TexCoord", ir_var_in, FRAG_ATTRIB_TEX0, vec4_array_type, instructions, symtab); @@ -256,7 +258,7 @@ generate_ARB_draw_buffers_fs_variables(exec_list *instructions, * FINISHME: at least 1, so hard-code 1 for now. */ const glsl_type *const vec4_array_type = - glsl_type::get_array_instance(glsl_type::vec4_type, 1); + glsl_type::get_array_instance(symtab, glsl_type::vec4_type, 1); ir_variable *const fd = add_variable("gl_FragData", ir_var_out, FRAG_RESULT_DATA0, @@ -279,13 +281,14 @@ static void generate_130_fs_variables(exec_list *instructions, glsl_symbol_table *symtab) { + void *ctx = symtab; generate_120_fs_variables(instructions, symtab); /* FINISHME: The size of this array is implementation dependent based on * FINISHME: the value of GL_MAX_CLIP_DISTANCES. */ const glsl_type *const clip_distance_array_type = - glsl_type::get_array_instance(glsl_type::float_type, 8); + glsl_type::get_array_instance(ctx, glsl_type::float_type, 8); /* FINISHME: gl_ClipDistance needs a real location assigned. */ add_variable("gl_ClipDistance", ir_var_in, -1, clip_distance_array_type, diff --git a/ir_vec_index_to_swizzle.cpp b/ir_vec_index_to_swizzle.cpp index eb0e556c9d..bbd873791a 100644 --- a/ir_vec_index_to_swizzle.cpp +++ b/ir_vec_index_to_swizzle.cpp @@ -60,6 +60,7 @@ public: ir_rvalue * ir_vec_index_to_swizzle_visitor::convert_vec_index_to_swizzle(ir_rvalue *ir) { + void *ctx = talloc_parent(ir); ir_dereference_array *deref = ir->as_dereference_array(); ir_constant *ir_constant; @@ -75,7 +76,8 @@ ir_vec_index_to_swizzle_visitor::convert_vec_index_to_swizzle(ir_rvalue *ir) return ir; this->progress = true; - return new ir_swizzle(deref->array, ir_constant->value.i[0], 0, 0, 0, 1); + return new(ctx) ir_swizzle(deref->array, + ir_constant->value.i[0], 0, 0, 0, 1); } ir_visitor_status @@ -66,7 +66,13 @@ #ifndef __cplusplus #include <stddef.h> +#include <talloc.h> +#else +extern "C" { +#include <talloc.h> +} #endif + #include <assert.h> struct exec_node { @@ -74,6 +80,25 @@ struct exec_node { struct exec_node *prev; #ifdef __cplusplus + /* Callers of this talloc-based new need not call delete. It's + * easier to just talloc_free 'ctx' (or any of its ancestors). */ + static void* operator new(size_t size, void *ctx) + { + void *node; + + node = talloc_size(ctx, size); + assert(node != NULL); + + return node; + } + + /* If the user *does* call delete, that's OK, we will just + * talloc_free in that case. */ + static void operator delete(void *node) + { + talloc_free(node); + } + exec_node() : next(NULL), prev(NULL) { /* empty */ @@ -29,10 +29,6 @@ #include <fcntl.h> #include <unistd.h> -extern "C" { -#include <talloc.h> -} - #include "ast.h" #include "glsl_parser_extras.h" #include "glsl_parser.h" @@ -40,9 +36,9 @@ extern "C" { #include "ir_print_visitor.h" #include "program.h" - +/* Returned string will have 'ctx' as its talloc owner. */ static char * -load_text_file(const char *file_name, size_t *size) +load_text_file(void *ctx, const char *file_name, size_t *size) { char *text = NULL; struct stat st; @@ -55,7 +51,7 @@ load_text_file(const char *file_name, size_t *size) } if (fstat(fd, & st) == 0) { - text = (char *) malloc(st.st_size + 1); + text = (char *) talloc_size(ctx, st.st_size + 1); if (text != NULL) { do { ssize_t bytes = read(fd, text + total_read, @@ -106,38 +102,39 @@ const struct option compiler_opts[] = { void compile_shader(struct glsl_shader *shader) { - struct _mesa_glsl_parse_state state; + struct _mesa_glsl_parse_state *state; + + state = talloc_zero(talloc_parent(shader), struct _mesa_glsl_parse_state); - memset(& state, 0, sizeof(state)); switch (shader->Type) { - case GL_VERTEX_SHADER: state.target = vertex_shader; break; - case GL_FRAGMENT_SHADER: state.target = fragment_shader; break; - case GL_GEOMETRY_SHADER: state.target = geometry_shader; break; + case GL_VERTEX_SHADER: state->target = vertex_shader; break; + case GL_FRAGMENT_SHADER: state->target = fragment_shader; break; + case GL_GEOMETRY_SHADER: state->target = geometry_shader; break; } - state.scanner = NULL; - state.translation_unit.make_empty(); - state.symbols = new glsl_symbol_table; - state.info_log = talloc_strdup(shader, ""); - state.error = false; - state.temp_index = 0; - state.loop_or_switch_nesting = NULL; - state.ARB_texture_rectangle_enable = true; + state->scanner = NULL; + state->translation_unit.make_empty(); + state->symbols = new(shader) glsl_symbol_table; + state->info_log = talloc_strdup(shader, ""); + state->error = false; + state->temp_index = 0; + state->loop_or_switch_nesting = NULL; + state->ARB_texture_rectangle_enable = true; /* Create a new context for the preprocessor output. Ultimately, this * should probably be the parser context, but there isn't one yet. */ const char *source = shader->Source; - state.error = preprocess(shader, &source, &state.info_log); + state->error = preprocess(shader, &source, &state->info_log); - if (!state.error) { - _mesa_glsl_lexer_ctor(& state, source); - _mesa_glsl_parse(& state); - _mesa_glsl_lexer_dtor(& state); + if (!state->error) { + _mesa_glsl_lexer_ctor(state, source); + _mesa_glsl_parse(state); + _mesa_glsl_lexer_dtor(state); } if (dump_ast) { - foreach_list_const(n, &state.translation_unit) { + foreach_list_const(n, &state->translation_unit) { ast_node *ast = exec_node_data(ast_node, n, link); ast->print(); } @@ -145,13 +142,13 @@ compile_shader(struct glsl_shader *shader) } shader->ir.make_empty(); - if (!state.error && !state.translation_unit.is_empty()) - _mesa_ast_to_hir(&shader->ir, &state); + if (!state->error && !state->translation_unit.is_empty()) + _mesa_ast_to_hir(&shader->ir, state); validate_ir_tree(&shader->ir); /* Optimization passes */ - if (!state.error && !shader->ir.is_empty()) { + if (!state->error && !shader->ir.is_empty()) { bool progress; do { progress = false; @@ -171,17 +168,19 @@ compile_shader(struct glsl_shader *shader) validate_ir_tree(&shader->ir); /* Print out the resulting IR */ - if (!state.error && dump_lir) { - _mesa_print_ir(&shader->ir, &state); + if (!state->error && dump_lir) { + _mesa_print_ir(&shader->ir, state); } - shader->symbols = state.symbols; - shader->CompileStatus = !state.error; + shader->symbols = state->symbols; + shader->CompileStatus = !state->error; if (shader->InfoLog) talloc_free(shader->InfoLog); - shader->InfoLog = state.info_log; + shader->InfoLog = state->info_log; + + talloc_free(state); return; } @@ -200,20 +199,21 @@ main(int argc, char **argv) if (argc <= optind) usage_fail(argv[0]); - struct glsl_program whole_program; - memset(&whole_program, 0, sizeof(whole_program)); + struct glsl_program *whole_program; + + whole_program = talloc_zero (NULL, struct glsl_program); + assert(whole_program != NULL); for (/* empty */; argc > optind; optind++) { - whole_program.Shaders = (struct glsl_shader **) - realloc(whole_program.Shaders, - sizeof(struct glsl_shader *) * (whole_program.NumShaders + 1)); - assert(whole_program.Shaders != NULL); + whole_program->Shaders = (struct glsl_shader **) + talloc_realloc(whole_program, whole_program->Shaders, + struct glsl_shader *, whole_program->NumShaders + 1); + assert(whole_program->Shaders != NULL); - /* talloc context should probably be whole_program */ - struct glsl_shader *shader = talloc_zero(NULL, glsl_shader); + struct glsl_shader *shader = talloc_zero(whole_program, glsl_shader); - whole_program.Shaders[whole_program.NumShaders] = shader; - whole_program.NumShaders++; + whole_program->Shaders[whole_program->NumShaders] = shader; + whole_program->NumShaders++; const unsigned len = strlen(argv[optind]); if (len < 6) @@ -229,7 +229,8 @@ main(int argc, char **argv) else usage_fail(argv[0]); - shader->Source = load_text_file(argv[optind], &shader->SourceLen); + shader->Source = load_text_file(whole_program, + argv[optind], &shader->SourceLen); if (shader->Source == NULL) { printf("File \"%s\" does not exist.\n", argv[optind]); exit(EXIT_FAILURE); @@ -245,9 +246,11 @@ main(int argc, char **argv) } if ((status == EXIT_SUCCESS) && do_link) { - link_shaders(&whole_program); - status = (whole_program.LinkStatus) ? EXIT_SUCCESS : EXIT_FAILURE; + link_shaders(whole_program); + status = (whole_program->LinkStatus) ? EXIT_SUCCESS : EXIT_FAILURE; } + talloc_free(whole_program); + return status; } diff --git a/s_expression.cpp b/s_expression.cpp index 4022dfab7a..26be23ea8f 100644 --- a/s_expression.cpp +++ b/s_expression.cpp @@ -30,29 +30,14 @@ s_symbol::s_symbol(const char *tmp) { - this->str = new char [strlen(tmp) + 1]; - strcpy(this->str, tmp); -} - -s_symbol::~s_symbol() -{ - delete [] this->str; - this->str = NULL; + this->str = talloc_strdup (this, tmp); + assert(this->str != NULL); } s_list::s_list() { } -s_list::~s_list() -{ - exec_list_iterator it(this->subexpressions.iterator()); - while (it.has_next()) - it.remove(); - - assert(this->subexpressions.is_empty()); -} - unsigned s_list::length() const { @@ -64,7 +49,7 @@ s_list::length() const } static s_expression * -read_atom(const char *& src) +read_atom(void *ctx, const char *& src) { char buf[101]; int n; @@ -80,20 +65,20 @@ read_atom(const char *& src) int i = strtol(buf, &int_end, 10); // If strtod matched more characters, it must have a decimal part if (float_end > int_end) - return new s_float(f); + return new(ctx) s_float(f); - return new s_int(i); + return new(ctx) s_int(i); } // Not a number; return a symbol. - return new s_symbol(buf); + return new(ctx) s_symbol(buf); } s_expression * -s_expression::read_expression(const char *&src) +s_expression::read_expression(void *ctx, const char *&src) { assert(src != NULL); - s_expression *atom = read_atom(src); + s_expression *atom = read_atom(ctx, src); if (atom != NULL) return atom; @@ -102,10 +87,10 @@ s_expression::read_expression(const char *&src) if (sscanf(src, " %c%n", &c, &n) == 1 && c == '(') { src += n; - s_list *list = new s_list; + s_list *list = new(ctx) s_list; s_expression *expr; - while ((expr = read_expression(src)) != NULL) { + while ((expr = read_expression(ctx, src)) != NULL) { list->subexpressions.push_tail(expr); } if (sscanf(src, " %c%n", &c, &n) != 1 || c != ')') { diff --git a/s_expression.h b/s_expression.h index d5e52c16e8..1a0c03c218 100644 --- a/s_expression.h +++ b/s_expression.h @@ -46,13 +46,13 @@ class s_expression : public exec_node { public: - virtual ~s_expression() { } - /** * Read an S-Expression from the given string. * Advances the supplied pointer to just after the expression read. + * + * Any allocation will be performed with 'ctx' as the talloc owner. */ - static s_expression *read_expression(const char *&src); + static s_expression *read_expression(void *ctx, const char *&src); /** * Print out an S-Expression. Useful for debugging. @@ -73,8 +73,6 @@ protected: class s_number : public s_expression { public: - virtual ~s_number() { } - bool is_number() const { return true; } virtual float fvalue() = 0; @@ -87,7 +85,6 @@ class s_int : public s_number { public: s_int(int x) : val(x) { } - virtual ~s_int() { } bool is_int() const { return true; } @@ -104,7 +101,6 @@ class s_float : public s_number { public: s_float(float x) : val(x) { } - virtual ~s_float() { } float fvalue() { return this->val; } @@ -118,7 +114,6 @@ class s_symbol : public s_expression { public: s_symbol(const char *); - virtual ~s_symbol(); bool is_symbol() const { return true; } @@ -135,7 +130,6 @@ class s_list : public s_expression { public: s_list(); - virtual ~s_list(); virtual bool is_list() const { return true; } unsigned length() const; |