Lines Matching refs:this
6 * copy of this software and associated documentation files (the "Software"),
12 * The above copyright notice and this permission notice (including the next
50 * Each concrete class derived from \c ir_instruction has a value in this
59 * types, this allows writing very straightforward, readable code.
150 assume(this != NULL); \
151 return is_##TYPE() ? (ir_##TYPE *) this : NULL; \
155 assume(this != NULL); \
156 return is_##TYPE() ? (ir_##TYPE *) this : NULL; \
167 assume(this != NULL); \
168 return ir_type == ir_type_##TYPE ? (ir_##TYPE *) this : NULL; \
172 assume(this != NULL); \
173 return ir_type == ir_type_##TYPE ? (const ir_##TYPE *) this : NULL; \
195 * return the same value as this one.
229 v->visit(this);
270 * The base implementation of this function always returns \c false. The
271 * \c ir_constant class over-rides this function to return \c true \b only
282 * The base implementation of this function always returns \c false. The
283 * \c ir_constant class over-rides this function to return \c true \b only
294 * The base implementation of this function always returns \c false. The
295 * \c ir_constant class over-rides this function to return \c true \b only
348 * Normal declaration (for most variables, this means an explicit
430 v->visit(this);
442 return (this->data.mode == ir_var_uniform ||
443 this->data.mode == ir_var_shader_storage) &&
444 this->interface_type != NULL;
452 return this->data.mode == ir_var_shader_storage &&
453 this->interface_type != NULL;
477 return this->type->without_array() == this->interface_type;
481 * Return whether this variable contains a bindless sampler/image.
485 if (!this->type->contains_sampler() && !this->type->contains_image())
488 return this->data.bindless || this->data.mode != ir_var_uniform;
492 * Set this->interface_type on a newly created variable.
496 assert(this->interface_type == NULL);
497 this->interface_type = type;
498 if (this->is_interface_instance()) {
499 this->u.max_ifc_array_access =
500 ralloc_array(this, int, type->length);
502 this->u.max_ifc_array_access[i] = -1;
508 * Change this->interface_type on a variable that previously had a
514 if (this->u.max_ifc_array_access != NULL) {
518 assert(this->interface_type->length == type->length);
520 this->interface_type = type;
524 * Change this->interface_type on a variable that previously had a
531 if (this->u.max_ifc_array_access != NULL) {
538 for (unsigned i = 0; i < this->interface_type->length; i++)
539 assert(this->u.max_ifc_array_access[i] == -1);
541 ralloc_free(this->u.max_ifc_array_access);
542 this->u.max_ifc_array_access = NULL;
544 this->interface_type = NULL;
550 return this->interface_type;
555 return this->interface_type->get_interface_packing();
565 assert(this->data._num_state_slots == 0);
566 return this->u.max_ifc_array_access;
571 assert(!this->is_interface_instance()
572 || this->data._num_state_slots == 0);
573 return this->data._num_state_slots;
578 assert(!this->is_interface_instance()
580 this->data._num_state_slots = n;
585 return this->is_interface_instance() ? NULL : this->u.state_slots;
590 return this->is_interface_instance() ? NULL : this->u.state_slots;
595 assert(!this->is_interface_instance());
597 this->u.state_slots = ralloc_array(this, ir_state_slot, n);
598 this->data._num_state_slots = 0;
600 if (this->u.state_slots != NULL)
601 this->data._num_state_slots = n;
603 return this->u.state_slots;
608 return this->data.interpolation == INTERP_MODE_FLAT ||
609 this->type->contains_integer() ||
610 this->type->contains_double();
615 return this->name != ir_variable::tmp_name &&
616 this->name != this->name_storage;
620 * Enable emitting extension warnings for this variable
625 * Get the extension warning string for this variable
680 * Has this variable been used for reading or writing?
692 * Has this variable been statically assigned?
754 * Does this variable have an initializer?
767 * Is this variable a generic output or input that has not yet been matched
776 * Is this varying used by transform feedback?
783 * Is this varying used only by transform feedback?
805 * If non-zero, then this variable may be packed along with other variables
806 * into a single varying slot, so this offset should be applied when
808 * component of this variable is actually stored in component y of the
819 * Non-zero if this variable was created by lowering a named interface
845 * To make things easy, we make it so that this field is always
848 * for this field will never break a desktop shader compile.
855 * This is not equal to \c ir_depth_layout_none if and only if this
877 * Whether this is a fragment shader output implicitly initialized with
879 * framebuffer location corresponding to this shader invocation.
884 * Non-zero if this variable is considered bindless as defined by
890 * Non-zero if this variable is considered bound as defined by
902 * Emit a warning if this variable is accessed.
929 * For array types, this represents the binding point for the first element.
934 * Storage location of the base of this variable
936 * The precise meaning of this field depends on the nature of the variable.
958 * but this causes problems with indirect samplers and AoA.
1020 * this points to an array of integers such that if the ith member of
1026 * For variables whose type is not an interface block, this pointer is
1032 * Built-in state that backs this uniform
1044 * interface block, this is the \c GLSL_TYPE_INTERFACE type for that block.
1059 * When this global is false, names passed to the constructor for
1198 v->visit(this);
1204 * Attempt to evaluate this function as a constant expression,
1213 * Get the name of the function for which this is a signature
1218 * Get a handle to the function for which this is a signature
1220 * There is no setter function, this function returns a \c const pointer,
1231 return this->_function;
1235 * Check whether the qualifiers match between this signature's parameters
1263 /** Whether or not this function has a body (which may be empty). */
1273 /** Whether or not this function signature is a built-in. */
1277 * Whether or not this function is an intrinsic to be implemented
1285 /** Identifier for this intrinsic. */
1288 /** Whether or not a built-in is available for this shader. */
1301 /** Function of which this signature is one overload. */
1304 /** Function signature of which this one is a prototype clone */
1340 v->visit(this);
1347 sig->_function = this;
1348 this->signatures.push_tail(sig);
1380 /** Whether or not this function has a signature that isn't a built-in. */
1384 * List of ir_function_signature for each overloaded function with this name.
1389 * is this function a subroutine type declaration
1395 * is this function associated to a subroutine type
1408 return this->_function->name;
1427 v->visit(this);
1451 v->visit(this);
1482 v->visit(this);
1528 * For non-vector types in the LHS, this field will be zero. For vector
1581 * If the expression cannot be constant folded, this method will return
1614 v->visit(this);
1627 num_operands = this->type->vector_elements;
1651 actual_parameters->move_nodes_to(& this->actual_parameters);
1661 actual_parameters->move_nodes_to(& this->actual_parameters);
1671 v->visit(this);
1701 /* List of ir_rvalue of paramaters passed in this call. */
1749 v->visit(this);
1776 this->mode = mode;
1783 v->visit(this);
1810 this->condition = NULL;
1816 this->condition = cond;
1823 v->visit(this);
1848 v->visit(this);
1916 v->visit(this);
1948 * If there is no projective divide (the common case), this will be
1949 * \c NULL. Optimization passes should check for this to point to a constant
1957 * If there is no shadow comparison, this will be \c NULL. For the
1958 * \c ir_txf opcode, this *must* be \c NULL.
2019 v->visit(this);
2093 return this->var;
2098 return this->var->data.precision;
2104 * variable. However, if this dereference is dereferenced by anything
2109 return this->var;
2114 v->visit(this);
2146 return this->array->variable_referenced();
2151 ir_dereference *deref = this->array->as_dereference();
2161 v->visit(this);
2191 return this->record->variable_referenced();
2203 v->visit(this);
2273 v->visit(this);
2323 * Note that this function only handles what assign can handle,
2339 * Return true if this ir_constant represents the given value.
2341 * For vectors, this checks that each component is the given value.
2351 * Note that this will return true even for signed integer ir_constants, as
2389 v->visit(this);
2394 return new(mem_ctx) ir_emit_vertex(this->stream->clone(mem_ctx, ht));
2422 v->visit(this);
2427 return new(mem_ctx) ir_end_primitive(this->stream->clone(mem_ctx, ht));
2452 v->visit(this);