SPIRV-Cross-Vulnerable/spirv_cross.cpp

/*
 * Copyright 2015-2016 ARM Limited
 *
 * 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.
 */

#include "spirv_cross.hpp"
#include "GLSL.std.450.h"
#include <cstring>
#include <algorithm>
#include <utility>

using namespace std;
using namespace spv;
using namespace spirv_cross;

#define log(...) fprintf(stderr, __VA_ARGS__)

Instruction::Instruction(const vector<uint32_t> &spirv, uint32_t &index)
{
    op = spirv[index] & 0xffff;
    count = (spirv[index] >> 16) & 0xffff;
    offset = index + 1;
    length = count - 1;

    index += count;

    if (index > spirv.size())
        throw CompilerError("SPIR-V instruction goes out of bounds.");
}

Compiler::Compiler(vector<uint32_t> ir)
    : spirv(move(ir))
{
    parse();
}

string Compiler::compile() { return ""; }

bool Compiler::variable_storage_is_aliased(const SPIRVariable &v)
{
    auto &type = get<SPIRType>(v.basetype);
    bool ssbo = (meta[type.self].decoration.decoration_flags & (1ull << DecorationBufferBlock)) != 0;
    bool image = type.basetype == SPIRType::Image;
    bool counter = type.basetype == SPIRType::AtomicCounter;
    return ssbo || image || counter;
}

bool Compiler::block_is_pure(const SPIRBlock &block)
{
    for (auto &i : block.ops)
    {
        auto ops = stream(i);
        auto op = static_cast<Op>(i.op);

        switch (op)
        {
            case OpFunctionCall:
            {
                uint32_t func = ops[2];
                if (!function_is_pure(get<SPIRFunction>(func)))
                    return false;
                break;
            }

            case OpStore:
            {
                auto &type = expression_type(ops[0]);
                if (type.storage != StorageClassFunction)
                    return false;
                break;
            }

            case OpImageWrite:
                return false;

            default:
                break;
        }
    }

    return true;
}

string Compiler::to_name(uint32_t id)
{
    if (meta[id].decoration.alias.empty())
        return join("_", id);
    else
        return meta.at(id).decoration.alias;
}

bool Compiler::function_is_pure(const SPIRFunction &func)
{
    for (auto block : func.blocks)
    {
        if (!block_is_pure(get<SPIRBlock>(block)))
        {
            //fprintf(stderr, "Function %s is impure!\n", to_name(func.self).c_str());
            return false;
        }
    }

    //fprintf(stderr, "Function %s is pure!\n", to_name(func.self).c_str());
    return true;
}

void Compiler::register_global_read_dependencies(const SPIRBlock &block, uint32_t id)
{
    for (auto &i : block.ops)
    {
        auto ops = stream(i);
        auto op = static_cast<Op>(i.op);

        switch (op)
        {
            case OpFunctionCall:
            {
                uint32_t func = ops[2];
                register_global_read_dependencies(get<SPIRFunction>(func), id);
                break;
            }

            case OpLoad:
            case OpImageRead:
            {
                // If we're in a storage class which does not get invalidated, adding dependencies here is no big deal.
                auto *var = maybe_get_backing_variable(ops[2]);
                if (var && var->storage != StorageClassFunction)
                {
                    auto &type = get<SPIRType>(var->basetype);

                    // InputTargets are immutable.
                    if (type.basetype != SPIRType::Image && type.image.dim != DimSubpassData)
                        var->dependees.push_back(id);
                }
                break;
            }

            default:
                break;
        }
    }
}

void Compiler::register_global_read_dependencies(const SPIRFunction &func, uint32_t id)
{
    for (auto block : func.blocks)
        register_global_read_dependencies(get<SPIRBlock>(block), id);
}

SPIRVariable* Compiler::maybe_get_backing_variable(uint32_t chain)
{
    auto *var = maybe_get<SPIRVariable>(chain);
    if (!var)
    {
        auto *cexpr = maybe_get<SPIRExpression>(chain);
        if (cexpr)
            var = maybe_get<SPIRVariable>(cexpr->loaded_from);
    }

    return var;
}

void Compiler::register_read(uint32_t expr, uint32_t chain, bool forwarded)
{
    auto &e = get<SPIRExpression>(expr);
    auto *var = maybe_get_backing_variable(chain);

    if (var)
    {
        e.loaded_from = var->self;

        // If the backing variable is immutable, we do not need to depend on the variable.
        if (forwarded && !is_immutable(var->self))
            var->dependees.push_back(e.self);

        // If we load from a parameter, make sure we create "inout" if we also write to the parameter.
        // The default is "in" however, so we never invalidate our compilation by reading.
        if (var && var->parameter)
            var->parameter->read_count++;
    }
}

void Compiler::register_write(uint32_t chain)
{
    auto *var = maybe_get<SPIRVariable>(chain);
    if (!var)
    {
        // If we're storing through an access chain, invalidate the backing variable instead.
        auto *expr = maybe_get<SPIRExpression>(chain);
        if (expr && expr->loaded_from)
            var = maybe_get<SPIRVariable>(expr->loaded_from);
    }

    if (var)
    {
        // If our variable is in a storage class which can alias with other buffers,
        // invalidate all variables which depend on aliased variables.
        if (variable_storage_is_aliased(*var))
            flush_all_aliased_variables();
        else if (var)
            flush_dependees(*var);

        // We tried to write to a parameter which is not marked with out qualifier, force a recompile.
        if (var->parameter && var->parameter->write_count == 0)
        {
            var->parameter->write_count++;
            force_recompile = true;
        }
    }
}

void Compiler::flush_dependees(SPIRVariable &var)
{
    for (auto expr : var.dependees)
    {
        invalid_expressions.insert(expr);
        get<SPIRExpression>(expr).invalidated_by.push_back(var.self);
    }
    var.dependees.clear();
}

void Compiler::flush_all_aliased_variables()
{
    for (auto aliased : aliased_variables)
        flush_dependees(get<SPIRVariable>(aliased));
}

void Compiler::flush_all_atomic_capable_variables()
{
    for (auto global : global_variables)
        flush_dependees(get<SPIRVariable>(global));
    flush_all_aliased_variables();
}

