Subversion Repositories Kolibri OS

/* -*- c++ -*- */

/*

 * Copyright © 2010 Intel Corporation

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice (including the next

 * paragraph) shall be included in all copies or substantial portions of the

 * Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

 * DEALINGS IN THE SOFTWARE.

 */

#pragma once

#ifndef IR_H

#define IR_H

#include 

#include 

#include "ralloc.h"

#include "glsl_types.h"

#include "list.h"

#include "ir_visitor.h"

#include "ir_hierarchical_visitor.h"

#include "main/mtypes.h"

#ifdef __cplusplus

/**

 * \defgroup IR Intermediate representation nodes

 *

 * @{

 */

/**

 * Class tags

 *

 * Each concrete class derived from \c ir_instruction has a value in this

 * enumerant.  The value for the type is stored in \c ir_instruction::ir_type

 * by the constructor.  While using type tags is not very C++, it is extremely

 * convenient.  For example, during debugging you can simply inspect

 * \c ir_instruction::ir_type to find out the actual type of the object.

 *

 * In addition, it is possible to use a switch-statement based on \c

 * \c ir_instruction::ir_type to select different behavior for different object

 * types.  For functions that have only slight differences for several object

 * types, this allows writing very straightforward, readable code.

 */

enum ir_node_type {

   /**

    * Zero is unused so that the IR validator can detect cases where

    * \c ir_instruction::ir_type has not been initialized.

    */

   ir_type_unset,

   ir_type_variable,

   ir_type_assignment,

   ir_type_call,

   ir_type_constant,

   ir_type_dereference_array,

   ir_type_dereference_record,

   ir_type_dereference_variable,

   ir_type_discard,

   ir_type_expression,

   ir_type_function,

   ir_type_function_signature,

   ir_type_if,

   ir_type_loop,

   ir_type_loop_jump,

   ir_type_return,

   ir_type_swizzle,

   ir_type_texture,

   ir_type_max /**< maximum ir_type enum number, for validation */

};

/**

 * Base class of all IR instructions

 */

class ir_instruction : public exec_node {

public:

   enum ir_node_type ir_type;

   /**

    * GCC 4.7+ and clang warn when deleting an ir_instruction unless

    * there's a virtual destructor present.  Because we almost

    * universally use ralloc for our memory management of

    * ir_instructions, the destructor doesn't need to do any work.

    */

   virtual ~ir_instruction()

   {

   }

   /** ir_print_visitor helper for debugging. */

   void print(void) const;

   virtual void accept(ir_visitor *) = 0;

   virtual ir_visitor_status accept(ir_hierarchical_visitor *) = 0;

   virtual ir_instruction *clone(void *mem_ctx,

				 struct hash_table *ht) const = 0;

   /**

    * \name IR instruction downcast functions

    *

    * These functions either cast the object to a derived class or return

    * \c NULL if the object's type does not match the specified derived class.

    * Additional downcast functions will be added as needed.

    */

   /*@{*/

   virtual class ir_variable *          as_variable()         { return NULL; }

   virtual class ir_function *          as_function()         { return NULL; }

   virtual class ir_dereference *       as_dereference()      { return NULL; }

   virtual class ir_dereference_array *	as_dereference_array() { return NULL; }

   virtual class ir_dereference_variable *as_dereference_variable() { return NULL; }

   virtual class ir_dereference_record *as_dereference_record() { return NULL; }

   virtual class ir_expression *        as_expression()       { return NULL; }

   virtual class ir_rvalue *            as_rvalue()           { return NULL; }

   virtual class ir_loop *              as_loop()             { return NULL; }

   virtual class ir_assignment *        as_assignment()       { return NULL; }

   virtual class ir_call *              as_call()             { return NULL; }

   virtual class ir_return *            as_return()           { return NULL; }

   virtual class ir_if *                as_if()               { return NULL; }

   virtual class ir_swizzle *           as_swizzle()          { return NULL; }

