glsl-optimizer/src/compiler/glsl/opt_copy_propagation

Bug Summary

File:	root/firefox-clang/third_party/rust/glslopt/glsl-optimizer/src/compiler/glsl/opt_copy_propagation_elements.cpp
Warning:	line 704, column 8 Dereference of null pointer

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name opt_copy_propagation_elements.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/root/firefox-clang/third_party/rust/glslopt -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/root/firefox-clang/third_party/rust/glslopt -resource-dir /usr/lib/llvm-21/lib/clang/21 -include /root/firefox-clang/config/gcc_hidden.h -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -I glsl-optimizer/include -I glsl-optimizer/src/mesa -I glsl-optimizer/src/mapi -I glsl-optimizer/src/compiler -I glsl-optimizer/src/compiler/glsl -I glsl-optimizer/src/gallium/auxiliary -I glsl-optimizer/src/gallium/include -I glsl-optimizer/src -I glsl-optimizer/src/util -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/stl_wrappers -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D _GLIBCXX_ASSERTIONS -D DEBUG=1 -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -D MOZILLA_CONFIG_H -D __STDC_FORMAT_MACROS -D _GNU_SOURCE -D HAVE_ENDIAN_H -D HAVE_PTHREAD -D HAVE_TIMESPEC_GET -D MOZ_INCLUDE_MOZALLOC_H -D mozilla_throw_gcc_h -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/x86_64-linux-gnu/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14/backward -internal-isystem /usr/lib/llvm-21/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-error=pessimizing-move -Wno-error=large-by-value-copy=128 -Wno-error=implicit-int-float-conversion -Wno-error=thread-safety-analysis -Wno-error=tautological-type-limit-compare -Wno-invalid-offsetof -Wno-range-loop-analysis -Wno-deprecated-anon-enum-enum-conversion -Wno-deprecated-enum-enum-conversion -Wno-deprecated-this-capture -Wno-inline-new-delete -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-vla-cxx-extension -Wno-unknown-warning-option -fdeprecated-macro -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fno-rtti -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fno-sized-deallocation -fno-aligned-allocation -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2025-06-27-100320-3286336-1 -x c++ glsl-optimizer/src/compiler/glsl/opt_copy_propagation_elements.cpp

glsl-optimizer/src/compiler/glsl/opt_copy_propagation_elements.cpp

→

1/*
* 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.
*/

24/**
* \file opt_copy_propagation_elements.cpp
*
* Replaces usage of recently-copied components of variables with the
* previous copy of the variable.
*
* This should reduce the number of MOV instructions in the generated
* programs and help triggering other optimizations that live in GLSL
* level.
*/

35#include "ir.h"
36#include "ir_rvalue_visitor.h"
37#include "ir_basic_block.h"
38#include "ir_optimization.h"
39#include "compiler/glsl_types.h"
40#include "util/hash_table.h"
41#include "util/set.h"

43static bool debug = false;