void Compiler::flush_all_active_variables()
{
    // Invalidate all temporaries we read from variables in this block since they were forwarded.
    // Invalidate all temporaries we read from globals.
    for (auto &v : function->local_variables)
        flush_dependees(get<SPIRVariable>(v));
    for (auto &arg : function->arguments)
        flush_dependees(get<SPIRVariable>(arg.id));
    for (auto global : global_variables)
        flush_dependees(get<SPIRVariable>(global));

    flush_all_aliased_variables();
}

const SPIRType& Compiler::expression_type(uint32_t id) const
{
    switch (ids[id].get_type())
    {
        case TypeVariable:
            return get<SPIRType>(get<SPIRVariable>(id).basetype);

        case TypeExpression:
            return get<SPIRType>(get<SPIRExpression>(id).expression_type);

        case TypeConstant:
            return get<SPIRType>(get<SPIRConstant>(id).constant_type);

        case TypeUndef:
            return get<SPIRType>(get<SPIRUndef>(id).basetype);

        default:
            throw CompilerError("Cannot resolve expression type.");
    }
}

bool Compiler::expression_is_lvalue(uint32_t id) const
{
    auto &type = expression_type(id);
    switch (type.basetype)
    {
        case SPIRType::SampledImage:
        case SPIRType::Image:
        case SPIRType::Sampler:
            return false;

        default:
            return true;
    }
}

bool Compiler::is_immutable(uint32_t id) const
{
    if (ids[id].get_type() == TypeVariable)
    {
        auto &var = get<SPIRVariable>(id);

        // Anything we load from the UniformConstant address space is guaranteed to be immutable.
        bool pointer_to_const = var.storage == StorageClassUniformConstant;
        return pointer_to_const || var.phi_variable || var.forwardable || !expression_is_lvalue(id);
    }
    else if (ids[id].get_type() == TypeExpression)
        return get<SPIRExpression>(id).immutable;
    else if (ids[id].get_type() == TypeConstant || ids[id].get_type() == TypeUndef)
        return true;
    else
        return false;
}

bool Compiler::is_builtin_variable(const SPIRVariable &var) const
{
    if (var.compat_builtin || meta[var.self].decoration.builtin)
        return true;

    // We can have builtin structs as well. If one member of a struct is builtin, the struct must also be builtin.
    for (auto &m : meta[get<SPIRType>(var.basetype).self].members)
        if (m.builtin)
            return true;

    return false;
}

bool Compiler::is_member_builtin(const SPIRType &type, uint32_t index, BuiltIn *builtin) const
{
    auto &memb = meta[type.self].members;
    if (index < memb.size() && memb[index].builtin)
    {
        if (builtin)
            *builtin = memb[index].builtin_type;
        return true;
    }

    return false;
}

bool Compiler::is_scalar(const SPIRType &type) const
{
    return type.vecsize == 1 && type.columns == 1;
}

bool Compiler::is_vector(const SPIRType &type) const
{
    return type.vecsize > 1 && type.columns == 1;
}

bool Compiler::is_matrix(const SPIRType &type) const
{
    return type.vecsize > 1 && type.columns > 1;
}

ShaderResources Compiler::get_shader_resources() const
{
    ShaderResources res;

    for (auto &id : ids)
    {
        if (id.get_type() != TypeVariable)
            continue;

        auto &var = id.get<SPIRVariable>();
        auto &type = get<SPIRType>(var.basetype);

        if (!type.pointer || is_builtin_variable(var))
            continue;

        // Input
        if (var.storage == StorageClassInput)
        {
            if (meta[type.self].decoration.decoration_flags & (1ull << DecorationBlock))
                res.stage_inputs.push_back({ var.self, type.self, meta[type.self].decoration.alias });
            else
                res.stage_inputs.push_back({ var.self, type.self, meta[var.self].decoration.alias });
        }
        // Subpass inputs
        else if (var.storage == StorageClassUniformConstant &&
                type.image.dim == DimSubpassData)
        {
            res.subpass_inputs.push_back({ var.self, type.self, meta[var.self].decoration.alias });
        }
        // Outputs
        else if (var.storage == StorageClassOutput)
        {
            if (meta[type.self].decoration.decoration_flags & (1ull << DecorationBlock))
                res.stage_outputs.push_back({ var.self, type.self, meta[type.self].decoration.alias });
            else
                res.stage_outputs.push_back({ var.self, type.self, meta[var.self].decoration.alias });
        }
        // UBOs
        else if (type.storage == StorageClassUniform &&
                (meta[type.self].decoration.decoration_flags & (1ull << DecorationBlock)))
        {
            res.uniform_buffers.push_back({ var.self, type.self, meta[type.self].decoration.alias });
        }
        // SSBOs
        else if (type.storage == StorageClassUniform &&
                (meta[type.self].decoration.decoration_flags & (1ull << DecorationBufferBlock)))
        {
            res.storage_buffers.push_back({ var.self, type.self, meta[type.self].decoration.alias });
        }
        // Push constant blocks
        else if (type.storage == StorageClassPushConstant)
        {
            // There can only be one push constant block, but keep the vector in case this restriction is lifted
            // in the future.
            res.push_constant_buffers.push_back({ var.self, type.self, meta[var.self].decoration.alias });
        }
        // Images
        else if (type.storage == StorageClassUniformConstant && type.basetype == SPIRType::Image)
        {
            res.storage_images.push_back({ var.self, type.self, meta[var.self].decoration.alias });
        }
        // Textures
        else if (type.storage == StorageClassUniformConstant && type.basetype == SPIRType::SampledImage)
        {
            res.sampled_images.push_back({ var.self, type.self, meta[var.self].decoration.alias });
        }
        // Atomic counters
        else if (type.storage == StorageClassAtomicCounter)
        {
            res.atomic_counters.push_back({ var.self, type.self, meta[var.self].decoration.alias });
        }
    }

    return res;
}

static inline uint32_t swap_endian(uint32_t v)
{
    return ((v >> 24) & 0x000000ffu) |
           ((v >>  8) & 0x0000ff00u) |
           ((v <<  8) & 0x00ff0000u) |
           ((v << 24) & 0xff000000u);
}

static string extract_string(const vector<uint32_t> &spirv, uint32_t offset)
{
    string ret;
    for (uint32_t i = offset; i < spirv.size(); i++)
    {
        uint32_t w = spirv[i];

        for (uint32_t j = 0; j < 4; j++, w >>= 8)
        {
            char c = w & 0xff;
            if (c == '\0')
                return ret;
            ret += c;
        }
    }

    throw CompilerError("String was not terminated before EOF");
}