   virtual class ir_constant *          as_constant()         { return NULL; }

   virtual class ir_discard *           as_discard()          { return NULL; }

   virtual class ir_jump *              as_jump()             { return NULL; }

   /*@}*/

protected:

   ir_instruction()

   {

      ir_type = ir_type_unset;

   }

};

/**

 * The base class for all "values"/expression trees.

 */

class ir_rvalue : public ir_instruction {

public:

   const struct glsl_type *type;

   virtual ir_rvalue *clone(void *mem_ctx, struct hash_table *) const;

   virtual void accept(ir_visitor *v)

   {

      v->visit(this);

   }

   virtual ir_visitor_status accept(ir_hierarchical_visitor *);

   virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);

   virtual ir_rvalue * as_rvalue()

   {

      return this;

   }

   ir_rvalue *as_rvalue_to_saturate();

   virtual bool is_lvalue() const

   {

      return false;

   }

   /**

    * Get the variable that is ultimately referenced by an r-value

    */

   virtual ir_variable *variable_referenced() const

   {

      return NULL;

   }

   /**

    * If an r-value is a reference to a whole variable, get that variable

    *

    * \return

    * Pointer to a variable that is completely dereferenced by the r-value.  If

    * the r-value is not a dereference or the dereference does not access the

    * entire variable (i.e., it's just one array element, struct field), \c NULL

    * is returned.

    */

   virtual ir_variable *whole_variable_referenced()

   {

      return NULL;

   }

   /**

    * Determine if an r-value has the value zero

    *

    * The base implementation of this function always returns \c false.  The

    * \c ir_constant class over-rides this function to return \c true \b only

    * for vector and scalar types that have all elements set to the value

    * zero (or \c false for booleans).

    *

    * \sa ir_constant::has_value, ir_rvalue::is_one, ir_rvalue::is_negative_one,

    *     ir_constant::is_basis

    */

   virtual bool is_zero() const;

   /**

    * Determine if an r-value has the value one

    *

    * The base implementation of this function always returns \c false.  The

    * \c ir_constant class over-rides this function to return \c true \b only

    * for vector and scalar types that have all elements set to the value

    * one (or \c true for booleans).

    *

    * \sa ir_constant::has_value, ir_rvalue::is_zero, ir_rvalue::is_negative_one,

    *     ir_constant::is_basis

    */

   virtual bool is_one() const;

   /**

    * Determine if an r-value has the value negative one

    *

    * The base implementation of this function always returns \c false.  The

    * \c ir_constant class over-rides this function to return \c true \b only

    * for vector and scalar types that have all elements set to the value

    * negative one.  For boolean types, the result is always \c false.

    *

    * \sa ir_constant::has_value, ir_rvalue::is_zero, ir_rvalue::is_one

    *     ir_constant::is_basis

    */

   virtual bool is_negative_one() const;

   /**

    * Determine if an r-value is a basis vector

    *

    * The base implementation of this function always returns \c false.  The

    * \c ir_constant class over-rides this function to return \c true \b only

    * for vector and scalar types that have one element set to the value one,

    * and the other elements set to the value zero.  For boolean types, the

    * result is always \c false.

    *

    * \sa ir_constant::has_value, ir_rvalue::is_zero, ir_rvalue::is_one,

    *     is_constant::is_negative_one

    */

   virtual bool is_basis() const;

   /**

    * Return a generic value of error_type.

    *

    * Allocation will be performed with 'mem_ctx' as ralloc owner.

    */

   static ir_rvalue *error_value(void *mem_ctx);

protected:

   ir_rvalue();

};

/**

 * Variable storage classes

 */

enum ir_variable_mode {

   ir_var_auto = 0,     /**< Function local variables and globals. */

   ir_var_uniform,      /**< Variable declared as a uniform. */

   ir_var_shader_in,

   ir_var_shader_out,

   ir_var_function_in,

