/src/spirv-cross/spirv_cross_parsed_ir.cpp

Source
/*
 * Copyright 2018-2021 Arm Limited
 * SPDX-License-Identifier: Apache-2.0 OR MIT
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 * At your option, you may choose to accept this material under either:
 *  1. The Apache License, Version 2.0, found at <http://www.apache.org/licenses/LICENSE-2.0>, or
 *  2. The MIT License, found at <http://opensource.org/licenses/MIT>.
 */

#include "spirv_cross_parsed_ir.hpp"
#include <algorithm>
#include <assert.h>

using namespace std;
using namespace SPIRV_CROSS_SPV_HEADER_NAMESPACE;

namespace SPIRV_CROSS_NAMESPACE
{
ParsedIR::ParsedIR()
{
  // If we move ParsedIR, we need to make sure the pointer stays fixed since the child Variant objects consume a pointer to this group,
  // so need an extra pointer here.
  pool_group.reset(new ObjectPoolGroup);

  pool_group->pools[TypeType].reset(new ObjectPool<SPIRType>);
  pool_group->pools[TypeVariable].reset(new ObjectPool<SPIRVariable>);
  pool_group->pools[TypeConstant].reset(new ObjectPool<SPIRConstant>);
  pool_group->pools[TypeFunction].reset(new ObjectPool<SPIRFunction>);
  pool_group->pools[TypeFunctionPrototype].reset(new ObjectPool<SPIRFunctionPrototype>);
  pool_group->pools[TypeBlock].reset(new ObjectPool<SPIRBlock>);
  pool_group->pools[TypeExtension].reset(new ObjectPool<SPIRExtension>);
  pool_group->pools[TypeExpression].reset(new ObjectPool<SPIRExpression>);
  pool_group->pools[TypeConstantOp].reset(new ObjectPool<SPIRConstantOp>);
  pool_group->pools[TypeCombinedImageSampler].reset(new ObjectPool<SPIRCombinedImageSampler>);
  pool_group->pools[TypeAccessChain].reset(new ObjectPool<SPIRAccessChain>);
  pool_group->pools[TypeUndef].reset(new ObjectPool<SPIRUndef>);
  pool_group->pools[TypeString].reset(new ObjectPool<SPIRString>);
  pool_group->pools[TypeDebugLocalVariable].reset(new ObjectPool<SPIRDebugLocalVariable>);
}

// Should have been default-implemented, but need this on MSVC 2013.
ParsedIR::ParsedIR(ParsedIR &&other) SPIRV_CROSS_NOEXCEPT
{
  *this = std::move(other);
}

ParsedIR &ParsedIR::operator=(ParsedIR &&other) SPIRV_CROSS_NOEXCEPT
{
  if (this != &other)
  {
    pool_group = std::move(other.pool_group);
    spirv = std::move(other.spirv);
    meta = std::move(other.meta);
    for (int i = 0; i < TypeCount; i++)
      ids_for_type[i] = std::move(other.ids_for_type[i]);
    ids_for_constant_undef_or_type = std::move(other.ids_for_constant_undef_or_type);
    ids_for_constant_or_variable = std::move(other.ids_for_constant_or_variable);
    declared_capabilities = std::move(other.declared_capabilities);
    declared_extensions = std::move(other.declared_extensions);
    block_meta = std::move(other.block_meta);
    continue_block_to_loop_header = std::move(other.continue_block_to_loop_header);
    entry_points = std::move(other.entry_points);
    ids = std::move(other.ids);
    addressing_model = other.addressing_model;
    memory_model = other.memory_model;

    default_entry_point = other.default_entry_point;
    sources = std::move(other.sources);
    loop_iteration_depth_hard = other.loop_iteration_depth_hard;
    loop_iteration_depth_soft = other.loop_iteration_depth_soft;

    meta_needing_name_fixup = std::move(other.meta_needing_name_fixup);
    load_type_width = std::move(other.load_type_width);
  }
  return *this;
}

ParsedIR::ParsedIR(const ParsedIR &other)
    : ParsedIR()
{
  *this = other;
}

ParsedIR &ParsedIR::operator=(const ParsedIR &other)
{
  if (this != &other)
  {
    spirv = other.spirv;
    meta = other.meta;
    for (int i = 0; i < TypeCount; i++)
      ids_for_type[i] = other.ids_for_type[i];
    ids_for_constant_undef_or_type = other.ids_for_constant_undef_or_type;
    ids_for_constant_or_variable = other.ids_for_constant_or_variable;
    declared_capabilities = other.declared_capabilities;
    declared_extensions = other.declared_extensions;
    block_meta = other.block_meta;
    continue_block_to_loop_header = other.continue_block_to_loop_header;
    entry_points = other.entry_points;
    default_entry_point = other.default_entry_point;
    sources = other.sources;
    loop_iteration_depth_hard = other.loop_iteration_depth_hard;
    loop_iteration_depth_soft = other.loop_iteration_depth_soft;
    addressing_model = other.addressing_model;
    memory_model = other.memory_model;


    meta_needing_name_fixup = other.meta_needing_name_fixup;
    load_type_width = other.load_type_width;

    // Very deliberate copying of IDs. There is no default copy constructor, nor a simple default constructor.
    // Construct object first so we have the correct allocator set-up, then we can copy object into our new pool group.
    ids.clear();
    ids.reserve(other.ids.size());
    for (size_t i = 0; i < other.ids.size(); i++)
    {
      ids.emplace_back(pool_group.get());
      ids.back() = other.ids[i];
    }
  }
  return *this;
}

void ParsedIR::set_id_bounds(uint32_t bounds)
{
  ids.reserve(bounds);
  while (ids.size() < bounds)
    ids.emplace_back(pool_group.get());

  block_meta.resize(bounds);
}

// Roll our own versions of these functions to avoid potential locale shenanigans.
static bool is_alpha(char c)
{
  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
}

static bool is_numeric(char c)
{
  return c >= '0' && c <= '9';
}

static bool is_alphanumeric(char c)
{
  return is_alpha(c) || is_numeric(c);
}

static bool is_valid_identifier(const string &name)
{
  if (name.empty())
    return true;

  if (is_numeric(name[0]))
    return false;

  for (auto c : name)
    if (!is_alphanumeric(c) && c != '_')
      return false;

  bool saw_underscore = false;
  // Two underscores in a row is not a valid identifier either.
  // Technically reserved, but it's easier to treat it as invalid.
  for (auto c : name)
  {
    bool is_underscore = c == '_';
    if (is_underscore && saw_underscore)
      return false;
    saw_underscore = is_underscore;
  }

  return true;
}

static bool is_reserved_prefix(const string &name)
{
  // Generic reserved identifiers used by the implementation.
  return name.compare(0, 3, "gl_", 3) == 0 ||
         // Ignore this case for now, might rewrite internal code to always use spv prefix.
         //name.compare(0, 11, "SPIRV_Cross", 11) == 0 ||
         name.compare(0, 3, "spv", 3) == 0;
}

static bool is_reserved_identifier(const string &name, bool member, bool allow_reserved_prefixes)
{
  if (!allow_reserved_prefixes && is_reserved_prefix(name))
    return true;

  if (member)
  {
    // Reserved member identifiers come in one form:
    // _m[0-9]+$.
    if (name.size() < 3)
      return false;

    if (name.compare(0, 2, "_m", 2) != 0)
      return false;

    size_t index = 2;
    while (index < name.size() && is_numeric(name[index]))
      index++;

    return index == name.size();
  }
  else
  {
    // Reserved non-member identifiers come in two forms:
    // _[0-9]+$, used for temporaries which map directly to a SPIR-V ID.
    // _[0-9]+_, used for auxillary temporaries which derived from a SPIR-V ID.
    if (name.size() < 2)
      return false;

    if (name[0] != '_' || !is_numeric(name[1]))
      return false;

    size_t index = 2;
    while (index < name.size() && is_numeric(name[index]))
      index++;

    return index == name.size() || (index < name.size() && name[index] == '_');
  }
}

bool ParsedIR::is_globally_reserved_identifier(std::string &str, bool allow_reserved_prefixes)
{
  return is_reserved_identifier(str, false, allow_reserved_prefixes);
}

uint32_t ParsedIR::get_spirv_version() const
{
  return spirv[1];
}

static string make_unreserved_identifier(const string &name)
{
  if (is_reserved_prefix(name))
    return "_RESERVED_IDENTIFIER_FIXUP_" + name;
  else
    return "_RESERVED_IDENTIFIER_FIXUP" + name;
}

void ParsedIR::sanitize_underscores(std::string &str)
{
  // Compact adjacent underscores to make it valid.
  auto dst = str.begin();
  auto src = dst;
  bool saw_underscore = false;
  while (src != str.end())
  {
    bool is_underscore = *src == '_';
    if (saw_underscore && is_underscore)
    {
      src++;
    }
    else
    {
      if (dst != src)
        *dst = *src;
      dst++;
      src++;
      saw_underscore = is_underscore;
    }
  }
  str.erase(dst, str.end());
}

static string ensure_valid_identifier(const string &name)
{
  // Functions in glslangValidator are mangled with name(<mangled> stuff.
  // Normally, we would never see '(' in any legal identifiers, so just strip them out.
  auto str = name.substr(0, name.find('('));

  if (str.empty())
    return str;

  if (is_numeric(str[0]))
    str[0] = '_';

  for (auto &c : str)
    if (!is_alphanumeric(c) && c != '_')
      c = '_';

  ParsedIR::sanitize_underscores(str);
  return str;
}

const string &ParsedIR::get_name(ID id) const
{
  auto *m = find_meta(id);
  if (m)
    return m->decoration.alias;
  else
    return empty_string;
}

const string &ParsedIR::get_member_name(TypeID id, uint32_t index) const
{
  auto *m = find_meta(id);
  if (m)
  {
    if (index >= m->members.size())
      return empty_string;
    return m->members[index].alias;
  }
  else
    return empty_string;
}

void ParsedIR::sanitize_identifier(std::string &name, bool member, bool allow_reserved_prefixes)
{
  if (!is_valid_identifier(name))
    name = ensure_valid_identifier(name);
  if (is_reserved_identifier(name, member, allow_reserved_prefixes))
    name = make_unreserved_identifier(name);
}

void ParsedIR::fixup_reserved_names()
{
  for (uint32_t id : meta_needing_name_fixup)
  {
    // Don't rename remapped variables like 'gl_LastFragDepthARM'.
    if (ids[id].get_type() == TypeVariable && get<SPIRVariable>(id).remapped_variable)
      continue;

    auto &m = meta[id];
    sanitize_identifier(m.decoration.alias, false, false);
    for (auto &memb : m.members)
      sanitize_identifier(memb.alias, true, false);
  }
  meta_needing_name_fixup.clear();
}

void ParsedIR::set_name(ID id, const string &name)
{
  auto &m = meta[id];
  m.decoration.alias = name;
  if (!is_valid_identifier(name) || is_reserved_identifier(name, false, false))
    meta_needing_name_fixup.insert(id);
}

void ParsedIR::set_member_name(TypeID id, uint32_t index, const string &name)
{
  auto &m = meta[id];
  m.members.resize(max(m.members.size(), size_t(index) + 1));
  m.members[index].alias = name;
  if (!is_valid_identifier(name) || is_reserved_identifier(name, true, false))
    meta_needing_name_fixup.insert(id);
}

void ParsedIR::set_decoration_string(ID id, Decoration decoration, const string &argument)
{
  auto &dec = meta[id].decoration;
  dec.decoration_flags.set(decoration);

  switch (decoration)
  {
  case DecorationUserSemantic:
    dec.user_semantic = argument;
    break;

  case DecorationUserTypeGOOGLE:
    dec.user_type = argument;
    break;

  default:
    break;
  }
}

void ParsedIR::set_decoration(ID id, Decoration decoration, uint32_t argument)
{
  auto &dec = meta[id].decoration;
  dec.decoration_flags.set(decoration);

  switch (decoration)
  {
  case DecorationBuiltIn:
    dec.builtin = true;
    dec.builtin_type = static_cast<BuiltIn>(argument);
    break;

  case DecorationLocation:
    dec.location = argument;
    break;

  case DecorationComponent:
    dec.component = argument;
    break;

  case DecorationOffset:
    dec.offset = argument;
    break;

  case DecorationXfbBuffer:
    dec.xfb_buffer = argument;
    break;

  case DecorationXfbStride:
    dec.xfb_stride = argument;
    break;

  case DecorationStream:
    dec.stream = argument;
    break;

  case DecorationArrayStride:
    dec.array_stride = argument;
    break;

  case DecorationMatrixStride:
    dec.matrix_stride = argument;
    break;

  case DecorationBinding:
    dec.binding = argument;
    break;

  case DecorationDescriptorSet:
    dec.set = argument;
    break;

  case DecorationInputAttachmentIndex:
    dec.input_attachment = argument;
    break;

  case DecorationSpecId:
    dec.spec_id = argument;
    break;

  case DecorationIndex:
    dec.index = argument;
    break;

  case DecorationHlslCounterBufferGOOGLE:
    meta[id].hlsl_magic_counter_buffer = argument;
    meta[argument].hlsl_is_magic_counter_buffer = true;
    break;

  case DecorationFPRoundingMode:
    dec.fp_rounding_mode = static_cast<FPRoundingMode>(argument);
    break;

  case DecorationFPFastMathMode:
    dec.fp_fast_math_mode = static_cast<FPFastMathModeMask>(argument);
    break;

  default:
    break;
  }
}

void ParsedIR::set_member_decoration(TypeID id, uint32_t index, Decoration decoration, uint32_t argument)
{
  auto &m = meta[id];
  m.members.resize(max(m.members.size(), size_t(index) + 1));
  auto &dec = m.members[index];
  dec.decoration_flags.set(decoration);

  switch (decoration)
  {
  case DecorationBuiltIn:
    dec.builtin = true;
    dec.builtin_type = static_cast<BuiltIn>(argument);
    break;

  case DecorationLocation:
    dec.location = argument;
    break;

  case DecorationComponent:
    dec.component = argument;
    break;

  case DecorationBinding:
    dec.binding = argument;
    break;

  case DecorationOffset:
    dec.offset = argument;
    break;

  case DecorationXfbBuffer:
    dec.xfb_buffer = argument;
    break;

  case DecorationXfbStride:
    dec.xfb_stride = argument;
    break;

  case DecorationStream:
    dec.stream = argument;
    break;

  case DecorationSpecId:
    dec.spec_id = argument;
    break;

  case DecorationMatrixStride:
    dec.matrix_stride = argument;
    break;

  case DecorationIndex:
    dec.index = argument;
    break;

  default:
    break;
  }
}

// Recursively marks any constants referenced by the specified constant instruction as being used
// as an array length. The id must be a constant instruction (SPIRConstant or SPIRConstantOp).
void ParsedIR::mark_used_as_array_length(ID id)
{
  switch (ids[id].get_type())
  {
  case TypeConstant:
  {
    auto &c = get<SPIRConstant>(id);
    c.is_used_as_array_length = true;

    // Mark composite dependencies as well.
    for (auto &sub_id: c.m.id)
      if (sub_id)
        mark_used_as_array_length(sub_id);

    for (uint32_t col = 0; col < c.m.columns; col++)
    {
      for (auto &sub_id : c.m.c[col].id)
        if (sub_id)
          mark_used_as_array_length(sub_id);
    }

    for (auto &sub_id : c.subconstants)
      if (sub_id)
        mark_used_as_array_length(sub_id);
    break;
  }

  case TypeConstantOp:
  {
    auto &cop = get<SPIRConstantOp>(id);
    if (cop.opcode == OpCompositeExtract)
      mark_used_as_array_length(cop.arguments[0]);
    else if (cop.opcode == OpCompositeInsert)
    {
      mark_used_as_array_length(cop.arguments[0]);
      mark_used_as_array_length(cop.arguments[1]);
    }
    else
      for (uint32_t arg_id : cop.arguments)
        mark_used_as_array_length(arg_id);
    break;
  }

  case TypeUndef:
    break;

  default:
    assert(0);
  }
}

Bitset ParsedIR::get_buffer_block_type_flags(const SPIRType &type) const
{
  if (type.member_types.empty())
    return {};

  Bitset all_members_flags = get_member_decoration_bitset(type.self, 0);
  for (uint32_t i = 1; i < uint32_t(type.member_types.size()); i++)
    all_members_flags.merge_and(get_member_decoration_bitset(type.self, i));
  return all_members_flags;
}

Bitset ParsedIR::get_buffer_block_flags(const SPIRVariable &var) const
{
  auto &type = get<SPIRType>(var.basetype);
  if (type.basetype != SPIRType::Struct)
    SPIRV_CROSS_THROW("Cannot get buffer block flags for non-buffer variable.");

  // Some flags like non-writable, non-readable are actually found
  // as member decorations. If all members have a decoration set, propagate
  // the decoration up as a regular variable decoration.
  Bitset base_flags;
  auto *m = find_meta(var.self);
  if (m)
    base_flags = m->decoration.decoration_flags;

  if (type.member_types.empty())
    return base_flags;

  auto all_members_flags = get_buffer_block_type_flags(type);
  base_flags.merge_or(all_members_flags);
  return base_flags;
}

const Bitset &ParsedIR::get_member_decoration_bitset(TypeID id, uint32_t index) const
{
  auto *m = find_meta(id);
  if (m)
  {
    if (index >= m->members.size())
      return cleared_bitset;
    return m->members[index].decoration_flags;
  }
  else
    return cleared_bitset;
}

bool ParsedIR::has_decoration(ID id, Decoration decoration) const
{
  return get_decoration_bitset(id).get(decoration);
}

uint32_t ParsedIR::get_decoration(ID id, Decoration decoration) const
{
  auto *m = find_meta(id);
  if (!m)
    return 0;

  auto &dec = m->decoration;
  if (!dec.decoration_flags.get(decoration))
    return 0;

  switch (decoration)
  {
  case DecorationBuiltIn:
    return dec.builtin_type;
  case DecorationLocation:
    return dec.location;
  case DecorationComponent:
    return dec.component;
  case DecorationOffset:
    return dec.offset;
  case DecorationXfbBuffer:
    return dec.xfb_buffer;
  case DecorationXfbStride:
    return dec.xfb_stride;
  case DecorationStream:
    return dec.stream;
  case DecorationBinding:
    return dec.binding;
  case DecorationDescriptorSet:
    return dec.set;
  case DecorationInputAttachmentIndex:
    return dec.input_attachment;
  case DecorationSpecId:
    return dec.spec_id;
  case DecorationArrayStride:
    return dec.array_stride;
  case DecorationMatrixStride:
    return dec.matrix_stride;
  case DecorationIndex:
    return dec.index;
  case DecorationFPRoundingMode:
    return dec.fp_rounding_mode;
  case DecorationFPFastMathMode:
    return dec.fp_fast_math_mode;
  default:
    return 1;
  }
}

const string &ParsedIR::get_decoration_string(ID id, Decoration decoration) const
{
  auto *m = find_meta(id);
  if (!m)
    return empty_string;

  auto &dec = m->decoration;

  if (!dec.decoration_flags.get(decoration))
    return empty_string;

  switch (decoration)
  {
  case DecorationUserSemantic:
    return dec.user_semantic;

  case DecorationUserTypeGOOGLE:
    return dec.user_type;

  default:
    return empty_string;
  }
}

void ParsedIR::unset_decoration(ID id, Decoration decoration)
{
  auto &dec = meta[id].decoration;
  dec.decoration_flags.clear(decoration);
  switch (decoration)
  {
  case DecorationBuiltIn:
    dec.builtin = false;
    break;

  case DecorationLocation:
    dec.location = 0;
    break;

  case DecorationComponent:
    dec.component = 0;
    break;

  case DecorationOffset:
    dec.offset = 0;
    break;

  case DecorationXfbBuffer:
    dec.xfb_buffer = 0;
    break;

  case DecorationXfbStride:
    dec.xfb_stride = 0;
    break;

  case DecorationStream:
    dec.stream = 0;
    break;

  case DecorationBinding:
    dec.binding = 0;
    break;

  case DecorationDescriptorSet:
    dec.set = 0;
    break;

  case DecorationInputAttachmentIndex:
    dec.input_attachment = 0;
    break;

  case DecorationSpecId:
    dec.spec_id = 0;
    break;

  case DecorationUserSemantic:
    dec.user_semantic.clear();
    break;

  case DecorationFPRoundingMode:
    dec.fp_rounding_mode = FPRoundingModeMax;
    break;

  case DecorationFPFastMathMode:
    dec.fp_fast_math_mode = FPFastMathModeMaskNone;
    break;

  case DecorationHlslCounterBufferGOOGLE:
  {
    auto &counter = meta[id].hlsl_magic_counter_buffer;
    if (counter)
    {
      meta[counter].hlsl_is_magic_counter_buffer = false;
      counter = 0;
    }
    break;
  }

  default:
    break;
  }
}

bool ParsedIR::has_member_decoration(TypeID id, uint32_t index, Decoration decoration) const
{
  return get_member_decoration_bitset(id, index).get(decoration);
}

uint32_t ParsedIR::get_member_decoration(TypeID id, uint32_t index, Decoration decoration) const
{
  auto *m = find_meta(id);
  if (!m)
    return 0;

  if (index >= m->members.size())
    return 0;

  auto &dec = m->members[index];
  if (!dec.decoration_flags.get(decoration))
    return 0;

  switch (decoration)
  {
  case DecorationBuiltIn:
    return dec.builtin_type;
  case DecorationLocation:
    return dec.location;
  case DecorationComponent:
    return dec.component;
  case DecorationBinding:
    return dec.binding;
  case DecorationOffset:
    return dec.offset;
  case DecorationXfbBuffer:
    return dec.xfb_buffer;
  case DecorationXfbStride:
    return dec.xfb_stride;
  case DecorationStream:
    return dec.stream;
  case DecorationSpecId:
    return dec.spec_id;
  case DecorationMatrixStride:
    return dec.matrix_stride;
  case DecorationIndex:
    return dec.index;
  default:
    return 1;
  }
}

const Bitset &ParsedIR::get_decoration_bitset(ID id) const
{
  auto *m = find_meta(id);
  if (m)
  {
    auto &dec = m->decoration;
    return dec.decoration_flags;
  }
  else
    return cleared_bitset;
}

void ParsedIR::set_member_decoration_string(TypeID id, uint32_t index, Decoration decoration, const string &argument)
{
  auto &m = meta[id];
  m.members.resize(max(m.members.size(), size_t(index) + 1));
  auto &dec = meta[id].members[index];
  dec.decoration_flags.set(decoration);

  switch (decoration)
  {
  case DecorationUserSemantic:
    dec.user_semantic = argument;
    break;

  default:
    break;
  }
}

const string &ParsedIR::get_member_decoration_string(TypeID id, uint32_t index, Decoration decoration) const
{
  auto *m = find_meta(id);
  if (m)
  {
    if (!has_member_decoration(id, index, decoration))
      return empty_string;

    auto &dec = m->members[index];

    switch (decoration)
    {
    case DecorationUserSemantic:
      return dec.user_semantic;

    default:
      return empty_string;
    }
  }
  else
    return empty_string;
}

void ParsedIR::unset_member_decoration(TypeID id, uint32_t index, Decoration decoration)
{
  auto &m = meta[id];
  if (index >= m.members.size())
    return;

  auto &dec = m.members[index];

  dec.decoration_flags.clear(decoration);
  switch (decoration)
  {
  case DecorationBuiltIn:
    dec.builtin = false;
    break;

  case DecorationLocation:
    dec.location = 0;
    break;

  case DecorationComponent:
    dec.component = 0;
    break;

  case DecorationOffset:
    dec.offset = 0;
    break;

  case DecorationXfbBuffer:
    dec.xfb_buffer = 0;
    break;

  case DecorationXfbStride:
    dec.xfb_stride = 0;
    break;

  case DecorationStream:
    dec.stream = 0;
    break;

  case DecorationSpecId:
    dec.spec_id = 0;
    break;

  case DecorationUserSemantic:
    dec.user_semantic.clear();
    break;

  default:
    break;
  }
}

uint32_t ParsedIR::increase_bound_by(uint32_t incr_amount)
{
  auto curr_bound = ids.size();
  auto new_bound = curr_bound + incr_amount;

  ids.reserve(ids.size() + incr_amount);
  for (uint32_t i = 0; i < incr_amount; i++)
    ids.emplace_back(pool_group.get());

  block_meta.resize(new_bound);
  return uint32_t(curr_bound);
}

void ParsedIR::remove_typed_id(Types type, ID id)
{
  auto &type_ids = ids_for_type[type];
  type_ids.erase(remove(begin(type_ids), end(type_ids), id), end(type_ids));
}

void ParsedIR::reset_all_of_type(Types type)
{
  for (auto &id : ids_for_type[type])
    if (ids[id].get_type() == type)
      ids[id].reset();

  ids_for_type[type].clear();
}

void ParsedIR::add_typed_id(Types type, ID id)
{
  assert(id < ids.size());

  if (loop_iteration_depth_hard != 0)
    SPIRV_CROSS_THROW("Cannot add typed ID while looping over it.");

  if (loop_iteration_depth_soft != 0)
  {
    if (!ids[id].empty())
      SPIRV_CROSS_THROW("Cannot override IDs when loop is soft locked.");
    return;
  }

  if (ids[id].empty() || ids[id].get_type() != type)
  {
    switch (type)
    {
    case TypeConstant:
      ids_for_constant_or_variable.push_back(id);
      ids_for_constant_undef_or_type.push_back(id);
      break;

    case TypeVariable:
      ids_for_constant_or_variable.push_back(id);
      break;

    case TypeType:
    case TypeConstantOp:
    case TypeUndef:
      ids_for_constant_undef_or_type.push_back(id);
      break;

    default:
      break;
    }
  }

  if (ids[id].empty())
  {
    ids_for_type[type].push_back(id);
  }
  else if (ids[id].get_type() != type)
  {
    remove_typed_id(ids[id].get_type(), id);
    ids_for_type[type].push_back(id);
  }
}

const Meta *ParsedIR::find_meta(ID id) const
{
  auto itr = meta.find(id);
  if (itr != end(meta))
    return &itr->second;
  else
    return nullptr;
}

Meta *ParsedIR::find_meta(ID id)
{
  auto itr = meta.find(id);
  if (itr != end(meta))
    return &itr->second;
  else
    return nullptr;
}

ParsedIR::LoopLock ParsedIR::create_loop_hard_lock() const
{
  return ParsedIR::LoopLock(&loop_iteration_depth_hard);
}

ParsedIR::LoopLock ParsedIR::create_loop_soft_lock() const
{
  return ParsedIR::LoopLock(&loop_iteration_depth_soft);
}

ParsedIR::LoopLock::~LoopLock()
{
  if (lock)
    (*lock)--;
}

ParsedIR::LoopLock::LoopLock(uint32_t *lock_)
    : lock(lock_)
{
  if (lock)
    (*lock)++;
}

ParsedIR::LoopLock::LoopLock(LoopLock &&other) SPIRV_CROSS_NOEXCEPT
{
  *this = std::move(other);
}

ParsedIR::LoopLock &ParsedIR::LoopLock::operator=(LoopLock &&other) SPIRV_CROSS_NOEXCEPT
{
  if (lock)
    (*lock)--;
  lock = other.lock;
  other.lock = nullptr;
  return *this;
}

void ParsedIR::make_constant_null(uint32_t id, uint32_t type, bool add_to_typed_id_set)
{
  assert(id < ids.size());

  auto &constant_type = get<SPIRType>(type);

  if (constant_type.pointer)
  {
    if (add_to_typed_id_set)
      add_typed_id(TypeConstant, id);
    auto &constant = variant_set<SPIRConstant>(ids[id], type);
    constant.self = id;
    constant.make_null(constant_type);
  }
  else if (!constant_type.array.empty())
  {
    assert(constant_type.parent_type);
    uint32_t parent_id = increase_bound_by(1);
    make_constant_null(parent_id, constant_type.parent_type, add_to_typed_id_set);

    // The array size of OpConstantNull can be either literal or specialization constant.
    // In the latter case, we cannot take the value as-is, as it can be changed to anything.
    // Rather, we assume it to be *one* for the sake of initializer.
    bool is_literal_array_size = constant_type.array_size_literal.back();
    uint32_t count = is_literal_array_size ? constant_type.array.back() : 1;

    SmallVector<uint32_t> elements(count);
    for (uint32_t i = 0; i < count; i++)
      elements[i] = parent_id;

    if (add_to_typed_id_set)
      add_typed_id(TypeConstant, id);
    auto& constant = variant_set<SPIRConstant>(ids[id], type, elements.data(), uint32_t(elements.size()), false);
    constant.self = id;
    constant.is_null_array_specialized_length = !is_literal_array_size;
  }
  else if (!constant_type.member_types.empty())
  {
    uint32_t member_ids = increase_bound_by(uint32_t(constant_type.member_types.size()));
    SmallVector<uint32_t> elements(constant_type.member_types.size());
    for (uint32_t i = 0; i < constant_type.member_types.size(); i++)
    {
      make_constant_null(member_ids + i, constant_type.member_types[i], add_to_typed_id_set);
      elements[i] = member_ids + i;
    }

    if (add_to_typed_id_set)
      add_typed_id(TypeConstant, id);
    variant_set<SPIRConstant>(ids[id], type, elements.data(), uint32_t(elements.size()), false).self = id;
  }
  else
  {
    if (add_to_typed_id_set)
      add_typed_id(TypeConstant, id);
    auto &constant = variant_set<SPIRConstant>(ids[id], type);
    constant.self = id;
    constant.make_null(constant_type);
  }
}

} // namespace SPIRV_CROSS_NAMESPACE

Coverage Report

Created: 2026-02-11 06:37