void Compiler::parse()
{
    auto len = spirv.size();
    if (len < 5)
        throw CompilerError("SPIRV file too small.");

    auto s = spirv.data();

    // Endian-swap if we need to.
    if (s[0] == swap_endian(MagicNumber))
        transform(begin(spirv), end(spirv), begin(spirv), [](uint32_t c) { return swap_endian(c); });

    // Allow v99 since it tends to just work, but warn about this.
    if (s[0] != MagicNumber || (s[1] != Version && s[1] != 99))
        throw CompilerError("Invalid SPIRV format.");

    if (s[1] != Version)
    {
        fprintf(stderr, "SPIRV-Cross was compiled against SPIR-V version %d, but SPIR-V uses version %u. Buggy behavior due to ABI incompatibility might occur.\n",
            Version, s[1]);
    }

    uint32_t bound = s[3];
    ids.resize(bound);
    meta.resize(bound);

    uint32_t offset = 5;
    while (offset < len)
        inst.emplace_back(spirv, offset);

    for (auto &i : inst)
        parse(i);

    if (function)
        throw CompilerError("Function was not terminated.");
    if (block)
        throw CompilerError("Block was not terminated.");
}

void Compiler::flatten_interface_block(uint32_t id)
{
    auto &var = get<SPIRVariable>(id);
    auto &type = get<SPIRType>(var.basetype);
    auto flags = meta.at(type.self).decoration.decoration_flags;

    if (!type.array.empty())
        throw CompilerError("Type is array of UBOs.");
    if (type.basetype != SPIRType::Struct)
        throw CompilerError("Type is not a struct.");
    if ((flags & (1ull << DecorationBlock)) == 0)
        throw CompilerError("Type is not a block.");
    if (type.member_types.empty())
        throw CompilerError("Member list of struct is empty.");

    uint32_t t = type.member_types[0];
    for (auto &m : type.member_types)
        if (t != m)
            throw CompilerError("Types in block differ.");

    auto &mtype = get<SPIRType>(t);
    if (!mtype.array.empty())
        throw CompilerError("Member type cannot be arrays.");
    if (mtype.basetype == SPIRType::Struct)
        throw CompilerError("Member type cannot be struct.");

    // Inherit variable name from interface block name.
    meta.at(var.self).decoration.alias = meta.at(type.self).decoration.alias;

    auto storage = var.storage;
    if (storage == StorageClassUniform)
        storage = StorageClassUniformConstant;

    // Change type definition in-place into an array instead.
    // Access chains will still work as-is.
    uint32_t array_size = uint32_t(type.member_types.size());
    type = mtype;
    type.array.push_back(array_size);
    type.pointer = true;
    type.storage = storage;
    var.storage = storage;
}

void Compiler::update_name_cache(unordered_set<string> &cache, string &name)
{
    if (name.empty())
        return;

    if (cache.find(name) == end(cache))
    {
        cache.insert(name);
        return;
    }

    uint32_t counter = 0;
    auto tmpname = name;

    // If there is a collision (very rare),
    // keep tacking on extra identifier until it's unique.
    do
    {
        counter++;
        name = tmpname + "_" + convert_to_string(counter);
    } while (cache.find(name) != end(cache));
    cache.insert(name);
}

void Compiler::set_name(uint32_t id, const std::string& name)
{
    auto &str = meta.at(id).decoration.alias;
    str.clear();

    if (name.empty())
        return;
    // Reserved for temporaries.
    if (name[0] == '_')
        return;

    // Functions in glslangValidator are mangled with name(<mangled> stuff.
    // Normally, we would never see '(' in any legal indentifiers, so just strip them out.
    str = name.substr(0, name.find('('));

    for (uint32_t i = 0; i < str.size(); i++)
    {
        auto &c = str[i];

        // _<num> variables are reserved by the internal implementation,
        // otherwise, make sure the name is a valid identifier.
        if (i == 0 || (str[0] == '_' && i == 1))
            c = isalpha(c) ? c : '_';
        else
            c = isalnum(c) ? c : '_';
    }
}

const SPIRType& Compiler::get_type(uint32_t id) const
{
    return get<SPIRType>(id);
}

void Compiler::set_member_decoration(uint32_t id, uint32_t index, Decoration decoration, uint32_t argument)
{
    meta.at(id).members.resize(max(meta[id].members.size(), size_t(index) + 1));
    auto &dec = meta.at(id).members[index];
    dec.decoration_flags |= 1ull << decoration;

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

        case DecorationLocation:
            dec.location = argument;
            break;

        case DecorationOffset:
            dec.offset = argument;
            break;

        default:
            break;
    }
}

void Compiler::set_member_name(uint32_t id, uint32_t index, const std::string& name)
{
    meta.at(id).members.resize(max(meta[id].members.size(), size_t(index) + 1));
    meta.at(id).members[index].alias = name;
}

const std::string& Compiler::get_member_name(uint32_t id, uint32_t index) const
{
    auto &m = meta.at(id);
    if (index >= m.members.size())
    {
        static string empty;
        return empty;
    }

    return m.members[index].alias;
}

uint32_t Compiler::get_member_decoration(uint32_t id, uint32_t index, Decoration decoration) const
{
    auto &dec = meta.at(id).members.at(index);
    if (!(dec.decoration_flags & (1ull << decoration)))
        return 0;

    switch (decoration)
    {
        case DecorationBuiltIn: return dec.builtin_type;
        case DecorationLocation: return dec.location;
        case DecorationOffset: return dec.offset;
        default: return 0;
    }
}

uint64_t Compiler::get_member_decoration_mask(uint32_t id, uint32_t index) const
{
    auto &m = meta.at(id);
    if (index >= m.members.size())
        return 0;

    return m.members[index].decoration_flags;
}

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

    auto &dec = m.members[index];

    dec.decoration_flags &= ~(1ull << decoration);
    switch (decoration)
    {
        case DecorationBuiltIn:
            dec.builtin = false;
            break;

        case DecorationLocation:
            dec.location = 0;
            break;

        case DecorationOffset:
            dec.offset = 0;
            break;

        default:
            break;
    }
}