   ir_var_function_out,

   ir_var_function_inout,

   ir_var_const_in,	/**< "in" param that must be a constant expression */

   ir_var_system_value, /**< Ex: front-face, instance-id, etc. */

   ir_var_temporary,	/**< Temporary variable generated during compilation. */

   ir_var_mode_count	/**< Number of variable modes */

};

/**

 * \brief Layout qualifiers for gl_FragDepth.

 *

 * The AMD/ARB_conservative_depth extensions allow gl_FragDepth to be redeclared

 * with a layout qualifier.

 */

enum ir_depth_layout {

    ir_depth_layout_none, /**< No depth layout is specified. */

    ir_depth_layout_any,

    ir_depth_layout_greater,

    ir_depth_layout_less,

    ir_depth_layout_unchanged

};

/**

 * \brief Convert depth layout qualifier to string.

 */

const char*

depth_layout_string(ir_depth_layout layout);

/**

 * Description of built-in state associated with a uniform

 *

 * \sa ir_variable::state_slots

 */

struct ir_state_slot {

   int tokens[5];

   int swizzle;

};

class ir_variable : public ir_instruction {

public:

   ir_variable(const struct glsl_type *, const char *, ir_variable_mode);

   virtual ir_variable *clone(void *mem_ctx, struct hash_table *ht) const;

   virtual ir_variable *as_variable()

   {

      return this;

   }

   virtual void accept(ir_visitor *v)

   {

      v->visit(this);

   }

   virtual ir_visitor_status accept(ir_hierarchical_visitor *);

   /**

    * Get the string value for the interpolation qualifier

    *

    * \return The string that would be used in a shader to specify \c

    * mode will be returned.

    *

    * This function is used to generate error messages of the form "shader

    * uses %s interpolation qualifier", so in the case where there is no

    * interpolation qualifier, it returns "no".

    *

    * This function should only be used on a shader input or output variable.

    */

   const char *interpolation_string() const;

   /**

    * Determine how this variable should be interpolated based on its

    * interpolation qualifier (if present), whether it is gl_Color or

    * gl_SecondaryColor, and whether flatshading is enabled in the current GL

    * state.

    *

    * The return value will always be either INTERP_QUALIFIER_SMOOTH,

    * INTERP_QUALIFIER_NOPERSPECTIVE, or INTERP_QUALIFIER_FLAT.

    */

   glsl_interp_qualifier determine_interpolation_mode(bool flat_shade);

   /**

    * Determine whether or not a variable is part of a uniform block.

    */

   inline bool is_in_uniform_block() const

   {

      return this->mode == ir_var_uniform && this->interface_type != NULL;

   }

   /**

    * Determine whether or not a variable is the declaration of an interface

    * block

    *

    * For the first declaration below, there will be an \c ir_variable named

    * "instance" whose type and whose instance_type will be the same

    *  \cglsl_type.  For the second declaration, there will be an \c ir_variable

    * named "f" whose type is float and whose instance_type is B2.

    *

    * "instance" is an interface instance variable, but "f" is not.

    *

    * uniform B1 {

    *     float f;

    * } instance;

    *

    * uniform B2 {

    *     float f;

    * };

    */

   inline bool is_interface_instance() const

   {

      const glsl_type *const t = this->type;

      return (t == this->interface_type)

         || (t->is_array() && t->fields.array == this->interface_type);

    }

   /**

    * Declared type of the variable

    */

   const struct glsl_type *type;

   /**

    * Declared name of the variable

    */

   const char *name;

   /**

    * Highest element accessed with a constant expression array index

    *

    * Not used for non-array variables.

    */

   unsigned max_array_access;

   /**

    * Is the variable read-only?

    *

    * This is set for variables declared as \c const, shader inputs,

    * and uniforms.

    */

   unsigned read_only:1;

   unsigned centroid:1;

   unsigned invariant:1;

