2010-03-10 21:58:12 +00:00
|
|
|
/* -*- c++ -*- */
|
2010-02-22 21:19:34 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2010-03-15 22:20:15 +00:00
|
|
|
#pragma once
|
|
|
|
#ifndef IR_H
|
|
|
|
#define IR_H
|
|
|
|
|
2010-03-09 07:44:00 +00:00
|
|
|
#include "list.h"
|
2010-03-10 00:23:37 +00:00
|
|
|
#include "ir_visitor.h"
|
2010-03-09 07:44:00 +00:00
|
|
|
|
2010-02-22 21:19:34 +00:00
|
|
|
struct ir_program {
|
|
|
|
void *bong_hits;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Base class of all IR instructions
|
|
|
|
*/
|
2010-03-09 07:44:00 +00:00
|
|
|
class ir_instruction : public exec_node {
|
2010-02-22 21:19:34 +00:00
|
|
|
public:
|
|
|
|
const struct glsl_type *type;
|
|
|
|
|
2010-03-10 00:23:37 +00:00
|
|
|
virtual void accept(ir_visitor *) = 0;
|
|
|
|
|
2010-03-26 06:30:28 +00:00
|
|
|
/**
|
|
|
|
* \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_dereference * as_dereference() { return NULL; }
|
2010-03-26 07:25:36 +00:00
|
|
|
virtual class ir_rvalue * as_rvalue() { return NULL; }
|
2010-03-26 06:30:28 +00:00
|
|
|
/*@}*/
|
|
|
|
|
2010-02-22 21:19:34 +00:00
|
|
|
protected:
|
2010-03-26 06:30:28 +00:00
|
|
|
ir_instruction()
|
2010-03-11 22:23:41 +00:00
|
|
|
{
|
|
|
|
/* empty */
|
|
|
|
}
|
2010-02-22 21:19:34 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2010-03-26 07:25:36 +00:00
|
|
|
class ir_rvalue : public ir_instruction {
|
|
|
|
public:
|
|
|
|
virtual ir_rvalue * as_rvalue()
|
|
|
|
{
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual bool is_lvalue()
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
ir_rvalue() : ir_instruction() { }
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2010-02-22 21:19:34 +00:00
|
|
|
enum ir_variable_mode {
|
|
|
|
ir_var_auto = 0,
|
|
|
|
ir_var_uniform,
|
|
|
|
ir_var_in,
|
|
|
|
ir_var_out,
|
|
|
|
ir_var_inout
|
|
|
|
};
|
|
|
|
|
|
|
|
enum ir_varaible_interpolation {
|
|
|
|
ir_var_smooth = 0,
|
|
|
|
ir_var_flat,
|
|
|
|
ir_var_noperspective
|
|
|
|
};
|
|
|
|
|
2010-03-26 07:25:36 +00:00
|
|
|
|
2010-02-22 21:19:34 +00:00
|
|
|
class ir_variable : public ir_instruction {
|
|
|
|
public:
|
|
|
|
ir_variable(const struct glsl_type *, const char *);
|
|
|
|
|
2010-03-26 06:30:28 +00:00
|
|
|
virtual ir_variable *as_variable()
|
|
|
|
{
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2010-03-10 00:23:37 +00:00
|
|
|
virtual void accept(ir_visitor *v)
|
|
|
|
{
|
|
|
|
v->visit(this);
|
|
|
|
}
|
|
|
|
|
2010-02-22 21:19:34 +00:00
|
|
|
const char *name;
|
|
|
|
|
|
|
|
unsigned read_only:1;
|
|
|
|
unsigned centroid:1;
|
|
|
|
unsigned invariant:1;
|
|
|
|
|
|
|
|
unsigned mode:3;
|
|
|
|
unsigned interpolation:2;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class ir_label : public ir_instruction {
|
|
|
|
public:
|
|
|
|
ir_label(const char *label);
|
|
|
|
|
2010-03-10 00:23:37 +00:00
|
|
|
virtual void accept(ir_visitor *v)
|
|
|
|
{
|
|
|
|
v->visit(this);
|
|
|
|
}
|
|
|
|
|
2010-02-22 21:19:34 +00:00
|
|
|
const char *label;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*@{*/
|
|
|
|
class ir_function_signature : public ir_instruction {
|
|
|
|
public:
|
2010-03-23 19:19:13 +00:00
|
|
|
ir_function_signature(const glsl_type *return_type);
|
2010-02-22 21:19:34 +00:00
|
|
|
|
2010-03-10 00:23:37 +00:00
|
|
|
virtual void accept(ir_visitor *v)
|
|
|
|
{
|
|
|
|
v->visit(this);
|
|
|
|
}
|
|
|
|
|
2010-02-22 21:19:34 +00:00
|
|
|
/**
|
|
|
|
* Function return type.
|
|
|
|
*
|
|
|
|
* \note This discards the optional precision qualifier.
|
|
|
|
*/
|
|
|
|
const struct glsl_type *return_type;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* List of function parameters stored as ir_variable objects.
|
|
|
|
*/
|
2010-03-09 07:44:00 +00:00
|
|
|
struct exec_list parameters;
|
2010-02-22 21:19:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Pointer to the label that begins the function definition.
|
|
|
|
*/
|
|
|
|
ir_label *definition;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Header for tracking functions in the symbol table
|
|
|
|
*/
|
|
|
|
class ir_function : public ir_instruction {
|
|
|
|
public:
|
2010-03-24 00:42:04 +00:00
|
|
|
ir_function(const char *name);
|
2010-02-22 21:19:34 +00:00
|
|
|
|
2010-03-10 00:23:37 +00:00
|
|
|
virtual void accept(ir_visitor *v)
|
|
|
|
{
|
|
|
|
v->visit(this);
|
|
|
|
}
|
|
|
|
|
2010-03-11 22:50:30 +00:00
|
|
|
/**
|
|
|
|
* Find a signature that matches a set of actual parameters.
|
|
|
|
*/
|
|
|
|
const ir_function_signature *matching_signature(exec_list *actual_param);
|
|
|
|
|
2010-02-22 21:19:34 +00:00
|
|
|
/**
|
|
|
|
* Name of the function.
|
|
|
|
*/
|
|
|
|
const char *name;
|
|
|
|
|
2010-03-11 22:50:30 +00:00
|
|
|
/**
|
|
|
|
* Set of overloaded functions with this name.
|
|
|
|
*/
|
2010-03-09 07:44:00 +00:00
|
|
|
struct exec_list signatures;
|
2010-02-22 21:19:34 +00:00
|
|
|
};
|
|
|
|
/*@}*/
|
|
|
|
|
|
|
|
|
2010-03-26 07:25:36 +00:00
|
|
|
class ir_assignment : public ir_rvalue {
|
2010-02-22 21:19:34 +00:00
|
|
|
public:
|
2010-03-26 07:25:36 +00:00
|
|
|
ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs, ir_rvalue *condition);
|
2010-02-22 21:19:34 +00:00
|
|
|
|
2010-03-10 00:23:37 +00:00
|
|
|
virtual void accept(ir_visitor *v)
|
|
|
|
{
|
|
|
|
v->visit(this);
|
|
|
|
}
|
|
|
|
|
2010-02-22 21:19:34 +00:00
|
|
|
/**
|
|
|
|
* Left-hand side of the assignment.
|
|
|
|
*/
|
2010-03-26 07:25:36 +00:00
|
|
|
ir_rvalue *lhs;
|
2010-02-22 21:19:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Value being assigned
|
|
|
|
*/
|
2010-03-26 07:25:36 +00:00
|
|
|
ir_rvalue *rhs;
|
2010-02-22 21:19:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Optional condition for the assignment.
|
|
|
|
*/
|
2010-03-26 07:25:36 +00:00
|
|
|
ir_rvalue *condition;
|
2010-02-22 21:19:34 +00:00
|
|
|
};
|
|
|
|
|
2010-03-26 18:00:07 +00:00
|
|
|
/* Update ir_print_visitor.cpp when updating this list. */
|
2010-02-22 21:19:34 +00:00
|
|
|
enum ir_expression_operation {
|
|
|
|
ir_unop_bit_not,
|
|
|
|
ir_unop_logic_not,
|
|
|
|
ir_unop_neg,
|
|
|
|
ir_unop_abs,
|
|
|
|
ir_unop_rcp,
|
|
|
|
ir_unop_rsq,
|
2010-03-27 20:01:51 +00:00
|
|
|
ir_unop_sqrt,
|
2010-02-22 21:19:34 +00:00
|
|
|
ir_unop_exp,
|
|
|
|
ir_unop_log,
|
|
|
|
ir_unop_f2i, /**< Float-to-integer conversion. */
|
|
|
|
ir_unop_i2f, /**< Integer-to-float conversion. */
|
2010-03-26 23:11:48 +00:00
|
|
|
ir_unop_u2f, /**< Unsigned-to-float conversion. */
|
2010-02-22 21:19:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* \name Unary floating-point rounding operations.
|
|
|
|
*/
|
|
|
|
/*@{*/
|
|
|
|
ir_unop_trunc,
|
|
|
|
ir_unop_ceil,
|
|
|
|
ir_unop_floor,
|
|
|
|
/*@}*/
|
|
|
|
|
|
|
|
ir_binop_add,
|
|
|
|
ir_binop_sub,
|
|
|
|
ir_binop_mul,
|
|
|
|
ir_binop_div,
|
|
|
|
ir_binop_mod,
|
|
|
|
|
|
|
|
/**
|
|
|
|
* \name Binary comparison operators
|
|
|
|
*/
|
|
|
|
/*@{*/
|
|
|
|
ir_binop_less,
|
|
|
|
ir_binop_greater,
|
|
|
|
ir_binop_lequal,
|
|
|
|
ir_binop_gequal,
|
|
|
|
ir_binop_equal,
|
|
|
|
ir_binop_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_logic_not,
|
|
|
|
|
|
|
|
ir_binop_dot,
|
|
|
|
ir_binop_min,
|
|
|
|
ir_binop_max,
|
|
|
|
|
|
|
|
ir_binop_pow
|
|
|
|
};
|
|
|
|
|
2010-03-26 07:25:36 +00:00
|
|
|
class ir_expression : public ir_rvalue {
|
2010-02-22 21:19:34 +00:00
|
|
|
public:
|
|
|
|
ir_expression(int op, const struct glsl_type *type,
|
2010-03-26 07:25:36 +00:00
|
|
|
ir_rvalue *, ir_rvalue *);
|
2010-02-22 21:19:34 +00:00
|
|
|
|
2010-03-10 00:23:37 +00:00
|
|
|
virtual void accept(ir_visitor *v)
|
|
|
|
{
|
|
|
|
v->visit(this);
|
|
|
|
}
|
|
|
|
|
2010-02-22 21:19:34 +00:00
|
|
|
ir_expression_operation operation;
|
2010-03-26 07:25:36 +00:00
|
|
|
ir_rvalue *operands[2];
|
2010-02-22 21:19:34 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2010-03-11 22:34:27 +00:00
|
|
|
/**
|
|
|
|
* IR instruction representing a function call
|
|
|
|
*/
|
2010-03-26 07:25:36 +00:00
|
|
|
class ir_call : public ir_rvalue {
|
2010-03-11 22:34:27 +00:00
|
|
|
public:
|
2010-03-11 22:50:30 +00:00
|
|
|
ir_call(const ir_function_signature *callee, exec_list *actual_parameters)
|
2010-03-26 07:25:36 +00:00
|
|
|
: ir_rvalue(), callee(callee)
|
2010-03-11 22:34:27 +00:00
|
|
|
{
|
2010-03-23 19:21:18 +00:00
|
|
|
assert(callee->return_type != NULL);
|
|
|
|
type = callee->return_type;
|
2010-03-11 22:50:30 +00:00
|
|
|
actual_parameters->move_nodes_to(& this->actual_parameters);
|
2010-03-11 22:34:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
virtual void accept(ir_visitor *v)
|
|
|
|
{
|
|
|
|
v->visit(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get a generic ir_call object when an error occurs
|
|
|
|
*/
|
|
|
|
static ir_call *get_error_instruction();
|
|
|
|
|
2010-03-27 00:19:47 +00:00
|
|
|
/**
|
|
|
|
* Get an iterator for the set of acutal parameters
|
|
|
|
*/
|
|
|
|
exec_list_iterator iterator()
|
|
|
|
{
|
|
|
|
return actual_parameters.iterator();
|
|
|
|
}
|
|
|
|
|
2010-03-27 00:29:29 +00:00
|
|
|
/**
|
|
|
|
* Get the name of the function being called.
|
|
|
|
*/
|
|
|
|
const char *callee_name() const
|
|
|
|
{
|
|
|
|
/* FINISHME: This only works for functions that have definitions. */
|
|
|
|
return callee->definition->label;
|
|
|
|
}
|
|
|
|
|
2010-03-11 22:34:27 +00:00
|
|
|
private:
|
2010-03-11 22:50:30 +00:00
|
|
|
ir_call()
|
2010-03-26 07:25:36 +00:00
|
|
|
: ir_rvalue(), callee(NULL)
|
2010-03-11 22:50:30 +00:00
|
|
|
{
|
|
|
|
/* empty */
|
|
|
|
}
|
|
|
|
|
|
|
|
const ir_function_signature *callee;
|
2010-03-11 22:34:27 +00:00
|
|
|
exec_list actual_parameters;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2010-03-19 23:44:52 +00:00
|
|
|
/**
|
|
|
|
* \name Jump-like IR instructions.
|
|
|
|
*
|
|
|
|
* These include \c break, \c continue, \c return, and \c discard.
|
|
|
|
*/
|
|
|
|
/*@{*/
|
|
|
|
class ir_jump : public ir_instruction {
|
|
|
|
protected:
|
|
|
|
ir_jump()
|
2010-03-26 06:30:28 +00:00
|
|
|
: ir_instruction()
|
2010-03-19 23:44:52 +00:00
|
|
|
{
|
|
|
|
/* empty */
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class ir_return : public ir_jump {
|
|
|
|
public:
|
|
|
|
ir_return()
|
|
|
|
: value(NULL)
|
|
|
|
{
|
|
|
|
/* empty */
|
|
|
|
}
|
|
|
|
|
2010-03-26 07:25:36 +00:00
|
|
|
ir_return(ir_rvalue *value)
|
2010-03-19 23:44:52 +00:00
|
|
|
: value(value)
|
|
|
|
{
|
|
|
|
/* empty */
|
|
|
|
}
|
|
|
|
|
2010-03-26 07:25:36 +00:00
|
|
|
ir_rvalue *get_value() const
|
2010-03-19 23:44:52 +00:00
|
|
|
{
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void accept(ir_visitor *v)
|
|
|
|
{
|
|
|
|
v->visit(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2010-03-26 07:25:36 +00:00
|
|
|
ir_rvalue *value;
|
2010-03-19 23:44:52 +00:00
|
|
|
};
|
|
|
|
/*@}*/
|
|
|
|
|
|
|
|
|
2010-02-22 21:19:34 +00:00
|
|
|
struct ir_swizzle_mask {
|
|
|
|
unsigned x:2;
|
|
|
|
unsigned y:2;
|
|
|
|
unsigned z:2;
|
|
|
|
unsigned w:2;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Number of components in the swizzle.
|
|
|
|
*/
|
2010-03-25 18:22:42 +00:00
|
|
|
unsigned num_components:3;
|
2010-02-22 21:19:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Does the swizzle contain duplicate components?
|
|
|
|
*
|
|
|
|
* L-value swizzles cannot contain duplicate components.
|
|
|
|
*/
|
|
|
|
unsigned has_duplicates:1;
|
|
|
|
};
|
|
|
|
|
2010-03-26 08:20:08 +00:00
|
|
|
|
|
|
|
class ir_swizzle : public ir_rvalue {
|
|
|
|
public:
|
|
|
|
ir_swizzle(ir_rvalue *, unsigned x, unsigned y, unsigned z, unsigned w,
|
|
|
|
unsigned count);
|
|
|
|
/**
|
|
|
|
* Construct an ir_swizzle from the textual representation. Can fail.
|
|
|
|
*/
|
|
|
|
static ir_swizzle *create(ir_rvalue *, const char *, unsigned vector_length);
|
|
|
|
|
|
|
|
virtual void accept(ir_visitor *v)
|
|
|
|
{
|
|
|
|
v->visit(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool is_lvalue()
|
|
|
|
{
|
|
|
|
return val->is_lvalue();
|
|
|
|
}
|
|
|
|
|
|
|
|
ir_rvalue *val;
|
|
|
|
ir_swizzle_mask mask;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2010-03-26 07:25:36 +00:00
|
|
|
class ir_dereference : public ir_rvalue {
|
2010-02-22 21:19:34 +00:00
|
|
|
public:
|
|
|
|
ir_dereference(struct ir_instruction *);
|
|
|
|
|
2010-03-26 07:25:36 +00:00
|
|
|
ir_dereference(ir_instruction *variable, ir_rvalue *array_index);
|
2010-03-26 00:01:15 +00:00
|
|
|
|
2010-03-26 06:30:28 +00:00
|
|
|
virtual ir_dereference *as_dereference()
|
|
|
|
{
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2010-03-10 00:23:37 +00:00
|
|
|
virtual void accept(ir_visitor *v)
|
|
|
|
{
|
|
|
|
v->visit(this);
|
|
|
|
}
|
|
|
|
|
2010-03-26 07:25:36 +00:00
|
|
|
bool is_lvalue()
|
|
|
|
{
|
2010-03-26 22:51:45 +00:00
|
|
|
ir_variable *as_var;
|
|
|
|
|
|
|
|
if (var == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
as_var = var->as_variable();
|
|
|
|
|
|
|
|
if (as_var == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return !as_var->read_only;
|
2010-03-26 07:25:36 +00:00
|
|
|
}
|
|
|
|
|
2010-02-22 21:19:34 +00:00
|
|
|
enum {
|
|
|
|
ir_reference_variable,
|
|
|
|
ir_reference_array,
|
|
|
|
ir_reference_record
|
|
|
|
} mode;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Object being dereferenced.
|
|
|
|
*
|
2010-03-26 07:25:36 +00:00
|
|
|
* Must be either an \c ir_variable or an \c ir_rvalue.
|
2010-02-22 21:19:34 +00:00
|
|
|
*/
|
|
|
|
ir_instruction *var;
|
|
|
|
|
|
|
|
union {
|
2010-03-26 07:25:36 +00:00
|
|
|
ir_rvalue *array_index;
|
2010-02-22 21:19:34 +00:00
|
|
|
const char *field;
|
|
|
|
} selector;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2010-03-26 07:25:36 +00:00
|
|
|
class ir_constant : public ir_rvalue {
|
2010-02-22 21:19:34 +00:00
|
|
|
public:
|
|
|
|
ir_constant(const struct glsl_type *type, const void *data);
|
2010-03-26 19:07:44 +00:00
|
|
|
ir_constant(bool b);
|
|
|
|
ir_constant(unsigned int u);
|
|
|
|
ir_constant(int i);
|
|
|
|
ir_constant(float f);
|
2010-02-22 21:19:34 +00:00
|
|
|
|
2010-03-10 00:23:37 +00:00
|
|
|
virtual void accept(ir_visitor *v)
|
|
|
|
{
|
|
|
|
v->visit(this);
|
|
|
|
}
|
|
|
|
|
2010-02-22 21:19:34 +00:00
|
|
|
/**
|
|
|
|
* Value of the constant.
|
|
|
|
*
|
|
|
|
* The field used to back the values supplied by the constant is determined
|
|
|
|
* by the type associated with the \c ir_instruction. Constants may be
|
|
|
|
* scalars, vectors, or matrices.
|
|
|
|
*/
|
|
|
|
union {
|
|
|
|
unsigned u[16];
|
|
|
|
int i[16];
|
|
|
|
float f[16];
|
|
|
|
bool b[16];
|
|
|
|
} value;
|
|
|
|
};
|
|
|
|
|
2010-03-10 18:43:16 +00:00
|
|
|
|
|
|
|
extern void
|
|
|
|
_mesa_glsl_initialize_variables(exec_list *instructions,
|
|
|
|
struct _mesa_glsl_parse_state *state);
|
2010-03-15 22:20:15 +00:00
|
|
|
|
2010-03-27 01:20:30 +00:00
|
|
|
extern void
|
|
|
|
_mesa_glsl_initialize_functions(exec_list *instructions,
|
|
|
|
struct _mesa_glsl_parse_state *state);
|
|
|
|
|
2010-03-15 22:20:15 +00:00
|
|
|
#endif /* IR_H */
|