void Compiler::set_decoration(uint32_t id, Decoration decoration, uint32_t argument)
{
    auto &dec = meta.at(id).decoration;
    dec.decoration_flags |= 1ull << decoration;

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

        case DecorationLocation:
            dec.location = argument;
            break;

        case DecorationOffset:
            dec.offset = argument;
            break;

        case DecorationArrayStride:
            dec.array_stride = argument;
            break;

        case DecorationBinding:
            dec.binding = argument;
            break;

        case DecorationDescriptorSet:
            dec.set = argument;
            break;

        case DecorationInputAttachmentIndex:
            dec.input_attachment = argument;
            break;

        default:
            break;
    }
}

StorageClass Compiler::get_storage_class(uint32_t id) const
{
    return get<SPIRVariable>(id).storage;
}

const std::string& Compiler::get_name(uint32_t id) const
{
    return meta.at(id).decoration.alias;
}

uint64_t Compiler::get_decoration_mask(uint32_t id) const
{
    auto &dec = meta.at(id).decoration;
    return dec.decoration_flags;
}

uint32_t Compiler::get_decoration(uint32_t id, Decoration decoration) const
{
    auto &dec = meta.at(id).decoration;
    if (!(dec.decoration_flags & (1ull << decoration)))
        return 0;

    switch (decoration)
    {
        case DecorationBuiltIn: return dec.builtin_type;
        case DecorationLocation: return dec.location;
        case DecorationOffset: return dec.offset;
        case DecorationBinding: return dec.binding;
        case DecorationDescriptorSet: return dec.set;
        case DecorationInputAttachmentIndex: return dec.input_attachment;
        default: return 0;
    }
}

void Compiler::unset_decoration(uint32_t id, Decoration decoration)
{
    auto &dec = meta.at(id).decoration;
    dec.decoration_flags &= ~(1ull << decoration);
    switch (decoration)
    {
        case DecorationBuiltIn:
            dec.builtin = false;
            break;

        case DecorationLocation:
            dec.location = 0;
            break;

        case DecorationOffset:
            dec.offset = 0;
            break;

        case DecorationBinding:
            dec.binding = 0;
            break;

        case DecorationDescriptorSet:
            dec.set = 0;
            break;

        default:
            break;
    }
}