   /**

    * Has this variable been used for reading or writing?

    *

    * Several GLSL semantic checks require knowledge of whether or not a

    * variable has been used.  For example, it is an error to redeclare a

    * variable as invariant after it has been used.

    *

    * This is only maintained in the ast_to_hir.cpp path, not in

    * Mesa's fixed function or ARB program paths.

    */

   unsigned used:1;

   /**

    * Has this variable been statically assigned?

    *

    * This answers whether the variable was assigned in any path of

    * the shader during ast_to_hir.  This doesn't answer whether it is

    * still written after dead code removal, nor is it maintained in

    * non-ast_to_hir.cpp (GLSL parsing) paths.

    */

   unsigned assigned:1;

   /**

    * Storage class of the variable.

    *

    * \sa ir_variable_mode

    */

   unsigned mode:4;

   /**

    * Interpolation mode for shader inputs / outputs

    *

    * \sa ir_variable_interpolation

    */

   unsigned interpolation:2;

   /**

    * \name ARB_fragment_coord_conventions

    * @{

    */

   unsigned origin_upper_left:1;

   unsigned pixel_center_integer:1;

   /*@}*/

   /**

    * Was the location explicitly set in the shader?

    *

    * If the location is explicitly set in the shader, it \b cannot be changed

    * by the linker or by the API (e.g., calls to \c glBindAttribLocation have

    * no effect).

    */

   unsigned explicit_location:1;

   unsigned explicit_index:1;

   /**

    * Was an initial binding explicitly set in the shader?

    *

    * If so, constant_value contains an integer ir_constant representing the

    * initial binding point.

    */

   unsigned explicit_binding:1;

   /**

    * Does this variable have an initializer?

    *

    * This is used by the linker to cross-validiate initializers of global

    * variables.

    */

   unsigned has_initializer:1;

   /**

    * Is this variable a generic output or input that has not yet been matched

    * up to a variable in another stage of the pipeline?

    *

    * This is used by the linker as scratch storage while assigning locations

    * to generic inputs and outputs.

    */

   unsigned is_unmatched_generic_inout:1;

   /**

    * If non-zero, then this variable may be packed along with other variables

    * into a single varying slot, so this offset should be applied when

    * accessing components.  For example, an offset of 1 means that the x

    * component of this variable is actually stored in component y of the

    * location specified by \c location.

    */

   unsigned location_frac:2;

   /**

    * \brief Layout qualifier for gl_FragDepth.

    *

    * This is not equal to \c ir_depth_layout_none if and only if this

    * variable is \c gl_FragDepth and a layout qualifier is specified.

    */

   ir_depth_layout depth_layout;

   /**

    * Storage location of the base of this variable

    *

    * The precise meaning of this field depends on the nature of the variable.

    *

    *   - Vertex shader input: one of the values from \c gl_vert_attrib.

    *   - Vertex shader output: one of the values from \c gl_varying_slot.

    *   - Fragment shader input: one of the values from \c gl_varying_slot.

    *   - Fragment shader output: one of the values from \c gl_frag_result.

    *   - Uniforms: Per-stage uniform slot number for default uniform block.

    *   - Uniforms: Index within the uniform block definition for UBO members.

    *   - Other: This field is not currently used.

    *

    * If the variable is a uniform, shader input, or shader output, and the

    * slot has not been assigned, the value will be -1.

    */

   int location;

   /**

    * output index for dual source blending.

    */

   int index;

   /**

    * Initial binding point for a sampler or UBO.

    *

    * For array types, this represents the binding point for the first element.

    */

   int binding;

   /**

    * Built-in state that backs this uniform

    *

    * Once set at variable creation, \c state_slots must remain invariant.

    * This is because, ideally, this array would be shared by all clones of

    * this variable in the IR tree.  In other words, we'd really like for it

    * to be a fly-weight.

    *

    * If the variable is not a uniform, \c num_state_slots will be zero and

    * \c state_slots will be \c NULL.

    */