45namespace {

47class acp_entry
48{
49public:
 DECLARE_LINEAR_ZALLOC_CXX_OPERATORS(acp_entry)private: static void _ralloc_destructor(void *p) { reinterpret_cast
<acp_entry *>(p)->acp_entry::~acp_entry(); } public:
 static void* operator new(size_t size, void *mem_ctx) { void
 *p = linear_zalloc_child(mem_ctx, size); (static_cast <bool
> (p != __null) ? void (0) : __assert_fail ("p != NULL", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); if
 (!__has_trivial_destructor(acp_entry)) ralloc_set_destructor
(p, _ralloc_destructor); return p; } static void operator delete
(void *p) { if (!__has_trivial_destructor(acp_entry)) ralloc_set_destructor
(p, __null); ralloc_free(p); }

 /* If set, rhs_full indicates that this ACP entry represents a
  * whole-variable copy.  The rhs_element[] array will still be filled,
  * to allow the swizzling from its components in case the variable
  * was a vector (and to simplify some of the erase() and write_vector()
  * logic).
  */

 ir_variable *rhs_full;
 ir_variable *rhs_element[4];
 unsigned rhs_channel[4];

 /* Set of variables that use the variable associated with this acp_entry as
  * RHS.  This has the "reverse references" of rhs_full/rhs_element.  It is
  * used to speed up invalidating those references when the acp_entry
  * changes.
  */
 set *dsts;
69};

71class copy_propagation_state {
72public:
 DECLARE_RZALLOC_CXX_OPERATORS(copy_propagation_state)private: static void _ralloc_destructor(void *p) { reinterpret_cast
<copy_propagation_state *>(p)->copy_propagation_state
::~copy_propagation_state(); } public: static void* operator new
(size_t size, void *mem_ctx) { void *p = rzalloc_size(mem_ctx
, size); (static_cast <bool> (p != __null) ? void (0) :
 __assert_fail ("p != NULL", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__)); if (!__has_trivial_destructor
(copy_propagation_state)) ralloc_set_destructor(p, _ralloc_destructor
); return p; } static void operator delete(void *p) { if (!__has_trivial_destructor
(copy_propagation_state)) ralloc_set_destructor(p, __null); ralloc_free
(p); };

 static
 copy_propagation_state* create(void *mem_ctx)
 {
    return new (mem_ctx) copy_propagation_state(NULL__null);
 }

 copy_propagation_state* clone()
 {
    return new (ralloc_parent(this)) copy_propagation_state(this);
 }

 void erase_all()
 {
    /* Individual elements were allocated from a linear allocator, so will
     * be destroyed when the state is destroyed.
     */
    _mesa_hash_table_clear(acp, NULL__null);
    fallback = NULL__null;
 }

 void erase(ir_variable *var, unsigned write_mask)
 {
    acp_entry *entry = pull_acp(var);
    entry->rhs_full = NULL__null;

    for (int i = 0; i < 4; i++) {
       if (!entry->rhs_element[i])
          continue;
       if ((write_mask & (1 << i)) == 0)
          continue;

       ir_variable *to_remove = entry->rhs_element[i];
       entry->rhs_element[i] = NULL__null;
       remove_unused_var_from_dsts(entry, var, to_remove);
    }

    /* TODO: Check write mask, and possibly not clear everything. */

    /* For any usage of our variable on the RHS, clear it out. */
    set_foreach(entry->dsts, set_entry)for (struct set_entry *set_entry = _mesa_set_next_entry(entry
->dsts, __null); set_entry != __null; set_entry = _mesa_set_next_entry
(entry->dsts, set_entry)) {
       ir_variable *dst_var = (ir_variable *)set_entry->key;
       acp_entry *dst_entry = pull_acp(dst_var);
       for (int i = 0; i < 4; i++) {
          if (dst_entry->rhs_element[i] == var)
             dst_entry->rhs_element[i] = NULL__null;
       }
       if (dst_entry->rhs_full == var)
          dst_entry->rhs_full = NULL__null;
       _mesa_set_remove(entry->dsts, set_entry);
    }
 }

 acp_entry *read(ir_variable *var)
 {
    for (copy_propagation_state *s = this; s != NULL__null; s = s->fallback) {
       hash_entry *ht_entry = _mesa_hash_table_search(s->acp, var);
       if (ht_entry)
          return (acp_entry *) ht_entry->data;
    }
    return NULL__null;
 }

 void write_elements(ir_variable *lhs, ir_variable *rhs, unsigned write_mask, int swizzle[4])
 {
    acp_entry *lhs_entry = pull_acp(lhs);
    lhs_entry->rhs_full = NULL__null;

    for (int i = 0; i < 4; i++) {
       if ((write_mask & (1 << i)) == 0)
          continue;
       ir_variable *to_remove = lhs_entry->rhs_element[i];
       lhs_entry->rhs_element[i] = rhs;
       lhs_entry->rhs_channel[i] = swizzle[i];

       remove_unused_var_from_dsts(lhs_entry, lhs, to_remove);
    }

    acp_entry *rhs_entry = pull_acp(rhs);
    _mesa_set_add(rhs_entry->dsts, lhs);
 }

 void write_full(ir_variable *lhs, ir_variable *rhs)
 {
    acp_entry *lhs_entry = pull_acp(lhs);
    if (lhs_entry->rhs_full == rhs)
       return;

    if (lhs_entry->rhs_full) {
       remove_from_dsts(lhs_entry->rhs_full, lhs);
    } else if (lhs->type->is_vector()) {
       for (int i = 0; i < 4; i++) {
          if (lhs_entry->rhs_element[i])
             remove_from_dsts(lhs_entry->rhs_element[i], lhs);
       }
    }

    lhs_entry->rhs_full = rhs;
    acp_entry *rhs_entry = pull_acp(rhs);
    _mesa_set_add(rhs_entry->dsts, lhs);

    if (lhs->type->is_vector()) {
       for (int i = 0; i < 4; i++) {
          lhs_entry->rhs_element[i] = rhs;
          lhs_entry->rhs_channel[i] = i;
       }
    }
 }

 void remove_unused_var_from_dsts(acp_entry *lhs_entry, ir_variable *lhs, ir_variable *var)
 {
    if (!var)
       return;

    /* If lhs still uses var, don't remove anything. */
    for (int j = 0; j < 4; j++) {
       if (lhs_entry->rhs_element[j] == var)
          return;
    }

    acp_entry *element = pull_acp(var);
    assert(element)(static_cast <bool> (element) ? void (0) : __assert_fail
 ("element", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
    _mesa_set_remove_key(element->dsts, lhs);
 }

199private:
 explicit copy_propagation_state(copy_propagation_state *fallback)
 {
    this->fallback = fallback;
    /* Use 'this' as context for the table, no explicit destruction
     * needed later.
     */
    acp = _mesa_pointer_hash_table_create(this);
    lin_ctx = linear_alloc_parent(this, 0);
 }

 acp_entry *pull_acp(ir_variable *var)
 {
    hash_entry *ht_entry = _mesa_hash_table_search(acp, var);
    if (ht_entry)
       return (acp_entry *) ht_entry->data;

    /* If not found, create one and copy data from fallback if available. */
    acp_entry *entry = new(lin_ctx) acp_entry();
    _mesa_hash_table_insert(acp, var, entry);

    bool found = false;
    for (copy_propagation_state *s = fallback; s != NULL__null; s = s->fallback) {
       hash_entry *fallback_ht_entry = _mesa_hash_table_search(s->acp, var);
       if (fallback_ht_entry) {
          acp_entry *fallback_entry = (acp_entry *) fallback_ht_entry->data;
          *entry = *fallback_entry;
          entry->dsts = _mesa_set_clone(fallback_entry->dsts, this);
          found = true;
          break;
       }
    }

    if (!found) {
       entry->dsts = _mesa_pointer_set_create(this);
    }

    return entry;
 }

 void
 remove_from_dsts(ir_variable *var, ir_variable *to_remove)
 {
    acp_entry *entry = pull_acp(var);
    assert(entry)(static_cast <bool> (entry) ? void (0) : __assert_fail (
"entry", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
    _mesa_set_remove_key(entry->dsts, to_remove);
 }

 /** Available Copy to Propagate table, from variable to the entry
  *  containing the current sources that can be used. */
 hash_table *acp;

 /** When a state is cloned, entries are copied on demand from fallback. */
 copy_propagation_state *fallback;

 void *lin_ctx;
255};

257class kill_entry : public exec_node
258{
259public:
 /* override operator new from exec_node */
 DECLARE_LINEAR_ZALLOC_CXX_OPERATORS(kill_entry)private: static void _ralloc_destructor(void *p) { reinterpret_cast
<kill_entry *>(p)->kill_entry::~kill_entry(); } public
: static void* operator new(size_t size, void *mem_ctx) { void
 *p = linear_zalloc_child(mem_ctx, size); (static_cast <bool
> (p != __null) ? void (0) : __assert_fail ("p != NULL", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); if
 (!__has_trivial_destructor(kill_entry)) ralloc_set_destructor
(p, _ralloc_destructor); return p; } static void operator delete
(void *p) { if (!__has_trivial_destructor(kill_entry)) ralloc_set_destructor
(p, __null); ralloc_free(p); }

 kill_entry(ir_variable *var, int write_mask)
 {
    this->var = var;
    this->write_mask = write_mask;
 }

 ir_variable *var;
 unsigned int write_mask;
271};

273class ir_copy_propagation_elements_visitor : public ir_rvalue_visitor {
274public:
 ir_copy_propagation_elements_visitor()
 {
    this->progress = false;
    this->killed_all = false;
    this->mem_ctx = ralloc_context(NULL__null);
    this->lin_ctx = linear_alloc_parent(this->mem_ctx, 0);
    this->shader_mem_ctx = NULL__null;
    this->kills = new(mem_ctx) exec_list;
    this->state = copy_propagation_state::create(mem_ctx);
 }
 ~ir_copy_propagation_elements_visitor()
 {
    ralloc_free(mem_ctx);
 }

 virtual ir_visitor_status visit(ir_dereference_variable *);

 void handle_loop(ir_loop *, bool keep_acp);
 virtual ir_visitor_status visit_enter(class ir_loop *);
 virtual ir_visitor_status visit_enter(class ir_function_signature *);
 virtual ir_visitor_status visit_leave(class ir_assignment *);
 virtual ir_visitor_status visit_enter(class ir_call *);
 virtual ir_visitor_status visit_enter(class ir_if *);
 virtual ir_visitor_status visit_leave(class ir_swizzle *);

 void handle_rvalue(ir_rvalue **rvalue);

 void add_copy(ir_assignment *ir);
 void kill(kill_entry *k);
 void handle_if_block(exec_list *instructions, exec_list *kills, bool *killed_all);

 copy_propagation_state *state;

 /**
  * List of kill_entry: The variables whose values were killed in this
  * block.
  */
 exec_list *kills;

 bool progress;

 bool killed_all;

 /* Context for our local data structures. */
 void *mem_ctx;
 void *lin_ctx;
 /* Context for allocating new shader nodes. */
 void *shader_mem_ctx;
323};

325} /* unnamed namespace */

327ir_visitor_status
328ir_copy_propagation_elements_visitor::visit(ir_dereference_variable *ir)
329{
 if (this->in_assignee)
    return visit_continue;

 const acp_entry *entry = state->read(ir->var);
 if (entry && entry->rhs_full) {
    ir->var = (ir_variable *) entry->rhs_full;
    progress = true;
 }

 return visit_continue;
340}

342ir_visitor_status
343ir_copy_propagation_elements_visitor::visit_enter(ir_function_signature *ir)
344{
 /* Treat entry into a function signature as a completely separate
  * block.  Any instructions at global scope will be shuffled into
  * main() at link time, so they're irrelevant to us.
  */
 exec_list *orig_kills = this->kills;
 bool orig_killed_all = this->killed_all;

 this->kills = new(mem_ctx) exec_list;
 this->killed_all = false;

 copy_propagation_state *orig_state = state;
 this->state = copy_propagation_state::create(mem_ctx);

 visit_list_elements(this, &ir->body);

 delete this->state;
 this->state = orig_state;

 ralloc_free(this->kills);
 this->kills = orig_kills;
 this->killed_all = orig_killed_all;

 return visit_continue_with_parent;
368}

370ir_visitor_status
371ir_copy_propagation_elements_visitor::visit_leave(ir_assignment *ir)
372{
 ir_dereference_variable *lhs = ir->lhs->as_dereference_variable();
 ir_variable *var = ir->lhs->variable_referenced();

 kill_entry *k;

 if (lhs0.1
'lhs' is null
1
'lhs' is null
 && var->type->is_vector())
    k = new(this->lin_ctx) kill_entry(var, ir->write_mask);
 else
    k = new(this->lin_ctx) kill_entry(var, ~0);

 kill(k);

 add_copy(ir);
1
Calling 'ir_copy_propagation_elements_visitor::add_copy'→

 return visit_continue;
388}

390ir_visitor_status
391ir_copy_propagation_elements_visitor::visit_leave(ir_swizzle *)
392{
 /* Don't visit the values of swizzles since they are handled while
  * visiting the swizzle itself.
  */
 return visit_continue;
397}

399/**
* Replaces dereferences of ACP RHS variables with ACP LHS variables.
*
* This is where the actual copy propagation occurs.  Note that the
* rewriting of ir_dereference means that the ir_dereference instance
* must not be shared by multiple IR operations!
*/
406void
407ir_copy_propagation_elements_visitor::handle_rvalue(ir_rvalue **ir)
408{
 int swizzle_chan[4];
 ir_dereference_variable *deref_var;
 ir_variable *source[4] = {NULL__null, NULL__null, NULL__null, NULL__null};
 int source_chan[4] = {0, 0, 0, 0};
 int chans;
 bool noop_swizzle = true;

 if (!*ir)
    return;

 ir_swizzle *swizzle = (*ir)->as_swizzle();
 if (swizzle) {
    deref_var = swizzle->val->as_dereference_variable();
    if (!deref_var)
return;

    swizzle_chan[0] = swizzle->mask.x;
    swizzle_chan[1] = swizzle->mask.y;
    swizzle_chan[2] = swizzle->mask.z;
    swizzle_chan[3] = swizzle->mask.w;
    chans = swizzle->type->vector_elements;
 } else {
    deref_var = (*ir)->as_dereference_variable();
    if (!deref_var)
return;

    swizzle_chan[0] = 0;
    swizzle_chan[1] = 1;
    swizzle_chan[2] = 2;
    swizzle_chan[3] = 3;
    chans = deref_var->type->vector_elements;
 }

 if (this->in_assignee)
    return;

 ir_variable *var = deref_var->var;

 /* Try to find ACP entries covering swizzle_chan[], hoping they're
  * the same source variable.
  */

 const acp_entry *entry = state->read(var);
 if (entry) {
    for (int c = 0; c < chans; c++) {
       unsigned index = swizzle_chan[c];
       ir_variable *src = entry->rhs_element[index];
       if (!src)
          continue;
       source[c] = src;
       source_chan[c] = entry->rhs_channel[index];
       if (source_chan[c] != swizzle_chan[c])
          noop_swizzle = false;
    }
 }

 /* Make sure all channels are copying from the same source variable. */
 if (!source[0])
    return;
 for (int c = 1; c < chans; c++) {
    if (source[c] != source[0])
return;
 }

 if (!shader_mem_ctx)
    shader_mem_ctx = ralloc_parent(deref_var);

 /* Don't pointlessly replace the rvalue with itself (or a noop swizzle
  * of itself, which would just be deleted by opt_noop_swizzle).
  */
 if (source[0] == var && noop_swizzle)
    return;

 if (debug) {
    printf("Copy propagation from:\n");
    (*ir)->print();
 }

 deref_var = new(shader_mem_ctx) ir_dereference_variable(source[0]);
 *ir = new(shader_mem_ctx) ir_swizzle(deref_var,
			source_chan[0],
			source_chan[1],
			source_chan[2],
			source_chan[3],
			chans);
 progress = true;

 if (debug) {
    printf("to:\n");
    (*ir)->print();
    printf("\n");
 }
501}


504ir_visitor_status
505ir_copy_propagation_elements_visitor::visit_enter(ir_call *ir)
506{
 /* Do copy propagation on call parameters, but skip any out params */
 foreach_two_lists(formal_node, &ir->callee->parameters,for (struct exec_node * formal_node = (&ir->callee->
parameters)->head_sentinel.next, * actual_node = (&ir->
actual_parameters)->head_sentinel.next, * __next1 = formal_node
->next, * __next2 = actual_node->next ; __next1 != __null
 && __next2 != __null ; formal_node = __next1, actual_node
 = __next2, __next1 = __next1->next, __next2 = __next2->
next)
                   actual_node, &ir->actual_parameters)for (struct exec_node * formal_node = (&ir->callee->
parameters)->head_sentinel.next, * actual_node = (&ir->
actual_parameters)->head_sentinel.next, * __next1 = formal_node
->next, * __next2 = actual_node->next ; __next1 != __null
 && __next2 != __null ; formal_node = __next1, actual_node
 = __next2, __next1 = __next1->next, __next2 = __next2->
next) {
    ir_variable *sig_param = (ir_variable *) formal_node;
    ir_rvalue *ir = (ir_rvalue *) actual_node;
    if (sig_param->data.mode != ir_var_function_out
        && sig_param->data.mode != ir_var_function_inout) {
       ir->accept(this);
    }
 }

 if (!ir->callee->is_intrinsic()) {
    state->erase_all();
    this->killed_all = true;
 } else {
    if (ir->return_deref) {
       kill(new(this->lin_ctx) kill_entry(ir->return_deref->var, ~0));
    }

    foreach_two_lists(formal_node, &ir->callee->parameters,for (struct exec_node * formal_node = (&ir->callee->
parameters)->head_sentinel.next, * actual_node = (&ir->
actual_parameters)->head_sentinel.next, * __next1 = formal_node
->next, * __next2 = actual_node->next ; __next1 != __null
 && __next2 != __null ; formal_node = __next1, actual_node
 = __next2, __next1 = __next1->next, __next2 = __next2->
next)
                      actual_node, &ir->actual_parameters)for (struct exec_node * formal_node = (&ir->callee->
parameters)->head_sentinel.next, * actual_node = (&ir->
actual_parameters)->head_sentinel.next, * __next1 = formal_node
->next, * __next2 = actual_node->next ; __next1 != __null
 && __next2 != __null ; formal_node = __next1, actual_node
 = __next2, __next1 = __next1->next, __next2 = __next2->
next) {
       ir_variable *sig_param = (ir_variable *) formal_node;
       if (sig_param->data.mode == ir_var_function_out ||
           sig_param->data.mode == ir_var_function_inout) {
          ir_rvalue *ir = (ir_rvalue *) actual_node;
          ir_variable *var = ir->variable_referenced();
          kill(new(this->lin_ctx) kill_entry(var, ~0));
       }
    }
 }

 return visit_continue_with_parent;
539}

541void
542ir_copy_propagation_elements_visitor::handle_if_block(exec_list *instructions, exec_list *kills, bool *killed_all)
543{
 exec_list *orig_kills = this->kills;
 bool orig_killed_all = this->killed_all;

 this->kills = kills;
 this->killed_all = false;

 /* Populate the initial acp with a copy of the original */
 copy_propagation_state *orig_state = state;
 this->state = orig_state->clone();

 visit_list_elements(this, instructions);

 delete this->state;
 this->state = orig_state;

 *killed_all = this->killed_all;
 this->kills = orig_kills;
 this->killed_all = orig_killed_all;
562}

564ir_visitor_status
565ir_copy_propagation_elements_visitor::visit_enter(ir_if *ir)
566{
 ir->condition->accept(this);

 exec_list *new_kills = new(mem_ctx) exec_list;
 bool then_killed_all = false;
 bool else_killed_all = false;

 handle_if_block(&ir->then_instructions, new_kills, &then_killed_all);
 handle_if_block(&ir->else_instructions, new_kills, &else_killed_all);

 if (then_killed_all || else_killed_all) {
    state->erase_all();
    killed_all = true;
 } else {
    foreach_in_list_safe(kill_entry, k, new_kills)for (kill_entry *k = (!exec_node_is_tail_sentinel((new_kills)
->head_sentinel.next) ? (kill_entry *) ((new_kills)->head_sentinel
.next) : __null), *__next = (k) ? (!exec_node_is_tail_sentinel
((new_kills)->head_sentinel.next->next) ? (kill_entry *
) ((new_kills)->head_sentinel.next->next) : __null) : __null
; (k) != __null; (k) = __next, __next = __next ? (!exec_node_is_tail_sentinel
(__next->next) ? (kill_entry *) (__next->next) : __null
) : __null)
       kill(k);
 }

 ralloc_free(new_kills);

 /* handle_if_block() already descended into the children. */
 return visit_continue_with_parent;
588}

590void
591ir_copy_propagation_elements_visitor::handle_loop(ir_loop *ir, bool keep_acp)
592{
 exec_list *orig_kills = this->kills;
 bool orig_killed_all = this->killed_all;

 this->kills = new(mem_ctx) exec_list;
 this->killed_all = false;

 copy_propagation_state *orig_state = state;

 if (keep_acp) {
    /* Populate the initial acp with a copy of the original */
    this->state = orig_state->clone();
 } else {
    this->state = copy_propagation_state::create(mem_ctx);
 }

 visit_list_elements(this, &ir->body_instructions);

 delete this->state;
 this->state = orig_state;

 if (this->killed_all)
    this->state->erase_all();

 exec_list *new_kills = this->kills;
 this->kills = orig_kills;
 this->killed_all = this->killed_all || orig_killed_all;

 foreach_in_list_safe(kill_entry, k, new_kills)for (kill_entry *k = (!exec_node_is_tail_sentinel((new_kills)
->head_sentinel.next) ? (kill_entry *) ((new_kills)->head_sentinel
.next) : __null), *__next = (k) ? (!exec_node_is_tail_sentinel
((new_kills)->head_sentinel.next->next) ? (kill_entry *
) ((new_kills)->head_sentinel.next->next) : __null) : __null
; (k) != __null; (k) = __next, __next = __next ? (!exec_node_is_tail_sentinel
(__next->next) ? (kill_entry *) (__next->next) : __null
) : __null) {
    kill(k);
 }

 ralloc_free(new_kills);
625}

627ir_visitor_status
628ir_copy_propagation_elements_visitor::visit_enter(ir_loop *ir)
629{
 handle_loop(ir, false);
 handle_loop(ir, true);

 /* already descended into the children. */
 return visit_continue_with_parent;
635}

637/* Remove any entries currently in the ACP for this kill. */
638void
639ir_copy_propagation_elements_visitor::kill(kill_entry *k)
640{
 state->erase(k->var, k->write_mask);

 /* If we were on a list, remove ourselves before inserting */
 if (k->next)
    k->remove();

 this->kills->push_tail(k);
648}

650/**
* Adds directly-copied channels between vector variables to the available
* copy propagation list.
*/
654void
655ir_copy_propagation_elements_visitor::add_copy(ir_assignment *ir)
656{
 if (ir->condition)
2
←
Assuming field 'condition' is null→
3
←
Taking false branch→
    return;

 {
    ir_variable *lhs_var = ir->whole_variable_written();
    ir_dereference_variable *rhs = ir->rhs->as_dereference_variable();
4
←
Calling 'ir_instruction::as_dereference_variable'→
10
←
Returning from 'ir_instruction::as_dereference_variable'→

    if (lhs_var != NULL__null && rhs11.1
'rhs' is non-null
1
'rhs' is non-null
 && rhs->var != NULL__null && lhs_var != rhs->var) {
11
←
Assuming 'lhs_var' is not equal to NULL→
12
←
Assuming field 'var' is equal to NULL→
       if (lhs_var->data.mode == ir_var_shader_storage ||
           lhs_var->data.mode == ir_var_shader_shared ||
           rhs->var->data.mode == ir_var_shader_storage ||
           rhs->var->data.mode == ir_var_shader_shared ||
           lhs_var->data.precise != rhs->var->data.precise) {
          return;
       }
       state->write_full(lhs_var, rhs->var);
       return;
    }
 }

 int orig_swizzle[4] = {0, 1, 2, 3};
 int swizzle[4];

 ir_dereference_variable *lhs = ir->lhs->as_dereference_variable();
13
←
Calling 'ir_instruction::as_dereference_variable'→
19
←
Returning from 'ir_instruction::as_dereference_variable'→
 if (!lhs19.1
'lhs' is non-null
1
'lhs' is non-null
 || !(lhs->type->is_scalar() || lhs->type->is_vector()))
    return;

 if (lhs->var->data.mode == ir_var_shader_storage ||
20
←
Assuming field 'mode' is not equal to ir_var_shader_storage→
22
←
Taking false branch→
     lhs->var->data.mode == ir_var_shader_shared)
21
←
Assuming field 'mode' is not equal to ir_var_shader_shared→
    return;

 ir_dereference_variable *rhs = ir->rhs->as_dereference_variable();
23
←
Calling 'ir_instruction::as_dereference_variable'→
28
←
Returning from 'ir_instruction::as_dereference_variable'→
 if (!rhs28.1
'rhs' is non-null
1
'rhs' is non-null
) {
    ir_swizzle *swiz = ir->rhs->as_swizzle();
    if (!swiz)
return;

    rhs = swiz->val->as_dereference_variable();
    if (!rhs)
return;

    orig_swizzle[0] = swiz->mask.x;
    orig_swizzle[1] = swiz->mask.y;
    orig_swizzle[2] = swiz->mask.z;
    orig_swizzle[3] = swiz->mask.w;
 }

 if (rhs->var->data.mode == ir_var_shader_storage ||
29
←
Dereference of null pointer
     rhs->var->data.mode == ir_var_shader_shared)
    return;

 /* Move the swizzle channels out to the positions they match in the
  * destination.  We don't want to have to rewrite the swizzle[]
  * array every time we clear a bit of the write_mask.
  */
 int j = 0;
 for (int i = 0; i < 4; i++) {
    if (ir->write_mask & (1 << i))
swizzle[i] = orig_swizzle[j++];
 }

 int write_mask = ir->write_mask;
 if (lhs->var == rhs->var) {
    /* If this is a copy from the variable to itself, then we need
     * to be sure not to include the updated channels from this
     * instruction in the set of new source channels to be
     * copy-propagated from.
     */
    for (int i = 0; i < 4; i++) {
if (ir->write_mask & (1 << orig_swizzle[i]))
   write_mask &= ~(1 << i);
    }
 }

 if (lhs->var->data.precise != rhs->var->data.precise)
    return;

 state->write_elements(lhs->var, rhs->var, write_mask, swizzle);
735}

737bool
738do_copy_propagation_elements(exec_list *instructions)
739{
 ir_copy_propagation_elements_visitor v;

 visit_list_elements(&v, instructions);

 return v.progress;
745}

←

glsl-optimizer/src/compiler/glsl/ir.h

1/* -*- c++ -*- */
2/*
* 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.
*/

25#ifndef IR_H
26#define IR_H

28#include <stdio.h>
29#include <stdlib.h>

31#include "util/ralloc.h"
32#include "util/format/u_format.h"
33#include "util/half_float.h"
34#include "compiler/glsl_types.h"
35#include "list.h"
36#include "ir_visitor.h"
37#include "ir_hierarchical_visitor.h"

39#ifdef __cplusplus201703L

41/**
* \defgroup IR Intermediate representation nodes
*
* @{
*/

47/**
* 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.
*/
61enum ir_node_type {
 ir_type_dereference_array,
 ir_type_dereference_record,
 ir_type_dereference_variable,
 ir_type_constant,
 ir_type_expression,
 ir_type_swizzle,
 ir_type_texture,
 ir_type_variable,
 ir_type_assignment,
 ir_type_call,
 ir_type_function,
 ir_type_function_signature,
 ir_type_if,
 ir_type_loop,
 ir_type_loop_jump,
 ir_type_return,
 ir_type_precision,
 ir_type_typedecl,
 ir_type_discard,
 ir_type_demote,
 ir_type_emit_vertex,
 ir_type_end_primitive,
 ir_type_barrier,
 ir_type_max, /**< maximum ir_type enum number, for validation */
 ir_type_unset = ir_type_max
87};


90/**
* Base class of all IR instructions
*/
93class ir_instruction : public exec_node {
94public:
 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;
 void fprint(FILE *f) 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;

 bool is_rvalue() const
 {
    return ir_type == ir_type_dereference_array ||
           ir_type == ir_type_dereference_record ||
           ir_type == ir_type_dereference_variable ||
           ir_type == ir_type_constant ||
           ir_type == ir_type_expression ||
           ir_type == ir_type_swizzle ||
           ir_type == ir_type_texture;
 }

 bool is_dereference() const
 {
    return ir_type == ir_type_dereference_array ||
           ir_type == ir_type_dereference_record ||
           ir_type == ir_type_dereference_variable;
 }

 bool is_jump() const
 {
    return ir_type == ir_type_loop_jump ||
           ir_type == ir_type_return ||
           ir_type == ir_type_discard;
 }

 /**
  * \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.
  */
 /*@{*/
 #define AS_BASE(TYPE)                                \
 class ir_##TYPE *as_##TYPE()                         \
 {                                                    \
    assume(this != NULL)do { (static_cast <bool> (this != __null) ? void (0) : __assert_fail
 ("this != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); __builtin_assume(this != __null); } while
 (0);                             \
    return is_##TYPE() ? (ir_##TYPE *) this : NULL__null;   \
 }                                                    \
 const class ir_##TYPE *as_##TYPE() const             \
 {                                                    \
    assume(this != NULL)do { (static_cast <bool> (this != __null) ? void (0) : __assert_fail
 ("this != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); __builtin_assume(this != __null); } while
 (0);                             \
    return is_##TYPE() ? (ir_##TYPE *) this : NULL__null;   \
 }

 AS_BASE(rvalue)
 AS_BASE(dereference)
 AS_BASE(jump)
 #undef AS_BASE

 #define AS_CHILD(TYPE) \
 class ir_##TYPE * as_##TYPE() \
 { \
    assume(this != NULL)do { (static_cast <bool> (this != __null) ? void (0) : __assert_fail
 ("this != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); __builtin_assume(this != __null); } while
 (0);                                         \
    return ir_type == ir_type_##TYPE ? (ir_##TYPE *) this : NULL__null; \
 }                                                                      \
 const class ir_##TYPE * as_##TYPE() const                              \
 {                                                                      \
    assume(this != NULL)do { (static_cast <bool> (this != __null) ? void (0) : __assert_fail
 ("this != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); __builtin_assume(this != __null); } while
 (0);                                               \
    return ir_type == ir_type_##TYPE ? (const ir_##TYPE *) this : NULL__null; \
 }
 AS_CHILD(variable)
 AS_CHILD(function)
 AS_CHILD(dereference_array)
 AS_CHILD(dereference_variable)
5
←
'?' condition is true→
6
←
Loop condition is false.  Exiting loop→
7
←
Assuming field 'ir_type' is equal to ir_type_dereference_variable→
8
←
'?' condition is true→
9
←
Returning pointer, which participates in a condition later→
14
←
'?' condition is true→
15
←
Loop condition is false.  Exiting loop→
16
←
Assuming field 'ir_type' is equal to ir_type_dereference_variable→
17
←
'?' condition is true→
18
←
Returning pointer, which participates in a condition later→
24
←
'?' condition is true→
25
←
Loop condition is false.  Exiting loop→
26
←
'?' condition is true→
27
←
Returning pointer, which participates in a condition later→
 AS_CHILD(dereference_record)
 AS_CHILD(expression)
 AS_CHILD(loop)
 AS_CHILD(assignment)
 AS_CHILD(call)
 AS_CHILD(return)
 AS_CHILD(if)
 AS_CHILD(swizzle)
 AS_CHILD(texture)
 AS_CHILD(constant)
 AS_CHILD(discard)
 #undef AS_CHILD
 /*@}*/

 /**
  * IR equality method: Return true if the referenced instruction would
  * return the same value as this one.
  *
  * This intended to be used for CSE and algebraic optimizations, on rvalues
  * in particular.  No support for other instruction types (assignments,
  * jumps, calls, etc.) is planned.
  */
 virtual bool equals(const ir_instruction *ir,
                     enum ir_node_type ignore = ir_type_unset) const;

206protected:
 ir_instruction(enum ir_node_type t)
    : ir_type(t)
 {
 }

212private:
 ir_instruction()
 {
    assert(!"Should not get here.")(static_cast <bool> (!"Should not get here.") ? void (0
) : __assert_fail ("!\"Should not get here.\"", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
 }
217};


220/**
* The base class for all "values"/expression trees.
*/
223class ir_rvalue : public ir_instruction {
224public:
 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(void *mem_ctx,
                                                struct hash_table *variable_context = NULL__null);

 ir_rvalue *as_rvalue_to_saturate();

 virtual bool is_lvalue(const struct _mesa_glsl_parse_state * = NULL__null) const
 {
    return false;
 }

 /**
  * Get the variable that is ultimately referenced by an r-value
  */
 virtual ir_variable *variable_referenced() const
 {
    return NULL__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__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
  */
 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
  */
 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
  */
 virtual bool is_negative_one() const;

 /**
  * Determine if an r-value is an unsigned integer constant which can be
  * stored in 16 bits.
  *
  * \sa ir_constant::is_uint16_constant.
  */
 virtual bool is_uint16_constant() const { return false; }

 /**
  * 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);

320protected:
 ir_rvalue(enum ir_node_type t);
322};


325/**
* Variable storage classes
*/
328enum ir_variable_mode {
 ir_var_auto = 0,             /**< Function local variables and globals. */
 ir_var_uniform,              /**< Variable declared as a uniform. */
 ir_var_shader_storage,       /**< Variable declared as an ssbo. */
 ir_var_shader_shared,        /**< Variable declared as shared. */
 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 */
342};

344/**
* Enum keeping track of how a variable was declared.  For error checking of
* the gl_PerVertex redeclaration rules.
*/
348enum ir_var_declaration_type {
 /**
  * Normal declaration (for most variables, this means an explicit
  * declaration.  Exception: temporaries are always implicitly declared, but
  * they still use ir_var_declared_normally).
  *
  * Note: an ir_variable that represents a named interface block uses
  * ir_var_declared_normally.
  */
 ir_var_declared_normally = 0,

 /**
  * Variable was explicitly declared (or re-declared) in an unnamed
  * interface block.
  */
 ir_var_declared_in_block,

 /**
  * Variable is an implicitly declared built-in that has not been explicitly
  * re-declared by the shader.
  */
 ir_var_declared_implicitly,

 /**
  * Variable is implicitly generated by the compiler and should not be
  * visible via the API.
  */
 ir_var_hidden,
376};

378/**
* \brief Layout qualifiers for gl_FragDepth.
*
* The AMD/ARB_conservative_depth extensions allow gl_FragDepth to be redeclared
* with a layout qualifier.
*/
384enum 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
390};

392/**
* \brief Convert depth layout qualifier to string.
*/
395const char*
396depth_layout_string(ir_depth_layout layout);

398/**
* Description of built-in state associated with a uniform
*
* \sa ir_variable::state_slots
*/
403struct ir_state_slot {
 gl_state_index16 tokens[STATE_LENGTH5];
 int swizzle;
406};


409/**
* Get the string value for an 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.
*/
421const char *interpolation_string(unsigned interpolation);


424class ir_variable : public ir_instruction {
425public:
 ir_variable(const struct glsl_type *, const char *, ir_variable_mode);

 virtual ir_variable *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 *);


 /**
  * Determine whether or not a variable is part of a uniform or
  * shader storage block.
  */
 inline bool is_in_buffer_block() const
 {
    return (this->data.mode == ir_var_uniform ||
            this->data.mode == ir_var_shader_storage) &&
           this->interface_type != NULL__null;
 }

 /**
  * Determine whether or not a variable is part of a shader storage block.
  */
 inline bool is_in_shader_storage_block() const
 {
    return this->data.mode == ir_var_shader_storage &&
           this->interface_type != NULL__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
  * \c glsl_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
 {
    return this->type->without_array() == this->interface_type;
 }

 /**
  * Return whether this variable contains a bindless sampler/image.
  */
 inline bool contains_bindless() const
 {
    if (!this->type->contains_sampler() && !this->type->contains_image())
       return false;

    return this->data.bindless || this->data.mode != ir_var_uniform;
 }

 /**
  * Set this->interface_type on a newly created variable.
  */
 void init_interface_type(const struct glsl_type *type)
 {
    assert(this->interface_type == NULL)(static_cast <bool> (this->interface_type == __null)
 ? void (0) : __assert_fail ("this->interface_type == NULL"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
    this->interface_type = type;
    if (this->is_interface_instance()) {
       this->u.max_ifc_array_access =
          ralloc_array(this, int, type->length)((int *) ralloc_array_size(this, sizeof(int), type->length
));
       for (unsigned i = 0; i < type->length; i++) {
          this->u.max_ifc_array_access[i] = -1;
       }
    }
 }

 /**
  * Change this->interface_type on a variable that previously had a
  * different, but compatible, interface_type.  This is used during linking
  * to set the size of arrays in interface blocks.
  */
 void change_interface_type(const struct glsl_type *type)
 {
    if (this->u.max_ifc_array_access != NULL__null) {
       /* max_ifc_array_access has already been allocated, so make sure the
        * new interface has the same number of fields as the old one.
        */
       assert(this->interface_type->length == type->length)(static_cast <bool> (this->interface_type->length
 == type->length) ? void (0) : __assert_fail ("this->interface_type->length == type->length"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
    }
    this->interface_type = type;
 }

 /**
  * Change this->interface_type on a variable that previously had a
  * different, and incompatible, interface_type. This is used during
  * compilation to handle redeclaration of the built-in gl_PerVertex
  * interface block.
  */
 void reinit_interface_type(const struct glsl_type *type)
 {
    if (this->u.max_ifc_array_access != NULL__null) {
534#ifndef NDEBUG
       /* Redeclaring gl_PerVertex is only allowed if none of the built-ins
        * it defines have been accessed yet; so it's safe to throw away the
        * old max_ifc_array_access pointer, since all of its values are
        * zero.
        */
       for (unsigned i = 0; i < this->interface_type->length; i++)
          assert(this->u.max_ifc_array_access[i] == -1)(static_cast <bool> (this->u.max_ifc_array_access[i]
 == -1) ? void (0) : __assert_fail ("this->u.max_ifc_array_access[i] == -1"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
542#endif
       ralloc_free(this->u.max_ifc_array_access);
       this->u.max_ifc_array_access = NULL__null;
    }
    this->interface_type = NULL__null;
    init_interface_type(type);
 }

 const glsl_type *get_interface_type() const
 {
    return this->interface_type;
 }

 enum glsl_interface_packing get_interface_type_packing() const
 {
   return this->interface_type->get_interface_packing();
 }
 /**
  * Get the max_ifc_array_access pointer
  *
  * A "set" function is not needed because the array is dynmically allocated
  * as necessary.
  */
 inline int *get_max_ifc_array_access()
 {
    assert(this->data._num_state_slots == 0)(static_cast <bool> (this->data._num_state_slots == 0
) ? void (0) : __assert_fail ("this->data._num_state_slots == 0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
    return this->u.max_ifc_array_access;
 }

 inline unsigned get_num_state_slots() const
 {
    assert(!this->is_interface_instance()(static_cast <bool> (!this->is_interface_instance() ||
 this->data._num_state_slots == 0) ? void (0) : __assert_fail
 ("!this->is_interface_instance() || this->data._num_state_slots == 0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
           || this->data._num_state_slots == 0)(static_cast <bool> (!this->is_interface_instance() ||
 this->data._num_state_slots == 0) ? void (0) : __assert_fail
 ("!this->is_interface_instance() || this->data._num_state_slots == 0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
    return this->data._num_state_slots;
 }

 inline void set_num_state_slots(unsigned n)
 {
    assert(!this->is_interface_instance()(static_cast <bool> (!this->is_interface_instance() ||
 n == 0) ? void (0) : __assert_fail ("!this->is_interface_instance() || n == 0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
           || n == 0)(static_cast <bool> (!this->is_interface_instance() ||
 n == 0) ? void (0) : __assert_fail ("!this->is_interface_instance() || n == 0"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
    this->data._num_state_slots = n;
 }

 inline ir_state_slot *get_state_slots()
 {
    return this->is_interface_instance() ? NULL__null : this->u.state_slots;
 }

 inline const ir_state_slot *get_state_slots() const
 {
    return this->is_interface_instance() ? NULL__null : this->u.state_slots;
 }

 inline ir_state_slot *allocate_state_slots(unsigned n)
 {
    assert(!this->is_interface_instance())(static_cast <bool> (!this->is_interface_instance())
 ? void (0) : __assert_fail ("!this->is_interface_instance()"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));

    this->u.state_slots = ralloc_array(this, ir_state_slot, n)((ir_state_slot *) ralloc_array_size(this, sizeof(ir_state_slot
), n));
    this->data._num_state_slots = 0;

    if (this->u.state_slots != NULL__null)
       this->data._num_state_slots = n;

    return this->u.state_slots;
 }

 inline bool is_interpolation_flat() const
 {
    return this->data.interpolation == INTERP_MODE_FLAT ||
           this->type->contains_integer() ||
           this->type->contains_double();
 }

 inline bool is_name_ralloced() const
 {
    return this->name != ir_variable::tmp_name &&
           this->name != this->name_storage;
 }

 /**
  * Enable emitting extension warnings for this variable
  */
 void enable_extension_warning(const char *extension);

 /**
  * Get the extension warning string for this variable
  *
  * If warnings are not enabled, \c NULL is returned.
  */
 const char *get_extension_warning() const;

 /**
  * Declared type of the variable
  */
 const struct glsl_type *type;

 /**
  * Declared name of the variable
  */
 const char *name;

643private:
 /**
  * If the name length fits into name_storage, it's used, otherwise
  * the name is ralloc'd. shader-db mining showed that 70% of variables
  * fit here. This is a win over ralloc where only ralloc_header has
  * 20 bytes on 64-bit (28 bytes with DEBUG), and we can also skip malloc.
  */
 char name_storage[16];

652public:
 struct ir_variable_data {

    /**
     * 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 sample:1;
    unsigned patch:1;
    /**
     * Was an 'invariant' qualifier explicitly set in the shader?
     *
     * This is used to cross validate qualifiers.
     */
    unsigned explicit_invariant:1;
    /**
     * Is the variable invariant?
     *
     * It can happen either by having the 'invariant' qualifier
     * explicitly set in the shader or by being used in calculations
     * of other invariant variables.
     */
    unsigned invariant:1;
    unsigned precise: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 maintained in the ast_to_hir.cpp path and during linking,
     * but 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;

    /**
     * When separate shader programs are enabled, only input/outputs between
     * the stages of a multi-stage separate program can be safely removed
     * from the shader interface. Other input/outputs must remains active.
     */
    unsigned always_active_io:1;

    /**
     * Enum indicating how the variable was declared.  See
     * ir_var_declaration_type.
     *
     * This is used to detect certain kinds of illegal variable redeclarations.
     */
    unsigned how_declared:2;

    /**
     * Storage class of the variable.
     *
     * \sa ir_variable_mode
     */
    unsigned mode:4;

    /**
     * Interpolation mode for shader inputs / outputs
     *
     * \sa glsl_interp_mode
     */
    unsigned interpolation:2;

    /**
     * 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;

    /**
     * Was an initial component explicitly set in the shader?
     */
    unsigned explicit_component: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;

    /**
     * Is this varying used by transform feedback?
     *
     * This is used by the linker to decide if it's safe to pack the varying.
     */
    unsigned is_xfb:1;

    /**
     * Is this varying used only by transform feedback?
     *
     * This is used by the linker to decide if its safe to pack the varying.
     */
    unsigned is_xfb_only:1;

    /**
     * Was a transform feedback buffer set in the shader?
     */
    unsigned explicit_xfb_buffer:1;

    /**
     * Was a transform feedback offset set in the shader?
     */
    unsigned explicit_xfb_offset:1;

    /**
     * Was a transform feedback stride set in the shader?
     */
    unsigned explicit_xfb_stride: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;

    /**
     * Layout of the matrix.  Uses glsl_matrix_layout values.
     */
    unsigned matrix_layout:2;

    /**
     * Non-zero if this variable was created by lowering a named interface
     * block.
     */
    unsigned from_named_ifc_block:1;

    /**
     * Non-zero if the variable must be a shader input. This is useful for
     * constraints on function parameters.
     */
    unsigned must_be_shader_input:1;

    /**
     * Output index for dual source blending.
     *
     * \note
     * The GLSL spec only allows the values 0 or 1 for the index in \b dual
     * source blending.
     */
    unsigned index:1;

    /**
     * Precision qualifier.
     *
     * In desktop GLSL we do not care about precision qualifiers at all, in
     * fact, the spec says that precision qualifiers are ignored.
     *
     * To make things easy, we make it so that this field is always
     * GLSL_PRECISION_NONE on desktop shaders. This way all the variables
     * have the same precision value and the checks we add in the compiler
     * for this field will never break a desktop shader compile.
     */
    unsigned precision: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:3;

    /**
     * Memory qualifiers.
     */
    unsigned memory_read_only:1; /**< "readonly" qualifier. */
    unsigned memory_write_only:1; /**< "writeonly" qualifier. */
    unsigned memory_coherent:1;
    unsigned memory_volatile:1;
    unsigned memory_restrict:1;

    /**
     * ARB_shader_storage_buffer_object
     */
    unsigned from_ssbo_unsized_array:1; /**< unsized array buffer variable. */

    unsigned implicit_sized_array:1;

    /**
     * Whether this is a fragment shader output implicitly initialized with
     * the previous contents of the specified render target at the
     * framebuffer location corresponding to this shader invocation.
     */
    unsigned fb_fetch_output:1;

    /**
     * Non-zero if this variable is considered bindless as defined by
     * ARB_bindless_texture.
     */
    unsigned bindless:1;

    /**
     * Non-zero if this variable is considered bound as defined by
     * ARB_bindless_texture.
     */
    unsigned bound:1;

    /**
     * Emit a warning if this variable is accessed.
     */
 private:
    uint8_t warn_extension_index;

 public:
    /**
     * Image internal format if specified explicitly, otherwise
     * PIPE_FORMAT_NONE.
     */
    enum pipe_format image_format;

 private:
    /**
     * Number of state slots used
     *
     * \note
     * This could be stored in as few as 7-bits, if necessary.  If it is made
     * smaller, add an assertion to \c ir_variable::allocate_state_slots to
     * be safe.
     */
    uint16_t _num_state_slots;

 public:
    /**
     * Initial binding point for a sampler, atomic, or UBO.
     *
     * For array types, this represents the binding point for the first element.
     */
    uint16_t binding;

    /**
     * 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.
     *   - Geometry shader input: one of the values from \c gl_varying_slot.
     *   - Geometry 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.
     *   - Non-UBO Uniforms: explicit location until linking then reused to
     *     store uniform slot number.
     *   - 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;

    /**
     * for glsl->tgsi/mesa IR we need to store the index into the
     * parameters for uniforms, initially the code overloaded location
     * but this causes problems with indirect samplers and AoA.
     * This is assigned in _mesa_generate_parameters_list_for_uniforms.
     */
    int param_index;

    /**
     * Vertex stream output identifier.
     *
     * For packed outputs, bit 31 is set and bits [2*i+1,2*i] indicate the
     * stream of the i-th component.
     */
    unsigned stream;

    /**
     * Atomic, transform feedback or block member offset.
     */
    unsigned offset;

    /**
     * Highest element accessed with a constant expression array index
     *
     * Not used for non-array variables. -1 is never accessed.
     */
    int max_array_access;

    /**
     * Transform feedback buffer.
     */
    unsigned xfb_buffer;

    /**
     * Transform feedback stride.
     */
    unsigned xfb_stride;

    /**
     * Allow (only) ir_variable direct access private members.
     */
    friend class ir_variable;
 } data;

 /**
  * 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;

1005private:
 static const char *const warn_extension_table[];

 union {
    /**
     * For variables which satisfy the is_interface_instance() predicate,
     * this points to an array of integers such that if the ith member of
     * the interface block is an array, max_ifc_array_access[i] is the
     * maximum array element of that member that has been accessed.  If the
     * ith member of the interface block is not an array,
     * max_ifc_array_access[i] is unused.
     *
     * For variables whose type is not an interface block, this pointer is
     * NULL.
     */
    int *max_ifc_array_access;

    /**
     * Built-in state that backs this uniform
     *
     * Once set at variable creation, \c state_slots must remain invariant.
     *
     * If the variable is not a uniform, \c _num_state_slots will be zero
     * and \c state_slots will be \c NULL.
     */
    ir_state_slot *state_slots;
 } u;

 /**
  * 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;

 /**
  * Name used for anonymous compiler temporaries
  */
 static const char tmp_name[];

1046public:
 /**
  * Should the construct keep names for ir_var_temporary variables?
  *
  * When this global is false, names passed to the constructor for
  * \c ir_var_temporary variables will be dropped.  Instead, the variable will
  * be named "compiler_temp".  This name will be in static storage.
  *
  * \warning
  * \b NEVER change the mode of an \c ir_var_temporary.
  *
  * \warning
  * This variable is \b not thread-safe.  It is global, \b not
  * per-context. It begins life false.  A context can, at some point, make
  * it true.  From that point on, it will be true forever.  This should be
  * okay since it will only be set true while debugging.
  */
 static bool temporaries_allocate_names;
1064};

1066/**
* A function that returns whether a built-in function is available in the
* current shading language (based on version, ES or desktop, and extensions).
*/
1070typedef bool (*builtin_available_predicate)(const _mesa_glsl_parse_state *);

1072#define MAKE_INTRINSIC_FOR_TYPE(op, t)ir_intrinsic_generic_op - ir_intrinsic_generic_load + ir_intrinsic_t_load \
 ir_intrinsic_generic_ ## op - ir_intrinsic_generic_load + ir_intrinsic_ ## t ## _ ## load

1075#define MAP_INTRINSIC_TO_TYPE(i, t)ir_intrinsic_id(int(i) - int(ir_intrinsic_generic_load) + int
(ir_intrinsic_t_load)) \
 ir_intrinsic_id(int(i) - int(ir_intrinsic_generic_load) + int(ir_intrinsic_ ## t ## _ ## load))

1078enum ir_intrinsic_id {
 ir_intrinsic_invalid = 0,

 /**
  * \name Generic intrinsics
  *
  * Each of these intrinsics has a specific version for shared variables and
  * SSBOs.
  */
 /*@{*/
 ir_intrinsic_generic_load,
 ir_intrinsic_generic_store,
 ir_intrinsic_generic_atomic_add,
 ir_intrinsic_generic_atomic_and,
 ir_intrinsic_generic_atomic_or,
 ir_intrinsic_generic_atomic_xor,
 ir_intrinsic_generic_atomic_min,
 ir_intrinsic_generic_atomic_max,
 ir_intrinsic_generic_atomic_exchange,
 ir_intrinsic_generic_atomic_comp_swap,
 /*@}*/

 ir_intrinsic_atomic_counter_read,
 ir_intrinsic_atomic_counter_increment,
 ir_intrinsic_atomic_counter_predecrement,
 ir_intrinsic_atomic_counter_add,
 ir_intrinsic_atomic_counter_and,
 ir_intrinsic_atomic_counter_or,
 ir_intrinsic_atomic_counter_xor,
 ir_intrinsic_atomic_counter_min,
 ir_intrinsic_atomic_counter_max,
 ir_intrinsic_atomic_counter_exchange,
 ir_intrinsic_atomic_counter_comp_swap,

 ir_intrinsic_image_load,
 ir_intrinsic_image_store,
 ir_intrinsic_image_atomic_add,
 ir_intrinsic_image_atomic_and,
 ir_intrinsic_image_atomic_or,
 ir_intrinsic_image_atomic_xor,
 ir_intrinsic_image_atomic_min,
 ir_intrinsic_image_atomic_max,
 ir_intrinsic_image_atomic_exchange,
 ir_intrinsic_image_atomic_comp_swap,
 ir_intrinsic_image_size,
 ir_intrinsic_image_samples,
 ir_intrinsic_image_atomic_inc_wrap,
 ir_intrinsic_image_atomic_dec_wrap,

 ir_intrinsic_ssbo_load,
 ir_intrinsic_ssbo_store = MAKE_INTRINSIC_FOR_TYPE(store, ssbo)ir_intrinsic_generic_store - ir_intrinsic_generic_load + ir_intrinsic_ssbo_load,
 ir_intrinsic_ssbo_atomic_add = MAKE_INTRINSIC_FOR_TYPE(atomic_add, ssbo)ir_intrinsic_generic_atomic_add - ir_intrinsic_generic_load +
 ir_intrinsic_ssbo_load,
 ir_intrinsic_ssbo_atomic_and = MAKE_INTRINSIC_FOR_TYPE(atomic_and, ssbo)ir_intrinsic_generic_atomic_and - ir_intrinsic_generic_load +
 ir_intrinsic_ssbo_load,
 ir_intrinsic_ssbo_atomic_or = MAKE_INTRINSIC_FOR_TYPE(atomic_or, ssbo)ir_intrinsic_generic_atomic_or - ir_intrinsic_generic_load + ir_intrinsic_ssbo_load,
 ir_intrinsic_ssbo_atomic_xor = MAKE_INTRINSIC_FOR_TYPE(atomic_xor, ssbo)ir_intrinsic_generic_atomic_xor - ir_intrinsic_generic_load +
 ir_intrinsic_ssbo_load,
 ir_intrinsic_ssbo_atomic_min = MAKE_INTRINSIC_FOR_TYPE(atomic_min, ssbo)ir_intrinsic_generic_atomic_min - ir_intrinsic_generic_load +
 ir_intrinsic_ssbo_load,
 ir_intrinsic_ssbo_atomic_max = MAKE_INTRINSIC_FOR_TYPE(atomic_max, ssbo)ir_intrinsic_generic_atomic_max - ir_intrinsic_generic_load +
 ir_intrinsic_ssbo_load,
 ir_intrinsic_ssbo_atomic_exchange = MAKE_INTRINSIC_FOR_TYPE(atomic_exchange, ssbo)ir_intrinsic_generic_atomic_exchange - ir_intrinsic_generic_load
 + ir_intrinsic_ssbo_load,
 ir_intrinsic_ssbo_atomic_comp_swap = MAKE_INTRINSIC_FOR_TYPE(atomic_comp_swap, ssbo)ir_intrinsic_generic_atomic_comp_swap - ir_intrinsic_generic_load
 + ir_intrinsic_ssbo_load,

 ir_intrinsic_memory_barrier,
 ir_intrinsic_shader_clock,
 ir_intrinsic_group_memory_barrier,
 ir_intrinsic_memory_barrier_atomic_counter,
 ir_intrinsic_memory_barrier_buffer,
 ir_intrinsic_memory_barrier_image,
 ir_intrinsic_memory_barrier_shared,
 ir_intrinsic_begin_invocation_interlock,
 ir_intrinsic_end_invocation_interlock,

 ir_intrinsic_vote_all,
 ir_intrinsic_vote_any,
 ir_intrinsic_vote_eq,
 ir_intrinsic_ballot,
 ir_intrinsic_read_invocation,
 ir_intrinsic_read_first_invocation,

 ir_intrinsic_helper_invocation,

 ir_intrinsic_shared_load,
 ir_intrinsic_shared_store = MAKE_INTRINSIC_FOR_TYPE(store, shared)ir_intrinsic_generic_store - ir_intrinsic_generic_load + ir_intrinsic_shared_load,
 ir_intrinsic_shared_atomic_add = MAKE_INTRINSIC_FOR_TYPE(atomic_add, shared)ir_intrinsic_generic_atomic_add - ir_intrinsic_generic_load +
 ir_intrinsic_shared_load,
 ir_intrinsic_shared_atomic_and = MAKE_INTRINSIC_FOR_TYPE(atomic_and, shared)ir_intrinsic_generic_atomic_and - ir_intrinsic_generic_load +
 ir_intrinsic_shared_load,
 ir_intrinsic_shared_atomic_or = MAKE_INTRINSIC_FOR_TYPE(atomic_or, shared)ir_intrinsic_generic_atomic_or - ir_intrinsic_generic_load + ir_intrinsic_shared_load,
 ir_intrinsic_shared_atomic_xor = MAKE_INTRINSIC_FOR_TYPE(atomic_xor, shared)ir_intrinsic_generic_atomic_xor - ir_intrinsic_generic_load +
 ir_intrinsic_shared_load,
 ir_intrinsic_shared_atomic_min = MAKE_INTRINSIC_FOR_TYPE(atomic_min, shared)ir_intrinsic_generic_atomic_min - ir_intrinsic_generic_load +
 ir_intrinsic_shared_load,
 ir_intrinsic_shared_atomic_max = MAKE_INTRINSIC_FOR_TYPE(atomic_max, shared)ir_intrinsic_generic_atomic_max - ir_intrinsic_generic_load +
 ir_intrinsic_shared_load,
 ir_intrinsic_shared_atomic_exchange = MAKE_INTRINSIC_FOR_TYPE(atomic_exchange, shared)ir_intrinsic_generic_atomic_exchange - ir_intrinsic_generic_load
 + ir_intrinsic_shared_load,
 ir_intrinsic_shared_atomic_comp_swap = MAKE_INTRINSIC_FOR_TYPE(atomic_comp_swap, shared)ir_intrinsic_generic_atomic_comp_swap - ir_intrinsic_generic_load
 + ir_intrinsic_shared_load,
1167};

1169/*@{*/
1170/**
* The representation of a function instance; may be the full definition or
* simply a prototype.
*/
1174class ir_function_signature : public ir_instruction {
 /* An ir_function_signature will be part of the list of signatures in
  * an ir_function.
  */
1178public:
 ir_function_signature(const glsl_type *return_type,
                       builtin_available_predicate builtin_avail = NULL__null);

 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(void *mem_ctx,
                                        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 The precision qualifier is stored separately in return_precision.
  */
 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;

 /*
  * Precision qualifier for the return type.
  *
  * See the comment for ir_variable_data::precision for more details.
  */
 unsigned return_precision:2;

 /** Whether or not this function signature is a built-in. */
 bool is_builtin() const;

 /**
  * Whether or not this function is an intrinsic to be implemented
  * by the driver.
  */
 inline bool is_intrinsic() const
 {
    return intrinsic_id != ir_intrinsic_invalid;
 }

 /** Indentifier for this intrinsic. */
 enum ir_intrinsic_id intrinsic_id;

 /** Whether or not a built-in is available for this shader. */
 bool is_builtin_available(const _mesa_glsl_parse_state *state) const;

 /** Body of instructions in the function. */
 struct exec_list body;

1285private:
 /**
  * A function pointer to a predicate that answers whether a built-in
  * function is available in the current shader.  NULL if not a built-in.
  */
 builtin_available_predicate builtin_avail;

 /** 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(void *mem_ctx,
                                                   const struct exec_list &body,
				     struct hash_table *variable_context,
				     ir_constant **result);
1315};


1318/**
* Header for tracking multiple overloaded functions with the same name.
* Contains a list of ir_function_signatures representing each of the
* actual functions.
*/
1323class ir_function : public ir_instruction {
1324public:
 ir_function(const char *name);

 virtual ir_function *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 *);

 void add_signature(ir_function_signature *sig)
 {
    sig->_function = this;
    this->signatures.push_tail(sig);
 }

 /**
  * 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(_mesa_glsl_parse_state *state,
                                           const exec_list *actual_param,
                                           bool allow_builtins,
			     bool *match_is_exact);

 /**
  * Find a signature that matches a set of actual parameters, taking implicit
  * conversions into account.
  */
 ir_function_signature *matching_signature(_mesa_glsl_parse_state *state,
                                           const exec_list *actual_param,
                                           bool allow_builtins);

 /**
  * Find a signature that exactly matches a set of actual parameters without
  * any implicit type conversions.
  */
 ir_function_signature *exact_matching_signature(_mesa_glsl_parse_state *state,
                                                 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;

 /**
  * is this function a subroutine type declaration
  * e.g. subroutine void type1(float arg1);
  */
 bool is_subroutine;

 /**
  * is this function associated to a subroutine type
  * e.g. subroutine (type1, type2) function_name { function_body };
  * would have num_subroutine_types 2,
  * and pointers to the type1 and type2 types.
  */
 int num_subroutine_types;
 const struct glsl_type **subroutine_types;

 int subroutine_index;
1395};

1397inline const char *ir_function_signature::function_name() const
1398{
 return this->_function->name;
1400}
1401/*@}*/


1404/**
* IR instruction representing high-level if-statements
*/
1407class ir_if : public ir_instruction {
1408public:
 ir_if(ir_rvalue *condition)
    : ir_instruction(ir_type_if), condition(condition)
 {
 }

 virtual ir_if *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 *);

 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;
1428};


1431/**
* IR instruction representing a high-level loop structure.
*/
1434class ir_loop : public ir_instruction {
1435public:
 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 *);

 /** List of ir_instruction that make up the body of the loop. */
 exec_list body_instructions;
1449};


1452class ir_assignment : public ir_instruction {
1453public:
 ir_assignment(ir_rvalue *lhs, ir_rvalue *rhs, ir_rvalue *condition = NULL__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(void *mem_ctx,
                                                struct hash_table *variable_context = NULL__null);

 virtual void accept(ir_visitor *v)
 {
    v->visit(this);
 }

 virtual ir_visitor_status accept(ir_hierarchical_visitor *);

 /**
  * 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;
1532};

1534#include "ir_expression_operation.h"

1536extern const char *const ir_expression_operation_strings[ir_last_opcode + 1];
1537extern const char *const ir_expression_operation_enum_strings[ir_last_opcode + 1];

1539class ir_expression : public ir_rvalue {
1540public:
 ir_expression(int op, const struct glsl_type *type,
               ir_rvalue *op0, ir_rvalue *op1 = NULL__null,
               ir_rvalue *op2 = NULL__null, ir_rvalue *op3 = NULL__null);

 /**
  * Constructor for unary operation expressions
  */
 ir_expression(int op, ir_rvalue *);

 /**
  * Constructor for binary operation expressions
  */
 ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1);

 /**
  * Constructor for ternary operation expressions
  */
 ir_expression(int op, ir_rvalue *op0, ir_rvalue *op1, ir_rvalue *op2);

 virtual bool equals(const ir_instruction *ir,
                     enum ir_node_type ignore = ir_type_unset) const;

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

 /**
  * Attempt to constant-fold the expression
  *
  * The "variable_context" hash table links ir_variable * to ir_constant *
  * that represent the variables' values.  \c NULL represents an empty
  * context.
  *
  * If the expression cannot be constant folded, this method will return
  * \c NULL.
  */
 virtual ir_constant *constant_expression_value(void *mem_ctx,
                                                struct hash_table *variable_context = NULL__null);

 /**
  * This is only here for ir_reader to used for testing purposes please use
  * the precomputed num_operands field if you need the number of operands.
  */
 static unsigned get_num_operands(ir_expression_operation);

 /**
  * Return whether the expression operates on vectors horizontally.
  */
 bool is_horizontal() const
 {
    return operation == ir_binop_all_equal ||
           operation == ir_binop_any_nequal ||
           operation == ir_binop_dot ||
           operation == ir_binop_vector_extract ||
           operation == ir_triop_vector_insert ||
           operation == ir_binop_ubo_load ||
           operation == ir_quadop_vector;
 }

 /**
  * Do a reverse-lookup to translate the given string into an operator.
  */
 static ir_expression_operation get_operator(const char *);

 virtual void accept(ir_visitor *v)
 {
    v->visit(this);
 }

 virtual ir_visitor_status accept(ir_hierarchical_visitor *);

 virtual ir_variable *variable_referenced() const;

 /**
  * Determine the number of operands used by an expression
  */
 void init_num_operands()
 {
    if (operation == ir_quadop_vector) {
       num_operands = this->type->vector_elements;
    } else {
       num_operands = get_num_operands(operation);
    }
 }

 ir_expression_operation operation;
 ir_rvalue *operands[4];
 uint8_t num_operands;
1627};


1630/**
* HIR instruction representing a high-level function call, containing a list
* of parameters and returning a value in the supplied temporary.
*/
1634class ir_call : public ir_instruction {
1635public:
 ir_call(ir_function_signature *callee,
  ir_dereference_variable *return_deref,
  exec_list *actual_parameters)
    : ir_instruction(ir_type_call), return_deref(return_deref), callee(callee), sub_var(NULL__null), array_idx(NULL__null)
 {
    assert(callee->return_type != NULL)(static_cast <bool> (callee->return_type != __null) ?
 void (0) : __assert_fail ("callee->return_type != NULL", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    actual_parameters->move_nodes_to(& this->actual_parameters);
 }

 ir_call(ir_function_signature *callee,
  ir_dereference_variable *return_deref,
  exec_list *actual_parameters,
  ir_variable *var, ir_rvalue *array_idx)
    : ir_instruction(ir_type_call), return_deref(return_deref), callee(callee), sub_var(var), array_idx(array_idx)
 {
    assert(callee->return_type != NULL)(static_cast <bool> (callee->return_type != __null) ?
 void (0) : __assert_fail ("callee->return_type != NULL", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    actual_parameters->move_nodes_to(& this->actual_parameters);
 }

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

 virtual ir_constant *constant_expression_value(void *mem_ctx,
                                                struct hash_table *variable_context = NULL__null);

 virtual void accept(ir_visitor *v)
 {
    v->visit(this);
 }

 virtual ir_visitor_status accept(ir_hierarchical_visitor *);

 /**
  * Get the name of the function being called.
  */
 const char *callee_name() const
 {
    return callee->function_name();
 }

 /**
  * Generates an inline version of the function before @ir,
  * storing the return value in return_deref.
  */
 void generate_inline(ir_instruction *ir);

 /**
  * Storage for the function's return value.
  * This must be NULL if the return type is void.
  */
 ir_dereference_variable *return_deref;

 /**
  * The specific function signature being called.
  */
 ir_function_signature *callee;

 /* List of ir_rvalue of paramaters passed in this call. */
 exec_list actual_parameters;

 /*
  * ARB_shader_subroutine support -
  * the subroutine uniform variable and array index
  * rvalue to be used in the lowering pass later.
  */
 ir_variable *sub_var;
 ir_rvalue *array_idx;
1702};


1705/**
* \name Jump-like IR instructions.
*
* These include \c break, \c continue, \c return, and \c discard.
*/
1710/*@{*/
1711class ir_jump : public ir_instruction {
1712protected:
 ir_jump(enum ir_node_type t)
    : ir_instruction(t)
 {
 }
1717};

1719class ir_return : public ir_jump {
1720public:
 ir_return()
    : ir_jump(ir_type_return), value(NULL__null)
 {
 }

 ir_return(ir_rvalue *value)
    : ir_jump(ir_type_return), value(value)
 {
 }

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

 ir_rvalue *get_value() const
 {
    return value;
 }

 virtual void accept(ir_visitor *v)
 {
    v->visit(this);
 }

 virtual ir_visitor_status accept(ir_hierarchical_visitor *);

 ir_rvalue *value;
1746};


1749/**
* Jump instructions used inside loops
*
* These include \c break and \c continue.  The \c break within a loop is
* different from the \c break within a switch-statement.
*
* \sa ir_switch_jump
*/
1757class ir_loop_jump : public ir_jump {
1758public:
 enum jump_mode {
    jump_break,
    jump_continue
 };

 ir_loop_jump(jump_mode mode)
    : ir_jump(ir_type_loop_jump)
 {
    this->mode = mode;
 }

 virtual ir_loop_jump *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 *);

 bool is_break() const
 {
    return mode == jump_break;
 }

 bool is_continue() const
 {
    return mode == jump_continue;
 }

 /** Mode selector for the jump instruction. */
 enum jump_mode mode;
1791};

1793/**
* IR instruction representing discard statements.
*/
1796class ir_discard : public ir_jump {
1797public:
 ir_discard()
    : ir_jump(ir_type_discard)
 {
    this->condition = NULL__null;
 }

 ir_discard(ir_rvalue *cond)
    : ir_jump(ir_type_discard)
 {
    this->condition = cond;
 }

 virtual ir_discard *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 *);

 ir_rvalue *condition;
1820};
1821/*@}*/


1824/**
* IR instruction representing demote statements from
* GL_EXT_demote_to_helper_invocation.
*/
1828class ir_demote : public ir_instruction {
1829public:
 ir_demote()
    : ir_instruction(ir_type_demote)
 {
 }

 virtual ir_demote *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 *);
1843};


1846/**
* Texture sampling opcodes used in ir_texture
*/
1849enum ir_texture_opcode {
 ir_tex,		/**< Regular texture look-up */
 ir_txb,		/**< Texture look-up with LOD bias */
 ir_txl,		/**< Texture look-up with explicit LOD */
 ir_txd,		/**< Texture look-up with partial derivatvies */
 ir_txf,		/**< Texel fetch with explicit LOD */
 ir_txf_ms,           /**< Multisample texture fetch */
 ir_txs,		/**< Texture size */
 ir_lod,		/**< Texture lod query */
 ir_tg4,		/**< Texture gather */
 ir_query_levels,     /**< Texture levels query */
 ir_texture_samples,  /**< Texture samples query */
 ir_samples_identical, /**< Query whether all samples are definitely identical. */
1862};


1865/**
* IR instruction to sample a texture
*
* The specific form of the IR instruction depends on the \c mode value
* selected from \c ir_texture_opcodes.  In the printed IR, these will
* appear as:
*
*                                    Texel offset (0 or an expression)
*                                    | Projection divisor
*                                    | |  Shadow comparator
*                                    | |  |
*                                    v v  v
* (tex <type> <sampler> <coordinate> 0 1 ( ))
* (txb <type> <sampler> <coordinate> 0 1 ( ) <bias>)
* (txl <type> <sampler> <coordinate> 0 1 ( ) <lod>)
* (txd <type> <sampler> <coordinate> 0 1 ( ) (dPdx dPdy))
* (txf <type> <sampler> <coordinate> 0       <lod>)
* (txf_ms
*      <type> <sampler> <coordinate>         <sample_index>)
* (txs <type> <sampler> <lod>)
* (lod <type> <sampler> <coordinate>)
* (tg4 <type> <sampler> <coordinate> <offset> <component>)
* (query_levels <type> <sampler>)
* (samples_identical <sampler> <coordinate>)
*/
1890class ir_texture : public ir_rvalue {
1891public:
 ir_texture(enum ir_texture_opcode op)
    : ir_rvalue(ir_type_texture),
      op(op), sampler(NULL__null), coordinate(NULL__null), projector(NULL__null),
      shadow_comparator(NULL__null), offset(NULL__null)
 {
    memset(&lod_info, 0, sizeof(lod_info));
 }

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

 virtual ir_constant *constant_expression_value(void *mem_ctx,
                                                struct hash_table *variable_context = NULL__null);

 virtual void accept(ir_visitor *v)
 {
    v->visit(this);
 }

 virtual ir_visitor_status accept(ir_hierarchical_visitor *);

 virtual bool equals(const ir_instruction *ir,
                     enum ir_node_type ignore = ir_type_unset) const;

 /**
  * Return a string representing the ir_texture_opcode.
  */
 const char *opcode_string();

 /** Set the sampler and type. */
 void set_sampler(ir_dereference *sampler, const glsl_type *type);

 static bool has_lod(const glsl_type *sampler_type);

 /**
  * Do a reverse-lookup to translate a string into an ir_texture_opcode.
  */
 static ir_texture_opcode get_opcode(const char *);

 enum ir_texture_opcode op;

 /** Sampler to use for the texture access. */
 ir_dereference *sampler;

 /** Texture coordinate to sample */
 ir_rvalue *coordinate;

 /**
  * Value used for projective divide.
  *
  * If there is no projective divide (the common case), this will be
  * \c NULL.  Optimization passes should check for this to point to a constant
  * of 1.0 and replace that with \c NULL.
  */
 ir_rvalue *projector;

 /**
  * Coordinate used for comparison on shadow look-ups.
  *
  * If there is no shadow comparison, this will be \c NULL.  For the
  * \c ir_txf opcode, this *must* be \c NULL.
  */
 ir_rvalue *shadow_comparator;

 /** Texel offset. */
 ir_rvalue *offset;

 union {
    ir_rvalue *lod;		/**< Floating point LOD */
    ir_rvalue *bias;		/**< Floating point LOD bias */
    ir_rvalue *sample_index;  /**< MSAA sample index */
    ir_rvalue *component;     /**< Gather component selector */
    struct {
ir_rvalue *dPdx;	/**< Partial derivative of coordinate wrt X */
ir_rvalue *dPdy;	/**< Partial derivative of coordinate wrt Y */
    } grad;
 } lod_info;
1968};


1971struct ir_swizzle_mask {
 unsigned x:2;
 unsigned y:2;
 unsigned z:2;
 unsigned w:2;

 /**
  * Number of components in the swizzle.
  */
 unsigned num_components:3;

 /**
  * Does the swizzle contain duplicate components?
  *
  * L-value swizzles cannot contain duplicate components.
  */
 unsigned has_duplicates:1;
1988};


1991class ir_swizzle : public ir_rvalue {
1992public:
 ir_swizzle(ir_rvalue *, unsigned x, unsigned y, unsigned z, unsigned w,
            unsigned count);

 ir_swizzle(ir_rvalue *val, const unsigned *components, unsigned count);

 ir_swizzle(ir_rvalue *val, ir_swizzle_mask mask);

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

 virtual ir_constant *constant_expression_value(void *mem_ctx,
                                                struct hash_table *variable_context = NULL__null);

 /**
  * 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);
 }

 virtual ir_visitor_status accept(ir_hierarchical_visitor *);

 virtual bool equals(const ir_instruction *ir,
                     enum ir_node_type ignore = ir_type_unset) const;

 bool is_lvalue(const struct _mesa_glsl_parse_state *state) const
 {
    return val->is_lvalue(state) && !mask.has_duplicates;
 }

 /**
  * Get the variable that is ultimately referenced by an r-value
  */
 virtual ir_variable *variable_referenced() const;

 ir_rvalue *val;
 ir_swizzle_mask mask;

2033private:
 /**
  * Initialize the mask component of a swizzle
  *
  * This is used by the \c ir_swizzle constructors.
  */
 void init_mask(const unsigned *components, unsigned count);
2040};


2043class ir_dereference : public ir_rvalue {
2044public:
 virtual ir_dereference *clone(void *mem_ctx, struct hash_table *) const = 0;

 bool is_lvalue(const struct _mesa_glsl_parse_state *state) const;

 /**
  * Get the variable that is ultimately referenced by an r-value
  */
 virtual ir_variable *variable_referenced() const = 0;

 /**
  * Get the precision. This can either come from the eventual variable that
  * is dereferenced, or from a record member.
  */
 virtual int precision() const = 0;

2060protected:
 ir_dereference(enum ir_node_type t)
    : ir_rvalue(t)
 {
 }
2065};


2068class ir_dereference_variable : public ir_dereference {
2069public:
 ir_dereference_variable(ir_variable *var);

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

 virtual ir_constant *constant_expression_value(void *mem_ctx,
                                                struct hash_table *variable_context = NULL__null);

 virtual bool equals(const ir_instruction *ir,
                     enum ir_node_type ignore = ir_type_unset) const;

 /**
  * Get the variable that is ultimately referenced by an r-value
  */
 virtual ir_variable *variable_referenced() const
 {
    return this->var;
 }

 virtual int precision() const
 {
    return this->var->data.precision;
 }

 virtual ir_variable *whole_variable_referenced()
 {
    /* ir_dereference_variable objects always dereference the entire
     * variable.  However, if this dereference is dereferenced by anything
     * else, the complete deferefernce chain is not a whole-variable
     * dereference.  This method should only be called on the top most
     * ir_rvalue in a dereference chain.
     */
    return this->var;
 }

 virtual void accept(ir_visitor *v)
 {
    v->visit(this);
 }

 virtual ir_visitor_status accept(ir_hierarchical_visitor *);

 /**
  * Object being dereferenced.
  */
 ir_variable *var;
2116};


2119class ir_dereference_array : public ir_dereference {
2120public:
 ir_dereference_array(ir_rvalue *value, ir_rvalue *array_index);

 ir_dereference_array(ir_variable *var, ir_rvalue *array_index);

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

 virtual ir_constant *constant_expression_value(void *mem_ctx,
                                                struct hash_table *variable_context = NULL__null);

 virtual bool equals(const ir_instruction *ir,
                     enum ir_node_type ignore = ir_type_unset) const;

 /**
  * Get the variable that is ultimately referenced by an r-value
  */
 virtual ir_variable *variable_referenced() const
 {
    return this->array->variable_referenced();
 }

 virtual int precision() const
 {
    ir_dereference *deref = this->array->as_dereference();

    if (deref == NULL__null)
       return GLSL_PRECISION_NONE;
    else
       return deref->precision();
 }

 virtual void accept(ir_visitor *v)
 {
    v->visit(this);
 }

 virtual ir_visitor_status accept(ir_hierarchical_visitor *);

 ir_rvalue *array;
 ir_rvalue *array_index;

2162private:
 void set_array(ir_rvalue *value);
2164};


2167class ir_dereference_record : public ir_dereference {
2168public:
 ir_dereference_record(ir_rvalue *value, const char *field);

 ir_dereference_record(ir_variable *var, const char *field);

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

 virtual ir_constant *constant_expression_value(void *mem_ctx,
                                                struct hash_table *variable_context = NULL__null);

 /**
  * Get the variable that is ultimately referenced by an r-value
  */
 virtual ir_variable *variable_referenced() const
 {
    return this->record->variable_referenced();
 }

 virtual int precision() const
 {
    glsl_struct_field *field = record->type->fields.structure + field_idx;

    return field->precision;
 }

 virtual void accept(ir_visitor *v)
 {
    v->visit(this);
 }

 virtual ir_visitor_status accept(ir_hierarchical_visitor *);

 ir_rvalue *record;
 int field_idx;
2203};


2206/**
* Data stored in an ir_constant
*/
2209union ir_constant_data {
    unsigned u[16];
    int i[16];
    float f[16];
    bool b[16];
    double d[16];
    uint16_t f16[16];
    uint64_t u64[16];
    int64_t i64[16];
2218};


2221class ir_constant : public ir_rvalue {
2222public:
 ir_constant(const struct glsl_type *type, const ir_constant_data *data);
 ir_constant(bool b, unsigned vector_elements=1);
 ir_constant(unsigned int u, unsigned vector_elements=1);
 ir_constant(int i, unsigned vector_elements=1);
 ir_constant(float16_t f16, unsigned vector_elements=1);
 ir_constant(float f, unsigned vector_elements=1);
 ir_constant(double d, unsigned vector_elements=1);
 ir_constant(uint64_t u64, unsigned vector_elements=1);
 ir_constant(int64_t i64, unsigned vector_elements=1);

 /**
  * Construct an ir_constant from a list of ir_constant values
  */
 ir_constant(const struct glsl_type *type, exec_list *values);

 /**
  * Construct an ir_constant from a scalar component of another ir_constant
  *
  * The new \c ir_constant inherits the type of the component from the
  * source constant.
  *
  * \note
  * In the case of a matrix constant, the new constant is a scalar, \b not
  * a vector.
  */
 ir_constant(const ir_constant *c, unsigned i);

 /**
  * Return a new ir_constant of the specified type containing all zeros.
  */
 static ir_constant *zero(void *mem_ctx, const glsl_type *type);

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

 virtual ir_constant *constant_expression_value(void *mem_ctx,
                                                struct hash_table *variable_context = NULL__null);

 virtual void accept(ir_visitor *v)
 {
    v->visit(this);
 }

 virtual ir_visitor_status accept(ir_hierarchical_visitor *);

 virtual bool equals(const ir_instruction *ir,
                     enum ir_node_type ignore = ir_type_unset) const;

 /**
  * Get a particular component of a constant as a specific type
  *
  * This is useful, for example, to get a value from an integer constant
  * as a float or bool.  This appears frequently when constructors are
  * called with all constant parameters.
  */
 /*@{*/
 bool get_bool_component(unsigned i) const;
 float get_float_component(unsigned i) const;
 uint16_t get_float16_component(unsigned i) const;
 double get_double_component(unsigned i) const;
 int get_int_component(unsigned i) const;
 unsigned get_uint_component(unsigned i) const;
 int64_t get_int64_component(unsigned i) const;
 uint64_t get_uint64_component(unsigned i) const;
 /*@}*/

 ir_constant *get_array_element(unsigned i) const;

 ir_constant *get_record_field(int idx);

 /**
  * Copy the values on another constant at a given offset.
  *
  * The offset is ignored for array or struct copies, it's only for
  * scalars or vectors into vectors or matrices.
  *
  * With identical types on both sides and zero offset it's clone()
  * without creating a new object.
  */

 void copy_offset(ir_constant *src, int offset);

 /**
  * Copy the values on another constant at a given offset and
  * following an assign-like mask.
  *
  * The mask is ignored for scalars.
  *
  * Note that this function only handles what assign can handle,
  * i.e. at most a vector as source and a column of a matrix as
  * destination.
  */

 void copy_masked_offset(ir_constant *src, int offset, unsigned int mask);

 /**
  * Determine whether a constant has the same value as another constant
  *
  * \sa ir_constant::is_zero, ir_constant::is_one,
  * ir_constant::is_negative_one
  */
 bool has_value(const ir_constant *) const;

 /**
  * Return true if this ir_constant represents the given value.
  *
  * For vectors, this checks that each component is the given value.
  */
 virtual bool is_value(float f, int i) const;
 virtual bool is_zero() const;
 virtual bool is_one() const;
 virtual bool is_negative_one() const;

 /**
  * Return true for constants that could be stored as 16-bit unsigned values.
  *
  * Note that this will return true even for signed integer ir_constants, as
  * long as the value is non-negative and fits in 16-bits.
  */
 virtual bool is_uint16_constant() const;

 /**
  * 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 ir_constant_data value;

 /* Array elements and structure fields */
 ir_constant **const_elements;

2355private:
 /**
  * Parameterless constructor only used by the clone method
  */
 ir_constant(void);
2360};

2362class ir_precision_statement : public ir_instruction {
2363public:
 ir_precision_statement(const char *statement_to_store)
: ir_instruction(ir_type_precision)
 {
  ir_type = ir_type_precision;
  precision_statement = statement_to_store;
 }

 virtual ir_precision_statement *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 *);

 /**
  * Precision statement
  */
 const char *precision_statement;
2384};

2386class ir_typedecl_statement : public ir_instruction {
2387public:
 ir_typedecl_statement(const glsl_type* type_decl)
    : ir_instruction(ir_type_typedecl)
 {
    this->ir_type = ir_type_typedecl;
    this->type_decl = type_decl;
 }

 virtual ir_typedecl_statement *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 *);

 const glsl_type* type_decl;
2405};

2407/**
* IR instruction to emit a vertex in a geometry shader.
*/
2410class ir_emit_vertex : public ir_instruction {
2411public:
 ir_emit_vertex(ir_rvalue *stream)
    : ir_instruction(ir_type_emit_vertex),
      stream(stream)
 {
    assert(stream)(static_cast <bool> (stream) ? void (0) : __assert_fail
 ("stream", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
 }

 virtual void accept(ir_visitor *v)
 {
    v->visit(this);
 }

 virtual ir_emit_vertex *clone(void *mem_ctx, struct hash_table *ht) const
 {
    return new(mem_ctx) ir_emit_vertex(this->stream->clone(mem_ctx, ht));
 }

 virtual ir_visitor_status accept(ir_hierarchical_visitor *);

 int stream_id() const
 {
    return stream->as_constant()->value.i[0];
 }

 ir_rvalue *stream;
2437};

2439/**
* IR instruction to complete the current primitive and start a new one in a
* geometry shader.
*/
2443class ir_end_primitive : public ir_instruction {
2444public:
 ir_end_primitive(ir_rvalue *stream)
    : ir_instruction(ir_type_end_primitive),
      stream(stream)
 {
    assert(stream)(static_cast <bool> (stream) ? void (0) : __assert_fail
 ("stream", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
 }

 virtual void accept(ir_visitor *v)
 {
    v->visit(this);
 }

 virtual ir_end_primitive *clone(void *mem_ctx, struct hash_table *ht) const
 {
    return new(mem_ctx) ir_end_primitive(this->stream->clone(mem_ctx, ht));
 }

 virtual ir_visitor_status accept(ir_hierarchical_visitor *);

 int stream_id() const
 {
    return stream->as_constant()->value.i[0];
 }

 ir_rvalue *stream;
2470};

2472/**
* IR instruction for tessellation control and compute shader barrier.
*/
2475class ir_barrier : public ir_instruction {
2476public:
 ir_barrier()
    : ir_instruction(ir_type_barrier)
 {
 }

 virtual void accept(ir_visitor *v)
 {
    v->visit(this);
 }

 virtual ir_barrier *clone(void *mem_ctx, struct hash_table *) const
 {
    return new(mem_ctx) ir_barrier();
 }

 virtual ir_visitor_status accept(ir_hierarchical_visitor *);
2493};

2495/*@}*/

2497/**
* Apply a visitor to each IR node in a list
*/
2500void
2501visit_exec_list(exec_list *list, ir_visitor *visitor);

2503/**
* Validate invariants on each IR node in a list
*/
2506void validate_ir_tree(exec_list *instructions);

2508struct _mesa_glsl_parse_state;
2509struct gl_shader_program;

2511/**
* Detect whether an unlinked shader contains static recursion
*
* If the list of instructions is determined to contain static recursion,
* \c _mesa_glsl_error will be called to emit error messages for each function
* that is in the recursion cycle.
*/
2518void
2519detect_recursion_unlinked(struct _mesa_glsl_parse_state *state,
	  exec_list *instructions);

2522/**
* Detect whether a linked shader contains static recursion
*
* If the list of instructions is determined to contain static recursion,
* \c link_error_printf will be called to emit error messages for each function
* that is in the recursion cycle.  In addition,
* \c gl_shader_program::LinkStatus will be set to false.
*/
2530void
2531detect_recursion_linked(struct gl_shader_program *prog,
	exec_list *instructions);

2534/**
* Make a clone of each IR instruction in a list
*
* \param in   List of IR instructions that are to be cloned
* \param out  List to hold the cloned instructions
*/
2540void
2541clone_ir_list(void *mem_ctx, exec_list *out, const exec_list *in);

2543extern void
2544_mesa_glsl_initialize_variables(exec_list *instructions,
		struct _mesa_glsl_parse_state *state);

2547extern void
2548reparent_ir(exec_list *list, void *mem_ctx);

2550extern void
2551do_set_program_inouts(exec_list *instructions, struct gl_program *prog,
                    gl_shader_stage shader_stage);

2554extern char *
2555prototype_string(const glsl_type *return_type, const char *name,
 exec_list *parameters);

2558const char *
2559mode_string(const ir_variable *var);

2561/**
* Built-in / reserved GL variables names start with "gl_"
*/
2564static inline bool
2565is_gl_identifier(const char *s)
2566{
 return s && s[0] == 'g' && s[1] == 'l' && s[2] == '_';
2568}

2570extern "C" {
2571#endif /* __cplusplus */

2573extern void _mesa_print_ir(FILE *f, struct exec_list *instructions,
                         struct _mesa_glsl_parse_state *state);

2576extern void
2577fprint_ir(FILE *f, const void *instruction);

2579extern const struct gl_builtin_uniform_desc *
2580_mesa_glsl_get_builtin_uniform_desc(const char *name);

2582#ifdef __cplusplus201703L
2583} /* extern "C" */
2584#endif

2586unsigned
2587vertices_per_prim(GLenum prim);

2589#endif /* IR_H */