void Compiler::parse(const Instruction &i)
{
    auto ops = stream(i);
    auto op = static_cast<Op>(i.op);
    uint32_t length = i.length;

    if (i.offset + length > spirv.size())
        throw CompilerError("Compiler::parse() opcode out of range.");

    switch (op)
    {
        case OpMemoryModel:
        case OpSourceExtension:
        case OpNop:
            break;

        case OpSource:
        {
            auto lang = static_cast<SourceLanguage>(ops[0]);
            switch (lang)
            {
                case SourceLanguageESSL:
                    source.es = true;
                    source.version = ops[1];
                    source.known = true;
                    break;

                case SourceLanguageGLSL:
                    source.es = false;
                    source.version = ops[1];
                    source.known = true;
                    break;

                default:
                    source.known = false;
                    break;
            }
            break;
        }

        case OpUndef:
        {
            uint32_t result_type = ops[0];
            uint32_t id = ops[1];
            set<SPIRUndef>(id, result_type);
            break;
        }

        case OpCapability:
        {
            uint32_t cap = ops[0];
            if (cap == CapabilityKernel)
                throw CompilerError("Kernel capability not supported.");
            break;
        }

        case OpExtInstImport:
        {
            uint32_t id = ops[0];
            auto ext = extract_string(spirv, i.offset + 1);
            if (ext == "GLSL.std.450")
                set<SPIRExtension>(id, SPIRExtension::GLSL);
            else
                throw CompilerError("Only GLSL.std.450 extension interface supported.");

            break;
        }

        case OpEntryPoint:
        {
            if (execution.entry_point)
                throw CompilerError("More than one entry point not supported.");

            execution.model = static_cast<ExecutionModel>(ops[0]);
            execution.entry_point = ops[1];
            break;
        }

        case OpExecutionMode:
        {
            uint32_t entry = ops[0];
            if (entry != execution.entry_point)
                throw CompilerError("Cannot set execution mode to non-existing entry point.");

            auto mode = static_cast<ExecutionMode>(ops[1]);
            execution.flags |= 1ull << mode;

            switch (mode)
            {
                case ExecutionModeInvocations:
                    execution.invocations = ops[2];
                    break;

                case ExecutionModeLocalSize:
                    execution.workgroup_size.x = ops[2];
                    execution.workgroup_size.y = ops[3];
                    execution.workgroup_size.z = ops[4];
                    break;

                case ExecutionModeOutputVertices:
                    execution.output_vertices = ops[2];
                    break;

                default:
                    break;
            }
            break;
        }

        case OpName:
        {
            uint32_t id = ops[0];
            set_name(id, extract_string(spirv, i.offset + 1));
            break;
        }

        case OpMemberName:
        {
            uint32_t id = ops[0];
            uint32_t member = ops[1];
            set_member_name(id, member, extract_string(spirv, i.offset + 2));
            break;
        }

        case OpDecorate:
        {
            uint32_t id = ops[0];

            auto decoration = static_cast<Decoration>(ops[1]);
            if (length >= 3)
                set_decoration(id, decoration, ops[2]);
            else
                set_decoration(id, decoration);
            break;
        }

        case OpMemberDecorate:
        {
            uint32_t id = ops[0];
            uint32_t member = ops[1];
            auto decoration = static_cast<Decoration>(ops[2]);
            if (length >= 4)
                set_member_decoration(id, member, decoration, ops[3]);
            else
                set_member_decoration(id, member, decoration);
            break;
        }

        // Build up basic types.
        case OpTypeVoid:
        {
            uint32_t id = ops[0];
            auto &type = set<SPIRType>(id);
            type.basetype = SPIRType::Void;
            break;
        }

        case OpTypeBool:
        {
            uint32_t id = ops[0];
            auto &type = set<SPIRType>(id);
            type.basetype = SPIRType::Bool;
            type.width = 1;
            break;
        }

        case OpTypeFloat:
        {
            uint32_t id = ops[0];
            uint32_t width = ops[1];
            auto &type = set<SPIRType>(id);
            type.basetype = SPIRType::Float;
            type.width = width;
            break;
        }

        case OpTypeInt:
        {
            uint32_t id = ops[0];
            uint32_t width = ops[1];
            auto &type = set<SPIRType>(id);
            type.basetype = ops[2] ? SPIRType::Int : SPIRType::UInt;
            type.width = width;
            break;
        }

        // Build composite types by "inheriting".
        // NOTE: The self member is also copied! For pointers and array modifiers this is a good thing
        // since we can refer to decorations on pointee classes which is needed for UBO/SSBO, I/O blocks in geometry/tess etc.
        case OpTypeVector:
        {
            uint32_t id = ops[0];
            uint32_t vecsize = ops[2];

            auto &base = get<SPIRType>(ops[1]);
            auto &vecbase = set<SPIRType>(id);

            vecbase = base;
            vecbase.vecsize = vecsize;
            vecbase.self = id;
            break;
        }

        case OpTypeMatrix:
        {
            uint32_t id = ops[0];
            uint32_t colcount = ops[2];

            auto &base = get<SPIRType>(ops[1]);
            auto &matrixbase = set<SPIRType>(id);

            matrixbase = base;
            matrixbase.columns = colcount;
            matrixbase.self = id;
            break;
        }

        case OpTypeArray:
        {
            uint32_t id = ops[0];

            auto &base = get<SPIRType>(ops[1]);
            auto &arraybase = set<SPIRType>(id);

            arraybase = base;
            arraybase.array.push_back(get<SPIRConstant>(ops[2]).scalar());
            // Do NOT set arraybase.self!
            break;
        }

        case OpTypeRuntimeArray:
        {
            uint32_t id = ops[0];

            auto &base = get<SPIRType>(ops[1]);
            auto &arraybase = set<SPIRType>(id);

            arraybase = base;
            arraybase.array.push_back(0);
            // Do NOT set arraybase.self!
            break;
        }

        case OpTypeImage:
        {
            uint32_t id = ops[0];
            auto &type = set<SPIRType>(id);
            type.basetype = SPIRType::Image;
            type.image.type = ops[1];
            type.image.dim = static_cast<Dim>(ops[2]);
            type.image.depth = ops[3] != 0;
            type.image.arrayed = ops[4] != 0;
            type.image.ms = ops[5] != 0;
            type.image.sampled = ops[6];
            type.image.format = static_cast<ImageFormat>(ops[7]);
            break;
        }

        case OpTypeSampledImage:
        {
            uint32_t id = ops[0];
            uint32_t imagetype = ops[1];
            auto &type = set<SPIRType>(id);
            type = get<SPIRType>(imagetype);
            type.basetype = SPIRType::SampledImage;
            type.self = id;
            break;
        }

        // Not really used.
        case OpTypeSampler:
        {
            uint32_t id = ops[0];
            auto &type = set<SPIRType>(id);
            type.basetype = SPIRType::Sampler;
            break;
        }

        case OpTypePointer:
        {
            uint32_t id = ops[0];

            auto &base = get<SPIRType>(ops[2]);
            auto &ptrbase = set<SPIRType>(id);

            ptrbase = base;
            if (ptrbase.pointer)
                throw CompilerError("Cannot make pointer-to-pointer type.");
            ptrbase.pointer = true;
            ptrbase.storage = static_cast<StorageClass>(ops[1]);

            if (ptrbase.storage == StorageClassAtomicCounter)
                ptrbase.basetype = SPIRType::AtomicCounter;

            // Do NOT set ptrbase.self!
            break;
        }

        case OpTypeStruct:
        {
            uint32_t id = ops[0];
            auto &type = set<SPIRType>(id);
            type.basetype = SPIRType::Struct;
            for (uint32_t i = 1; i < length; i++)
                type.member_types.push_back(ops[i]);
            break;
        }

        case OpTypeFunction:
        {
            uint32_t id = ops[0];
            uint32_t ret = ops[1];

            auto &func = set<SPIRFunctionPrototype>(id, ret);
            for (uint32_t i = 2; i < length; i++)
                func.parameter_types.push_back(ops[i]);
            break;
        }

        // Variable declaration
        // All variables are essentially pointers with a storage qualifier.
        case OpVariable:
        {
            uint32_t type = ops[0];
            uint32_t id = ops[1];
            auto storage = static_cast<StorageClass>(ops[2]);
            uint32_t initializer = length == 4 ? ops[3] : 0;

            if (storage == StorageClassFunction)
            {
                if (!function)
                    throw CompilerError("No function currently in scope");
                function->add_local_variable(id);
            }
            else if (storage == StorageClassPrivate ||
                    storage == StorageClassWorkgroup ||
                    storage == StorageClassOutput)
            {
                global_variables.push_back(id);
            }

            auto &var = set<SPIRVariable>(id, type, storage, initializer);

            if (variable_storage_is_aliased(var))
                aliased_variables.push_back(var.self);

            // glslangValidator does not emit required qualifiers here.
            // Solve this by making the image access as restricted as possible
            // and loosen up if we need to.
            auto &vartype = expression_type(id);
            if (vartype.basetype == SPIRType::Image)
            {
                auto &flags = meta.at(id).decoration.decoration_flags;
                flags |= 1ull << DecorationNonWritable;
                flags |= 1ull << DecorationNonReadable;
            }

            break;
        }

        // OpPhi
        // OpPhi is a fairly magical opcode.
        // It selects temporary variables based on which parent block we *came from*.
        // In high-level languages we can "de-SSA" by creating a function local, and flush out temporaries to this function-local
        // variable to emulate SSA Phi.
        case OpPhi:
        {
            if (!function)
                throw CompilerError("No function currently in scope");
            if (!block)
                throw CompilerError("No block currently in scope");

            uint32_t result_type = ops[0];
            uint32_t id = ops[1];

            // Instead of a temporary, create a new function-wide temporary with this ID instead.
            auto &var = set<SPIRVariable>(id, result_type, spv::StorageClassFunction);
            var.phi_variable = true;

            function->add_local_variable(id);

            for (uint32_t i = 2; i + 2 <= length; i += 2)
                block->phi_variables.push_back({ ops[i], ops[i + 1], id });
            break;
        }

        // Constants
        case OpSpecConstant:
        case OpConstant:
        {
            uint32_t id = ops[1];
            set<SPIRConstant>(id, ops[0], ops[2]).specialization = op == OpSpecConstant;
            break;
        }

        case OpSpecConstantFalse:
        case OpConstantFalse:
        {
            uint32_t id = ops[1];
            set<SPIRConstant>(id, ops[0], 0).specialization = op == OpSpecConstantFalse;
            break;
        }

        case OpSpecConstantTrue:
        case OpConstantTrue:
        {
            uint32_t id = ops[1];
            set<SPIRConstant>(id, ops[0], 1).specialization = op == OpSpecConstantTrue;
            break;
        }

        case OpSpecConstantComposite:
        case OpConstantComposite:
        {
            uint32_t id = ops[1];
            uint32_t type = ops[0];

            auto &ctype = get<SPIRType>(type);
            SPIRConstant *constant = nullptr;

            // We can have constants which are structs and arrays.
            // In this case, our SPIRConstant will be a list of other SPIRConstant ids which we
            // can refer to.
            if (ctype.basetype == SPIRType::Struct || !ctype.array.empty())
            {
                constant = &set<SPIRConstant>(id, type, ops + 2, length - 2);
                constant->specialization = op == OpSpecConstantComposite;
                break;
            }

            bool matrix = ctype.columns > 1;

            if (matrix)
            {
                switch (length - 2)
                {
                    case 1:
                        constant = &set<SPIRConstant>(id, type,
                                get<SPIRConstant>(ops[2]).vector());
                        break;

                    case 2:
                        constant = &set<SPIRConstant>(id, type,
                                get<SPIRConstant>(ops[2]).vector(),
                                get<SPIRConstant>(ops[3]).vector());
                        break;

                    case 3:
                        constant = &set<SPIRConstant>(id, type,
                                get<SPIRConstant>(ops[2]).vector(),
                                get<SPIRConstant>(ops[3]).vector(),
                                get<SPIRConstant>(ops[4]).vector());
                        break;

                    case 4:
                        constant = &set<SPIRConstant>(id, type,
                                get<SPIRConstant>(ops[2]).vector(),
                                get<SPIRConstant>(ops[3]).vector(),
                                get<SPIRConstant>(ops[4]).vector(),
                                get<SPIRConstant>(ops[5]).vector());
                        break;

                    default: throw CompilerError("OpConstantComposite only supports 1, 2, 3 and 4 columns.");
                }
            }
            else
            {
                switch (length - 2)
                {
                    case 1:
                        constant = &set<SPIRConstant>(id, type,
                                get<SPIRConstant>(ops[2]).scalar());
                        break;

                    case 2:
                        constant = &set<SPIRConstant>(id, type,
                                get<SPIRConstant>(ops[2]).scalar(),
                                get<SPIRConstant>(ops[3]).scalar());
                        break;

                    case 3:
                        constant = &set<SPIRConstant>(id, type,
                                get<SPIRConstant>(ops[2]).scalar(),
                                get<SPIRConstant>(ops[3]).scalar(),
                                get<SPIRConstant>(ops[4]).scalar());
                        break;

                    case 4:
                        constant = &set<SPIRConstant>(id, type,
                                get<SPIRConstant>(ops[2]).scalar(),
                                get<SPIRConstant>(ops[3]).scalar(),
                                get<SPIRConstant>(ops[4]).scalar(),
                                get<SPIRConstant>(ops[5]).scalar());
                        break;

                    default: throw CompilerError("OpConstantComposite only supports 1, 2, 3 and 4 components.");
                }
            }

            constant->specialization = op == OpSpecConstantComposite;
            break;
        }

        // Functions
        case OpFunction:
        {
            uint32_t res = ops[0];
            uint32_t id = ops[1];
            // Control
            uint32_t type = ops[3];

            if (function)
                throw CompilerError("Must end a function before starting a new one!");

            function = &set<SPIRFunction>(id, res, type);
            break;
        }

        case OpFunctionParameter:
        {
            uint32_t type = ops[0];
            uint32_t id = ops[1];

            if (!function)
                throw CompilerError("Must be in a function!");

            function->add_parameter(type, id);
            set<SPIRVariable>(id, type, StorageClassFunction);
            break;
        }

        case OpFunctionEnd:
        {
            function = nullptr;
            break;
        }

        // Blocks
        case OpLabel:
        {
            // OpLabel always starts a block.
            if (!function)
                throw CompilerError("Blocks cannot exist outside functions!");

            uint32_t id = ops[0];

            function->blocks.push_back(id);
            if (!function->entry_block)
                function->entry_block = id;

            if (block)
                throw CompilerError("Cannot start a block before ending the current block.");

            block = &set<SPIRBlock>(id);
            break;
        }

        // Branch instructions end blocks.
        case OpBranch:
        {
            if (!block)
                throw CompilerError("Trying to end a non-existing block.");

            uint32_t target = ops[0];
            block->terminator = SPIRBlock::Direct;
            block->next_block = target;
            block = nullptr;
            break;
        }

        case OpBranchConditional:
        {
            if (!block)
                throw CompilerError("Trying to end a non-existing block.");

            block->condition = ops[0];
            block->true_block = ops[1];
            block->false_block = ops[2];

            block->terminator = SPIRBlock::Select;
            block = nullptr;
            break;
        }

        case OpSwitch:
        {
            if (!block)
                throw CompilerError("Trying to end a non-existing block.");

            if (block->merge == SPIRBlock::MergeNone)
                throw CompilerError("Switch statement is not structured");

            block->terminator = SPIRBlock::MultiSelect;

            block->condition = ops[0];
            block->default_block = ops[1];

            for (uint32_t i = 2; i + 2 <= length; i += 2)
                block->cases.push_back({ ops[i], ops[i + 1] });

            // If we jump to next block, make it break instead since we're inside a switch case block at that point.
            multiselect_merge_target.insert(block->next_block);

            block = nullptr;
            break;
        }

        case OpKill:
        {
            if (!block)
                throw CompilerError("Trying to end a non-existing block.");
            block->terminator = SPIRBlock::Kill;
            block = nullptr;
            break;
        }

        case OpReturn:
        {
            if (!block)
                throw CompilerError("Trying to end a non-existing block.");
            block->terminator = SPIRBlock::Return;
            block = nullptr;
            break;
        }

        case OpReturnValue:
        {
            if (!block)
                throw CompilerError("Trying to end a non-existing block.");
            block->terminator = SPIRBlock::Return;
            block->return_value = ops[0];
            block = nullptr;
            break;
        }

        case OpUnreachable:
        {
            if (!block)
                throw CompilerError("Trying to end a non-existing block.");
            block->terminator = SPIRBlock::Unreachable;
            block = nullptr;
            break;
        }

        case OpSelectionMerge:
        {
            if (!block)
                throw CompilerError("Trying to modify a non-existing block.");

            block->next_block = ops[0];
            block->merge = SPIRBlock::MergeSelection;
            selection_merge_target.insert(block->next_block);
            break;
        }

        case OpLoopMerge:
        {
            if (!block)
                throw CompilerError("Trying to modify a non-existing block.");

            block->merge_block = ops[0];
            block->continue_block = ops[1];
            block->merge = SPIRBlock::MergeLoop;

            loop_block.insert(block->self);
            loop_merge_target.insert(block->merge_block);

            // Don't add loop headers to continue blocks,
            // which would make it impossible branch into the loop header since
            // they are treated as continues.
            if (block->continue_block != block->self)
               continue_block.insert(block->continue_block);
            break;
        }

        // Actual opcodes.
        default:
        {
            if (!block)
                throw CompilerError("Currently no block to insert opcode.");

            block->ops.push_back(i);
            break;
        }
    }
}

bool Compiler::block_is_loop_candidate(const SPIRBlock &block, SPIRBlock::Method method) const
{
    // Tried and failed.
    if (block.disable_block_optimization || block.complex_continue)
        return false;

    if (method == SPIRBlock::MergeToSelectForLoop)
    {
        // Try to detect common for loop pattern
        // which the code backend can use to create cleaner code.
        // for(;;) { if (cond) { some_body; } else { break; } }
        // is the pattern we're looking for.
        bool ret =
            block.terminator == SPIRBlock::Select &&
            block.merge == SPIRBlock::MergeLoop &&
            block.true_block != block.merge_block &&
            block.true_block != block.self &&
            block.false_block == block.merge_block;

        // If we have OpPhi which depends on branches which came from our own block,
        // we need to flush phi variables in else block instead of a trivial break,
        // so we cannot assume this is a for loop candidate.
        if (ret)
        {
            for (auto &phi : block.phi_variables)
                if (phi.parent == block.self)
                    return false;

            auto *merge = maybe_get<SPIRBlock>(block.merge_block);
            if (merge)
                for (auto &phi : merge->phi_variables)
                    if (phi.parent == block.self)
                        return false;
        }
        return ret;
    }
    else if (method == SPIRBlock::MergeToDirectForLoop)
    {
        // Empty loop header that just sets up merge target
        // and branches to loop body.
        bool ret =
            block.terminator == SPIRBlock::Direct &&
            block.merge == SPIRBlock::MergeLoop &&
            block.ops.empty();

        if (!ret)
            return false;

        auto &child = get<SPIRBlock>(block.next_block);
        ret =
            child.terminator == SPIRBlock::Select &&
            child.merge == SPIRBlock::MergeNone &&
            child.false_block == block.merge_block &&
            child.true_block != block.merge_block &&
            child.true_block != block.self;

        // If we have OpPhi which depends on branches which came from our own block,
        // we need to flush phi variables in else block instead of a trivial break,
        // so we cannot assume this is a for loop candidate.
        if (ret)
        {
            for (auto &phi : block.phi_variables)
                if (phi.parent == block.self || phi.parent == child.self)
                    return false;

            for (auto &phi : child.phi_variables)
                if (phi.parent == block.self)
                    return false;

            auto *merge = maybe_get<SPIRBlock>(block.merge_block);
            if (merge)
                for (auto &phi : merge->phi_variables)
                    if (phi.parent == block.self || phi.parent == child.false_block)
                        return false;
        }

        return ret;
    }
    else
        return false;
}

bool Compiler::block_is_outside_flow_control_from_block(const SPIRBlock &from, const SPIRBlock &to)
{
    auto *start = &from;

    if (start->self == to.self)
        return true;

    // Break cycles.
    if (is_continue(start->self))
        return false;

    // If our select block doesn't merge, we must break or continue in these blocks,
    // so if continues occur branchless within these blocks, consider them branchless as well.
    // This is typically used for loop control.
    if (start->terminator == SPIRBlock::Select &&
        start->merge == SPIRBlock::MergeNone &&
        (block_is_outside_flow_control_from_block(get<SPIRBlock>(start->true_block), to) ||
         block_is_outside_flow_control_from_block(get<SPIRBlock>(start->false_block), to)))
    {
        return true;
    }
    else if (start->merge_block &&
             block_is_outside_flow_control_from_block(get<SPIRBlock>(start->merge_block), to))
    {
        return true;
    }
    else if (start->next_block &&
             block_is_outside_flow_control_from_block(get<SPIRBlock>(start->next_block), to))
    {
        return true;
    }
    else
        return false;
}

bool Compiler::execution_is_noop(const SPIRBlock &from, const SPIRBlock &to) const
{
    if (!execution_is_branchless(from, to))
        return false;

    auto *start = &from;
    for (;;)
    {
        if (start->self == to.self)
            return true;

        if (!start->ops.empty())
            return false;

        start = &get<SPIRBlock>(start->next_block);
    }
}

bool Compiler::execution_is_branchless(const SPIRBlock &from, const SPIRBlock &to) const
{
    auto *start = &from;
    for (;;)
    {
        if (start->self == to.self)
            return true;

        if (start->terminator == SPIRBlock::Direct && start->merge == SPIRBlock::MergeNone)
            start = &get<SPIRBlock>(start->next_block);
        else
            return false;
    }
}

SPIRBlock::ContinueBlockType Compiler::continue_block_type(const SPIRBlock &continue_block) const
{
    // The block was deemed too complex during code emit, pick conservative fallback paths.
    if (continue_block.complex_continue)
        return SPIRBlock::ComplexLoop;

    // In older glslang output continue block can be equal to the loop header.
    // In this case, execution is clearly branchless, so just assume a while loop header here.
    if (continue_block.merge == SPIRBlock::MergeLoop)
        return SPIRBlock::WhileLoop;

    auto &dominator = get<SPIRBlock>(continue_block.loop_dominator);

    if (execution_is_noop(continue_block, dominator))
        return SPIRBlock::WhileLoop;
    else if (execution_is_branchless(continue_block, dominator))
        return SPIRBlock::ForLoop;
    else
    {
        if (continue_block.merge == SPIRBlock::MergeNone &&
            continue_block.terminator == SPIRBlock::Select &&
            continue_block.true_block == dominator.self &&
            continue_block.false_block == dominator.merge_block)
        {
            return SPIRBlock::DoWhileLoop;
        }
        else
            return SPIRBlock::ComplexLoop;
    }
}