   /*@{*/

   unsigned num_state_slots;    /**< Number of state slots used */

   ir_state_slot *state_slots;  /**< State descriptors. */

   /*@}*/

   /**

    * Emit a warning if this variable is accessed.

    */

   const char *warn_extension;

   /**

    * Value assigned in the initializer of a variable declared "const"

    */

   ir_constant *constant_value;

   /**

    * Constant expression assigned in the initializer of the variable

    *

    * \warning

    * This field and \c ::constant_value are distinct.  Even if the two fields

    * refer to constants with the same value, they must point to separate

    * objects.

    */

   ir_constant *constant_initializer;

   /**

    * For variables that are in an interface block or are an instance of an

    * interface block, this is the \c GLSL_TYPE_INTERFACE type for that block.

    *

    * \sa ir_variable::location

    */

   const glsl_type *interface_type;

};

/*@{*/

/**

 * The representation of a function instance; may be the full definition or

 * simply a prototype.

 */

class ir_function_signature : public ir_instruction {

   /* An ir_function_signature will be part of the list of signatures in

    * an ir_function.

    */

public:

   ir_function_signature(const glsl_type *return_type);

   virtual ir_function_signature *clone(void *mem_ctx,

					struct hash_table *ht) const;

   ir_function_signature *clone_prototype(void *mem_ctx,

					  struct hash_table *ht) const;

   virtual void accept(ir_visitor *v)

   {

      v->visit(this);

   }

   virtual ir_visitor_status accept(ir_hierarchical_visitor *);

   /**

    * Attempt to evaluate this function as a constant expression,

    * given a list of the actual parameters and the variable context.

    * Returns NULL for non-built-ins.

    */

   ir_constant *constant_expression_value(exec_list *actual_parameters, struct hash_table *variable_context);

   /**

    * Get the name of the function for which this is a signature

    */

   const char *function_name() const;

   /**

    * Get a handle to the function for which this is a signature

    *

    * There is no setter function, this function returns a \c const pointer,

    * and \c ir_function_signature::_function is private for a reason.  The

    * only way to make a connection between a function and function signature

    * is via \c ir_function::add_signature.  This helps ensure that certain

    * invariants (i.e., a function signature is in the list of signatures for

    * its \c _function) are met.

    *

    * \sa ir_function::add_signature

    */

   inline const class ir_function *function() const

   {

      return this->_function;

   }

   /**

    * Check whether the qualifiers match between this signature's parameters

    * and the supplied parameter list.  If not, returns the name of the first

    * parameter with mismatched qualifiers (for use in error messages).

    */

   const char *qualifiers_match(exec_list *params);

   /**

    * Replace the current parameter list with the given one.  This is useful

    * if the current information came from a prototype, and either has invalid

    * or missing parameter names.

    */

   void replace_parameters(exec_list *new_params);

   /**

    * Function return type.

    *

    * \note This discards the optional precision qualifier.

    */

   const struct glsl_type *return_type;

   /**

    * List of ir_variable of function parameters.

    *

    * This represents the storage.  The paramaters passed in a particular

    * call will be in ir_call::actual_paramaters.

    */

   struct exec_list parameters;

   /** Whether or not this function has a body (which may be empty). */

   unsigned is_defined:1;

   /** Whether or not this function signature is a built-in. */

   unsigned is_builtin:1;

   /** Body of instructions in the function. */

   struct exec_list body;

private:

   /** Function of which this signature is one overload. */

   class ir_function *_function;

   /** Function signature of which this one is a prototype clone */

   const ir_function_signature *origin;

   friend class ir_function;

   /**

    * Helper function to run a list of instructions for constant

    * expression evaluation.

    *

    * The hash table represents the values of the visible variables.

    * There are no scoping issues because the table is indexed on

    * ir_variable pointers, not variable names.

    *

    * Returns false if the expression is not constant, true otherwise,

    * and the value in *result if result is non-NULL.

    */

   bool constant_expression_evaluate_expression_list(const struct exec_list &body,

						     struct hash_table *variable_context,

						     ir_constant **result);

};

/**

 * Header for tracking multiple overloaded functions with the same name.

 * Contains a list of ir_function_signatures representing each of the

 * actual functions.

 */

class ir_function : public ir_instruction {

public:

   ir_function(const char *name);

   virtual ir_function *clone(void *mem_ctx, struct hash_table *ht) const;

   virtual ir_function *as_function()

   {

      return this;

   }

   virtual void accept(ir_visitor *v)

   {

      v->visit(this);

   }

   virtual ir_visitor_status accept(ir_hierarchical_visitor *);

   void add_signature(ir_function_signature *sig)

   {

      sig->_function = this;

      this->signatures.push_tail(sig);

   }

   /**

    * Get an iterator for the set of function signatures

    */

   exec_list_iterator iterator()

   {

      return signatures.iterator();

   }

   /**

    * Find a signature that matches a set of actual parameters, taking implicit

    * conversions into account.  Also flags whether the match was exact.

    */

   ir_function_signature *matching_signature(const exec_list *actual_param,

					     bool *match_is_exact);

   /**

    * Find a signature that matches a set of actual parameters, taking implicit

    * conversions into account.

    */

   ir_function_signature *matching_signature(const exec_list *actual_param);

   /**

    * Find a signature that exactly matches a set of actual parameters without

    * any implicit type conversions.

    */

   ir_function_signature *exact_matching_signature(const exec_list *actual_ps);

   /**

    * Name of the function.

    */

   const char *name;

   /** Whether or not this function has a signature that isn't a built-in. */

   bool has_user_signature();

   /**

    * List of ir_function_signature for each overloaded function with this name.

    */

   struct exec_list signatures;

};

inline const char *ir_function_signature::function_name() const

{

   return this->_function->name;

}

/*@}*/

/**

 * IR instruction representing high-level if-statements

 */

class ir_if : public ir_instruction {

public:

   ir_if(ir_rvalue *condition)

      : condition(condition)

   {

      ir_type = ir_type_if;

   }

   virtual ir_if *clone(void *mem_ctx, struct hash_table *ht) const;

   virtual ir_if *as_if()

   {

      return this;

   }

   virtual void accept(ir_visitor *v)

   {

      v->visit(this);

   }

   virtual ir_visitor_status accept(ir_hierarchical_visitor *);

   ir_rvalue *condition;

   /** List of ir_instruction for the body of the then branch */

   exec_list  then_instructions;

   /** List of ir_instruction for the body of the else branch */

   exec_list  else_instructions;

};

/**

 * IR instruction representing a high-level loop structure.

 */

class ir_loop : public ir_instruction {

public:

   ir_loop();

   virtual ir_loop *clone(void *mem_ctx, struct hash_table *ht) const;

   virtual void accept(ir_visitor *v)

   {

      v->visit(this);

   }

   virtual ir_visitor_status accept(ir_hierarchical_visitor *);

   virtual ir_loop *as_loop()

   {

      return this;

   }

   /**

    * Get an iterator for the instructions of the loop body

    */

   exec_list_iterator iterator()

   {

      return body_instructions.iterator();

   }

   /** List of ir_instruction that make up the body of the loop. */

   exec_list body_instructions;

   /**

    * \name Loop counter and controls

    *

    * Represents a loop like a FORTRAN \c do-loop.

    *

    * \note

    * If \c from and \c to are the same value, the loop will execute once.

    */

   /*@{*/

   ir_rvalue *from;             /** Value of the loop counter on the first

				 * iteration of the loop.

				 */

   ir_rvalue *to;               /** Value of the loop counter on the last

				 * iteration of the loop.

				 */

   ir_rvalue *increment;

   ir_variable *counter;

