From: Marek Olšák <marek.ol...@amd.com>
---
src/compiler/glsl/ast.h | 4 +-
src/compiler/glsl/ast_type.cpp | 13 +-
src/compiler/glsl/glsl_parser.yy | 202 +++++++++++++++----------------
src/compiler/glsl/glsl_parser_extras.cpp | 4 +-
src/compiler/glsl/glsl_symbol_table.cpp | 3 +-
src/compiler/glsl/glsl_symbol_table.h | 1 +
6 files changed, 114 insertions(+), 113 deletions(-)
diff --git a/src/compiler/glsl/ast.h b/src/compiler/glsl/ast.h
index 0713582..2195141 100644
--- a/src/compiler/glsl/ast.h
+++ b/src/compiler/glsl/ast.h
@@ -42,21 +42,21 @@ struct YYLTYPE;
* syntactic checking is done. Symantic checking is performed by a later
* stage that converts the AST to a more generic intermediate representation.
*
*@{
*/
/**
* Base class of all abstract syntax tree nodes
*/
class ast_node {
public:
- DECLARE_RZALLOC_CXX_OPERATORS(ast_node);
+ DECLARE_LINEAR_ZALLOC_CXX_OPERATORS(ast_node);
/**
* Print an AST node in something approximating the original GLSL code
*/
virtual void print(void) const;
/**
* Convert the AST node to the high-level intermediate representation
*/
virtual ir_rvalue *hir(exec_list *instructions,
@@ -763,21 +763,21 @@ struct ast_type_qualifier {
const ast_type_qualifier &allowed_flags,
const char *message, const char *name);
ast_subroutine_list *subroutine_list;
};
class ast_declarator_list;
class ast_struct_specifier : public ast_node {
public:
- ast_struct_specifier(const char *identifier,
+ ast_struct_specifier(void *lin_ctx, const char *identifier,
ast_declarator_list *declarator_list);
virtual void print(void) const;
virtual ir_rvalue *hir(exec_list *instructions,
struct _mesa_glsl_parse_state *state);
const char *name;
ast_type_qualifier *layout;
/* List of ast_declarator_list * */
exec_list declarations;
diff --git a/src/compiler/glsl/ast_type.cpp b/src/compiler/glsl/ast_type.cpp
index b586f94..e4cbc84 100644
--- a/src/compiler/glsl/ast_type.cpp
+++ b/src/compiler/glsl/ast_type.cpp
@@ -257,24 +257,24 @@ ast_type_qualifier::merge_qualifier(YYLTYPE *loc,
/* Set xfb_stride flag to 0 to avoid adding duplicates every time
* there is a merge.
*/
this->flags.q.xfb_stride = 0;
unsigned buff_idx;
if (process_qualifier_constant(state, loc, "xfb_buffer",
this->xfb_buffer, &buff_idx)) {
if (state->out_qualifier->out_xfb_stride[buff_idx]) {
state->out_qualifier->out_xfb_stride[buff_idx]->merge_qualifier(
- new(state) ast_layout_expression(*loc, this->xfb_stride));
+ new(state->linalloc) ast_layout_expression(*loc,
this->xfb_stride));
} else {
state->out_qualifier->out_xfb_stride[buff_idx] =
- new(state) ast_layout_expression(*loc, this->xfb_stride);
+ new(state->linalloc) ast_layout_expression(*loc,
this->xfb_stride);
}
}
}
}
if (q.flags.q.vertices) {
if (this->vertices) {
this->vertices->merge_qualifier(q.vertices);
} else {
this->vertices = q.vertices;
@@ -356,21 +356,20 @@ ast_type_qualifier::merge_qualifier(YYLTYPE *loc,
return true;
}
bool
ast_type_qualifier::merge_out_qualifier(YYLTYPE *loc,
_mesa_glsl_parse_state *state,
const ast_type_qualifier &q,
ast_node* &node, bool create_node)
{
- void *mem_ctx = state;
const bool r = this->merge_qualifier(loc, state, q, false);
ast_type_qualifier valid_out_mask;
valid_out_mask.flags.i = 0;
if (state->stage == MESA_SHADER_GEOMETRY) {
if (q.flags.q.prim_type) {
/* Make sure this is a valid output primitive type. */
switch (q.prim_type) {
case GL_POINTS:
case GL_LINE_STRIP:
@@ -389,21 +388,21 @@ ast_type_qualifier::merge_out_qualifier(YYLTYPE *loc,
valid_out_mask.flags.q.stream = 1;
valid_out_mask.flags.q.explicit_stream = 1;
valid_out_mask.flags.q.explicit_xfb_buffer = 1;
valid_out_mask.flags.q.xfb_buffer = 1;
valid_out_mask.flags.q.explicit_xfb_stride = 1;
valid_out_mask.flags.q.xfb_stride = 1;
valid_out_mask.flags.q.max_vertices = 1;
valid_out_mask.flags.q.prim_type = 1;
} else if (state->stage == MESA_SHADER_TESS_CTRL) {
if (create_node) {
- node = new(mem_ctx) ast_tcs_output_layout(*loc);
+ node = new(state->linalloc) ast_tcs_output_layout(*loc);
}
valid_out_mask.flags.q.vertices = 1;
valid_out_mask.flags.q.explicit_xfb_buffer = 1;
valid_out_mask.flags.q.xfb_buffer = 1;
valid_out_mask.flags.q.explicit_xfb_stride = 1;
valid_out_mask.flags.q.xfb_stride = 1;
} else if (state->stage == MESA_SHADER_TESS_EVAL ||
state->stage == MESA_SHADER_VERTEX) {
valid_out_mask.flags.q.explicit_xfb_buffer = 1;
valid_out_mask.flags.q.xfb_buffer = 1;
@@ -429,21 +428,21 @@ ast_type_qualifier::merge_out_qualifier(YYLTYPE *loc,
return r;
}
bool
ast_type_qualifier::merge_in_qualifier(YYLTYPE *loc,
_mesa_glsl_parse_state *state,
const ast_type_qualifier &q,
ast_node* &node, bool create_node)
{
- void *mem_ctx = state;
+ void *lin_ctx = state->linalloc;
bool create_gs_ast = false;
bool create_cs_ast = false;
ast_type_qualifier valid_in_mask;
valid_in_mask.flags.i = 0;
switch (state->stage) {
case MESA_SHADER_TESS_EVAL:
if (q.flags.q.prim_type) {
/* Make sure this is a valid input primitive type. */
switch (q.prim_type) {
@@ -568,23 +567,23 @@ ast_type_qualifier::merge_in_qualifier(YYLTYPE *loc,
_mesa_glsl_error(loc, state,
"conflicting point mode specified");
}
} else if (q.flags.q.point_mode) {
this->flags.q.point_mode = 1;
this->point_mode = q.point_mode;
}
if (create_node) {
if (create_gs_ast) {
- node = new(mem_ctx) ast_gs_input_layout(*loc, q.prim_type);
+ node = new(lin_ctx) ast_gs_input_layout(*loc, q.prim_type);
} else if (create_cs_ast) {
- node = new(mem_ctx) ast_cs_input_layout(*loc, q.local_size);
+ node = new(lin_ctx) ast_cs_input_layout(*loc, q.local_size);
}
}
return true;
}
/**
* Check if the current type qualifier has any illegal flags.
*
* If so, print an error message, followed by a list of illegal flags.
diff --git a/src/compiler/glsl/glsl_parser.yy b/src/compiler/glsl/glsl_parser.yy
index 9e1fd9e..175bffd 100644
--- a/src/compiler/glsl/glsl_parser.yy
+++ b/src/compiler/glsl/glsl_parser.yy
@@ -425,94 +425,94 @@ external_declaration_list:
;
variable_identifier:
IDENTIFIER
| NEW_IDENTIFIER
;
primary_expression:
variable_identifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression(ast_identifier, NULL, NULL, NULL);
$$->set_location(@1);
$$->primary_expression.identifier = $1;
}
| INTCONSTANT
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression(ast_int_constant, NULL, NULL, NULL);
$$->set_location(@1);
$$->primary_expression.int_constant = $1;
}
| UINTCONSTANT
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression(ast_uint_constant, NULL, NULL, NULL);
$$->set_location(@1);
$$->primary_expression.uint_constant = $1;
}
| FLOATCONSTANT
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression(ast_float_constant, NULL, NULL, NULL);
$$->set_location(@1);
$$->primary_expression.float_constant = $1;
}
| DOUBLECONSTANT
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression(ast_double_constant, NULL, NULL, NULL);
$$->set_location(@1);
$$->primary_expression.double_constant = $1;
}
| BOOLCONSTANT
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression(ast_bool_constant, NULL, NULL, NULL);
$$->set_location(@1);
$$->primary_expression.bool_constant = $1;
}
| '(' expression ')'
{
$$ = $2;
}
;
postfix_expression:
primary_expression
| postfix_expression '[' integer_expression ']'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression(ast_array_index, $1, $3, NULL);
$$->set_location_range(@1, @4);
}
| function_call
{
$$ = $1;
}
| postfix_expression DOT_TOK FIELD_SELECTION
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression(ast_field_selection, $1, NULL, NULL);
$$->set_location_range(@1, @3);
$$->primary_expression.identifier = $3;
}
| postfix_expression INC_OP
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression(ast_post_inc, $1, NULL, NULL);
$$->set_location_range(@1, @2);
}
| postfix_expression DEC_OP
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression(ast_post_dec, $1, NULL, NULL);
$$->set_location_range(@1, @2);
}
;
integer_expression:
expression
;
function_call:
@@ -551,240 +551,240 @@ function_call_header_with_parameters:
// Grammar Note: Constructors look like functions, but lexical
// analysis recognized most of them as keywords. They are now
// recognized through "type_specifier".
function_call_header:
function_identifier '('
;
function_identifier:
type_specifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_function_expression($1);
$$->set_location(@1);
}
| postfix_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_function_expression($1);
$$->set_location(@1);
}
;
// Grammar Note: Constructors look like methods, but lexical
// analysis recognized most of them as keywords. They are now
// recognized through "type_specifier".
// Grammar Note: No traditional style type casts.
unary_expression:
postfix_expression
| INC_OP unary_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression(ast_pre_inc, $2, NULL, NULL);
$$->set_location(@1);
}
| DEC_OP unary_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression(ast_pre_dec, $2, NULL, NULL);
$$->set_location(@1);
}
| unary_operator unary_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression($1, $2, NULL, NULL);
$$->set_location_range(@1, @2);
}
;
// Grammar Note: No '*' or '&' unary ops. Pointers are not supported.
unary_operator:
'+' { $$ = ast_plus; }
| '-' { $$ = ast_neg; }
| '!' { $$ = ast_logic_not; }
| '~' { $$ = ast_bit_not; }
;
multiplicative_expression:
unary_expression
| multiplicative_expression '*' unary_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_mul, $1, $3);
$$->set_location_range(@1, @3);
}
| multiplicative_expression '/' unary_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_div, $1, $3);
$$->set_location_range(@1, @3);
}
| multiplicative_expression '%' unary_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_mod, $1, $3);
$$->set_location_range(@1, @3);
}
;
additive_expression:
multiplicative_expression
| additive_expression '+' multiplicative_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_add, $1, $3);
$$->set_location_range(@1, @3);
}
| additive_expression '-' multiplicative_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_sub, $1, $3);
$$->set_location_range(@1, @3);
}
;
shift_expression:
additive_expression
| shift_expression LEFT_OP additive_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_lshift, $1, $3);
$$->set_location_range(@1, @3);
}
| shift_expression RIGHT_OP additive_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_rshift, $1, $3);
$$->set_location_range(@1, @3);
}
;
relational_expression:
shift_expression
| relational_expression '<' shift_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_less, $1, $3);
$$->set_location_range(@1, @3);
}
| relational_expression '>' shift_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_greater, $1, $3);
$$->set_location_range(@1, @3);
}
| relational_expression LE_OP shift_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_lequal, $1, $3);
$$->set_location_range(@1, @3);
}
| relational_expression GE_OP shift_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_gequal, $1, $3);
$$->set_location_range(@1, @3);
}
;
equality_expression:
relational_expression
| equality_expression EQ_OP relational_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_equal, $1, $3);
$$->set_location_range(@1, @3);
}
| equality_expression NE_OP relational_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_nequal, $1, $3);
$$->set_location_range(@1, @3);
}
;
and_expression:
equality_expression
| and_expression '&' equality_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_bit_and, $1, $3);
$$->set_location_range(@1, @3);
}
;
exclusive_or_expression:
and_expression
| exclusive_or_expression '^' and_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_bit_xor, $1, $3);
$$->set_location_range(@1, @3);
}
;
inclusive_or_expression:
exclusive_or_expression
| inclusive_or_expression '|' exclusive_or_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_bit_or, $1, $3);
$$->set_location_range(@1, @3);
}
;
logical_and_expression:
inclusive_or_expression
| logical_and_expression AND_OP inclusive_or_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_logic_and, $1, $3);
$$->set_location_range(@1, @3);
}
;
logical_xor_expression:
logical_and_expression
| logical_xor_expression XOR_OP logical_and_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_logic_xor, $1, $3);
$$->set_location_range(@1, @3);
}
;
logical_or_expression:
logical_xor_expression
| logical_or_expression OR_OP logical_xor_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_bin(ast_logic_or, $1, $3);
$$->set_location_range(@1, @3);
}
;
conditional_expression:
logical_or_expression
| logical_or_expression '?' expression ':' assignment_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression(ast_conditional, $1, $3, $5);
$$->set_location_range(@1, @5);
}
;
assignment_expression:
conditional_expression
| unary_expression assignment_operator assignment_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression($2, $1, $3, NULL);
$$->set_location_range(@1, @3);
}
;
assignment_operator:
'=' { $$ = ast_assign; }
| MUL_ASSIGN { $$ = ast_mul_assign; }
| DIV_ASSIGN { $$ = ast_div_assign; }
| MOD_ASSIGN { $$ = ast_mod_assign; }
@@ -797,21 +797,21 @@ assignment_operator:
| OR_ASSIGN { $$ = ast_or_assign; }
;
expression:
assignment_expression
{
$$ = $1;
}
| expression ',' assignment_expression
{
- void *ctx = state;
+ void *ctx = state->linalloc;
if ($1->oper != ast_sequence) {
$$ = new(ctx) ast_expression(ast_sequence, NULL, NULL, NULL);
$$->set_location_range(@1, @3);
$$->expressions.push_tail(& $1->link);
} else {
$$ = $1;
}
$$->expressions.push_tail(& $3->link);
}
@@ -860,70 +860,70 @@ function_header_with_parameters:
| function_header_with_parameters ',' parameter_declaration
{
$$ = $1;
$$->parameters.push_tail(& $3->link);
}
;
function_header:
fully_specified_type variable_identifier '('
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_function();
$$->set_location(@2);
$$->return_type = $1;
$$->identifier = $2;
if ($1->qualifier.flags.q.subroutine) {
/* add type for IDENTIFIER search */
state->symbols->add_type($2, glsl_type::get_subroutine_instance($2));
} else
state->symbols->add_function(new(state) ir_function($2));
state->symbols->push_scope();
}
;
parameter_declarator:
type_specifier any_identifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_parameter_declarator();
$$->set_location_range(@1, @2);
$$->type = new(ctx) ast_fully_specified_type();
$$->type->set_location(@1);
$$->type->specifier = $1;
$$->identifier = $2;
state->symbols->add_variable(new(state) ir_variable(NULL, $2,
ir_var_auto));
}
| type_specifier any_identifier array_specifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_parameter_declarator();
$$->set_location_range(@1, @3);
$$->type = new(ctx) ast_fully_specified_type();
$$->type->set_location(@1);
$$->type->specifier = $1;
$$->identifier = $2;
$$->array_specifier = $3;
state->symbols->add_variable(new(state) ir_variable(NULL, $2,
ir_var_auto));
}
;
parameter_declaration:
parameter_qualifier parameter_declarator
{
$$ = $2;
$$->type->qualifier = $1;
}
| parameter_qualifier parameter_type_specifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_parameter_declarator();
$$->set_location(@2);
$$->type = new(ctx) ast_fully_specified_type();
$$->type->set_location_range(@1, @2);
$$->type->qualifier = $1;
$$->type->specifier = $2;
}
;
parameter_qualifier:
@@ -997,150 +997,150 @@ parameter_direction_qualifier:
;
parameter_type_specifier:
type_specifier
;
init_declarator_list:
single_declaration
| init_declarator_list ',' any_identifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
ast_declaration *decl = new(ctx) ast_declaration($3, NULL, NULL);
decl->set_location(@3);
$$ = $1;
$$->declarations.push_tail(&decl->link);
state->symbols->add_variable(new(state) ir_variable(NULL, $3,
ir_var_auto));
}
| init_declarator_list ',' any_identifier array_specifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
ast_declaration *decl = new(ctx) ast_declaration($3, $4, NULL);
decl->set_location_range(@3, @4);
$$ = $1;
$$->declarations.push_tail(&decl->link);
state->symbols->add_variable(new(state) ir_variable(NULL, $3,
ir_var_auto));
}
| init_declarator_list ',' any_identifier array_specifier '=' initializer
{
- void *ctx = state;
+ void *ctx = state->linalloc;
ast_declaration *decl = new(ctx) ast_declaration($3, $4, $6);
decl->set_location_range(@3, @4);
$$ = $1;
$$->declarations.push_tail(&decl->link);
state->symbols->add_variable(new(state) ir_variable(NULL, $3,
ir_var_auto));
}
| init_declarator_list ',' any_identifier '=' initializer
{
- void *ctx = state;
+ void *ctx = state->linalloc;
ast_declaration *decl = new(ctx) ast_declaration($3, NULL, $5);
decl->set_location(@3);
$$ = $1;
$$->declarations.push_tail(&decl->link);
state->symbols->add_variable(new(state) ir_variable(NULL, $3,
ir_var_auto));
}
;
// Grammar Note: No 'enum', or 'typedef'.
single_declaration:
fully_specified_type
{
- void *ctx = state;
+ void *ctx = state->linalloc;
/* Empty declaration list is valid. */
$$ = new(ctx) ast_declarator_list($1);
$$->set_location(@1);
}
| fully_specified_type any_identifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
ast_declaration *decl = new(ctx) ast_declaration($2, NULL, NULL);
decl->set_location(@2);
$$ = new(ctx) ast_declarator_list($1);
$$->set_location_range(@1, @2);
$$->declarations.push_tail(&decl->link);
state->symbols->add_variable(new(state) ir_variable(NULL, $2,
ir_var_auto));
}
| fully_specified_type any_identifier array_specifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
ast_declaration *decl = new(ctx) ast_declaration($2, $3, NULL);
decl->set_location_range(@2, @3);
$$ = new(ctx) ast_declarator_list($1);
$$->set_location_range(@1, @3);
$$->declarations.push_tail(&decl->link);
state->symbols->add_variable(new(state) ir_variable(NULL, $2,
ir_var_auto));
}
| fully_specified_type any_identifier array_specifier '=' initializer
{
- void *ctx = state;
+ void *ctx = state->linalloc;
ast_declaration *decl = new(ctx) ast_declaration($2, $3, $5);
decl->set_location_range(@2, @3);
$$ = new(ctx) ast_declarator_list($1);
$$->set_location_range(@1, @3);
$$->declarations.push_tail(&decl->link);
state->symbols->add_variable(new(state) ir_variable(NULL, $2,
ir_var_auto));
}
| fully_specified_type any_identifier '=' initializer
{
- void *ctx = state;
+ void *ctx = state->linalloc;
ast_declaration *decl = new(ctx) ast_declaration($2, NULL, $4);
decl->set_location(@2);
$$ = new(ctx) ast_declarator_list($1);
$$->set_location_range(@1, @2);
$$->declarations.push_tail(&decl->link);
state->symbols->add_variable(new(state) ir_variable(NULL, $2,
ir_var_auto));
}
| INVARIANT variable_identifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
ast_declaration *decl = new(ctx) ast_declaration($2, NULL, NULL);
decl->set_location(@2);
$$ = new(ctx) ast_declarator_list(NULL);
$$->set_location_range(@1, @2);
$$->invariant = true;
$$->declarations.push_tail(&decl->link);
}
| PRECISE variable_identifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
ast_declaration *decl = new(ctx) ast_declaration($2, NULL, NULL);
decl->set_location(@2);
$$ = new(ctx) ast_declarator_list(NULL);
$$->set_location_range(@1, @2);
$$->precise = true;
$$->declarations.push_tail(&decl->link);
}
;
fully_specified_type:
type_specifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_fully_specified_type();
$$->set_location(@1);
$$->specifier = $1;
}
| type_qualifier type_specifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_fully_specified_type();
$$->set_location_range(@1, @2);
$$->qualifier = $1;
$$->specifier = $2;
if ($$->specifier->structure != NULL &&
$$->specifier->structure->is_declaration) {
$$->specifier->structure->layout = &$$->qualifier;
}
}
;
@@ -1493,21 +1493,21 @@ layout_qualifier_id:
if (!$$.flags.i) {
_mesa_glsl_error(& @1, state, "unrecognized layout identifier "
"`%s'", $1);
YYERROR;
}
}
| any_identifier '=' constant_expression
{
memset(& $$, 0, sizeof($$));
- void *ctx = state;
+ void *ctx = state->linalloc;
if ($3->oper != ast_int_constant &&
$3->oper != ast_uint_constant &&
!state->has_enhanced_layouts()) {
_mesa_glsl_error(& @1, state,
"compile-time constant expressions require "
"GLSL 4.40 or ARB_enhanced_layouts");
}
if (match_layout_qualifier("align", $1, state) == 0) {
@@ -1715,30 +1715,30 @@ subroutine_qualifier:
{
memset(& $$, 0, sizeof($$));
$$.flags.q.subroutine_def = 1;
$$.subroutine_list = $3;
}
;
subroutine_type_list:
any_identifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
ast_declaration *decl = new(ctx) ast_declaration($1, NULL, NULL);
decl->set_location(@1);
$$ = new(ctx) ast_subroutine_list();
$$->declarations.push_tail(&decl->link);
}
| subroutine_type_list ',' any_identifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
ast_declaration *decl = new(ctx) ast_declaration($3, NULL, NULL);
decl->set_location(@3);
$$ = $1;
$$->declarations.push_tail(&decl->link);
}
;
interpolation_qualifier:
SMOOTH
@@ -2045,35 +2045,35 @@ memory_qualifier:
| WRITEONLY
{
memset(& $$, 0, sizeof($$));
$$.flags.q.write_only = 1;
}
;
array_specifier:
'[' ']'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_array_specifier(@1, new(ctx) ast_expression(
ast_unsized_array_dim, NULL,
NULL, NULL));
$$->set_location_range(@1, @2);
}
| '[' constant_expression ']'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_array_specifier(@1, $2);
$$->set_location_range(@1, @3);
}
| array_specifier '[' ']'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = $1;
if (state->check_arrays_of_arrays_allowed(& @1)) {
$$->add_dimension(new(ctx) ast_expression(ast_unsized_array_dim, NULL,
NULL, NULL));
}
}
| array_specifier '[' constant_expression ']'
{
$$ = $1;
@@ -2089,33 +2089,33 @@ type_specifier:
| type_specifier_nonarray array_specifier
{
$$ = $1;
$$->array_specifier = $2;
}
;
type_specifier_nonarray:
basic_type_specifier_nonarray
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_type_specifier($1);
$$->set_location(@1);
}
| struct_specifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_type_specifier($1);
$$->set_location(@1);
}
| TYPE_IDENTIFIER
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_type_specifier($1);
$$->set_location(@1);
}
;
basic_type_specifier_nonarray:
VOID_TOK { $$ = "void"; }
| FLOAT_TOK { $$ = "float"; }
| DOUBLE_TOK { $$ = "double"; }
| INT_TOK { $$ = "int"; }
@@ -2245,50 +2245,50 @@ precision_qualifier:
| LOWP
{
state->check_precision_qualifiers_allowed(&@1);
$$ = ast_precision_low;
}
;
struct_specifier:
STRUCT any_identifier '{' struct_declaration_list '}'
{
- void *ctx = state;
- $$ = new(ctx) ast_struct_specifier($2, $4);
+ void *ctx = state->linalloc;
+ $$ = new(ctx) ast_struct_specifier(ctx, $2, $4);
$$->set_location_range(@2, @5);
state->symbols->add_type($2, glsl_type::void_type);
}
| STRUCT '{' struct_declaration_list '}'
{
- void *ctx = state;
- $$ = new(ctx) ast_struct_specifier(NULL, $3);
+ void *ctx = state->linalloc;
+ $$ = new(ctx) ast_struct_specifier(ctx, NULL, $3);
$$->set_location_range(@2, @4);
}
;
struct_declaration_list:
struct_declaration
{
$$ = $1;
$1->link.self_link();
}
| struct_declaration_list struct_declaration
{
$$ = $1;
$$->link.insert_before(& $2->link);
}
;
struct_declaration:
fully_specified_type struct_declarator_list ';'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
ast_fully_specified_type *const type = $1;
type->set_location(@1);
if (type->qualifier.flags.i != 0)
_mesa_glsl_error(&@1, state,
"only precision qualifiers may be applied to "
"structure members");
$$ = new(ctx) ast_declarator_list(type);
$$->set_location(@2);
@@ -2306,48 +2306,48 @@ struct_declarator_list:
| struct_declarator_list ',' struct_declarator
{
$$ = $1;
$$->link.insert_before(& $3->link);
}
;
struct_declarator:
any_identifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_declaration($1, NULL, NULL);
$$->set_location(@1);
}
| any_identifier array_specifier
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_declaration($1, $2, NULL);
$$->set_location_range(@1, @2);
}
;
initializer:
assignment_expression
| '{' initializer_list '}'
{
$$ = $2;
}
| '{' initializer_list ',' '}'
{
$$ = $2;
}
;
initializer_list:
initializer
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_aggregate_initializer();
$$->set_location(@1);
$$->expressions.push_tail(& $1->link);
}
| initializer_list ',' initializer
{
$1->expressions.push_tail(& $3->link);
}
;
@@ -2367,52 +2367,52 @@ simple_statement:
| expression_statement
| selection_statement
| switch_statement
| iteration_statement
| jump_statement
;
compound_statement:
'{' '}'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_compound_statement(true, NULL);
$$->set_location_range(@1, @2);
}
| '{'
{
state->symbols->push_scope();
}
statement_list '}'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_compound_statement(true, $3);
$$->set_location_range(@1, @4);
state->symbols->pop_scope();
}
;
statement_no_new_scope:
compound_statement_no_new_scope { $$ = (ast_node *) $1; }
| simple_statement
;
compound_statement_no_new_scope:
'{' '}'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_compound_statement(false, NULL);
$$->set_location_range(@1, @2);
}
| '{' statement_list '}'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_compound_statement(false, $2);
$$->set_location_range(@1, @3);
}
;
statement_list:
statement
{
if ($1 == NULL) {
_mesa_glsl_error(& @1, state, "<nil> statement");
@@ -2429,37 +2429,37 @@ statement_list:
assert($2 != NULL);
}
$$ = $1;
$$->link.insert_before(& $2->link);
}
;
expression_statement:
';'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_statement(NULL);
$$->set_location(@1);
}
| expression ';'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_expression_statement($1);
$$->set_location(@1);
}
;
selection_statement:
IF '(' expression ')' selection_rest_statement
{
- $$ = new(state) ast_selection_statement($3, $5.then_statement,
- $5.else_statement);
+ $$ = new(state->linalloc) ast_selection_statement($3, $5.then_statement,
+ $5.else_statement);
$$->set_location_range(@1, @5);
}
;
selection_rest_statement:
statement ELSE statement
{
$$.then_statement = $1;
$$.else_statement = $3;
}
@@ -2470,135 +2470,135 @@ selection_rest_statement:
}
;
condition:
expression
{
$$ = (ast_node *) $1;
}
| fully_specified_type any_identifier '=' initializer
{
- void *ctx = state;
+ void *ctx = state->linalloc;
ast_declaration *decl = new(ctx) ast_declaration($2, NULL, $4);
ast_declarator_list *declarator = new(ctx) ast_declarator_list($1);
decl->set_location_range(@2, @4);
declarator->set_location(@1);
declarator->declarations.push_tail(&decl->link);
$$ = declarator;
}
;
/*
* switch_statement grammar is based on the syntax described in the body
* of the GLSL spec, not in it's appendix!!!
*/
switch_statement:
SWITCH '(' expression ')' switch_body
{
- $$ = new(state) ast_switch_statement($3, $5);
+ $$ = new(state->linalloc) ast_switch_statement($3, $5);
$$->set_location_range(@1, @5);
}
;
switch_body:
'{' '}'
{
- $$ = new(state) ast_switch_body(NULL);
+ $$ = new(state->linalloc) ast_switch_body(NULL);
$$->set_location_range(@1, @2);
}
| '{' case_statement_list '}'
{
- $$ = new(state) ast_switch_body($2);
+ $$ = new(state->linalloc) ast_switch_body($2);
$$->set_location_range(@1, @3);
}
;
case_label:
CASE expression ':'
{
- $$ = new(state) ast_case_label($2);
+ $$ = new(state->linalloc) ast_case_label($2);
$$->set_location(@2);
}
| DEFAULT ':'
{
- $$ = new(state) ast_case_label(NULL);
+ $$ = new(state->linalloc) ast_case_label(NULL);
$$->set_location(@2);
}
;
case_label_list:
case_label
{
- ast_case_label_list *labels = new(state) ast_case_label_list();
+ ast_case_label_list *labels = new(state->linalloc) ast_case_label_list();
labels->labels.push_tail(& $1->link);
$$ = labels;
$$->set_location(@1);
}
| case_label_list case_label
{
$$ = $1;
$$->labels.push_tail(& $2->link);
}
;
case_statement:
case_label_list statement
{
- ast_case_statement *stmts = new(state) ast_case_statement($1);
+ ast_case_statement *stmts = new(state->linalloc) ast_case_statement($1);
stmts->set_location(@2);
stmts->stmts.push_tail(& $2->link);
$$ = stmts;
}
| case_statement statement
{
$$ = $1;
$$->stmts.push_tail(& $2->link);
}
;
case_statement_list:
case_statement
{
- ast_case_statement_list *cases= new(state) ast_case_statement_list();
+ ast_case_statement_list *cases= new(state->linalloc)
ast_case_statement_list();
cases->set_location(@1);
cases->cases.push_tail(& $1->link);
$$ = cases;
}
| case_statement_list case_statement
{
$$ = $1;
$$->cases.push_tail(& $2->link);
}
;
iteration_statement:
WHILE '(' condition ')' statement_no_new_scope
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_while,
NULL, $3, NULL, $5);
$$->set_location_range(@1, @4);
}
| DO statement WHILE '(' expression ')' ';'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx)
ast_iteration_statement(ast_iteration_statement::ast_do_while,
NULL, $5, NULL, $2);
$$->set_location_range(@1, @6);
}
| FOR '(' for_init_statement for_rest_statement ')' statement_no_new_scope
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_iteration_statement(ast_iteration_statement::ast_for,
$3, $4.cond, $4.rest, $6);
$$->set_location_range(@1, @6);
}
;
for_init_statement:
expression_statement
| declaration_statement
;
@@ -2621,61 +2621,61 @@ for_rest_statement:
{
$$.cond = $1;
$$.rest = $3;
}
;
// Grammar Note: No 'goto'. Gotos are not supported.
jump_statement:
CONTINUE ';'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_continue, NULL);
$$->set_location(@1);
}
| BREAK ';'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_break, NULL);
$$->set_location(@1);
}
| RETURN ';'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, NULL);
$$->set_location(@1);
}
| RETURN expression ';'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_return, $2);
$$->set_location_range(@1, @2);
}
| DISCARD ';' // Fragment shader only.
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_jump_statement(ast_jump_statement::ast_discard, NULL);
$$->set_location(@1);
}
;
external_declaration:
function_definition { $$ = $1; }
| declaration { $$ = $1; }
| pragma_statement { $$ = NULL; }
| layout_defaults { $$ = $1; }
;
function_definition:
function_prototype compound_statement_no_new_scope
{
- void *ctx = state;
+ void *ctx = state->linalloc;
$$ = new(ctx) ast_function_definition();
$$->set_location_range(@1, @2);
$$->prototype = $1;
$$->body = $2;
state->symbols->pop_scope();
}
;
/* layout_qualifieropt is packed into this rule */
@@ -2767,51 +2767,51 @@ interface_qualifier:
_mesa_glsl_error(&@1, state, "duplicate patch qualifier");
}
$$ = $2;
$$.flags.q.patch = 1;
}
;
instance_name_opt:
/* empty */
{
- $$ = new(state) ast_interface_block(NULL, NULL);
+ $$ = new(state->linalloc) ast_interface_block(NULL, NULL);
}
| NEW_IDENTIFIER
{
- $$ = new(state) ast_interface_block($1, NULL);
+ $$ = new(state->linalloc) ast_interface_block($1, NULL);
$$->set_location(@1);
}
| NEW_IDENTIFIER array_specifier
{
- $$ = new(state) ast_interface_block($1, $2);
+ $$ = new(state->linalloc) ast_interface_block($1, $2);
$$->set_location_range(@1, @2);
}
;
member_list:
member_declaration
{
$$ = $1;
$1->link.self_link();
}
| member_declaration member_list
{
$$ = $1;
$2->link.insert_before(& $$->link);
}
;
member_declaration:
fully_specified_type struct_declarator_list ';'
{
- void *ctx = state;
+ void *ctx = state->linalloc;
ast_fully_specified_type *type = $1;
type->set_location(@1);
if (type->qualifier.flags.q.attribute) {
_mesa_glsl_error(& @1, state,
"keyword 'attribute' cannot be used with "
"interface block member");
} else if (type->qualifier.flags.q.varying) {
_mesa_glsl_error(& @1, state,
"keyword 'varying' cannot be used with "
diff --git a/src/compiler/glsl/glsl_parser_extras.cpp
b/src/compiler/glsl/glsl_parser_extras.cpp
index d649695..74dd8d3 100644
--- a/src/compiler/glsl/glsl_parser_extras.cpp
+++ b/src/compiler/glsl/glsl_parser_extras.cpp
@@ -1625,33 +1625,33 @@ void
ast_struct_specifier::print(void) const
{
printf("struct %s { ", name);
foreach_list_typed(ast_node, ast, link, &this->declarations) {
ast->print();
}
printf("} ");
}
-ast_struct_specifier::ast_struct_specifier(const char *identifier,
+ast_struct_specifier::ast_struct_specifier(void *lin_ctx, const char
*identifier,
ast_declarator_list *declarator_list)
{
if (identifier == NULL) {
static mtx_t mutex = _MTX_INITIALIZER_NP;
static unsigned anon_count = 1;
unsigned count;
mtx_lock(&mutex);
count = anon_count++;
mtx_unlock(&mutex);
- identifier = ralloc_asprintf(this, "#anon_struct_%04x", count);
+ identifier = linear_asprintf(lin_ctx, "#anon_struct_%04x", count);
}
name = identifier;
this->declarations.push_degenerate_list_at_head(&declarator_list->link);
is_declaration = true;
layout = NULL;
}
void ast_subroutine_list::print(void) const
{
foreach_list_typed (ast_node, ast, link, & this->declarations) {
diff --git a/src/compiler/glsl/glsl_symbol_table.cpp
b/src/compiler/glsl/glsl_symbol_table.cpp
index 6d7baad..0b21faa 100644
--- a/src/compiler/glsl/glsl_symbol_table.cpp
+++ b/src/compiler/glsl/glsl_symbol_table.cpp
@@ -99,20 +99,21 @@ public:
const glsl_type *ibi;
const glsl_type *ibo;
const class ast_type_specifier *a;
};
glsl_symbol_table::glsl_symbol_table()
{
this->separate_function_namespace = false;
this->table = _mesa_symbol_table_ctor();
this->mem_ctx = ralloc_context(NULL);
+ this->linalloc = linear_alloc_parent(this->mem_ctx, 0);
}
glsl_symbol_table::~glsl_symbol_table()
{
_mesa_symbol_table_dtor(table);
ralloc_free(mem_ctx);
}
void glsl_symbol_table::push_scope()
{
@@ -200,21 +201,21 @@ bool glsl_symbol_table::add_function(ir_function *f)
}
symbol_table_entry *entry = new(mem_ctx) symbol_table_entry(f);
return _mesa_symbol_table_add_symbol(table, -1, f->name, entry) == 0;
}
bool glsl_symbol_table::add_default_precision_qualifier(const char *type_name,
int precision)
{
char *name = ralloc_asprintf(mem_ctx, "#default_precision_%s", type_name);
- ast_type_specifier *default_specifier = new(mem_ctx)
ast_type_specifier(name);
+ ast_type_specifier *default_specifier = new(linalloc)
ast_type_specifier(name);
default_specifier->default_precision = precision;
symbol_table_entry *entry =
new(mem_ctx) symbol_table_entry(default_specifier);
return _mesa_symbol_table_add_symbol(table, -1, name, entry) == 0;
}
void glsl_symbol_table::add_global_function(ir_function *f)
{
diff --git a/src/compiler/glsl/glsl_symbol_table.h
b/src/compiler/glsl/glsl_symbol_table.h
index 2f94d4c..087cc71 100644
--- a/src/compiler/glsl/glsl_symbol_table.h
+++ b/src/compiler/glsl/glsl_symbol_table.h
@@ -103,13 +103,14 @@ struct glsl_symbol_table {
/**
* Replaces the variable in the entry by the new variable.
*/
void replace_variable(const char *name, ir_variable *v);
private:
symbol_table_entry *get_entry(const char *name);
struct _mesa_symbol_table *table;
void *mem_ctx;
+ void *linalloc;
};
#endif /* GLSL_SYMBOL_TABLE */
--
2.7.4
_______________________________________________
mesa-dev mailing list
mesa-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/mesa-dev