bool Compiler::traverse_all_reachable_opcodes(const SPIRBlock &block, OpcodeHandler &handler) const
{
    // Ideally, perhaps traverse the CFG instead of all blocks in order to eliminate dead blocks,
    // but this shouldn't be a problem in practice unless the SPIR-V is doing insane things like recursing
    // inside dead blocks ...
    for (auto &i : block.ops)
    {
        auto ops = stream(i);
        auto op = static_cast<Op>(i.op);

        if (!handler.handle(op, ops, i.length))
            return false;

        uint32_t func = ops[2];
        if (op == OpFunctionCall &&
                !traverse_all_reachable_opcodes(get<SPIRFunction>(func), handler))
            return false;
    }

    return true;
}

bool Compiler::traverse_all_reachable_opcodes(const SPIRFunction &func, OpcodeHandler &handler) const
{
    for (auto block : func.blocks)
        if (!traverse_all_reachable_opcodes(get<SPIRBlock>(block), handler))
            return false;

    return true;
}

uint32_t Compiler::type_struct_member_offset(const SPIRType &type, uint32_t index) const
{
    // Decoration must be set in valid SPIR-V, otherwise throw.
    auto &dec = meta[type.self].members.at(index);
    if (dec.decoration_flags & (1ull << DecorationOffset))
        return dec.offset;
    else
        throw CompilerError("Struct member does not have Offset set.");
}

uint32_t Compiler::type_struct_member_array_stride(const SPIRType &type, uint32_t index) const
{
    // Decoration must be set in valid SPIR-V, otherwise throw.
    // ArrayStride is part of the array type not OpMemberDecorate.
    auto &dec = meta[type.member_types[index]].decoration;
    if (dec.decoration_flags & (1ull << DecorationArrayStride))
        return dec.array_stride;
    else
        throw CompilerError("Struct member does not have ArrayStride set.");
}

size_t Compiler::get_declared_struct_size(const SPIRType &type) const
{
    uint32_t last = uint32_t(type.member_types.size() - 1);
    size_t offset = type_struct_member_offset(type, last);
    size_t size = get_declared_struct_member_size(type, last);
    return offset + size;
}

size_t Compiler::get_declared_struct_member_size(const SPIRType &struct_type, uint32_t index) const
{
    auto flags = get_member_decoration_mask(struct_type.self, index);
    auto &type = get<SPIRType>(struct_type.member_types[index]);

    if (type.basetype != SPIRType::Struct)
    {
        switch (type.basetype)
        {
            case SPIRType::Unknown:
            case SPIRType::Void:
            case SPIRType::Bool: // Bools are purely logical, and cannot be used for externally visible types.
            case SPIRType::AtomicCounter:
            case SPIRType::Image:
            case SPIRType::SampledImage:
            case SPIRType::Sampler:
                throw CompilerError("Querying size for object with opaque size.\n");

            default:
                break;
        }

        size_t component_size = type.width / 8; 
        unsigned vecsize = type.vecsize;
        unsigned columns = type.columns;

        if (type.array.empty())
        {
            // Vectors.
            if (columns == 1)
                return vecsize * component_size;
            else
            {
                // Per SPIR-V spec, matrices must be tightly packed and aligned up for vec3 accesses.
                if ((flags & (1ull << DecorationRowMajor)) && columns == 3)
                    columns = 4;
                else if ((flags & (1ull << DecorationColMajor)) && vecsize == 3)
                    vecsize = 4;

                return vecsize * columns * component_size;
            }
        }
        else
        {
            // For arrays, we can use ArrayStride to get an easy check.
            return type_struct_member_array_stride(struct_type, index) * type.array.back();
        }
    }
    else
    {
        // Recurse.
        uint32_t last = uint32_t(struct_type.member_types.size() - 1);
        uint32_t offset = type_struct_member_offset(struct_type, last);
        size_t size = get_declared_struct_size(get<SPIRType>(struct_type.member_types.back()));
        return offset + size;
    }
}

bool Compiler::BufferAccessHandler::handle(Op opcode, const uint32_t *args, uint32_t length)
{
    if (opcode != OpAccessChain && opcode != OpInBoundsAccessChain)
        return true;

    // Invalid SPIR-V.
    if (length < 4)
        return false;

    if (args[2] != id)
        return true;

    // Don't bother traversing the entire access chain tree yet.
    // If we access a struct member, assume we access the entire member.
    uint32_t index = compiler.get<SPIRConstant>(args[3]).scalar();

    // Seen this index already.
    if (seen.find(index) != end(seen))
        return true;
    seen.insert(index);

    auto &type = compiler.expression_type(id);
    uint32_t offset = compiler.type_struct_member_offset(type, index);

    size_t range;
    // If we have another member in the struct, deduce the range by looking at the next member.
    // This is okay since structs in SPIR-V can have padding, but Offset decoration must be
    // monotonically increasing.
    // Of course, this doesn't take into account if the SPIR-V for some reason decided to add
    // very large amounts of padding, but that's not really a big deal.
    if (index + 1 < type.member_types.size())
    {
        range = compiler.type_struct_member_offset(type, index + 1) - offset;
    }
    else
    {
        // No padding, so just deduce it from the size of the member directly.
        range = compiler.get_declared_struct_member_size(type, index);
    }

    ranges.push_back({ index, offset, range });
    return true;
}

std::vector<BufferRange> Compiler::get_active_buffer_ranges(unsigned id) const
{
    std::vector<BufferRange> ranges;
    BufferAccessHandler handler(*this, ranges, id);
    traverse_all_reachable_opcodes(get<SPIRFunction>(execution.entry_point), handler);
    return ranges;
}

// Increase the number of IDs by the specified incremental amount.
// Returns the value of the first ID available for use in the expanded bound.
uint32_t Compiler::increase_bound_by(uint32_t incr_amount)
{
    uint32_t curr_bound = (uint32_t)ids.size();
    uint32_t new_bound = curr_bound + incr_amount;
    ids.resize(new_bound);
    meta.resize(new_bound);
    return curr_bound;
}