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

nir: Use an integer index for specifying structure fields

Browse Source 
Previously, we used a string name.  It was nice for translating out of GLSL
IR (which also does that) but cumbersome the rest of the time.

Reviewed-by: Connor Abbott <cwabbott0@gmail.com>
This commit is contained in:
Jason Ekstrand
2014-11-25 21:36:25 -08:00
parent 4f8230e247
commit 829aa98320
9 changed files with 74 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/glsl/nir/glsl_to_nir.cpp
View File

@@ -1753,7 +1753,10 @@ nir_visitor::visit(ir_dereference_record *ir)
{
ir->record->accept(this);
nir_deref_struct *deref = nir_deref_struct_create(this->shader, ir->field);
int field_index = this->deref_tail->type->field_index(ir->field);
assert(field_index >= 0);
nir_deref_struct *deref = nir_deref_struct_create(this->shader, field_index);
deref->deref.type = ir->type;
this->deref_tail->child = &deref->deref;
this->deref_tail = &deref->deref;

6
src/glsl/nir/nir.c
View File

@@ -529,12 +529,12 @@ nir_deref_array_create(void *mem_ctx)
}
nir_deref_struct *
nir_deref_struct_create(void *mem_ctx, const char *field)
nir_deref_struct_create(void *mem_ctx, unsigned field_index)
{
nir_deref_struct *deref = ralloc(mem_ctx, nir_deref_struct);
deref->deref.deref_type = nir_deref_type_struct;
deref->deref.child = NULL;
deref->elem = ralloc_strdup(deref, field);
deref->index = field_index;
return deref;
}
@@ -566,7 +566,7 @@ copy_deref_array(void *mem_ctx, nir_deref_array *deref)
static nir_deref_struct *
copy_deref_struct(void *mem_ctx, nir_deref_struct *deref)
{
nir_deref_struct *ret = nir_deref_struct_create(mem_ctx, deref->elem);
nir_deref_struct *ret = nir_deref_struct_create(mem_ctx, deref->index);
ret->deref.type = deref->deref.type;
if (deref->deref.child)
ret->deref.child = nir_copy_deref(mem_ctx, deref->deref.child);

4
src/glsl/nir/nir.h
View File

@@ -650,7 +650,7 @@ typedef struct {
typedef struct {
nir_deref deref;
const char *elem;
unsigned index;
} nir_deref_struct;
#define nir_deref_as_var(_deref) exec_node_data(nir_deref_var, _deref, deref)
@@ -1292,7 +1292,7 @@ nir_ssa_undef_instr *nir_ssa_undef_instr_create(void *mem_ctx);
nir_deref_var *nir_deref_var_create(void *mem_ctx, nir_variable *var);
nir_deref_array *nir_deref_array_create(void *mem_ctx);
nir_deref_struct *nir_deref_struct_create(void *mem_ctx, const char *field);
nir_deref_struct *nir_deref_struct_create(void *mem_ctx, unsigned field_index);
nir_deref *nir_copy_deref(void *mem_ctx, nir_deref *deref);

17
src/glsl/nir/nir_lower_samplers.cpp
View File

@@ -47,10 +47,9 @@ get_deref_name_offset(nir_deref_var *deref_var,
*name = ralloc_strdup(mem_ctx, deref_var->var->name);
while (deref->child != NULL) {
deref = deref->child;
switch (deref->deref_type) {
switch (deref->child->deref_type) {
case nir_deref_type_array:
deref_array = nir_deref_as_array(deref);
deref_array = nir_deref_as_array(deref->child);
if (deref_array->deref_array_type == nir_deref_array_type_indirect) {
/* GLSL 1.10 and 1.20 allowed variable sampler array indices,
* while GLSL 1.30 requires that the array indices be
@@ -64,21 +63,25 @@ get_deref_name_offset(nir_deref_var *deref_var,
"This feature of the language was removed in GLSL 1.20 "
"and is unlikely to be supported for 1.10 in Mesa.\n");
}
if (deref->child == NULL) {
if (deref_array->deref.child == NULL) {
return deref_array->base_offset;
}
ralloc_asprintf_append(name, "[%u]", deref_array->base_offset);
break;
case nir_deref_type_struct:
deref_struct = nir_deref_as_struct(deref);
ralloc_asprintf_append(name, ".%s", deref_struct->elem);
case nir_deref_type_struct: {
deref_struct = nir_deref_as_struct(deref->child);
const char *field = glsl_get_struct_elem_name(deref->type,
deref_struct->index);
ralloc_asprintf_append(name, ".%s", field);
break;
}
default:
assert(0);
break;
}
deref = deref->child;
}
return 0;

20
src/glsl/nir/nir_lower_variables_scalar.c
View File

@@ -51,7 +51,7 @@ type_size(const struct glsl_type *type)
case GLSL_TYPE_STRUCT:
size = 0;
for (i = 0; i < glsl_get_length(type); i++) {
size += type_size(glsl_get_struct_elem_type(type, i));
size += type_size(glsl_get_struct_field(type, i));
}
return size;
case GLSL_TYPE_SAMPLER:
@@ -267,12 +267,8 @@ get_deref_offset(nir_deref_var *deref_var, nir_instr *instr,
} else {
nir_deref_struct *deref_struct = nir_deref_as_struct(deref);
unsigned i = 0;
while(strcmp(glsl_get_struct_elem_name(parent_type, i),
deref_struct->elem) != 0) {
base_offset += type_size(glsl_get_struct_elem_type(parent_type, i));
i++;
}
for (unsigned i = 0; i < deref_struct->index; i++)
base_offset += type_size(glsl_get_struct_field(parent_type, i));
}
}
@@ -411,7 +407,7 @@ reg_const_load(nir_reg_dest reg, nir_constant *constant,
case GLSL_TYPE_STRUCT:
for (unsigned i = 0; i < glsl_get_length(type); i++) {
const struct glsl_type *field = glsl_get_struct_elem_type(type, i);
const struct glsl_type *field = glsl_get_struct_field(type, i);
nir_reg_dest new_reg = reg;
new_reg.base_offset += offset;
reg_const_load(new_reg, constant->elements[i], field, impl,
@@ -528,14 +524,10 @@ var_reg_block_copy_impl(nir_reg_src reg, nir_deref_var *deref_head,
case GLSL_TYPE_STRUCT:
offset = 0;
for (unsigned i = 0; i < glsl_get_length(type); i++) {
const struct glsl_type *field_type =
glsl_get_struct_elem_type(type, i);
const char *field_name = glsl_get_struct_elem_name(type, i);
const struct glsl_type *field_type = glsl_get_struct_field(type, i);
nir_deref_struct *deref_struct =
nir_deref_struct_create(mem_ctx, field_name);
nir_deref_struct *deref_struct = nir_deref_struct_create(mem_ctx, i);
deref_struct->deref.type = field_type;
deref_struct->elem = field_name;
nir_deref_var *new_deref_head =
nir_deref_as_var(nir_copy_deref(mem_ctx, &deref_head->deref));

35
src/glsl/nir/nir_print.c
View File

@@ -282,33 +282,42 @@ print_deref_array(nir_deref_array *deref, print_var_state *state, FILE *fp)
}
static void
print_deref_struct(nir_deref_struct *deref, print_var_state *state, FILE *fp)
print_deref_struct(nir_deref_struct *deref, const struct glsl_type *parent_type,
print_var_state *state, FILE *fp)
{
fprintf(fp, ".%s", deref->elem);
fprintf(fp, ".%s", glsl_get_struct_elem_name(parent_type, deref->index));
}
static void
print_deref(nir_deref *deref, print_var_state *state, FILE *fp)
print_deref(nir_deref_var *deref, print_var_state *state, FILE *fp)
{
while (deref != NULL) {
switch (deref->deref_type) {
nir_deref *tail = &deref->deref;
nir_deref *pretail = NULL;
while (tail != NULL) {
switch (tail->deref_type) {
case nir_deref_type_var:
print_deref_var(nir_deref_as_var(deref), state, fp);
assert(pretail == NULL);
assert(tail == &deref->deref);
print_deref_var(deref, state, fp);
break;
case nir_deref_type_array:
print_deref_array(nir_deref_as_array(deref), state, fp);
assert(pretail != NULL);
print_deref_array(nir_deref_as_array(tail), state, fp);
break;
case nir_deref_type_struct:
print_deref_struct(nir_deref_as_struct(deref), state, fp);
assert(pretail != NULL);
print_deref_struct(nir_deref_as_struct(tail),
pretail->type, state, fp);
break;
default:
unreachable("Invalid deref type");
}
deref = deref->child;
pretail = tail;
tail = pretail->child;
}
}
@@ -350,7 +359,7 @@ print_intrinsic_instr(nir_intrinsic_instr *instr, print_var_state *state,
if (!first)
fprintf(fp, ", ");
print_deref(&instr->variables[i]->deref, state, fp);
print_deref(instr->variables[i], state, fp);
first = false;
}
@@ -485,7 +494,7 @@ print_tex_instr(nir_tex_instr *instr, print_var_state *state, FILE *fp)
}
if (instr->sampler) {
print_deref(&instr->sampler->deref, state, fp);
print_deref(instr->sampler, state, fp);
} else {
fprintf(fp, "%u", instr->sampler_index);
}
@@ -508,14 +517,14 @@ print_call_instr(nir_call_instr *instr, print_var_state *state, FILE *fp)
if (i != 0)
fprintf(fp, ", ");
print_deref(&instr->params[i]->deref, state, fp);
print_deref(instr->params[i], state, fp);
}
if (instr->return_deref != NULL) {
if (instr->num_params != 0)
fprintf(fp, ", ");
fprintf(fp, "returning ");
print_deref(&instr->return_deref->deref, state, fp);
print_deref(instr->return_deref, state, fp);
}
}

16
src/glsl/nir/nir_types.cpp
View File

@@ -65,15 +65,9 @@ glsl_get_array_element(const glsl_type* type)
}
const glsl_type *
glsl_get_struct_field(const glsl_type *type, const char *field)
glsl_get_struct_field(const glsl_type *type, unsigned index)
{
for (unsigned i = 0; i < type->length; i++) {
if (strcmp(type->fields.structure[i].name, field) == 0) {
return type->fields.structure[i].type;
}
}
return NULL;
return type->fields.structure[index].type;
}
const struct glsl_type *
@@ -112,12 +106,6 @@ glsl_get_length(const struct glsl_type *type)
return type->length;
}
const struct glsl_type *
glsl_get_struct_elem_type(const struct glsl_type *type, unsigned index)
{
return type->fields.structure[index].type;
}
const char *
glsl_get_struct_elem_name(const struct glsl_type *type, unsigned index)
{

5
src/glsl/nir/nir_types.h
View File

@@ -43,7 +43,7 @@ void glsl_print_type(const struct glsl_type *type, FILE *fp);
void glsl_print_struct(const struct glsl_type *type, FILE *fp);
const struct glsl_type *glsl_get_struct_field(const struct glsl_type *type,
const char *field);
unsigned index);
const struct glsl_type *glsl_get_array_element(const struct glsl_type *type);
@@ -59,9 +59,6 @@ unsigned glsl_get_matrix_columns(const struct glsl_type *type);
unsigned glsl_get_length(const struct glsl_type *type);
const struct glsl_type *glsl_get_struct_elem_type(const struct glsl_type *type,
unsigned index);
const char *glsl_get_struct_elem_name(const struct glsl_type *type,
unsigned index);

2
src/glsl/nir/nir_validate.c
View File

@@ -275,7 +275,7 @@ validate_deref_chain(nir_deref *deref, validate_state *state)
case nir_deref_type_struct:
assert(deref->type ==
glsl_get_struct_field(parent->type,
nir_deref_as_struct(deref)->elem));
nir_deref_as_struct(deref)->index));
break;
case nir_deref_type_var: