Put specialization constant instructions in the right section in SPIR-V

[libs/gl.git] / source / glsl / spirv.cpp

diff --git a/source/glsl/spirv.cpp b/source/glsl/spirv.cpp
index be226b3c556ff67650146cb8de9fbcaa2bb188cf..1cce97dfbf34888580ab6137140127e6fc67b094 100644 (file)
--- a/source/glsl/spirv.cpp
+++ b/source/glsl/spirv.cpp
@@ -394,9 +394,9 @@ SpirVGenerator::Id SpirVGenerator::begin_expression(Opcode opcode, Id type_id, u
                writer.begin_op(content.function_body, opcode, (n_args ? 1+has_result*2+n_args : 0));
        }
        else if(opcode==OP_COMPOSITE_CONSTRUCT)
-               writer.begin_op(content.function_body, OP_SPEC_CONSTANT_COMPOSITE, (n_args ? 1+has_result*2+n_args : 0));
+               writer.begin_op(content.globals, OP_SPEC_CONSTANT_COMPOSITE, (n_args ? 1+has_result*2+n_args : 0));
        else
-               writer.begin_op(content.function_body, OP_SPEC_CONSTANT_OP, (n_args ? 2+has_result*2+n_args : 0));
+               writer.begin_op(content.globals, OP_SPEC_CONSTANT_OP, (n_args ? 2+has_result*2+n_args : 0));
 
        Id result_id = next_id++;
        if(has_result)
@@ -455,16 +455,6 @@ SpirVGenerator::Id SpirVGenerator::write_construct(Id type_id, const Id *elem_id
        return result_id;
 }
 
-BasicTypeDeclaration &SpirVGenerator::get_element_type(BasicTypeDeclaration &basic)
-{
-       if(basic.kind==BasicTypeDeclaration::BOOL || basic.kind==BasicTypeDeclaration::INT || basic.kind==BasicTypeDeclaration::FLOAT)
-               return basic;
-       else if((basic.kind==BasicTypeDeclaration::VECTOR || basic.kind==BasicTypeDeclaration::MATRIX) && basic.base_type)
-               return get_element_type(dynamic_cast<BasicTypeDeclaration &>(*basic.base_type));
-       else
-               throw invalid_argument("SpirVGenerator::get_element_type");
-}
-
 void SpirVGenerator::visit(Block &block)
 {
        for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
@@ -665,7 +655,7 @@ void SpirVGenerator::visit(UnaryExpression &unary)
                return;
 
        BasicTypeDeclaration &basic = dynamic_cast<BasicTypeDeclaration &>(*unary.expression->type);
-       BasicTypeDeclaration &elem = get_element_type(basic);
+       BasicTypeDeclaration &elem = *get_element_type(basic);
 
        if(constant_expression && elem.kind!=BasicTypeDeclaration::BOOL && elem.kind!=BasicTypeDeclaration::INT)
                /* SPIR-V allows constant operations on floating-point values only for
@@ -747,7 +737,7 @@ void SpirVGenerator::visit(BinaryExpression &binary)
        BasicTypeDeclaration &basic_left = dynamic_cast<BasicTypeDeclaration &>(*binary.left->type);
        BasicTypeDeclaration &basic_right = dynamic_cast<BasicTypeDeclaration &>(*binary.right->type);
        // Expression resolver ensures that element types are the same
-       BasicTypeDeclaration &elem = get_element_type(basic_left);
+       BasicTypeDeclaration &elem = *get_element_type(basic_left);
 
        if(constant_expression && elem.kind!=BasicTypeDeclaration::BOOL && elem.kind!=BasicTypeDeclaration::INT)
                /* SPIR-V allows constant operations on floating-point values only for
@@ -1024,7 +1014,7 @@ void SpirVGenerator::visit(FunctionCall &call)
                for(NodeArray<Expression>::const_iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
                        if(BasicTypeDeclaration *basic_arg = dynamic_cast<BasicTypeDeclaration *>((*i)->type))
                        {
-                               BasicTypeDeclaration &elem_arg = get_element_type(*basic_arg);
+                               BasicTypeDeclaration &elem_arg = *get_element_type(*basic_arg);
                                switch(elem_arg.kind)
                                {
                                case BasicTypeDeclaration::BOOL: arg_types += 'b'; break;
@@ -1101,9 +1091,9 @@ void SpirVGenerator::visit_constructor(FunctionCall &call, const vector<Id> &arg
                return;
        }
 
-       BasicTypeDeclaration &elem = get_element_type(*basic);
+       BasicTypeDeclaration &elem = *get_element_type(*basic);
        BasicTypeDeclaration &basic_arg0 = dynamic_cast<BasicTypeDeclaration &>(*call.arguments[0]->type);
-       BasicTypeDeclaration &elem_arg0 = get_element_type(basic_arg0);
+       BasicTypeDeclaration &elem_arg0 = *get_element_type(basic_arg0);
 
        if(basic->kind==BasicTypeDeclaration::MATRIX)
        {