   /**

    * Comparison operation in the loop terminator.

    *

    * If any of the loop control fields are non-\c NULL, this field must be

    * one of \c ir_binop_less, \c ir_binop_greater, \c ir_binop_lequal,

    * \c ir_binop_gequal, \c ir_binop_equal, or \c ir_binop_nequal.

    */

   int cmp;

   /*@}*/

};

class ir_assignment : public ir_instruction {

public:

   ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs, ir_rvalue *condition = NULL);

   /**

    * Construct an assignment with an explicit write mask

    *

    * \note

    * Since a write mask is supplied, the LHS must already be a bare

    * \c ir_dereference.  The cannot be any swizzles in the LHS.

    */

   ir_assignment(ir_dereference *lhs, ir_rvalue *rhs, ir_rvalue *condition,

		 unsigned write_mask);

   virtual ir_assignment *clone(void *mem_ctx, struct hash_table *ht) const;

   virtual ir_constant *constant_expression_value(struct hash_table *variable_context = NULL);

   virtual void accept(ir_visitor *v)

   {

      v->visit(this);

   }

   virtual ir_visitor_status accept(ir_hierarchical_visitor *);

   virtual ir_assignment * as_assignment()

   {

      return this;

   }

   /**

    * Get a whole variable written by an assignment

    *

    * If the LHS of the assignment writes a whole variable, the variable is

    * returned.  Otherwise \c NULL is returned.  Examples of whole-variable

    * assignment are:

    *

    *  - Assigning to a scalar

    *  - Assigning to all components of a vector

    *  - Whole array (or matrix) assignment

    *  - Whole structure assignment

    */

   ir_variable *whole_variable_written();

   /**

    * Set the LHS of an assignment

    */

   void set_lhs(ir_rvalue *lhs);

   /**

    * Left-hand side of the assignment.

    *

    * This should be treated as read only.  If you need to set the LHS of an

    * assignment, use \c ir_assignment::set_lhs.

    */

   ir_dereference *lhs;

   /**

    * Value being assigned

    */

   ir_rvalue *rhs;

   /**

    * Optional condition for the assignment.

    */

   ir_rvalue *condition;

   /**

    * Component mask written

    *

    * For non-vector types in the LHS, this field will be zero.  For vector

    * types, a bit will be set for each component that is written.  Note that

    * for \c vec2 and \c vec3 types only the lower bits will ever be set.

    *

    * A partially-set write mask means that each enabled channel gets

    * the value from a consecutive channel of the rhs.  For example,

    * to write just .xyw of gl_FrontColor with color:

    *

    * (assign (constant bool (1)) (xyw)

    *     (var_ref gl_FragColor)

    *     (swiz xyw (var_ref color)))

    */

   unsigned write_mask:4;

};

/* Update ir_expression::get_num_operands() and operator_strs when

 * updating this list.

 */

enum ir_expression_operation {

   ir_unop_bit_not,

   ir_unop_logic_not,

   ir_unop_neg,

   ir_unop_abs,

   ir_unop_sign,

   ir_unop_rcp,

   ir_unop_rsq,

   ir_unop_sqrt,

   ir_unop_exp,         /**< Log base e on gentype */

   ir_unop_log,	        /**< Natural log on gentype */

   ir_unop_exp2,

   ir_unop_log2,

   ir_unop_f2i,         /**< Float-to-integer conversion. */

   ir_unop_f2u,         /**< Float-to-unsigned conversion. */

   ir_unop_i2f,         /**< Integer-to-float conversion. */

   ir_unop_f2b,         /**< Float-to-boolean conversion */

   ir_unop_b2f,         /**< Boolean-to-float conversion */

   ir_unop_i2b,         /**< int-to-boolean conversion */

   ir_unop_b2i,         /**< Boolean-to-int conversion */

   ir_unop_u2f,         /**< Unsigned-to-float conversion. */

   ir_unop_i2u,         /**< Integer-to-unsigned conversion. */

