OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

glsl2: Make the clone() method take a talloc context.

Browse Source 
In most cases, we needed to be reparenting the cloned IR to a
different context (for example, to the linked shader instead of the
unlinked shader), or optimization before the reparent would cause
memory usage of the original object to grow and grow.
This commit is contained in:
Eric Anholt
2010-08-04 12:34:56 -07:00
parent 84ee01f40a
commit 8273bd4687
9 changed files with 130 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/glsl/ast_to_hir.cpp
View File

@@ -966,7 +966,7 @@ ast_expression::hir(exec_list *instructions,
op[0], op[1]);
result = do_assignment(instructions, state,
op[0]->clone(NULL), temp_rhs,
op[0]->clone(ctx, NULL), temp_rhs,
this->subexpressions[0]->get_location());
type = result->type;
error_emitted = (op[0]->type->is_error());
@@ -992,7 +992,7 @@ ast_expression::hir(exec_list *instructions,
op[0], op[1]);
result = do_assignment(instructions, state,
op[0]->clone(NULL), temp_rhs,
op[0]->clone(ctx, NULL), temp_rhs,
this->subexpressions[0]->get_location());
type = result->type;
error_emitted = type->is_error();
@@ -1113,7 +1113,7 @@ ast_expression::hir(exec_list *instructions,
op[0], op[1]);
result = do_assignment(instructions, state,
op[0]->clone(NULL), temp_rhs,
op[0]->clone(ctx, NULL), temp_rhs,
this->subexpressions[0]->get_location());
type = result->type;
error_emitted = op[0]->type->is_error();
@@ -1139,10 +1139,10 @@ ast_expression::hir(exec_list *instructions,
/* Get a temporary of a copy of the lvalue before it's modified.
* This may get thrown away later.
*/
result = get_lvalue_copy(instructions, op[0]->clone(NULL));
result = get_lvalue_copy(instructions, op[0]->clone(ctx, NULL));
(void)do_assignment(instructions, state,
op[0]->clone(NULL), temp_rhs,
op[0]->clone(ctx, NULL), temp_rhs,
this->subexpressions[0]->get_location());
type = result->type;

47
src/glsl/ir.h
View File

@@ -76,7 +76,8 @@ public:
virtual void accept(ir_visitor *) = 0;
virtual ir_visitor_status accept(ir_hierarchical_visitor *) = 0;
virtual ir_instruction *clone(struct hash_table *ht) const = 0;
virtual ir_instruction *clone(void *mem_ctx,
struct hash_table *ht) const = 0;
/**
* \name IR instruction downcast functions
@@ -113,7 +114,7 @@ protected:
class ir_rvalue : public ir_instruction {
public:
virtual ir_rvalue *clone(struct hash_table *) const = 0;
virtual ir_rvalue *clone(void *mem_ctx, struct hash_table *) const = 0;
virtual ir_constant *constant_expression_value() = 0;
@@ -175,7 +176,7 @@ class ir_variable : public ir_instruction {
public:
ir_variable(const struct glsl_type *, const char *, ir_variable_mode);
virtual ir_variable *clone(struct hash_table *ht) const;
virtual ir_variable *clone(void *mem_ctx, struct hash_table *ht) const;
virtual ir_variable *as_variable()
{
@@ -283,7 +284,8 @@ class ir_function_signature : public ir_instruction {
public:
ir_function_signature(const glsl_type *return_type);
virtual ir_function_signature *clone(struct hash_table *ht) const;
virtual ir_function_signature *clone(void *mem_ctx,
struct hash_table *ht) const;
virtual void accept(ir_visitor *v)
{
@@ -369,7 +371,7 @@ class ir_function : public ir_instruction {
public:
ir_function(const char *name);
virtual ir_function *clone(struct hash_table *ht) const;
virtual ir_function *clone(void *mem_ctx, struct hash_table *ht) const;
virtual ir_function *as_function()
{
@@ -439,7 +441,7 @@ public:
ir_type = ir_type_if;
}
virtual ir_if *clone(struct hash_table *ht) const;
virtual ir_if *clone(void *mem_ctx, struct hash_table *ht) const;
virtual ir_if *as_if()
{
@@ -471,7 +473,7 @@ public:
ir_type = ir_type_loop;
}
virtual ir_loop *clone(struct hash_table *ht) const;
virtual ir_loop *clone(void *mem_ctx, struct hash_table *ht) const;
virtual void accept(ir_visitor *v)
{
@@ -512,7 +514,7 @@ class ir_assignment : public ir_instruction {
public:
ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs, ir_rvalue *condition);
virtual ir_assignment *clone(struct hash_table *ht) const;
virtual ir_assignment *clone(void *mem_ctx, struct hash_table *ht) const;
virtual ir_constant *constant_expression_value();
@@ -662,7 +664,7 @@ public:
return this;
}
virtual ir_expression *clone(struct hash_table *ht) const;
virtual ir_expression *clone(void *mem_ctx, struct hash_table *ht) const;
virtual ir_constant *constant_expression_value();
@@ -708,7 +710,7 @@ public:
actual_parameters->move_nodes_to(& this->actual_parameters);
}
virtual ir_call *clone(struct hash_table *ht) const;
virtual ir_call *clone(void *mem_ctx, struct hash_table *ht) const;
virtual ir_constant *constant_expression_value();
@@ -805,7 +807,7 @@ public:
this->ir_type = ir_type_return;
}
virtual ir_return *clone(struct hash_table *) const;
virtual ir_return *clone(void *mem_ctx, struct hash_table *) const;
virtual ir_return *as_return()
{
@@ -850,7 +852,7 @@ public:
this->loop = loop;
}
virtual ir_loop_jump *clone(struct hash_table *) const;
virtual ir_loop_jump *clone(void *mem_ctx, struct hash_table *) const;
virtual void accept(ir_visitor *v)
{
@@ -893,7 +895,7 @@ public:
this->condition = cond;
}
virtual ir_discard *clone(struct hash_table *ht) const;
virtual ir_discard *clone(void *mem_ctx, struct hash_table *ht) const;
virtual void accept(ir_visitor *v)
{
@@ -945,7 +947,7 @@ public:
this->ir_type = ir_type_texture;
}
virtual ir_texture *clone(struct hash_table *) const;
virtual ir_texture *clone(void *mem_ctx, struct hash_table *) const;
virtual ir_constant *constant_expression_value();
@@ -1037,7 +1039,7 @@ public:
ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask);
virtual ir_swizzle *clone(struct hash_table *) const;
virtual ir_swizzle *clone(void *mem_ctx, struct hash_table *) const;
virtual ir_constant *constant_expression_value();
@@ -1083,7 +1085,7 @@ private:
class ir_dereference : public ir_rvalue {
public:
virtual ir_dereference *clone(struct hash_table *) const = 0;
virtual ir_dereference *clone(void *mem_ctx, struct hash_table *) const = 0;
virtual ir_dereference *as_dereference()
{
@@ -1103,7 +1105,8 @@ class ir_dereference_variable : public ir_dereference {
public:
ir_dereference_variable(ir_variable *var);
virtual ir_dereference_variable *clone(struct hash_table *) const;
virtual ir_dereference_variable *clone(void *mem_ctx,
struct hash_table *) const;
virtual ir_constant *constant_expression_value();
@@ -1151,7 +1154,8 @@ public:
ir_dereference_array(ir_variable *var, ir_rvalue *array_index);
virtual ir_dereference_array *clone(struct hash_table *) const;
virtual ir_dereference_array *clone(void *mem_ctx,
struct hash_table *) const;
virtual ir_constant *constant_expression_value();
@@ -1189,7 +1193,8 @@ public:
ir_dereference_record(ir_variable *var, const char *field);
virtual ir_dereference_record *clone(struct hash_table *) const;
virtual ir_dereference_record *clone(void *mem_ctx,
struct hash_table *) const;
virtual ir_constant *constant_expression_value();
@@ -1254,7 +1259,7 @@ public:
*/
static ir_constant *zero(void *mem_ctx, const glsl_type *type);
virtual ir_constant *clone(struct hash_table *) const;
virtual ir_constant *clone(void *mem_ctx, struct hash_table *) const;
virtual ir_constant *constant_expression_value();
@@ -1327,7 +1332,7 @@ void validate_ir_tree(exec_list *instructions);
* \param out List to hold the cloned instructions
*/
void
clone_ir_list(exec_list *out, const exec_list *in);
clone_ir_list(void *mem_ctx, exec_list *out, const exec_list *in);
extern void
_mesa_glsl_initialize_variables(exec_list *instructions,

150
src/glsl/ir_clone.cpp
View File

@@ -36,11 +36,10 @@ extern "C" {
* eventually.
*/
ir_variable *
ir_variable::clone(struct hash_table *ht) const
ir_variable::clone(void *mem_ctx, struct hash_table *ht) const
{
void *ctx = talloc_parent(this);
ir_variable *var = new(ctx) ir_variable(this->type, this->name,
(ir_variable_mode) this->mode);
ir_variable *var = new(mem_ctx) ir_variable(this->type, this->name,
(ir_variable_mode) this->mode);
var->max_array_access = this->max_array_access;
var->read_only = this->read_only;
@@ -56,7 +55,7 @@ ir_variable::clone(struct hash_table *ht) const
var->pixel_center_integer = this->pixel_center_integer;
if (this->constant_value)
var->constant_value = this->constant_value->clone(ht);
var->constant_value = this->constant_value->clone(mem_ctx, ht);
if (ht) {
hash_table_insert(ht, var, (void *)const_cast<ir_variable *>(this));
@@ -66,118 +65,109 @@ ir_variable::clone(struct hash_table *ht) const
}
ir_swizzle *
ir_swizzle::clone(struct hash_table *ht) const
ir_swizzle::clone(void *mem_ctx, struct hash_table *ht) const
{
void *ctx = talloc_parent(this);
return new(ctx) ir_swizzle(this->val->clone(ht), this->mask);
return new(mem_ctx) ir_swizzle(this->val->clone(mem_ctx, ht), this->mask);
}
ir_return *
ir_return::clone(struct hash_table *ht) const
ir_return::clone(void *mem_ctx, struct hash_table *ht) const
{
void *ctx = talloc_parent(this);
ir_rvalue *new_value = NULL;
if (this->value)
new_value = this->value->clone(ht);
new_value = this->value->clone(mem_ctx, ht);
return new(ctx) ir_return(new_value);
return new(mem_ctx) ir_return(new_value);
}
ir_discard *
ir_discard::clone(struct hash_table *ht) const
ir_discard::clone(void *mem_ctx, struct hash_table *ht) const
{
void *ctx = talloc_parent(this);
ir_rvalue *new_condition = NULL;
if (this->condition != NULL)
new_condition = this->condition->clone(ht);
new_condition = this->condition->clone(mem_ctx, ht);
return new(ctx) ir_discard(new_condition);
return new(mem_ctx) ir_discard(new_condition);
}
ir_loop_jump *
ir_loop_jump::clone(struct hash_table *ht) const
ir_loop_jump::clone(void *mem_ctx, struct hash_table *ht) const
{
void *ctx = talloc_parent(this);
(void)ht;
return new(ctx) ir_loop_jump(this->mode);
return new(mem_ctx) ir_loop_jump(this->mode);
}
ir_if *
ir_if::clone(struct hash_table *ht) const
ir_if::clone(void *mem_ctx, struct hash_table *ht) const
{
void *ctx = talloc_parent(this);
ir_if *new_if = new(ctx) ir_if(this->condition->clone(ht));
ir_if *new_if = new(mem_ctx) ir_if(this->condition->clone(mem_ctx, ht));
foreach_iter(exec_list_iterator, iter, this->then_instructions) {
ir_instruction *ir = (ir_instruction *)iter.get();
new_if->then_instructions.push_tail(ir->clone(ht));
new_if->then_instructions.push_tail(ir->clone(mem_ctx, ht));
}
foreach_iter(exec_list_iterator, iter, this->else_instructions) {
ir_instruction *ir = (ir_instruction *)iter.get();
new_if->else_instructions.push_tail(ir->clone(ht));
new_if->else_instructions.push_tail(ir->clone(mem_ctx, ht));
}
return new_if;
}
ir_loop *
ir_loop::clone(struct hash_table *ht) const
ir_loop::clone(void *mem_ctx, struct hash_table *ht) const
{
void *ctx = talloc_parent(this);
ir_loop *new_loop = new(ctx) ir_loop();
ir_loop *new_loop = new(mem_ctx) ir_loop();
if (this->from)
new_loop->from = this->from->clone(ht);
new_loop->from = this->from->clone(mem_ctx, ht);
if (this->to)
new_loop->to = this->to->clone(ht);
new_loop->to = this->to->clone(mem_ctx, ht);
if (this->increment)
new_loop->increment = this->increment->clone(ht);
new_loop->increment = this->increment->clone(mem_ctx, ht);
new_loop->counter = counter;
foreach_iter(exec_list_iterator, iter, this->body_instructions) {
ir_instruction *ir = (ir_instruction *)iter.get();
new_loop->body_instructions.push_tail(ir->clone(ht));
new_loop->body_instructions.push_tail(ir->clone(mem_ctx, ht));
}
return new_loop;
}
ir_call *
ir_call::clone(struct hash_table *ht) const
ir_call::clone(void *mem_ctx, struct hash_table *ht) const
{
void *ctx = talloc_parent(this);
exec_list new_parameters;
foreach_iter(exec_list_iterator, iter, this->actual_parameters) {
ir_instruction *ir = (ir_instruction *)iter.get();
new_parameters.push_tail(ir->clone(ht));
new_parameters.push_tail(ir->clone(mem_ctx, ht));
}
return new(ctx) ir_call(this->callee, &new_parameters);
return new(mem_ctx) ir_call(this->callee, &new_parameters);
}
ir_expression *
ir_expression::clone(struct hash_table *ht) const
ir_expression::clone(void *mem_ctx, struct hash_table *ht) const
{
void *ctx = talloc_parent(this);
ir_rvalue *op[2] = {NULL, NULL};
unsigned int i;
for (i = 0; i < get_num_operands(); i++) {
op[i] = this->operands[i]->clone(ht);
op[i] = this->operands[i]->clone(mem_ctx, ht);
}
return new(ctx) ir_expression(this->operation, this->type, op[0], op[1]);
return new(mem_ctx) ir_expression(this->operation, this->type, op[0], op[1]);
}
ir_dereference_variable *
ir_dereference_variable::clone(struct hash_table *ht) const
ir_dereference_variable::clone(void *mem_ctx, struct hash_table *ht) const
{
void *ctx = talloc_parent(this);
ir_variable *new_var;
if (ht) {
@@ -188,38 +178,36 @@ ir_dereference_variable::clone(struct hash_table *ht) const
new_var = this->var;
}
return new(ctx) ir_dereference_variable(new_var);
return new(mem_ctx) ir_dereference_variable(new_var);
}
ir_dereference_array *
ir_dereference_array::clone(struct hash_table *ht) const
ir_dereference_array::clone(void *mem_ctx, struct hash_table *ht) const
{
void *ctx = talloc_parent(this);
return new(ctx) ir_dereference_array(this->array->clone(ht),
this->array_index->clone(ht));
return new(mem_ctx) ir_dereference_array(this->array->clone(mem_ctx, ht),
this->array_index->clone(mem_ctx,
ht));
}
ir_dereference_record *
ir_dereference_record::clone(struct hash_table *ht) const
ir_dereference_record::clone(void *mem_ctx, struct hash_table *ht) const
{
void *ctx = talloc_parent(this);
return new(ctx) ir_dereference_record(this->record->clone(ht),
this->field);
return new(mem_ctx) ir_dereference_record(this->record->clone(mem_ctx, ht),
this->field);
}
ir_texture *
ir_texture::clone(struct hash_table *ht) const
ir_texture::clone(void *mem_ctx, struct hash_table *ht) const
{
void *ctx = talloc_parent(this);
ir_texture *new_tex = new(ctx) ir_texture(this->op);
ir_texture *new_tex = new(mem_ctx) ir_texture(this->op);
new_tex->type = this->type;
new_tex->sampler = this->sampler->clone(ht);
new_tex->coordinate = this->coordinate->clone(ht);
new_tex->sampler = this->sampler->clone(mem_ctx, ht);
new_tex->coordinate = this->coordinate->clone(mem_ctx, ht);
if (this->projector)
new_tex->projector = this->projector->clone(ht);
new_tex->projector = this->projector->clone(mem_ctx, ht);
if (this->shadow_comparitor) {
new_tex->shadow_comparitor = this->shadow_comparitor->clone(ht);
new_tex->shadow_comparitor = this->shadow_comparitor->clone(mem_ctx, ht);
}
for (int i = 0; i < 3; i++)
@@ -229,15 +217,15 @@ ir_texture::clone(struct hash_table *ht) const
case ir_tex:
break;
case ir_txb:
new_tex->lod_info.bias = this->lod_info.bias->clone(ht);
new_tex->lod_info.bias = this->lod_info.bias->clone(mem_ctx, ht);
break;
case ir_txl:
case ir_txf:
new_tex->lod_info.lod = this->lod_info.lod->clone(ht);
new_tex->lod_info.lod = this->lod_info.lod->clone(mem_ctx, ht);
break;
case ir_txd:
new_tex->lod_info.grad.dPdx = this->lod_info.grad.dPdx->clone(ht);
new_tex->lod_info.grad.dPdy = this->lod_info.grad.dPdy->clone(ht);
new_tex->lod_info.grad.dPdx = this->lod_info.grad.dPdx->clone(mem_ctx, ht);
new_tex->lod_info.grad.dPdy = this->lod_info.grad.dPdy->clone(mem_ctx, ht);
break;
}
@@ -245,30 +233,28 @@ ir_texture::clone(struct hash_table *ht) const
}
ir_assignment *
ir_assignment::clone(struct hash_table *ht) const
ir_assignment::clone(void *mem_ctx, struct hash_table *ht) const
{
ir_rvalue *new_condition = NULL;
if (this->condition)
new_condition = this->condition->clone(ht);
new_condition = this->condition->clone(mem_ctx, ht);
void *ctx = talloc_parent(this);
return new(ctx) ir_assignment(this->lhs->clone(ht),
this->rhs->clone(ht),
new_condition);
return new(mem_ctx) ir_assignment(this->lhs->clone(mem_ctx, ht),
this->rhs->clone(mem_ctx, ht),
new_condition);
}
ir_function *
ir_function::clone(struct hash_table *ht) const
ir_function::clone(void *mem_ctx, struct hash_table *ht) const
{
void *mem_ctx = talloc_parent(this);
ir_function *copy = new(mem_ctx) ir_function(this->name);
foreach_list_const(node, &this->signatures) {
const ir_function_signature *const sig =
(const ir_function_signature *const) node;
ir_function_signature *sig_copy = sig->clone(ht);
ir_function_signature *sig_copy = sig->clone(mem_ctx, ht);
copy->add_signature(sig_copy);
if (ht != NULL)
@@ -280,9 +266,8 @@ ir_function::clone(struct hash_table *ht) const
}
ir_function_signature *
ir_function_signature::clone(struct hash_table *ht) const
ir_function_signature::clone(void *mem_ctx, struct hash_table *ht) const
{
void *mem_ctx = talloc_parent(this);
ir_function_signature *copy =
new(mem_ctx) ir_function_signature(this->return_type);
@@ -296,7 +281,7 @@ ir_function_signature::clone(struct hash_table *ht) const
assert(const_cast<ir_variable *>(param)->as_variable() != NULL);
ir_variable *const param_copy = param->clone(ht);
ir_variable *const param_copy = param->clone(mem_ctx, ht);
copy->parameters.push_tail(param_copy);
}
@@ -305,7 +290,7 @@ ir_function_signature::clone(struct hash_table *ht) const
foreach_list_const(node, &this->body) {
const ir_instruction *const inst = (const ir_instruction *) node;
ir_instruction *const inst_copy = inst->clone(ht);
ir_instruction *const inst_copy = inst->clone(mem_ctx, ht);
copy->body.push_tail(inst_copy);
}
@@ -313,9 +298,8 @@ ir_function_signature::clone(struct hash_table *ht) const
}
ir_constant *
ir_constant::clone(struct hash_table *ht) const
ir_constant::clone(void *mem_ctx, struct hash_table *ht) const
{
void *ctx = talloc_parent(this);
(void)ht;
switch (this->type->base_type) {
@@ -323,10 +307,10 @@ ir_constant::clone(struct hash_table *ht) const
case GLSL_TYPE_INT:
case GLSL_TYPE_FLOAT:
case GLSL_TYPE_BOOL:
return new(ctx) ir_constant(this->type, &this->value);
return new(mem_ctx) ir_constant(this->type, &this->value);
case GLSL_TYPE_STRUCT: {
ir_constant *c = new(ctx) ir_constant;
ir_constant *c = new(mem_ctx) ir_constant;
c->type = this->type;
for (exec_node *node = this->components.head
@@ -334,19 +318,19 @@ ir_constant::clone(struct hash_table *ht) const
; node = node->next) {
ir_constant *const orig = (ir_constant *) node;
c->components.push_tail(orig->clone(NULL));
c->components.push_tail(orig->clone(mem_ctx, NULL));
}
return c;
}
case GLSL_TYPE_ARRAY: {
ir_constant *c = new(ctx) ir_constant;
ir_constant *c = new(mem_ctx) ir_constant;
c->type = this->type;
c->array_elements = talloc_array(c, ir_constant *, this->type->length);
for (unsigned i = 0; i < this->type->length; i++) {
c->array_elements[i] = this->array_elements[i]->clone(NULL);
c->array_elements[i] = this->array_elements[i]->clone(mem_ctx, NULL);
}
return c;
}
@@ -395,14 +379,14 @@ fixup_function_calls(struct hash_table *ht, exec_list *instructions)
void
clone_ir_list(exec_list *out, const exec_list *in)
clone_ir_list(void *mem_ctx, exec_list *out, const exec_list *in)
{
struct hash_table *ht =
hash_table_ctor(0, hash_table_pointer_hash, hash_table_pointer_compare);
foreach_list_const(node, in) {
const ir_instruction *const original = (ir_instruction *) node;
ir_instruction *copy = original->clone(ht);
ir_instruction *copy = original->clone(mem_ctx, ht);
out->push_tail(copy);
}

7
src/glsl/ir_constant_expression.cpp
View File

@@ -680,7 +680,10 @@ ir_dereference_variable::constant_expression_value()
if (var->mode == ir_var_uniform)
return NULL;
return var->constant_value ? var->constant_value->clone(NULL) : NULL;
if (!var->constant_value)
return NULL;
return var->constant_value->clone(talloc_parent(var), NULL);
}
@@ -732,7 +735,7 @@ ir_dereference_array::constant_expression_value()
return new(ctx) ir_constant(array, component);
} else {
const unsigned index = idx->value.u[0];
return array->get_array_element(index)->clone(NULL);
return array->get_array_element(index)->clone(ctx, NULL);
}
}
return NULL;

6
src/glsl/ir_function_inlining.cpp
View File

@@ -147,7 +147,7 @@ ir_call::generate_inline(ir_instruction *next_ir)
parameters[i] = NULL;
hash_table_insert(ht, param->variable_referenced(), sig_param);
} else {
parameters[i] = sig_param->clone(ht);
parameters[i] = sig_param->clone(ctx, ht);
parameters[i]->mode = ir_var_auto;
next_ir->insert_before(parameters[i]);
}
@@ -169,7 +169,7 @@ ir_call::generate_inline(ir_instruction *next_ir)
/* Generate the inlined body of the function. */
foreach_iter(exec_list_iterator, iter, callee->body) {
ir_instruction *ir = (ir_instruction *)iter.get();
ir_instruction *new_ir = ir->clone(ht);
ir_instruction *new_ir = ir->clone(ctx, ht);
next_ir->insert_before(new_ir);
visit_tree(new_ir, replace_return_with_assignment, retval);
@@ -190,7 +190,7 @@ ir_call::generate_inline(ir_instruction *next_ir)
sig_param->mode == ir_var_inout)) {
ir_assignment *assign;
assign = new(ctx) ir_assignment(param->clone(NULL)->as_rvalue(),
assign = new(ctx) ir_assignment(param->clone(ctx, NULL)->as_rvalue(),
new(ctx) ir_dereference_variable(parameters[i]),
NULL);
next_ir->insert_before(assign);

2
src/glsl/ir_import_prototypes.cpp
View File

@@ -95,7 +95,7 @@ public:
assert(const_cast<ir_variable *>(param)->as_variable() != NULL);
ir_variable *const param_copy = param->clone(NULL);
ir_variable *const param_copy = param->clone(mem_ctx, NULL);
copy->parameters.push_tail(param_copy);
}

8
src/glsl/ir_vec_index_to_cond_assign.cpp
View File

@@ -82,6 +82,8 @@ ir_vec_index_to_cond_assign_visitor::convert_vec_index_to_cond_assign(ir_rvalue
orig_deref->array->type->is_array())
return ir;
void *mem_ctx = talloc_parent(ir);
assert(orig_deref->array_index->type->base_type == GLSL_TYPE_INT);
/* Store the index to a temporary to avoid reusing its tree. */
@@ -109,7 +111,7 @@ ir_vec_index_to_cond_assign_visitor::convert_vec_index_to_cond_assign(ir_rvalue
/* Just clone the rest of the deref chain when trying to get at the
* underlying variable.
*/
swizzle = new(base_ir) ir_swizzle(orig_deref->array->clone(NULL),
swizzle = new(base_ir) ir_swizzle(orig_deref->array->clone(mem_ctx, NULL),
i, 0, 0, 0, 1);
deref = new(base_ir) ir_dereference_variable(var);
@@ -165,6 +167,8 @@ ir_vec_index_to_cond_assign_visitor::visit_leave(ir_assignment *ir)
orig_deref->array->type->is_array())
return visit_continue;
void *mem_ctx = talloc_parent(ir);
assert(orig_deref->array_index->type->base_type == GLSL_TYPE_INT);
/* Store the index to a temporary to avoid reusing its tree. */
@@ -196,7 +200,7 @@ ir_vec_index_to_cond_assign_visitor::visit_leave(ir_assignment *ir)
/* Just clone the rest of the deref chain when trying to get at the
* underlying variable.
*/
swizzle = new(ir) ir_swizzle(orig_deref->array->clone(NULL),
swizzle = new(ir) ir_swizzle(orig_deref->array->clone(mem_ctx, NULL),
i, 0, 0, 0, 1);
deref = new(ir) ir_dereference_variable(var);

6
src/glsl/link_functions.cpp
View File

@@ -143,7 +143,7 @@ public:
const ir_instruction *const original = (ir_instruction *) node;
assert(const_cast<ir_instruction *>(original)->as_variable());
ir_instruction *copy = original->clone(ht);
ir_instruction *copy = original->clone(linked, ht);
formal_parameters.push_tail(copy);
}
@@ -152,7 +152,7 @@ public:
foreach_list_const(node, &sig->body) {
const ir_instruction *const original = (ir_instruction *) node;
ir_instruction *copy = original->clone(ht);
ir_instruction *copy = original->clone(linked, ht);
linked_sig->body.push_tail(copy);
}
@@ -182,7 +182,7 @@ public:
/* Clone the ir_variable that the dereference already has and add
* it to the linked shader.
*/
var = ir->var->clone(NULL);
var = ir->var->clone(linked, NULL);
linked->symbols->add_variable(var->name, var);
linked->ir->push_head(var);
}

25
src/glsl/linker.cpp
View File

@@ -323,7 +323,8 @@ cross_validate_globals(struct gl_shader_program *prog,
* FINISHME: modify the shader, and linking with the second
* FINISHME: will fail.
*/
existing->constant_value = var->constant_value->clone(NULL);
existing->constant_value =
var->constant_value->clone(talloc_parent(existing), NULL);
}
} else
variables.add_variable(var->name, var);
@@ -488,16 +489,17 @@ populate_symbol_table(gl_shader *sh)
* should be added.
*/
void
remap_variables(ir_instruction *inst, glsl_symbol_table *symbols,
exec_list *instructions, hash_table *temps)
remap_variables(ir_instruction *inst, struct gl_shader *target,
hash_table *temps)
{
class remap_visitor : public ir_hierarchical_visitor {
public:
remap_visitor(glsl_symbol_table *symbols, exec_list *instructions,
remap_visitor(struct gl_shader *target,
hash_table *temps)
{
this->symbols = symbols;
this->instructions = instructions;
this->target = target;
this->symbols = target->symbols;
this->instructions = target->ir;
this->temps = temps;
}
@@ -516,7 +518,7 @@ remap_variables(ir_instruction *inst, glsl_symbol_table *symbols,
if (existing != NULL)
ir->var = existing;
else {
ir_variable *copy = ir->var->clone(NULL);
ir_variable *copy = ir->var->clone(this->target, NULL);
this->symbols->add_variable(copy->name, copy);
this->instructions->push_head(copy);
@@ -527,12 +529,13 @@ remap_variables(ir_instruction *inst, glsl_symbol_table *symbols,
}
private:
struct gl_shader *target;
glsl_symbol_table *symbols;
exec_list *instructions;
hash_table *temps;
};
remap_visitor v(symbols, instructions, temps);
remap_visitor v(target, temps);
inst->accept(&v);
}
@@ -583,12 +586,12 @@ move_non_declarations(exec_list *instructions, exec_node *last,
|| ((var != NULL) && (var->mode == ir_var_temporary)));
if (make_copies) {
inst = inst->clone(NULL);
inst = inst->clone(target, NULL);
if (var != NULL)
hash_table_insert(temps, inst, var);
else
remap_variables(inst, target->symbols, target->ir, temps);
remap_variables(inst, target, temps);
} else {
inst->remove();
}
@@ -713,7 +716,7 @@ link_intrastage_shaders(struct gl_shader_program *prog,
gl_shader *const linked = _mesa_new_shader(NULL, 0, main->Type);
linked->ir = new(linked) exec_list;
clone_ir_list(linked->ir, main->ir);
clone_ir_list(linked, linked->ir, main->ir);
populate_symbol_table(linked);