   ir_unop_u2i,         /**< Unsigned-to-integer conversion. */

   ir_unop_bitcast_i2f, /**< Bit-identical int-to-float "conversion" */

   ir_unop_bitcast_f2i, /**< Bit-identical float-to-int "conversion" */

   ir_unop_bitcast_u2f, /**< Bit-identical uint-to-float "conversion" */

   ir_unop_bitcast_f2u, /**< Bit-identical float-to-uint "conversion" */

   ir_unop_any,

   /**

    * \name Unary floating-point rounding operations.

    */

   /*@{*/

   ir_unop_trunc,

   ir_unop_ceil,

   ir_unop_floor,

   ir_unop_fract,

   ir_unop_round_even,

   /*@}*/

   /**

    * \name Trigonometric operations.

    */

   /*@{*/

   ir_unop_sin,

   ir_unop_cos,

   ir_unop_sin_reduced,    /**< Reduced range sin. [-pi, pi] */

   ir_unop_cos_reduced,    /**< Reduced range cos. [-pi, pi] */

   /*@}*/

   /**

    * \name Partial derivatives.

    */

   /*@{*/

   ir_unop_dFdx,

   ir_unop_dFdy,

   /*@}*/

   /**

    * \name Floating point pack and unpack operations.

    */

   /*@{*/

   ir_unop_pack_snorm_2x16,

   ir_unop_pack_snorm_4x8,

   ir_unop_pack_unorm_2x16,

   ir_unop_pack_unorm_4x8,

   ir_unop_pack_half_2x16,

   ir_unop_unpack_snorm_2x16,

   ir_unop_unpack_snorm_4x8,

   ir_unop_unpack_unorm_2x16,

   ir_unop_unpack_unorm_4x8,

   ir_unop_unpack_half_2x16,

   /*@}*/

   /**

    * \name Lowered floating point unpacking operations.

    *

    * \see lower_packing_builtins_visitor::split_unpack_half_2x16

    */

   /*@{*/

   ir_unop_unpack_half_2x16_split_x,

   ir_unop_unpack_half_2x16_split_y,

   /*@}*/

   /**

    * \name Bit operations, part of ARB_gpu_shader5.

    */

   /*@{*/

   ir_unop_bitfield_reverse,

   ir_unop_bit_count,

   ir_unop_find_msb,

   ir_unop_find_lsb,

   /*@}*/

   ir_unop_noise,

   /**

    * A sentinel marking the last of the unary operations.

    */

   ir_last_unop = ir_unop_noise,

   ir_binop_add,

   ir_binop_sub,

   ir_binop_mul,

   ir_binop_div,

   /**

    * Takes one of two combinations of arguments:

    *

    * - mod(vecN, vecN)

    * - mod(vecN, float)

    *

    * Does not take integer types.

    */

   ir_binop_mod,

   /**

    * \name Binary comparison operators which return a boolean vector.

    * The type of both operands must be equal.

    */

   /*@{*/

   ir_binop_less,

   ir_binop_greater,

   ir_binop_lequal,

   ir_binop_gequal,

   ir_binop_equal,

   ir_binop_nequal,

   /**

    * Returns single boolean for whether all components of operands[0]

    * equal the components of operands[1].

    */

   ir_binop_all_equal,

   /**

    * Returns single boolean for whether any component of operands[0]

    * is not equal to the corresponding component of operands[1].

    */

   ir_binop_any_nequal,

   /*@}*/

   /**

    * \name Bit-wise binary operations.

    */

   /*@{*/

   ir_binop_lshift,

   ir_binop_rshift,

   ir_binop_bit_and,

   ir_binop_bit_xor,

   ir_binop_bit_or,

   /*@}*/

   ir_binop_logic_and,

   ir_binop_logic_xor,

   ir_binop_logic_or,

   ir_binop_dot,

   ir_binop_min,

   ir_binop_max,

   ir_binop_pow,

   /**