| // Copyright 2023 The Dawn & Tint Authors | |
| // | |
| // Redistribution and use in source and binary forms, with or without | |
| // modification, are permitted provided that the following conditions are met: | |
| // | |
| // 1. Redistributions of source code must retain the above copyright notice, this | |
| // list of conditions and the following disclaimer. | |
| // | |
| // 2. Redistributions in binary form must reproduce the above copyright notice, | |
| // this list of conditions and the following disclaimer in the documentation | |
| // and/or other materials provided with the distribution. | |
| // | |
| // 3. Neither the name of the copyright holder nor the names of its | |
| // contributors may be used to endorse or promote products derived from | |
| // this software without specific prior written permission. | |
| // | |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE | |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| #include <string> | |
| #include <tuple> | |
| #include <utility> | |
| #include "gmock/gmock.h" | |
| #include "gtest/gtest.h" | |
| #include "src/tint/lang/core/address_space.h" | |
| #include "src/tint/lang/core/ir/builder.h" | |
| #include "src/tint/lang/core/ir/function_param.h" | |
| #include "src/tint/lang/core/ir/ir_helper_test.h" | |
| #include "src/tint/lang/core/ir/type/array_count.h" | |
| #include "src/tint/lang/core/ir/validator.h" | |
| #include "src/tint/lang/core/number.h" | |
| #include "src/tint/lang/core/texel_format.h" | |
| #include "src/tint/lang/core/type/manager.h" | |
| #include "src/tint/lang/core/type/matrix.h" | |
| #include "src/tint/lang/core/type/memory_view.h" | |
| #include "src/tint/lang/core/type/pointer.h" | |
| #include "src/tint/lang/core/type/reference.h" | |
| #include "src/tint/lang/core/type/storage_texture.h" | |
| #include "src/tint/lang/core/type/struct.h" | |
| #include "src/tint/utils/text/string.h" | |
| namespace tint::core::ir { | |
| namespace { | |
| using namespace tint::core::fluent_types; // NOLINT | |
| using namespace tint::core::number_suffixes; // NOLINT | |
| class IR_ValidatorTest : public IRTestHelper { | |
| public: | |
| /// Builds and returns a basic 'compute' entry point function, named @p name | |
| Function* ComputeEntryPoint(const std::string& name = "f") { return b.ComputeFunction(name); } | |
| /// Builds and returns a basic 'fragment' entry point function, named @p name | |
| Function* FragmentEntryPoint(const std::string& name = "f") { | |
| return b.Function(name, ty.void_(), Function::PipelineStage::kFragment); | |
| } | |
| /// Builds and returns a basic 'vertex' entry point function, named @p name | |
| Function* VertexEntryPoint(const std::string& name = "f") { | |
| auto* f = b.Function(name, ty.vec4<f32>(), Function::PipelineStage::kVertex); | |
| f->SetReturnBuiltin(BuiltinValue::kPosition); | |
| return f; | |
| } | |
| /// Adds to a function an input param named @p name of type @p type, and decorated with @p | |
| /// builtin | |
| void AddBuiltinParam(Function* func, | |
| const std::string& name, | |
| BuiltinValue builtin, | |
| const core::type::Type* type) { | |
| auto* p = b.FunctionParam(name, type); | |
| p->SetBuiltin(builtin); | |
| func->AppendParam(p); | |
| } | |
| /// Adds to a function an return value of type @p type with attributes @p attr. | |
| /// If there is an already existing non-structured return, both values are moved into a | |
| /// structured return using @p name as the name. | |
| /// If there is an already existing structured return, then this ICEs, since that is beyond the | |
| /// scope of this implementation. | |
| void AddReturn(Function* func, | |
| const std::string& name, | |
| const core::type::Type* type, | |
| const IOAttributes& attr = {}) { | |
| if (func->ReturnType()->Is<core::type::Struct>()) { | |
| TINT_ICE() << "AddReturn does not support adding to structured returns"; | |
| } | |
| if (func->ReturnType() == ty.void_()) { | |
| func->SetReturnAttributes(attr); | |
| func->SetReturnType(type); | |
| return; | |
| } | |
| std::string old_name = | |
| func->ReturnAttributes().builtin == BuiltinValue::kPosition ? "pos" : "old_ret"; | |
| auto* str_ty = | |
| ty.Struct(mod.symbols.New("OutputStruct"), | |
| { | |
| {mod.symbols.New(old_name), func->ReturnType(), func->ReturnAttributes()}, | |
| {mod.symbols.New(name), type, attr}, | |
| }); | |
| func->SetReturnAttributes({}); | |
| func->SetReturnType(str_ty); | |
| } | |
| /// Adds to a function an return value of type @p type, and decorated with @p builtin. | |
| /// See @ref AddReturn for more details | |
| void AddBuiltinReturn(Function* func, | |
| const std::string& name, | |
| BuiltinValue builtin, | |
| const core::type::Type* type) { | |
| IOAttributes attr; | |
| attr.builtin = builtin; | |
| AddReturn(func, name, type, attr); | |
| } | |
| }; | |
| TEST_F(IR_ValidatorTest, RootBlock_Var) { | |
| mod.root_block->Append(b.Var(ty.ptr<private_, i32>())); | |
| EXPECT_EQ(ir::Validate(mod), Success); | |
| } | |
| TEST_F(IR_ValidatorTest, RootBlock_NonVar) { | |
| auto* l = b.Loop(); | |
| l->Body()->Append(b.Continue(l)); | |
| mod.root_block->Append(l); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:3 error: loop: root block: invalid instruction: tint::core::ir::Loop | |
| loop [b: $B2] { # loop_1 | |
| ^^^^^^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| loop [b: $B2] { # loop_1 | |
| $B2: { # body | |
| continue # -> $B3 | |
| } | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, RootBlock_Let) { | |
| mod.root_block->Append(b.Let("a", 1_f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:12 error: let: root block: invalid instruction: tint::core::ir::Let | |
| %a:f32 = let 1.0f | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %a:f32 = let 1.0f | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, RootBlock_LetWithAllowModuleScopeLets) { | |
| mod.root_block->Append(b.Let("a", 1_f)); | |
| auto res = ir::Validate(mod, Capabilities{Capability::kAllowModuleScopeLets}); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, RootBlock_Construct) { | |
| mod.root_block->Append(b.Construct(ty.vec2<f32>(), 1_f, 2_f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:18 error: construct: root block: invalid instruction: tint::core::ir::Construct | |
| %1:vec2<f32> = construct 1.0f, 2.0f | |
| ^^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:vec2<f32> = construct 1.0f, 2.0f | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, RootBlock_ConstructWithAllowModuleScopeLets) { | |
| mod.root_block->Append(b.Construct(ty.vec2<f32>(), 1_f, 2_f)); | |
| auto res = ir::Validate(mod, Capabilities{Capability::kAllowModuleScopeLets}); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, RootBlock_VarBlockMismatch) { | |
| auto* var = b.Var(ty.ptr<private_, i32>()); | |
| mod.root_block->Append(var); | |
| auto* f = b.Function("f", ty.void_()); | |
| f->Block()->Append(b.Return(f)); | |
| var->SetBlock(f->Block()); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:38 error: var: instruction in root block does not have root block as parent | |
| %1:ptr<private, i32, read_write> = var | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:ptr<private, i32, read_write> = var | |
| } | |
| %f = func():void { | |
| $B2: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| f->SetParams({b.FunctionParam(ty.i32()), b.FunctionParam(ty.f32())}); | |
| f->Block()->Append(b.Return(f)); | |
| EXPECT_EQ(ir::Validate(mod), Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_NoType) { | |
| auto* valid = b.Function("valid", ty.void_()); | |
| valid->Block()->Append(b.Return(valid)); | |
| auto* invalid = mod.CreateValue<ir::Function>(nullptr, ty.void_()); | |
| invalid->SetBlock(mod.blocks.Create<ir::Block>()); | |
| mod.SetName(invalid, "invalid"); | |
| mod.functions.Push(invalid); | |
| invalid->Block()->Append(b.Return(invalid)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:6:1 error: functions must have type '<function>' | |
| %invalid = func():void { | |
| ^^^^^^^^ | |
| note: # Disassembly | |
| %valid = func():void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| %invalid = func():void { | |
| $B2: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Duplicate) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| // Function would auto-push by the builder, so this adds a duplicate | |
| mod.functions.Push(f); | |
| f->SetParams({b.FunctionParam(ty.i32()), b.FunctionParam(ty.f32())}); | |
| f->Block()->Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: function %my_func added to module multiple times | |
| %my_func = func(%2:i32, %3:f32):void { | |
| ^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func(%2:i32, %3:f32):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| %my_func = func(%2:i32, %3:f32):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_DuplicateEntryPointNames) { | |
| auto* c = ComputeEntryPoint("dup"); | |
| c->Block()->Append(b.Return(c)); | |
| auto* f = FragmentEntryPoint("dup"); | |
| f->Block()->Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:6:1 error: entry point name 'dup' is not unique | |
| %dup_1 = @fragment func():void { # %dup_1: 'dup' | |
| ^^^^^^ | |
| note: # Disassembly | |
| %dup = @compute @workgroup_size(1u, 1u, 1u) func():void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| %dup_1 = @fragment func():void { # %dup_1: 'dup' | |
| $B2: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_MultinBlock) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| f->SetBlock(b.MultiInBlock()); | |
| f->Block()->Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: root block for function cannot be a multi-in block | |
| %my_func = func():void { | |
| ^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_DeadParameter) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* p = b.FunctionParam("my_param", ty.f32()); | |
| f->SetParams({p}); | |
| f->Block()->Append(b.Return(f)); | |
| p->Destroy(); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:17 error: destroyed parameter found in function parameter list | |
| %my_func = func(%my_param:f32):void { | |
| ^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func(%my_param:f32):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_ParameterWithNullFunction) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* p = b.FunctionParam("my_param", ty.f32()); | |
| f->SetParams({p}); | |
| f->Block()->Append(b.Return(f)); | |
| p->SetFunction(nullptr); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:17 error: function parameter has nullptr parent function | |
| %my_func = func(%my_param:f32):void { | |
| ^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func(%my_param:f32):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_ParameterUsedInMultipleFunctions) { | |
| auto* p = b.FunctionParam("my_param", ty.f32()); | |
| auto* f1 = b.Function("my_func1", ty.void_()); | |
| auto* f2 = b.Function("my_func2", ty.void_()); | |
| f1->SetParams({p}); | |
| f2->SetParams({p}); | |
| f1->Block()->Append(b.Return(f1)); | |
| f2->Block()->Append(b.Return(f2)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:18 error: function parameter has incorrect parent function | |
| %my_func1 = func(%my_param:f32):void { | |
| ^^^^^^^^^^^^^ | |
| :6:1 note: parent function declared here | |
| %my_func2 = func(%my_param:f32):void { | |
| ^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func1 = func(%my_param:f32):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| %my_func2 = func(%my_param:f32):void { | |
| $B2: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_ParameterWithNullType) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* p = b.FunctionParam("my_param", nullptr); | |
| f->SetParams({p}); | |
| f->Block()->Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:17 error: function parameter has nullptr type | |
| %my_func = func(%my_param:undef):void { | |
| ^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func(%my_param:undef):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_ParameterDuplicated) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* p = b.FunctionParam("my_param", ty.u32()); | |
| f->SetParams({p, p}); | |
| f->Block()->Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:17 error: function parameter is not unique | |
| %my_func = func(%my_param:u32%my_param:u32):void { | |
| ^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func(%my_param:u32%my_param:u32):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Param_MultipleIOAnnotations) { | |
| auto* f = FragmentEntryPoint("my_func"); | |
| auto* p = b.FunctionParam("my_param", ty.vec4<f32>()); | |
| p->SetBuiltin(BuiltinValue::kPosition); | |
| p->SetLocation(0); | |
| f->SetParams({p}); | |
| b.Append(f->Block(), [&] { b.Return(f); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:27 error: input param has more than one IO annotation, [ @location, built-in ] | |
| %my_func = @fragment func(%my_param:vec4<f32> [@location(0), @position]):void { | |
| ^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = @fragment func(%my_param:vec4<f32> [@location(0), @position]):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Param_Struct_MultipleIOAnnotations) { | |
| auto* f = FragmentEntryPoint("my_func"); | |
| IOAttributes attr; | |
| attr.builtin = BuiltinValue::kPosition; | |
| attr.color = 0; | |
| auto* str_ty = | |
| ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.vec4<f32>(), attr}, | |
| }); | |
| auto* p = b.FunctionParam("my_param", str_ty); | |
| f->SetParams({p}); | |
| b.Append(f->Block(), [&] { b.Return(f); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:5:27 error: input param struct member has more than one IO annotation, [ built-in, @color ] | |
| %my_func = @fragment func(%my_param:MyStruct):void { | |
| ^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(16) { | |
| a:vec4<f32> @offset(0), @color(0), @builtin(position) | |
| } | |
| %my_func = @fragment func(%my_param:MyStruct):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Param_MissingIOAnnotations) { | |
| auto* f = FragmentEntryPoint("my_func"); | |
| auto* p = b.FunctionParam("my_param", ty.vec4<f32>()); | |
| f->SetParams({p}); | |
| b.Append(f->Block(), [&] { b.Return(f); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:1:27 error: input param must have at least one IO annotation, e.g. a binding point, a location, etc | |
| %my_func = @fragment func(%my_param:vec4<f32>):void { | |
| ^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = @fragment func(%my_param:vec4<f32>):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Param_Struct_MissingIOAnnotations) { | |
| auto* f = ComputeEntryPoint("my_func"); | |
| auto* str_ty = | |
| ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.vec4<f32>(), {}}, | |
| }); | |
| auto* p = b.FunctionParam("my_param", str_ty); | |
| f->SetParams({p}); | |
| b.Append(f->Block(), [&] { b.Return(f); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:5:54 error: input param struct members must have at least one IO annotation, e.g. a binding point, a location, etc | |
| %my_func = @compute @workgroup_size(1u, 1u, 1u) func(%my_param:MyStruct):void { | |
| ^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(16) { | |
| a:vec4<f32> @offset(0) | |
| } | |
| %my_func = @compute @workgroup_size(1u, 1u, 1u) func(%my_param:MyStruct):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Param_Struct_DuplicateAnnotations) { | |
| auto* f = ComputeEntryPoint("my_func"); | |
| IOAttributes attr; | |
| attr.location = 0; | |
| auto* str_ty = | |
| ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.vec4<f32>(), attr}, | |
| }); | |
| auto* p = b.FunctionParam("my_param", str_ty); | |
| p->SetLocation(0); | |
| f->SetParams({p}); | |
| b.Append(f->Block(), [&] { b.Return(f); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:5:54 error: input param struct member has same IO annotation, as top-level struct, '@location' | |
| %my_func = @compute @workgroup_size(1u, 1u, 1u) func(%my_param:MyStruct [@location(0)]):void { | |
| ^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(16) { | |
| a:vec4<f32> @offset(0), @location(0) | |
| } | |
| %my_func = @compute @workgroup_size(1u, 1u, 1u) func(%my_param:MyStruct [@location(0)]):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Param_WorkgroupPlusOtherIOAnnotation) { | |
| auto* f = ComputeEntryPoint("my_func"); | |
| auto* p = b.FunctionParam("my_param", ty.ptr<workgroup, i32>()); | |
| p->SetLocation(0); | |
| f->SetParams({p}); | |
| b.Append(f->Block(), [&] { b.Return(f); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:1:54 error: input param has more than one IO annotation, [ @location, <workgroup> ] | |
| %my_func = @compute @workgroup_size(1u, 1u, 1u) func(%my_param:ptr<workgroup, i32, read_write> [@location(0)]):void { | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = @compute @workgroup_size(1u, 1u, 1u) func(%my_param:ptr<workgroup, i32, read_write> [@location(0)]):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Param_Struct_WorkgroupPlusOtherIOAnnotations) { | |
| auto* f = ComputeEntryPoint("my_func"); | |
| IOAttributes attr; | |
| attr.location = 0; | |
| auto* str_ty = ty.Struct(mod.symbols.New("MyStruct"), | |
| { | |
| {mod.symbols.New("a"), ty.ptr<workgroup, i32>(), attr}, | |
| }); | |
| auto* p = b.FunctionParam("my_param", str_ty); | |
| f->SetParams({p}); | |
| b.Append(f->Block(), [&] { b.Return(f); }); | |
| auto res = ir::Validate(mod, Capabilities{Capability::kAllowPointersAndHandlesInStructures}); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:5:54 error: input param struct member has more than one IO annotation, [ @location, <workgroup> ] | |
| %my_func = @compute @workgroup_size(1u, 1u, 1u) func(%my_param:MyStruct):void { | |
| ^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(1) { | |
| a:ptr<workgroup, i32, read_write> @offset(0), @location(0) | |
| } | |
| %my_func = @compute @workgroup_size(1u, 1u, 1u) func(%my_param:MyStruct):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_ParameterWithConstructibleType) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* p = b.FunctionParam("my_param", ty.u32()); | |
| f->SetParams({p}); | |
| f->Block()->Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_ParameterWithPointerType) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* p = b.FunctionParam("my_param", ty.ptr<function, i32>()); | |
| f->SetParams({p}); | |
| f->Block()->Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_ParameterWithTextureType) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* p = b.FunctionParam("my_param", ty.external_texture()); | |
| f->SetParams({p}); | |
| f->Block()->Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_ParameterWithSamplerType) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* p = b.FunctionParam("my_param", ty.sampler()); | |
| f->SetParams({p}); | |
| f->Block()->Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_ParameterWithVoidType) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* p = b.FunctionParam("my_param", ty.void_()); | |
| f->SetParams({p}); | |
| f->Block()->Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:1:17 error: function parameter type must be constructible, a pointer, a texture, or a sampler | |
| %my_func = func(%my_param:void):void { | |
| ^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func(%my_param:void):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Param_InvariantWithPosition) { | |
| auto* f = b.Function("my_func", ty.void_(), Function::PipelineStage::kFragment); | |
| auto* p = b.FunctionParam("my_param", ty.vec4<f32>()); | |
| p->SetInvariant(true); | |
| p->SetBuiltin(BuiltinValue::kPosition); | |
| f->SetParams({p}); | |
| b.Append(f->Block(), [&] { b.Return(f); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Param_InvariantWithoutPosition) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* p = b.FunctionParam("my_param", ty.vec4<f32>()); | |
| p->SetInvariant(true); | |
| f->SetParams({p}); | |
| b.Append(f->Block(), [&] { b.Return(f); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:1:17 error: invariant can only decorate a param iff it is also decorated with position | |
| %my_func = func(%my_param:vec4<f32> [@invariant]):void { | |
| ^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func(%my_param:vec4<f32> [@invariant]):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Param_Struct_InvariantWithPosition) { | |
| auto* f = b.Function("my_func", ty.void_(), Function::PipelineStage::kFragment); | |
| IOAttributes attr; | |
| attr.invariant = true; | |
| attr.builtin = BuiltinValue::kPosition; | |
| auto* str_ty = | |
| ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("pos"), ty.vec4<f32>(), attr}, | |
| }); | |
| auto* p = b.FunctionParam("my_param", str_ty); | |
| f->SetParams({p}); | |
| b.Append(f->Block(), [&] { b.Return(f); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Param_Struct_InvariantWithoutPosition) { | |
| IOAttributes attr; | |
| attr.invariant = true; | |
| auto* str_ty = | |
| ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("pos"), ty.vec4<f32>(), attr}, | |
| }); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* p = b.FunctionParam("my_param", str_ty); | |
| f->SetParams({p}); | |
| b.Append(f->Block(), [&] { b.Return(f); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:5:17 error: invariant can only decorate a param member iff it is also decorated with position | |
| %my_func = func(%my_param:MyStruct):void { | |
| ^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(16) { | |
| pos:vec4<f32> @offset(0), @invariant | |
| } | |
| %my_func = func(%my_param:MyStruct):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Param_BindingPointWithoutCapability) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* p = b.FunctionParam("my_param", ty.ptr<uniform, i32>()); | |
| p->SetBindingPoint(0, 0); | |
| f->SetParams({p}); | |
| b.Append(f->Block(), [&] { b.Return(f); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:17 error: input param to non-entry point function has a binding point set | |
| %my_func = func(%my_param:ptr<uniform, i32, read> [@binding_point(0, 0)]):void { | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func(%my_param:ptr<uniform, i32, read> [@binding_point(0, 0)]):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Return_MultipleIOAnnotations) { | |
| auto* f = VertexEntryPoint("my_func"); | |
| f->SetReturnLocation(0); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: return values has more than one IO annotation, [ @location, built-in ] | |
| %my_func = @vertex func():vec4<f32> [@location(0), @position] { | |
| ^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = @vertex func():vec4<f32> [@location(0), @position] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Return_Struct_MultipleIOAnnotations) { | |
| IOAttributes attr; | |
| attr.builtin = BuiltinValue::kPosition; | |
| attr.location = 0; | |
| auto* str_ty = | |
| ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.vec4<f32>(), attr}, | |
| }); | |
| auto* f = b.Function("my_func", str_ty, Function::PipelineStage::kVertex); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:5:1 error: return values struct member has more than one IO annotation, [ @location, built-in ] | |
| %my_func = @vertex func():MyStruct { | |
| ^^^^^^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(16) { | |
| a:vec4<f32> @offset(0), @location(0), @builtin(position) | |
| } | |
| %my_func = @vertex func():MyStruct { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Return_Void_IOAnnotation) { | |
| auto* f = FragmentEntryPoint(); | |
| f->SetReturnLocation(0); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: return values with void type should never be annotated | |
| %f = @fragment func():void [@location(0)] { | |
| ^^ | |
| note: # Disassembly | |
| %f = @fragment func():void [@location(0)] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Return_NonVoid_MissingIOAnnotations) { | |
| auto* f = b.Function("my_func", ty.f32(), Function::PipelineStage::kFragment); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:1:1 error: return values must have at least one IO annotation, e.g. a binding point, a location, etc | |
| %my_func = @fragment func():f32 { | |
| ^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = @fragment func():f32 { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Return_NonVoid_Struct_MissingIOAnnotations) { | |
| auto* str_ty = ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.f32(), {}}, | |
| }); | |
| auto* f = b.Function("my_func", str_ty, Function::PipelineStage::kFragment); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:5:1 error: return values struct members must have at least one IO annotation, e.g. a binding point, a location, etc | |
| %my_func = @fragment func():MyStruct { | |
| ^^^^^^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(4) { | |
| a:f32 @offset(0) | |
| } | |
| %my_func = @fragment func():MyStruct { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Return_InvariantWithPosition) { | |
| auto* f = b.Function("my_func", ty.vec4<f32>(), Function::PipelineStage::kVertex); | |
| f->SetReturnBuiltin(BuiltinValue::kPosition); | |
| f->SetReturnInvariant(true); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Return_InvariantWithoutPosition) { | |
| auto* f = b.Function("my_func", ty.vec4<f32>()); | |
| f->SetReturnInvariant(true); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: invariant can only decorate outputs iff they are also position builtins | |
| %my_func = func():vec4<f32> [@invariant] { | |
| ^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():vec4<f32> [@invariant] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Return_Struct_InvariantWithPosition) { | |
| IOAttributes attr; | |
| attr.invariant = true; | |
| attr.builtin = BuiltinValue::kPosition; | |
| auto* str_ty = | |
| ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("pos"), ty.vec4<f32>(), attr}, | |
| }); | |
| auto* f = b.Function("my_func", str_ty, Function::PipelineStage::kVertex); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Return_Struct_InvariantWithoutPosition) { | |
| IOAttributes attr; | |
| attr.invariant = true; | |
| auto* str_ty = | |
| ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("pos"), ty.vec4<f32>(), attr}, | |
| }); | |
| auto* f = b.Function("my_func", str_ty); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:5:1 error: invariant can only decorate output members iff they are also position builtins | |
| %my_func = func():MyStruct { | |
| ^^^^^^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(16) { | |
| pos:vec4<f32> @offset(0), @invariant | |
| } | |
| %my_func = func():MyStruct { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_UnnamedEntryPoint) { | |
| auto* f = b.Function(ty.void_(), ir::Function::PipelineStage::kCompute); | |
| f->SetWorkgroupSize({b.Constant(1_u), b.Constant(1_u), b.Constant(1_u)}); | |
| b.Append(f->Block(), [&] { b.Return(f); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: entry points must have names | |
| %1 = @compute @workgroup_size(1u, 1u, 1u) func():void { | |
| ^^ | |
| note: # Disassembly | |
| %1 = @compute @workgroup_size(1u, 1u, 1u) func():void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_NonConstructibleReturnType) { | |
| auto types = Vector<const core::type::Type*, 2>{ | |
| ty.external_texture(), ty.sampler(), ty.runtime_array(ty.f32()), ty.ptr<function, i32>(), | |
| ty.ref<function, u32>(), | |
| }; | |
| for (auto t : types) { | |
| auto* f = b.Function(t); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| } | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: function return type must be constructible | |
| %1 = func():texture_external { | |
| ^^ | |
| :6:1 error: function return type must be constructible | |
| %2 = func():sampler { | |
| ^^ | |
| :11:1 error: function return type must be constructible | |
| %3 = func():array<f32> { | |
| ^^ | |
| :16:1 error: function return type must be constructible | |
| %4 = func():ptr<function, i32, read_write> { | |
| ^^ | |
| :21:1 error: reference types are not permitted here | |
| %5 = func():ref<function, u32, read_write> { | |
| ^^ | |
| :21:1 error: function return type must be constructible | |
| %5 = func():ref<function, u32, read_write> { | |
| ^^ | |
| note: # Disassembly | |
| %1 = func():texture_external { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| %2 = func():sampler { | |
| $B2: { | |
| unreachable | |
| } | |
| } | |
| %3 = func():array<f32> { | |
| $B3: { | |
| unreachable | |
| } | |
| } | |
| %4 = func():ptr<function, i32, read_write> { | |
| $B4: { | |
| unreachable | |
| } | |
| } | |
| %5 = func():ref<function, u32, read_write> { | |
| $B5: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Compute_NonVoidReturn) { | |
| auto* f = b.Function("my_func", ty.f32(), core::ir::Function::PipelineStage::kCompute); | |
| f->SetWorkgroupSize(b.Constant(1_u), b.Constant(1_u), b.Constant(1_u)); | |
| f->SetReturnLocation(0); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: compute entry point must not have a return type | |
| %my_func = @compute @workgroup_size(1u, 1u, 1u) func():f32 [@location(0)] { | |
| ^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = @compute @workgroup_size(1u, 1u, 1u) func():f32 [@location(0)] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_WorkgroupSize_MissingOnCompute) { | |
| auto* f = b.Function("f", ty.void_(), Function::PipelineStage::kCompute); | |
| b.Append(f->Block(), [&] { b.Return(f); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: compute entry point requires @workgroup_size | |
| %f = @compute func():void { | |
| ^^ | |
| note: # Disassembly | |
| %f = @compute func():void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_WorkgroupSize_NonCompute) { | |
| auto* f = FragmentEntryPoint(); | |
| f->SetWorkgroupSize(b.Constant(1_u), b.Constant(1_u), b.Constant(1_u)); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: @workgroup_size only valid on compute entry point | |
| %f = @fragment @workgroup_size(1u, 1u, 1u) func():void { | |
| ^^ | |
| note: # Disassembly | |
| %f = @fragment @workgroup_size(1u, 1u, 1u) func():void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_WorkgroupSize_ParamUndefined) { | |
| auto* f = ComputeEntryPoint(); | |
| f->SetWorkgroupSize({nullptr, b.Constant(2_u), b.Constant(3_u)}); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: a @workgroup_size param is undefined or missing a type | |
| %f = @compute @workgroup_size(undef, 2u, 3u) func():void { | |
| ^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(undef, 2u, 3u) func():void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_WorkgroupSize_ParamWrongType) { | |
| auto* f = ComputeEntryPoint(); | |
| f->SetWorkgroupSize({b.Constant(1_f), b.Constant(2_u), b.Constant(3_u)}); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: @workgroup_size params must be an i32 or u32 | |
| %f = @compute @workgroup_size(1.0f, 2u, 3u) func():void { | |
| ^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(1.0f, 2u, 3u) func():void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_WorkgroupSize_ParamsSameType) { | |
| auto* f = ComputeEntryPoint(); | |
| f->SetWorkgroupSize({b.Constant(1_u), b.Constant(2_i), b.Constant(3_u)}); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: @workgroup_size params must be all i32s or all u32s | |
| %f = @compute @workgroup_size(1u, 2i, 3u) func():void { | |
| ^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(1u, 2i, 3u) func():void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_WorkgroupSize_ParamsTooSmall) { | |
| auto* f = ComputeEntryPoint(); | |
| f->SetWorkgroupSize({b.Constant(-1_i), b.Constant(2_i), b.Constant(3_i)}); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: @workgroup_size params must be greater than 0 | |
| %f = @compute @workgroup_size(-1i, 2i, 3i) func():void { | |
| ^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(-1i, 2i, 3i) func():void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_WorkgroupSize_OverrideWithoutAllowOverrides) { | |
| auto* o = b.Override(ty.u32()); | |
| auto* f = ComputeEntryPoint(); | |
| f->SetWorkgroupSize({o->Result(0), o->Result(0), o->Result(0)}); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:1:1 error: @workgroup_size param is not a constant value, and IR capability 'kAllowOverrides' is not set | |
| %f = @compute @workgroup_size(%2, %2, %2) func():void { | |
| ^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(%2, %2, %2) func():void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_WorkgroupSize_NonRootBlockOverride) { | |
| auto* f = ComputeEntryPoint(); | |
| Override* o; | |
| b.Append(f->Block(), [&] { | |
| o = b.Override(ty.u32()); | |
| b.Return(f); | |
| }); | |
| f->SetWorkgroupSize({o->Result(0), o->Result(0), o->Result(0)}); | |
| auto res = ir::Validate(mod, Capabilities{Capability::kAllowOverrides}); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: @workgroup_size param defined by non-module scope value | |
| %f = @compute @workgroup_size(%2, %2, %2) func():void { | |
| ^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(%2, %2, %2) func():void { | |
| $B1: { | |
| %2:u32 = override @id(0) | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Vertex_BasicPosition) { | |
| auto* f = b.Function("my_func", ty.vec4<f32>(), Function::PipelineStage::kVertex); | |
| f->SetReturnBuiltin(BuiltinValue::kPosition); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Vertex_StructPosition) { | |
| auto pos_ty = ty.vec4<f32>(); | |
| auto pos_attr = IOAttributes(); | |
| pos_attr.builtin = BuiltinValue::kPosition; | |
| auto* str_ty = | |
| ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("pos"), pos_ty, pos_attr}, | |
| }); | |
| auto* f = b.Function("my_func", str_ty, Function::PipelineStage::kVertex); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Vertex_StructPositionAndClipDistances) { | |
| auto pos_ty = ty.vec4<f32>(); | |
| auto pos_attr = IOAttributes(); | |
| pos_attr.builtin = BuiltinValue::kPosition; | |
| auto clip_ty = ty.array<f32, 4>(); | |
| auto clip_attr = IOAttributes(); | |
| clip_attr.builtin = BuiltinValue::kClipDistances; | |
| auto* str_ty = | |
| ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("pos"), pos_ty, pos_attr}, | |
| {mod.symbols.New("clip"), clip_ty, clip_attr}, | |
| }); | |
| auto* f = b.Function("my_func", str_ty, Function::PipelineStage::kVertex); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Vertex_StructOnlyClipDistances) { | |
| auto clip_ty = ty.array<f32, 4>(); | |
| auto clip_attr = IOAttributes(); | |
| clip_attr.builtin = BuiltinValue::kClipDistances; | |
| auto* str_ty = | |
| ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("clip"), clip_ty, clip_attr}, | |
| }); | |
| auto* f = b.Function("my_func", str_ty, Function::PipelineStage::kVertex); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:1 error: position must be declared for vertex entry point output | |
| %my_func = @vertex func():MyStruct { | |
| ^^^^^^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(4) { | |
| clip:array<f32, 4> @offset(0), @builtin(clip_distances) | |
| } | |
| %my_func = @vertex func():MyStruct { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Vertex_MissingPosition) { | |
| auto* f = b.Function("my_func", ty.vec4<f32>(), Function::PipelineStage::kVertex); | |
| f->SetReturnLocation(0); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: position must be declared for vertex entry point output | |
| %my_func = @vertex func():vec4<f32> [@location(0)] { | |
| ^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = @vertex func():vec4<f32> [@location(0)] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_NonFragment_BoolInput) { | |
| auto* f = VertexEntryPoint(); | |
| auto* p = b.FunctionParam("invalid", ty.bool_()); | |
| p->SetLocation(0); | |
| f->AppendParam(p); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:19 error: entry point params can only be a bool for fragment shaders | |
| %f = @vertex func(%invalid:bool [@location(0)]):vec4<f32> [@position] { | |
| ^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @vertex func(%invalid:bool [@location(0)]):vec4<f32> [@position] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_NonFragment_BoolOutput) { | |
| auto* f = VertexEntryPoint(); | |
| IOAttributes attr; | |
| attr.location = 0; | |
| AddReturn(f, "invalid", ty.bool_(), attr); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:6:1 error: entry point return members can not be bool | |
| %f = @vertex func():OutputStruct { | |
| ^^ | |
| note: # Disassembly | |
| OutputStruct = struct @align(16) { | |
| pos:vec4<f32> @offset(0), @builtin(position) | |
| invalid:bool @offset(16), @location(0) | |
| } | |
| %f = @vertex func():OutputStruct { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Fragment_BoolInputWithoutFrontFacing) { | |
| auto* f = FragmentEntryPoint(); | |
| auto* p = b.FunctionParam("invalid", ty.bool_()); | |
| p->SetLocation(0); | |
| f->AppendParam(p); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:1:21 error: fragment entry point params can only be a bool if decorated with @builtin(front_facing) | |
| %f = @fragment func(%invalid:bool [@location(0)]):void { | |
| ^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @fragment func(%invalid:bool [@location(0)]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_Fragment_BoolOutput) { | |
| auto* f = FragmentEntryPoint(); | |
| IOAttributes attr; | |
| attr.location = 0; | |
| AddReturn(f, "invalid", ty.bool_(), attr); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: entry point returns can not be bool | |
| %f = @fragment func():bool [@location(0)] { | |
| ^^ | |
| note: # Disassembly | |
| %f = @fragment func():bool [@location(0)] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_BoolOutput_via_MSV) { | |
| auto* f = ComputeEntryPoint(); | |
| auto* v = b.Var(ty.ptr(AddressSpace::kOut, ty.bool_(), core::Access::kReadWrite)); | |
| IOAttributes attr; | |
| attr.location = 0; | |
| v->SetAttributes(attr); | |
| mod.root_block->Append(v); | |
| b.Append(f->Block(), [&] { | |
| b.Append( | |
| mod.CreateInstruction<ir::Store>(v->Result(0), b.Constant(b.ConstantValue(false)))); | |
| b.Unreachable(); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:5:1 error: IO address space values referenced by shader entry points can only be bool if in the input space, used only by fragment shaders and decorated with @builtin(front_facing) | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():void { | |
| ^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:ptr<__out, bool, read_write> = var @location(0) | |
| } | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():void { | |
| $B2: { | |
| store %1, false | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Function_BoolInputWithoutFrontFacing_via_MSV) { | |
| auto* f = FragmentEntryPoint(); | |
| auto* invalid = b.Var("invalid", AddressSpace::kIn, ty.bool_()); | |
| IOAttributes attr; | |
| attr.location = 0; | |
| invalid->SetAttributes(attr); | |
| mod.root_block->Append(invalid); | |
| b.Append(f->Block(), [&] { | |
| auto* l = b.Load(invalid); | |
| auto* v = b.Var("v", AddressSpace::kFunction, ty.bool_()); | |
| v->SetInitializer(l->Result(0)); | |
| b.Unreachable(); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:5:1 error: input address space values referenced by fragment shaders can only be a bool if decorated with @builtin(front_facing) | |
| %f = @fragment func():void { | |
| ^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %invalid:ptr<__in, bool, read> = var @location(0) | |
| } | |
| %f = @fragment func():void { | |
| $B2: { | |
| %3:bool = load %invalid | |
| %v:ptr<function, bool, read_write> = var, %3 | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_PointSize_WrongStage) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinReturn(f, "size", BuiltinValue::kPointSize, ty.f32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: __point_size must be used in a vertex shader entry point | |
| %f = @fragment func():f32 [@__point_size] { | |
| ^^ | |
| note: # Disassembly | |
| %f = @fragment func():f32 [@__point_size] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_PointSize_WrongIODirection) { | |
| auto* f = VertexEntryPoint(); | |
| AddBuiltinParam(f, "size", BuiltinValue::kPointSize, ty.f32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:19 error: __point_size must be an output of a shader entry point | |
| %f = @vertex func(%size:f32 [@__point_size]):vec4<f32> [@position] { | |
| ^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @vertex func(%size:f32 [@__point_size]):vec4<f32> [@position] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_PointSize_WrongType) { | |
| auto* f = VertexEntryPoint(); | |
| AddBuiltinReturn(f, "size", BuiltinValue::kPointSize, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:6:1 error: __point_size must be a f32 | |
| %f = @vertex func():OutputStruct { | |
| ^^ | |
| note: # Disassembly | |
| OutputStruct = struct @align(16) { | |
| pos:vec4<f32> @offset(0), @builtin(position) | |
| size:u32 @offset(16), @builtin(__point_size) | |
| } | |
| %f = @vertex func():OutputStruct { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_ClipDistances_WrongStage) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinReturn(f, "distances", BuiltinValue::kClipDistances, ty.array<f32, 2>()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: clip_distances must be used in a vertex shader entry point | |
| %f = @fragment func():array<f32, 2> [@clip_distances] { | |
| ^^ | |
| note: # Disassembly | |
| %f = @fragment func():array<f32, 2> [@clip_distances] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_ClipDistances_WrongIODirection) { | |
| auto* f = VertexEntryPoint(); | |
| AddBuiltinParam(f, "distances", BuiltinValue::kClipDistances, ty.array<f32, 2>()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:19 error: clip_distances must be an output of a shader entry point | |
| %f = @vertex func(%distances:array<f32, 2> [@clip_distances]):vec4<f32> [@position] { | |
| ^^^^^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @vertex func(%distances:array<f32, 2> [@clip_distances]):vec4<f32> [@position] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_ClipDistances_WrongType) { | |
| auto* f = VertexEntryPoint(); | |
| AddBuiltinReturn(f, "distances", BuiltinValue::kClipDistances, ty.f32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:6:1 error: clip_distances must be an array<f32, N>, where N <= 8 | |
| %f = @vertex func():OutputStruct { | |
| ^^ | |
| note: # Disassembly | |
| OutputStruct = struct @align(16) { | |
| pos:vec4<f32> @offset(0), @builtin(position) | |
| distances:f32 @offset(16), @builtin(clip_distances) | |
| } | |
| %f = @vertex func():OutputStruct { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_FragDepth_WrongStage) { | |
| auto* f = VertexEntryPoint(); | |
| AddBuiltinReturn(f, "depth", BuiltinValue::kFragDepth, ty.f32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:6:1 error: frag_depth must be used in a fragment shader entry point | |
| %f = @vertex func():OutputStruct { | |
| ^^ | |
| note: # Disassembly | |
| OutputStruct = struct @align(16) { | |
| pos:vec4<f32> @offset(0), @builtin(position) | |
| depth:f32 @offset(16), @builtin(frag_depth) | |
| } | |
| %f = @vertex func():OutputStruct { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_FragDepth_WrongIODirection) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinParam(f, "depth", BuiltinValue::kFragDepth, ty.f32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:21 error: frag_depth must be an output of a shader entry point | |
| %f = @fragment func(%depth:f32 [@frag_depth]):void { | |
| ^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @fragment func(%depth:f32 [@frag_depth]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_FragDepth_WrongType) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinReturn(f, "depth", BuiltinValue::kFragDepth, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: frag_depth must be a f32 | |
| %f = @fragment func():u32 [@frag_depth] { | |
| ^^ | |
| note: # Disassembly | |
| %f = @fragment func():u32 [@frag_depth] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_FrontFacing_WrongStage) { | |
| auto* f = VertexEntryPoint(); | |
| AddBuiltinParam(f, "facing", BuiltinValue::kFrontFacing, ty.bool_()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:19 error: front_facing must be used in a fragment shader entry point | |
| %f = @vertex func(%facing:bool [@front_facing]):vec4<f32> [@position] { | |
| ^^^^^^^^^^^^ | |
| :1:19 error: entry point params can only be a bool for fragment shaders | |
| %f = @vertex func(%facing:bool [@front_facing]):vec4<f32> [@position] { | |
| ^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @vertex func(%facing:bool [@front_facing]):vec4<f32> [@position] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_FrontFacing_WrongIODirection) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinReturn(f, "facing", BuiltinValue::kFrontFacing, ty.bool_()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: front_facing must be an input of a shader entry point | |
| %f = @fragment func():bool [@front_facing] { | |
| ^^ | |
| note: # Disassembly | |
| %f = @fragment func():bool [@front_facing] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_FrontFacing_WrongType) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinParam(f, "facing", BuiltinValue::kFrontFacing, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:21 error: front_facing must be a bool | |
| %f = @fragment func(%facing:u32 [@front_facing]):void { | |
| ^^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @fragment func(%facing:u32 [@front_facing]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_GlobalInvocationId_WrongStage) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinParam(f, "invocation", BuiltinValue::kGlobalInvocationId, ty.vec3<u32>()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:21 error: global_invocation_id must be used in a compute shader entry point | |
| %f = @fragment func(%invocation:vec3<u32> [@global_invocation_id]):void { | |
| ^^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @fragment func(%invocation:vec3<u32> [@global_invocation_id]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_GlobalInvocationId_WrongIODirection) { | |
| // This will also trigger the compute entry points should have void returns check | |
| auto* f = ComputeEntryPoint(); | |
| AddBuiltinReturn(f, "invocation", BuiltinValue::kGlobalInvocationId, ty.vec3<u32>()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: global_invocation_id must be an input of a shader entry point | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():vec3<u32> [@global_invocation_id] { | |
| ^^ | |
| :1:1 error: compute entry point must not have a return type | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():vec3<u32> [@global_invocation_id] { | |
| ^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():vec3<u32> [@global_invocation_id] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_GlobalInvocationId_WrongType) { | |
| auto* f = ComputeEntryPoint(); | |
| AddBuiltinParam(f, "invocation", BuiltinValue::kGlobalInvocationId, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:48 error: global_invocation_id must be an vec3<u32> | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func(%invocation:u32 [@global_invocation_id]):void { | |
| ^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func(%invocation:u32 [@global_invocation_id]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_InstanceIndex_WrongStage) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinParam(f, "instance", BuiltinValue::kInstanceIndex, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:21 error: instance_index must be used in a vertex shader entry point | |
| %f = @fragment func(%instance:u32 [@instance_index]):void { | |
| ^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @fragment func(%instance:u32 [@instance_index]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_InstanceIndex_WrongIODirection) { | |
| auto* f = VertexEntryPoint(); | |
| AddBuiltinReturn(f, "instance", BuiltinValue::kInstanceIndex, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:6:1 error: instance_index must be an input of a shader entry point | |
| %f = @vertex func():OutputStruct { | |
| ^^ | |
| note: # Disassembly | |
| OutputStruct = struct @align(16) { | |
| pos:vec4<f32> @offset(0), @builtin(position) | |
| instance:u32 @offset(16), @builtin(instance_index) | |
| } | |
| %f = @vertex func():OutputStruct { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_InstanceIndex_WrongType) { | |
| auto* f = VertexEntryPoint(); | |
| AddBuiltinParam(f, "instance", BuiltinValue::kInstanceIndex, ty.i32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:19 error: instance_index must be an u32 | |
| %f = @vertex func(%instance:i32 [@instance_index]):vec4<f32> [@position] { | |
| ^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @vertex func(%instance:i32 [@instance_index]):vec4<f32> [@position] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_LocalInvocationId_WrongStage) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinParam(f, "id", BuiltinValue::kLocalInvocationId, ty.vec3<u32>()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:21 error: local_invocation_id must be used in a compute shader entry point | |
| %f = @fragment func(%id:vec3<u32> [@local_invocation_id]):void { | |
| ^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @fragment func(%id:vec3<u32> [@local_invocation_id]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_LocalInvocationId_WrongIODirection) { | |
| // This will also trigger the compute entry points should have void returns check | |
| auto* f = ComputeEntryPoint(); | |
| AddBuiltinReturn(f, "id", BuiltinValue::kLocalInvocationId, ty.vec3<u32>()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: local_invocation_id must be an input of a shader entry point | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():vec3<u32> [@local_invocation_id] { | |
| ^^ | |
| :1:1 error: compute entry point must not have a return type | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():vec3<u32> [@local_invocation_id] { | |
| ^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():vec3<u32> [@local_invocation_id] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_LocalInvocationId_WrongType) { | |
| auto* f = ComputeEntryPoint(); | |
| AddBuiltinParam(f, "id", BuiltinValue::kLocalInvocationId, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:48 error: local_invocation_id must be an vec3<u32> | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func(%id:u32 [@local_invocation_id]):void { | |
| ^^^^^^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func(%id:u32 [@local_invocation_id]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_LocalInvocationIndex_WrongStage) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinParam(f, "index", BuiltinValue::kLocalInvocationIndex, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:21 error: local_invocation_index must be used in a compute shader entry point | |
| %f = @fragment func(%index:u32 [@local_invocation_index]):void { | |
| ^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @fragment func(%index:u32 [@local_invocation_index]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_LocalInvocationIndex_WrongIODirection) { | |
| // This will also trigger the compute entry points should have void returns check | |
| auto* f = ComputeEntryPoint(); | |
| AddBuiltinReturn(f, "index", BuiltinValue::kLocalInvocationIndex, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: local_invocation_index must be an input of a shader entry point | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():u32 [@local_invocation_index] { | |
| ^^ | |
| :1:1 error: compute entry point must not have a return type | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():u32 [@local_invocation_index] { | |
| ^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():u32 [@local_invocation_index] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_LocalInvocationIndex_WrongType) { | |
| auto* f = ComputeEntryPoint(); | |
| AddBuiltinParam(f, "index", BuiltinValue::kLocalInvocationIndex, ty.i32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:48 error: local_invocation_index must be an u32 | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func(%index:i32 [@local_invocation_index]):void { | |
| ^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func(%index:i32 [@local_invocation_index]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_NumWorkgroups_WrongStage) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinParam(f, "num", BuiltinValue::kNumWorkgroups, ty.vec3<u32>()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:21 error: num_workgroups must be used in a compute shader entry point | |
| %f = @fragment func(%num:vec3<u32> [@num_workgroups]):void { | |
| ^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @fragment func(%num:vec3<u32> [@num_workgroups]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_NumWorkgroups_WrongIODirection) { | |
| // This will also trigger the compute entry points should have void returns check | |
| auto* f = ComputeEntryPoint(); | |
| AddBuiltinReturn(f, "num", BuiltinValue::kNumWorkgroups, ty.vec3<u32>()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: num_workgroups must be an input of a shader entry point | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():vec3<u32> [@num_workgroups] { | |
| ^^ | |
| :1:1 error: compute entry point must not have a return type | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():vec3<u32> [@num_workgroups] { | |
| ^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():vec3<u32> [@num_workgroups] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_NumWorkgroups_WrongType) { | |
| auto* f = ComputeEntryPoint(); | |
| AddBuiltinParam(f, "num", BuiltinValue::kNumWorkgroups, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:48 error: num_workgroups must be an vec3<u32> | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func(%num:u32 [@num_workgroups]):void { | |
| ^^^^^^^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func(%num:u32 [@num_workgroups]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_SampleIndex_WrongStage) { | |
| auto* f = VertexEntryPoint(); | |
| AddBuiltinParam(f, "index", BuiltinValue::kSampleIndex, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:19 error: sample_index must be used in a fragment shader entry point | |
| %f = @vertex func(%index:u32 [@sample_index]):vec4<f32> [@position] { | |
| ^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @vertex func(%index:u32 [@sample_index]):vec4<f32> [@position] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_SampleIndex_WrongIODirection) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinReturn(f, "index", BuiltinValue::kSampleIndex, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: sample_index must be an input of a shader entry point | |
| %f = @fragment func():u32 [@sample_index] { | |
| ^^ | |
| note: # Disassembly | |
| %f = @fragment func():u32 [@sample_index] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_SampleIndex_WrongType) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinParam(f, "index", BuiltinValue::kSampleIndex, ty.f32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:21 error: sample_index must be an u32 | |
| %f = @fragment func(%index:f32 [@sample_index]):void { | |
| ^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @fragment func(%index:f32 [@sample_index]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_VertexIndex_WrongStage) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinParam(f, "index", BuiltinValue::kVertexIndex, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:21 error: vertex_index must be used in a vertex shader entry point | |
| %f = @fragment func(%index:u32 [@vertex_index]):void { | |
| ^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @fragment func(%index:u32 [@vertex_index]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_VertexIndex_WrongIODirection) { | |
| auto* f = VertexEntryPoint(); | |
| AddBuiltinReturn(f, "index", BuiltinValue::kVertexIndex, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:6:1 error: vertex_index must be an input of a shader entry point | |
| %f = @vertex func():OutputStruct { | |
| ^^ | |
| note: # Disassembly | |
| OutputStruct = struct @align(16) { | |
| pos:vec4<f32> @offset(0), @builtin(position) | |
| index:u32 @offset(16), @builtin(vertex_index) | |
| } | |
| %f = @vertex func():OutputStruct { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_VertexIndex_WrongType) { | |
| auto* f = VertexEntryPoint(); | |
| AddBuiltinParam(f, "index", BuiltinValue::kVertexIndex, ty.f32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:19 error: vertex_index must be an u32 | |
| %f = @vertex func(%index:f32 [@vertex_index]):vec4<f32> [@position] { | |
| ^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @vertex func(%index:f32 [@vertex_index]):vec4<f32> [@position] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_WorkgroupId_WrongStage) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinParam(f, "id", BuiltinValue::kWorkgroupId, ty.vec3<u32>()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:21 error: workgroup_id must be used in a compute shader entry point | |
| %f = @fragment func(%id:vec3<u32> [@workgroup_id]):void { | |
| ^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @fragment func(%id:vec3<u32> [@workgroup_id]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_WorkgroupId_WrongIODirection) { | |
| // This will also trigger the compute entry points should have void returns check | |
| auto* f = ComputeEntryPoint(); | |
| AddBuiltinReturn(f, "id", BuiltinValue::kWorkgroupId, ty.vec3<u32>()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: workgroup_id must be an input of a shader entry point | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():vec3<u32> [@workgroup_id] { | |
| ^^ | |
| :1:1 error: compute entry point must not have a return type | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():vec3<u32> [@workgroup_id] { | |
| ^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func():vec3<u32> [@workgroup_id] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_WorkgroupId_WrongType) { | |
| auto* f = ComputeEntryPoint(); | |
| AddBuiltinParam(f, "id", BuiltinValue::kWorkgroupId, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:48 error: workgroup_id must be an vec3<u32> | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func(%id:u32 [@workgroup_id]):void { | |
| ^^^^^^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func(%id:u32 [@workgroup_id]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_Position_WrongStage) { | |
| auto* f = ComputeEntryPoint(); | |
| AddBuiltinParam(f, "pos", BuiltinValue::kPosition, ty.vec4<f32>()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:48 error: position must be used in a fragment or vertex shader entry point | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func(%pos:vec4<f32> [@position]):void { | |
| ^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func(%pos:vec4<f32> [@position]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_Position_WrongIODirectionForVertex) { | |
| auto* f = VertexEntryPoint(); | |
| AddBuiltinParam(f, "pos", BuiltinValue::kPosition, ty.vec4<f32>()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:19 error: position must be an output for a vertex entry point | |
| %f = @vertex func(%pos:vec4<f32> [@position]):vec4<f32> [@position] { | |
| ^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @vertex func(%pos:vec4<f32> [@position]):vec4<f32> [@position] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_Position_WrongIODirectionForFragment) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinReturn(f, "pos", BuiltinValue::kPosition, ty.vec4<f32>()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: position must be an input for a fragment entry point | |
| %f = @fragment func():vec4<f32> [@position] { | |
| ^^ | |
| note: # Disassembly | |
| %f = @fragment func():vec4<f32> [@position] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_Position_WrongType) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinParam(f, "pos", BuiltinValue::kPosition, ty.f32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:21 error: position must be an vec4<f32> | |
| %f = @fragment func(%pos:f32 [@position]):void { | |
| ^^^^^^^^ | |
| note: # Disassembly | |
| %f = @fragment func(%pos:f32 [@position]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_SampleMask_WrongStage) { | |
| auto* f = VertexEntryPoint(); | |
| AddBuiltinParam(f, "mask", BuiltinValue::kSampleMask, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:19 error: sample_mask must be used in a fragment entry point | |
| %f = @vertex func(%mask:u32 [@sample_mask]):vec4<f32> [@position] { | |
| ^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @vertex func(%mask:u32 [@sample_mask]):vec4<f32> [@position] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_SampleMask_InputValid) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinParam(f, "mask", BuiltinValue::kSampleMask, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_SampleMask_OutputValid) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinReturn(f, "mask", BuiltinValue::kSampleMask, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_SampleMask_WrongType) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinParam(f, "mask", BuiltinValue::kSampleMask, ty.f32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:21 error: sample_mask must be an u32 | |
| %f = @fragment func(%mask:f32 [@sample_mask]):void { | |
| ^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @fragment func(%mask:f32 [@sample_mask]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_SubgroupSize_WrongStage) { | |
| auto* f = VertexEntryPoint(); | |
| AddBuiltinParam(f, "size", BuiltinValue::kSubgroupSize, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:19 error: subgroup_size must be used in a compute or fragment shader entry point | |
| %f = @vertex func(%size:u32 [@subgroup_size]):vec4<f32> [@position] { | |
| ^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @vertex func(%size:u32 [@subgroup_size]):vec4<f32> [@position] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_SubgroupSize_WrongIODirection) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinReturn(f, "size", BuiltinValue::kSubgroupSize, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: subgroup_size must be an input of a shader entry point | |
| %f = @fragment func():u32 [@subgroup_size] { | |
| ^^ | |
| note: # Disassembly | |
| %f = @fragment func():u32 [@subgroup_size] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_SubgroupSize_WrongType) { | |
| auto* f = ComputeEntryPoint(); | |
| AddBuiltinParam(f, "size", BuiltinValue::kSubgroupSize, ty.i32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:48 error: subgroup_size must be an u32 | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func(%size:i32 [@subgroup_size]):void { | |
| ^^^^^^^^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func(%size:i32 [@subgroup_size]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_SubgroupInvocationId_WrongStage) { | |
| auto* f = VertexEntryPoint(); | |
| AddBuiltinParam(f, "id", BuiltinValue::kSubgroupInvocationId, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:1:19 error: subgroup_invocation_id must be used in a compute or fragment shader entry point | |
| %f = @vertex func(%id:u32 [@subgroup_invocation_id]):vec4<f32> [@position] { | |
| ^^^^^^^ | |
| note: # Disassembly | |
| %f = @vertex func(%id:u32 [@subgroup_invocation_id]):vec4<f32> [@position] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_SubgroupInvocationId_WrongIODirection) { | |
| auto* f = FragmentEntryPoint(); | |
| AddBuiltinReturn(f, "id", BuiltinValue::kSubgroupInvocationId, ty.u32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:1 error: subgroup_invocation_id must be an input of a shader entry point | |
| %f = @fragment func():u32 [@subgroup_invocation_id] { | |
| ^^ | |
| note: # Disassembly | |
| %f = @fragment func():u32 [@subgroup_invocation_id] { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Builtin_SubgroupInvocationId_WrongType) { | |
| auto* f = ComputeEntryPoint(); | |
| AddBuiltinParam(f, "id", BuiltinValue::kSubgroupInvocationId, ty.i32()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:1:48 error: subgroup_invocation_id must be an u32 | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func(%id:i32 [@subgroup_invocation_id]):void { | |
| ^^^^^^^ | |
| note: # Disassembly | |
| %f = @compute @workgroup_size(1u, 1u, 1u) func(%id:i32 [@subgroup_invocation_id]):void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, CallToFunctionOutsideModule) { | |
| auto* f = b.Function("f", ty.void_()); | |
| auto* g = b.Function("g", ty.void_()); | |
| mod.functions.Pop(); // Remove g | |
| b.Append(f->Block(), [&] { | |
| b.Call(g); | |
| b.Return(f); | |
| }); | |
| b.Append(g->Block(), [&] { b.Return(g); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:20 error: call: %g is not part of the module | |
| %2:void = call %g | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %f = func():void { | |
| $B1: { | |
| %2:void = call %g | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, CallToEntryPointFunction) { | |
| auto* f = b.Function("f", ty.void_()); | |
| auto* g = ComputeEntryPoint("g"); | |
| b.Append(f->Block(), [&] { | |
| b.Call(g); | |
| b.Return(f); | |
| }); | |
| b.Append(g->Block(), [&] { b.Return(g); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:20 error: call: call target must not have a pipeline stage | |
| %2:void = call %g | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %f = func():void { | |
| $B1: { | |
| %2:void = call %g | |
| ret | |
| } | |
| } | |
| %g = @compute @workgroup_size(1u, 1u, 1u) func():void { | |
| $B2: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, CallToFunctionTooFewArguments) { | |
| auto* g = b.Function("g", ty.void_()); | |
| g->SetParams({b.FunctionParam<i32>(), b.FunctionParam<i32>()}); | |
| b.Append(g->Block(), [&] { b.Return(g); }); | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Call(g, 42_i); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:20 error: call: function has 2 parameters, but call provides 1 arguments | |
| %5:void = call %g, 42i | |
| ^^ | |
| :7:3 note: in block | |
| $B2: { | |
| ^^^ | |
| note: # Disassembly | |
| %g = func(%2:i32, %3:i32):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| %f = func():void { | |
| $B2: { | |
| %5:void = call %g, 42i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, CallToFunctionTooManyArguments) { | |
| auto* g = b.Function("g", ty.void_()); | |
| g->SetParams({b.FunctionParam<i32>(), b.FunctionParam<i32>()}); | |
| b.Append(g->Block(), [&] { b.Return(g); }); | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Call(g, 1_i, 2_i, 3_i); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:20 error: call: function has 2 parameters, but call provides 3 arguments | |
| %5:void = call %g, 1i, 2i, 3i | |
| ^^ | |
| :7:3 note: in block | |
| $B2: { | |
| ^^^ | |
| note: # Disassembly | |
| %g = func(%2:i32, %3:i32):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| %f = func():void { | |
| $B2: { | |
| %5:void = call %g, 1i, 2i, 3i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, CallToFunctionWrongArgType) { | |
| auto* g = b.Function("g", ty.void_()); | |
| g->SetParams({b.FunctionParam<i32>(), b.FunctionParam<i32>(), b.FunctionParam<i32>()}); | |
| b.Append(g->Block(), [&] { b.Return(g); }); | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Call(g, 1_i, 2_f, 3_i); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:8:28 error: call: function parameter 1 is of type 'i32', but argument is of type 'f32' | |
| %6:void = call %g, 1i, 2.0f, 3i | |
| ^^^^ | |
| :7:3 note: in block | |
| $B2: { | |
| ^^^ | |
| note: # Disassembly | |
| %g = func(%2:i32, %3:i32, %4:i32):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| %f = func():void { | |
| $B2: { | |
| %6:void = call %g, 1i, 2.0f, 3i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, CallToFunctionNullArg) { | |
| auto* g = b.Function("g", ty.void_()); | |
| g->SetParams({b.FunctionParam<i32>()}); | |
| b.Append(g->Block(), [&] { b.Return(g); }); | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Call(g, nullptr); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:24 error: call: operand is undefined | |
| %4:void = call %g, undef | |
| ^^^^^ | |
| :7:3 note: in block | |
| $B2: { | |
| ^^^ | |
| note: # Disassembly | |
| %g = func(%2:i32):void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| %f = func():void { | |
| $B2: { | |
| %4:void = call %g, undef | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, CallToNullFunction) { | |
| auto* g = b.Function("g", ty.void_()); | |
| b.Append(g->Block(), [&] { b.Return(g); }); | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* c = b.Call(g); | |
| c->SetOperands(Vector{static_cast<ir::Value*>(nullptr)}); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:20 error: call: operand is undefined | |
| %3:void = call undef | |
| ^^^^^ | |
| :7:3 note: in block | |
| $B2: { | |
| ^^^ | |
| note: # Disassembly | |
| %g = func():void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| %f = func():void { | |
| $B2: { | |
| %3:void = call undef | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, CallToFunctionNoResult) { | |
| auto* g = b.Function("g", ty.void_()); | |
| b.Append(g->Block(), [&] { b.Return(g); }); | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* c = b.Call(g); | |
| c->ClearResults(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:13 error: call: expected exactly 1 results, got 0 | |
| undef = call %g | |
| ^^^^ | |
| :7:3 note: in block | |
| $B2: { | |
| ^^^ | |
| note: # Disassembly | |
| %g = func():void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| %f = func():void { | |
| $B2: { | |
| undef = call %g | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, CallToFunctionNoOperands) { | |
| auto* g = b.Function("g", ty.void_()); | |
| b.Append(g->Block(), [&] { b.Return(g); }); | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* c = b.Call(g); | |
| c->ClearOperands(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:15 error: call: expected at least 1 operands, got 0 | |
| %3:void = call undef | |
| ^^^^ | |
| :7:3 note: in block | |
| $B2: { | |
| ^^^ | |
| note: # Disassembly | |
| %g = func():void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| %f = func():void { | |
| $B2: { | |
| %3:void = call undef | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, CallToNonFunctionTarget) { | |
| auto* g = b.Function("g", ty.void_()); | |
| mod.functions.Pop(); // Remove g, since it isn't actually going to be used, it is just needed | |
| // to create the UserCall before mangling it | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* c = b.Call(g); | |
| c->SetOperands(Vector{b.Value(0_i)}); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:20 error: call: target not defined or not a function | |
| %2:void = call 0i | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %f = func():void { | |
| $B1: { | |
| %2:void = call 0i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, CallToBuiltin_MissingResult) { | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* c = b.Call(ty.f32(), BuiltinFn::kAbs, 1_f); | |
| c->SetResults(Vector{static_cast<ir::InstructionResult*>(nullptr)}); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:13 error: abs: call to builtin does not have a return type | |
| undef = abs 1.0f | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %f = func():void { | |
| $B1: { | |
| undef = abs 1.0f | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, CallToBuiltin_MismatchResultType) { | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* c = b.Call(ty.f32(), BuiltinFn::kAbs, 1_f); | |
| c->Result(0)->SetType(ty.i32()); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:14 error: abs: call result type does not match builtin return type | |
| %2:i32 = abs 1.0f | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %f = func():void { | |
| $B1: { | |
| %2:i32 = abs 1.0f | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, CallToBuiltin_ArgNullType) { | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* i = b.Var<function, f32>("i"); | |
| i->SetInitializer(b.Constant(0_f)); | |
| auto* load = b.Load(i); | |
| auto* load_ret = load->Result(0); | |
| b.Call(ty.f32(), BuiltinFn::kAbs, load_ret); | |
| load_ret->SetType(nullptr); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:5 error: load: result type is undefined | |
| %3:undef = load %i | |
| ^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| :5:14 error: abs: argument to builtin has undefined type | |
| %4:f32 = abs %3 | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %f = func():void { | |
| $B1: { | |
| %i:ptr<function, f32, read_write> = var, 0.0f | |
| %3:undef = load %i | |
| %4:f32 = abs %3 | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, CallToBuiltin_NonSingularResult) { | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* i = b.Var<function, f32>("i"); | |
| i->SetInitializer(b.Constant(0_f)); | |
| auto* load = b.Load(i); | |
| auto* load_ret = load->Result(0); | |
| auto* too_many_call = b.Call(ty.f32(), BuiltinFn::kAbs, load_ret); | |
| too_many_call->SetResults(Vector{load_ret, load_ret}); | |
| auto* too_few_call = b.Call(ty.f32(), BuiltinFn::kAbs, load_ret); | |
| too_few_call->ClearResults(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:14 error: abs: call to builtin has 2 results, when 1 is expected | |
| %3:f32 = abs %3 | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| :6:13 error: abs: call to builtin has 0 results, when 1 is expected | |
| undef = abs %3 | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %f = func():void { | |
| $B1: { | |
| %i:ptr<function, f32, read_write> = var, 0.0f | |
| %3:f32 = load %i | |
| %3:f32 = abs %3 | |
| undef = abs %3 | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Bitcast_MissingArg) { | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* bitcast = b.Bitcast(ty.i32(), 1_u); | |
| bitcast->ClearOperands(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:14 error: bitcast: expected exactly 1 operands, got 0 | |
| %2:i32 = bitcast | |
| ^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %f = func():void { | |
| $B1: { | |
| %2:i32 = bitcast | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Bitcast_NullArg) { | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Bitcast(ty.i32(), nullptr); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:22 error: bitcast: operand is undefined | |
| %2:i32 = bitcast undef | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %f = func():void { | |
| $B1: { | |
| %2:i32 = bitcast undef | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Bitcast_MissingResult) { | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* bitcast = b.Bitcast(ty.i32(), 1_u); | |
| bitcast->ClearResults(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:13 error: bitcast: expected exactly 1 results, got 0 | |
| undef = bitcast 1u | |
| ^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %f = func():void { | |
| $B1: { | |
| undef = bitcast 1u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Bitcast_NullResult) { | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* c = b.Bitcast(ty.i32(), 1_u); | |
| c->SetResults(Vector<InstructionResult*, 1>{nullptr}); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:5 error: bitcast: result is undefined | |
| undef = bitcast 1u | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %f = func():void { | |
| $B1: { | |
| undef = bitcast 1u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Construct_Struct_ZeroValue) { | |
| auto* str_ty = ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.i32()}, | |
| {mod.symbols.New("b"), ty.u32()}, | |
| }); | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Construct(str_ty); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success) << res.Failure(); | |
| } | |
| TEST_F(IR_ValidatorTest, Construct_Struct_ValidArgs) { | |
| auto* str_ty = ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.i32()}, | |
| {mod.symbols.New("b"), ty.u32()}, | |
| }); | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Construct(str_ty, 1_i, 2_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success) << res.Failure(); | |
| } | |
| TEST_F(IR_ValidatorTest, Construct_Struct_UnusedArgs) { | |
| auto* str_ty = ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.i32()}, | |
| {mod.symbols.New("b"), ty.u32()}, | |
| }); | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Construct(str_ty, 1_i, b.Unused()); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success) << res.Failure(); | |
| } | |
| TEST_F(IR_ValidatorTest, Construct_Struct_NotEnoughArgs) { | |
| auto* str_ty = ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.i32()}, | |
| {mod.symbols.New("b"), ty.u32()}, | |
| }); | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Construct(str_ty, 1_i); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:19 error: construct: structure has 2 members, but construct provides 1 arguments | |
| %2:MyStruct = construct 1i | |
| ^^^^^^^^^ | |
| :7:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(4) { | |
| a:i32 @offset(0) | |
| b:u32 @offset(4) | |
| } | |
| %f = func():void { | |
| $B1: { | |
| %2:MyStruct = construct 1i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Construct_Struct_TooManyArgs) { | |
| auto* str_ty = ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.i32()}, | |
| {mod.symbols.New("b"), ty.u32()}, | |
| }); | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Construct(str_ty, 1_i, 2_u, 3_i); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:19 error: construct: structure has 2 members, but construct provides 3 arguments | |
| %2:MyStruct = construct 1i, 2u, 3i | |
| ^^^^^^^^^ | |
| :7:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(4) { | |
| a:i32 @offset(0) | |
| b:u32 @offset(4) | |
| } | |
| %f = func():void { | |
| $B1: { | |
| %2:MyStruct = construct 1i, 2u, 3i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Construct_Struct_WrongArgType) { | |
| auto* str_ty = ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.i32()}, | |
| {mod.symbols.New("b"), ty.u32()}, | |
| }); | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Construct(str_ty, 1_i, 2_i); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:8:33 error: construct: structure member 1 is of type 'u32', but argument is of type 'i32' | |
| %2:MyStruct = construct 1i, 2i | |
| ^^ | |
| :7:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(4) { | |
| a:i32 @offset(0) | |
| b:u32 @offset(4) | |
| } | |
| %f = func():void { | |
| $B1: { | |
| %2:MyStruct = construct 1i, 2i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Construct_NullArg) { | |
| auto* str_ty = ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.i32()}, | |
| {mod.symbols.New("b"), ty.u32()}, | |
| }); | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Construct(str_ty, 1_i, nullptr); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:33 error: construct: operand is undefined | |
| %2:MyStruct = construct 1i, undef | |
| ^^^^^ | |
| :7:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(4) { | |
| a:i32 @offset(0) | |
| b:u32 @offset(4) | |
| } | |
| %f = func():void { | |
| $B1: { | |
| %2:MyStruct = construct 1i, undef | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Construct_NullResult) { | |
| auto* str_ty = ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.i32()}, | |
| {mod.symbols.New("b"), ty.u32()}, | |
| }); | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* c = b.Construct(str_ty, 1_i, 2_u); | |
| c->SetResults(Vector<ir::InstructionResult*, 1>{nullptr}); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:5 error: construct: result is undefined | |
| undef = construct 1i, 2u | |
| ^^^^^ | |
| :7:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(4) { | |
| a:i32 @offset(0) | |
| b:u32 @offset(4) | |
| } | |
| %f = func():void { | |
| $B1: { | |
| undef = construct 1i, 2u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Construct_EmptyResult) { | |
| auto* str_ty = ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.i32()}, | |
| {mod.symbols.New("b"), ty.u32()}, | |
| }); | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* c = b.Construct(str_ty, 1_i, 2_u); | |
| c->ClearResults(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:13 error: construct: expected exactly 1 results, got 0 | |
| undef = construct 1i, 2u | |
| ^^^^^^^^^ | |
| :7:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(4) { | |
| a:i32 @offset(0) | |
| b:u32 @offset(4) | |
| } | |
| %f = func():void { | |
| $B1: { | |
| undef = construct 1i, 2u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Convert_MissingArg) { | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* c = b.Convert(ty.i32(), 1_f); | |
| c->ClearOperands(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:14 error: convert: expected exactly 1 operands, got 0 | |
| %2:i32 = convert | |
| ^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %f = func():void { | |
| $B1: { | |
| %2:i32 = convert | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Convert_NullArg) { | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Convert(ty.i32(), nullptr); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:22 error: convert: operand is undefined | |
| %2:i32 = convert undef | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %f = func():void { | |
| $B1: { | |
| %2:i32 = convert undef | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Convert_MissingResult) { | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* c = b.Convert(ty.i32(), 1_f); | |
| c->ClearResults(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:13 error: convert: expected exactly 1 results, got 0 | |
| undef = convert 1.0f | |
| ^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %f = func():void { | |
| $B1: { | |
| undef = convert 1.0f | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Convert_NullResult) { | |
| auto* f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* c = b.Convert(ty.i32(), 1_f); | |
| c->SetResults(Vector<InstructionResult*, 1>{nullptr}); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:5 error: convert: result is undefined | |
| undef = convert 1.0f | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %f = func():void { | |
| $B1: { | |
| undef = convert 1.0f | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Discard_TooManyOperands) { | |
| auto* func = b.Function("foo", ty.void_()); | |
| b.Append(func->Block(), [&] { | |
| auto* d = b.Discard(); | |
| d->SetOperands(Vector{b.Value(0_i)}); | |
| b.Return(func); | |
| }); | |
| auto* ep = FragmentEntryPoint("ep"); | |
| b.Append(ep->Block(), [&] { | |
| b.Call(func); | |
| b.Return(ep); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:5 error: discard: expected exactly 0 operands, got 1 | |
| discard | |
| ^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %foo = func():void { | |
| $B1: { | |
| discard | |
| ret | |
| } | |
| } | |
| %ep = @fragment func():void { | |
| $B2: { | |
| %3:void = call %foo | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Discard_TooManyResults) { | |
| auto* func = b.Function("foo", ty.void_()); | |
| b.Append(func->Block(), [&] { | |
| auto* d = b.Discard(); | |
| d->SetResults(Vector{b.InstructionResult(ty.i32())}); | |
| b.Return(func); | |
| }); | |
| auto* ep = FragmentEntryPoint("ep"); | |
| b.Append(ep->Block(), [&] { | |
| b.Call(func); | |
| b.Return(ep); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:5 error: discard: expected exactly 0 results, got 1 | |
| discard | |
| ^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %foo = func():void { | |
| $B1: { | |
| discard | |
| ret | |
| } | |
| } | |
| %ep = @fragment func():void { | |
| $B2: { | |
| %3:void = call %foo | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Discard_RootBlock) { | |
| mod.root_block->Append(b.Discard()); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:3 error: discard: root block: invalid instruction: tint::core::ir::Discard | |
| discard | |
| ^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| discard | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Terminator_RootBlock) { | |
| auto f = b.Function("f", ty.void_()); | |
| b.Append(f->Block(), [&] { b.Unreachable(); }); | |
| mod.root_block->Append(b.Return(f)); | |
| mod.root_block->Append(b.Unreachable()); | |
| mod.root_block->Append(b.TerminateInvocation()); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:3 error: return: root block: invalid instruction: tint::core::ir::Return | |
| ret | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| :3:3 error: unreachable: root block: invalid instruction: tint::core::ir::Unreachable | |
| unreachable | |
| ^^^^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| :4:3 error: terminate_invocation: root block: invalid instruction: tint::core::ir::TerminateInvocation | |
| terminate_invocation | |
| ^^^^^^^^^^^^^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| ret | |
| unreachable | |
| terminate_invocation | |
| } | |
| %f = func():void { | |
| $B2: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Terminator_HasResult) { | |
| auto* ret_func = b.Function("ret_func", ty.void_()); | |
| b.Append(ret_func->Block(), [&] { | |
| auto* r = b.Return(ret_func); | |
| r->SetResults(Vector{b.InstructionResult(ty.i32())}); | |
| }); | |
| auto* unreachable_func = b.Function("unreachable_func", ty.void_()); | |
| b.Append(unreachable_func->Block(), [&] { | |
| auto* r = b.Unreachable(); | |
| r->SetResults(Vector{b.InstructionResult(ty.i32())}); | |
| }); | |
| auto* terminate_func = b.Function("terminate_func", ty.void_()); | |
| b.Append(terminate_func->Block(), [&] { | |
| auto* r = b.TerminateInvocation(); | |
| r->SetResults(Vector{b.InstructionResult(ty.i32())}); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:5 error: return: expected exactly 0 results, got 1 | |
| ret | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| :8:5 error: unreachable: expected exactly 0 results, got 1 | |
| unreachable | |
| ^^^^^^^^^^^ | |
| :7:3 note: in block | |
| $B2: { | |
| ^^^ | |
| :13:5 error: terminate_invocation: expected exactly 0 results, got 1 | |
| terminate_invocation | |
| ^^^^^^^^^^^^^^^^^^^^ | |
| :12:3 note: in block | |
| $B3: { | |
| ^^^ | |
| note: # Disassembly | |
| %ret_func = func():void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| %unreachable_func = func():void { | |
| $B2: { | |
| unreachable | |
| } | |
| } | |
| %terminate_func = func():void { | |
| $B3: { | |
| terminate_invocation | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Discard_NotInFragment) { | |
| auto* func = b.Function("foo", ty.void_()); | |
| b.Append(func->Block(), [&] { | |
| b.Discard(); | |
| b.Return(func); | |
| }); | |
| auto* ep = ComputeEntryPoint("ep"); | |
| b.Append(ep->Block(), [&] { | |
| b.Call(func); | |
| b.Return(ep); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:5 error: discard: cannot be called in non-fragment end point | |
| discard | |
| ^^^^^^^ | |
| note: # Disassembly | |
| %foo = func():void { | |
| $B1: { | |
| discard | |
| ret | |
| } | |
| } | |
| %ep = @compute @workgroup_size(1u, 1u, 1u) func():void { | |
| $B2: { | |
| %3:void = call %foo | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Block_NoTerminator) { | |
| b.Function("my_func", ty.void_()); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:3 error: block does not end in a terminator instruction | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Block_VarBlockMismatch) { | |
| auto* var = b.Var(ty.ptr<function, i32>()); | |
| auto* f = b.Function("f", ty.void_()); | |
| f->Block()->Append(var); | |
| f->Block()->Append(b.Return(f)); | |
| auto* g = b.Function("g", ty.void_()); | |
| g->Block()->Append(b.Return(g)); | |
| var->SetBlock(g->Block()); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:41 error: var: block instruction does not have same block as parent | |
| %2:ptr<function, i32, read_write> = var | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %f = func():void { | |
| $B1: { | |
| %2:ptr<function, i32, read_write> = var | |
| ret | |
| } | |
| } | |
| %g = func():void { | |
| $B2: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Block_DeadParameter) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* p = b.BlockParam("my_param", ty.f32()); | |
| b.Append(f->Block(), [&] { | |
| auto* l = b.Loop(); | |
| b.Append(l->Initializer(), [&] { b.NextIteration(l, nullptr); }); | |
| l->Body()->SetParams({p}); | |
| b.Append(l->Body(), [&] { b.ExitLoop(l); }); | |
| b.Return(f); | |
| }); | |
| p->Destroy(); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:7:12 error: destroyed parameter found in block parameter list | |
| $B3 (%my_param:f32): { # body | |
| ^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [i: $B2, b: $B3] { # loop_1 | |
| $B2: { # initializer | |
| next_iteration undef # -> $B3 | |
| } | |
| $B3 (%my_param:f32): { # body | |
| exit_loop # loop_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Block_ParameterWithNullBlock) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* p = b.BlockParam("my_param", ty.f32()); | |
| b.Append(f->Block(), [&] { | |
| auto* l = b.Loop(); | |
| b.Append(l->Initializer(), [&] { b.NextIteration(l, nullptr); }); | |
| l->Body()->SetParams({p}); | |
| b.Append(l->Body(), [&] { b.ExitLoop(l); }); | |
| b.Return(f); | |
| }); | |
| p->SetBlock(nullptr); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:7:12 error: block parameter has nullptr parent block | |
| $B3 (%my_param:f32): { # body | |
| ^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [i: $B2, b: $B3] { # loop_1 | |
| $B2: { # initializer | |
| next_iteration undef # -> $B3 | |
| } | |
| $B3 (%my_param:f32): { # body | |
| exit_loop # loop_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Block_ParameterUsedInMultipleBlocks) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* p = b.BlockParam("my_param", ty.f32()); | |
| b.Append(f->Block(), [&] { | |
| auto* l = b.Loop(); | |
| b.Append(l->Initializer(), [&] { b.NextIteration(l, nullptr); }); | |
| l->Body()->SetParams({p}); | |
| b.Append(l->Body(), [&] { b.Continue(l, p); }); | |
| l->Continuing()->SetParams({p}); | |
| b.Append(l->Continuing(), [&] { b.NextIteration(l, p); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:7:12 error: block parameter has incorrect parent block | |
| $B3 (%my_param:f32): { # body | |
| ^^^^^^^^^ | |
| :10:7 note: parent block declared here | |
| $B4 (%my_param:f32): { # continuing | |
| ^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [i: $B2, b: $B3, c: $B4] { # loop_1 | |
| $B2: { # initializer | |
| next_iteration undef # -> $B3 | |
| } | |
| $B3 (%my_param:f32): { # body | |
| continue %my_param # -> $B4 | |
| } | |
| $B4 (%my_param:f32): { # continuing | |
| next_iteration %my_param # -> $B3 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_NoOperands) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.vec3<f32>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| auto* access = b.Access(ty.f32(), obj, 0_i); | |
| access->ClearOperands(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:14 error: access: expected at least 2 operands, got 0 | |
| %3:f32 = access | |
| ^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func(%2:vec3<f32>):void { | |
| $B1: { | |
| %3:f32 = access | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_NoIndices) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.vec3<f32>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.f32(), obj); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:14 error: access: expected at least 2 operands, got 1 | |
| %3:f32 = access %2 | |
| ^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func(%2:vec3<f32>):void { | |
| $B1: { | |
| %3:f32 = access %2 | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_NoResults) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.vec3<f32>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| auto* access = b.Access(ty.f32(), obj, 0_i); | |
| access->ClearResults(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:13 error: access: expected exactly 1 results, got 0 | |
| undef = access %2, 0i | |
| ^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func(%2:vec3<f32>):void { | |
| $B1: { | |
| undef = access %2, 0i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_NullObject) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.f32(), nullptr, 0_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:21 error: access: operand is undefined | |
| %2:f32 = access undef, 0u | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:f32 = access undef, 0u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_NullIndex) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.vec3<f32>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.f32(), obj, nullptr); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:25 error: access: operand is undefined | |
| %3:f32 = access %2, undef | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func(%2:vec3<f32>):void { | |
| $B1: { | |
| %3:f32 = access %2, undef | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_NegativeIndex) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.vec3<f32>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.f32(), obj, -1_i); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:25 error: access: constant index must be positive, got -1 | |
| %3:f32 = access %2, -1i | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func(%2:vec3<f32>):void { | |
| $B1: { | |
| %3:f32 = access %2, -1i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_OOB_Index_Value) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.mat3x2<f32>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.f32(), obj, 1_u, 3_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:29 error: access: index out of bounds for type 'vec2<f32>' | |
| %3:f32 = access %2, 1u, 3u | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| :3:29 note: acceptable range: [0..1] | |
| %3:f32 = access %2, 1u, 3u | |
| ^^ | |
| note: # Disassembly | |
| %my_func = func(%2:mat3x2<f32>):void { | |
| $B1: { | |
| %3:f32 = access %2, 1u, 3u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_OOB_Index_Ptr) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.ptr<private_, array<array<f32, 2>, 3>>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.ptr<private_, f32>(), obj, 1_u, 3_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:3:55 error: access: index out of bounds for type 'ptr<private, array<f32, 2>, read_write>' | |
| %3:ptr<private, f32, read_write> = access %2, 1u, 3u | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| :3:55 note: acceptable range: [0..1] | |
| %3:ptr<private, f32, read_write> = access %2, 1u, 3u | |
| ^^ | |
| note: # Disassembly | |
| %my_func = func(%2:ptr<private, array<array<f32, 2>, 3>, read_write>):void { | |
| $B1: { | |
| %3:ptr<private, f32, read_write> = access %2, 1u, 3u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_StaticallyUnindexableType_Value) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.f32()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.f32(), obj, 1_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:25 error: access: type 'f32' cannot be indexed | |
| %3:f32 = access %2, 1u | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func(%2:f32):void { | |
| $B1: { | |
| %3:f32 = access %2, 1u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_StaticallyUnindexableType_Ptr) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.ptr<private_, f32>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.ptr<private_, f32>(), obj, 1_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:51 error: access: type 'ptr<private, f32, read_write>' cannot be indexed | |
| %3:ptr<private, f32, read_write> = access %2, 1u | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func(%2:ptr<private, f32, read_write>):void { | |
| $B1: { | |
| %3:ptr<private, f32, read_write> = access %2, 1u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_DynamicallyUnindexableType_Value) { | |
| auto* str_ty = ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.i32()}, | |
| {mod.symbols.New("b"), ty.i32()}, | |
| }); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(str_ty); | |
| auto* idx = b.FunctionParam(ty.i32()); | |
| f->SetParams({obj, idx}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.i32(), obj, idx); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:25 error: access: type 'MyStruct' cannot be dynamically indexed | |
| %4:i32 = access %2, %3 | |
| ^^ | |
| :7:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(4) { | |
| a:i32 @offset(0) | |
| b:i32 @offset(4) | |
| } | |
| %my_func = func(%2:MyStruct, %3:i32):void { | |
| $B1: { | |
| %4:i32 = access %2, %3 | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_DynamicallyUnindexableType_Ptr) { | |
| auto* str_ty = ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.i32()}, | |
| {mod.symbols.New("b"), ty.i32()}, | |
| }); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.ptr<private_, read_write>(str_ty)); | |
| auto* idx = b.FunctionParam(ty.i32()); | |
| f->SetParams({obj, idx}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.i32(), obj, idx); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:8:25 error: access: type 'ptr<private, MyStruct, read_write>' cannot be dynamically indexed | |
| %4:i32 = access %2, %3 | |
| ^^ | |
| :7:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(4) { | |
| a:i32 @offset(0) | |
| b:i32 @offset(4) | |
| } | |
| %my_func = func(%2:ptr<private, MyStruct, read_write>, %3:i32):void { | |
| $B1: { | |
| %4:i32 = access %2, %3 | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_Incorrect_Type_Value_Value) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.mat3x2<f32>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.i32(), obj, 1_u, 1_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:3:14 error: access: result of access chain is type 'f32' but instruction type is 'i32' | |
| %3:i32 = access %2, 1u, 1u | |
| ^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func(%2:mat3x2<f32>):void { | |
| $B1: { | |
| %3:i32 = access %2, 1u, 1u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_Incorrect_Type_Ptr_Ptr) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.ptr<private_, array<array<f32, 2>, 3>>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.ptr<private_, i32>(), obj, 1_u, 1_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:3:40 error: access: result of access chain is type 'ptr<private, f32, read_write>' but instruction type is 'ptr<private, i32, read_write>' | |
| %3:ptr<private, i32, read_write> = access %2, 1u, 1u | |
| ^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func(%2:ptr<private, array<array<f32, 2>, 3>, read_write>):void { | |
| $B1: { | |
| %3:ptr<private, i32, read_write> = access %2, 1u, 1u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_Incorrect_Type_Ptr_Value) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.ptr<private_, array<array<f32, 2>, 3>>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.f32(), obj, 1_u, 1_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:3:14 error: access: result of access chain is type 'ptr<private, f32, read_write>' but instruction type is 'f32' | |
| %3:f32 = access %2, 1u, 1u | |
| ^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func(%2:ptr<private, array<array<f32, 2>, 3>, read_write>):void { | |
| $B1: { | |
| %3:f32 = access %2, 1u, 1u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_IndexVectorPtr) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.ptr<private_, vec3<f32>>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.f32(), obj, 1_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:25 error: access: cannot obtain address of vector element | |
| %3:f32 = access %2, 1u | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func(%2:ptr<private, vec3<f32>, read_write>):void { | |
| $B1: { | |
| %3:f32 = access %2, 1u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_IndexVectorPtr_WithCapability) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.ptr<private_, vec3<f32>>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.ptr<private_, f32>(), obj, 1_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod, Capabilities{Capability::kAllowVectorElementPointer}); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_IndexVectorPtr_ViaMatrixPtr) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.ptr<private_, mat3x2<f32>>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.f32(), obj, 1_u, 1_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:29 error: access: cannot obtain address of vector element | |
| %3:f32 = access %2, 1u, 1u | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func(%2:ptr<private, mat3x2<f32>, read_write>):void { | |
| $B1: { | |
| %3:f32 = access %2, 1u, 1u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_IndexVectorPtr_ViaMatrixPtr_WithCapability) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.ptr<private_, mat3x2<f32>>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.ptr<private_, f32>(), obj, 1_u, 1_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod, Capabilities{Capability::kAllowVectorElementPointer}); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_Incorrect_Ptr_AddressSpace) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.ptr<storage, array<f32, 2>, read>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.ptr<uniform, f32, read>(), obj, 1_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:3:34 error: access: result of access chain is type 'ptr<storage, f32, read>' but instruction type is 'ptr<uniform, f32, read>' | |
| %3:ptr<uniform, f32, read> = access %2, 1u | |
| ^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func(%2:ptr<storage, array<f32, 2>, read>):void { | |
| $B1: { | |
| %3:ptr<uniform, f32, read> = access %2, 1u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_Incorrect_Ptr_Access) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.ptr<storage, array<f32, 2>, read>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.ptr<storage, f32, read_write>(), obj, 1_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:3:40 error: access: result of access chain is type 'ptr<storage, f32, read>' but instruction type is 'ptr<storage, f32, read_write>' | |
| %3:ptr<storage, f32, read_write> = access %2, 1u | |
| ^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func(%2:ptr<storage, array<f32, 2>, read>):void { | |
| $B1: { | |
| %3:ptr<storage, f32, read_write> = access %2, 1u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_IndexVector) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.vec3<f32>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.f32(), obj, 1_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_IndexVector_ViaMatrix) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam(ty.mat3x2<f32>()); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ty.f32(), obj, 1_u, 1_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Access_ExtractPointerFromStruct) { | |
| auto* ptr = ty.ptr<private_, i32>(); | |
| Vector<core::type::Manager::StructMemberDesc, 1> members{ | |
| core::type::Manager::StructMemberDesc{mod.symbols.New("a"), ptr}, | |
| }; | |
| auto* str = ty.Struct(mod.symbols.New("MyStruct"), std::move(members)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* obj = b.FunctionParam("obj", str); | |
| f->SetParams({obj}); | |
| b.Append(f->Block(), [&] { | |
| b.Access(ptr, obj, 0_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod, Capabilities{Capability::kAllowPointersAndHandlesInStructures}); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Block_TerminatorInMiddle) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Return(f); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:5 error: return: must be the last instruction in the block | |
| ret | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| ret | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, If_RootBlock) { | |
| auto* if_ = b.If(true); | |
| if_->True()->Append(b.Unreachable()); | |
| mod.root_block->Append(if_); | |
| auto res = ir::Validate(mod, core::ir::Capabilities{core::ir::Capability::kAllowOverrides}); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:3 error: if: root block: invalid instruction: tint::core::ir::If | |
| if true [t: $B2] { # if_1 | |
| ^^^^^^^^^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| if true [t: $B2] { # if_1 | |
| $B2: { # true | |
| unreachable | |
| } | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, If_EmptyFalse) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* if_ = b.If(true); | |
| if_->True()->Append(b.Return(f)); | |
| f->Block()->Append(if_); | |
| f->Block()->Append(b.Return(f)); | |
| EXPECT_EQ(ir::Validate(mod), Success); | |
| } | |
| TEST_F(IR_ValidatorTest, If_EmptyTrue) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* if_ = b.If(true); | |
| if_->False()->Append(b.Return(f)); | |
| f->Block()->Append(if_); | |
| f->Block()->Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:7 error: block does not end in a terminator instruction | |
| $B2: { # true | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| if true [t: $B2, f: $B3] { # if_1 | |
| $B2: { # true | |
| } | |
| $B3: { # false | |
| ret | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, If_ConditionIsBool) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* if_ = b.If(1_i); | |
| if_->True()->Append(b.Return(f)); | |
| if_->False()->Append(b.Return(f)); | |
| f->Block()->Append(if_); | |
| f->Block()->Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:8 error: if: condition type must be 'bool' | |
| if 1i [t: $B2, f: $B3] { # if_1 | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| if 1i [t: $B2, f: $B3] { # if_1 | |
| $B2: { # true | |
| ret | |
| } | |
| $B3: { # false | |
| ret | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, If_ConditionIsNullptr) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* if_ = b.If(nullptr); | |
| if_->True()->Append(b.Return(f)); | |
| if_->False()->Append(b.Return(f)); | |
| f->Block()->Append(if_); | |
| f->Block()->Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:8 error: if: operand is undefined | |
| if undef [t: $B2, f: $B3] { # if_1 | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| if undef [t: $B2, f: $B3] { # if_1 | |
| $B2: { # true | |
| ret | |
| } | |
| $B3: { # false | |
| ret | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, If_NullResult) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* if_ = b.If(true); | |
| if_->True()->Append(b.Return(f)); | |
| if_->False()->Append(b.Return(f)); | |
| if_->SetResults(Vector<InstructionResult*, 1>{nullptr}); | |
| f->Block()->Append(if_); | |
| f->Block()->Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:5 error: if: result is undefined | |
| undef = if true [t: $B2, f: $B3] { # if_1 | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| undef = if true [t: $B2, f: $B3] { # if_1 | |
| $B2: { # true | |
| ret | |
| } | |
| $B3: { # false | |
| ret | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Loop_RootBlock) { | |
| auto* l = b.Loop(); | |
| l->Body()->Append(b.ExitLoop(l)); | |
| mod.root_block->Append(l); | |
| auto res = ir::Validate(mod, core::ir::Capabilities{core::ir::Capability::kAllowOverrides}); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:3 error: loop: root block: invalid instruction: tint::core::ir::Loop | |
| loop [b: $B2] { # loop_1 | |
| ^^^^^^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| loop [b: $B2] { # loop_1 | |
| $B2: { # body | |
| exit_loop # loop_1 | |
| } | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Loop_OnlyBody) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* l = b.Loop(); | |
| l->Body()->Append(b.ExitLoop(l)); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(l); | |
| sb.Return(f); | |
| EXPECT_EQ(ir::Validate(mod), Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Loop_EmptyBody) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(b.Loop()); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:7 error: block does not end in a terminator instruction | |
| $B2: { # body | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2] { # loop_1 | |
| $B2: { # body | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Switch_RootBlock) { | |
| auto* switch_ = b.Switch(1_i); | |
| auto* def = b.DefaultCase(switch_); | |
| def->Append(b.ExitSwitch(switch_)); | |
| mod.root_block->Append(switch_); | |
| auto res = ir::Validate(mod, core::ir::Capabilities{core::ir::Capability::kAllowOverrides}); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:3 error: switch: root block: invalid instruction: tint::core::ir::Switch | |
| switch 1i [c: (default, $B2)] { # switch_1 | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| switch 1i [c: (default, $B2)] { # switch_1 | |
| $B2: { # case | |
| exit_switch # switch_1 | |
| } | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Type_VectorElements) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Var("u32_valid", AddressSpace::kFunction, ty.vec4(ty.u32())); | |
| b.Var("i32_valid", AddressSpace::kFunction, ty.vec4(ty.i32())); | |
| b.Var("bool_valid", AddressSpace::kFunction, ty.vec2(ty.bool_())); | |
| b.Var("f16_valid", AddressSpace::kFunction, ty.vec3(ty.f16())); | |
| b.Var("f32_valid", AddressSpace::kFunction, ty.vec3(ty.f32())); | |
| b.Var("void_invalid", AddressSpace::kFunction, ty.vec2(ty.void_())); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:8:5 error: var: vector elements must be scalars | |
| %void_invalid:ptr<function, vec2<void>, read_write> = var | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %u32_valid:ptr<function, vec4<u32>, read_write> = var | |
| %i32_valid:ptr<function, vec4<i32>, read_write> = var | |
| %bool_valid:ptr<function, vec2<bool>, read_write> = var | |
| %f16_valid:ptr<function, vec3<f16>, read_write> = var | |
| %f32_valid:ptr<function, vec3<f32>, read_write> = var | |
| %void_invalid:ptr<function, vec2<void>, read_write> = var | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Type_MatrixElements) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Var("u32_invalid", AddressSpace::kFunction, ty.mat2x2(ty.u32())); | |
| b.Var("i32_invalid", AddressSpace::kFunction, ty.mat3x2(ty.i32())); | |
| b.Var("bool_invalid", AddressSpace::kFunction, ty.mat4x2(ty.bool_())); | |
| b.Var("f16_valid", AddressSpace::kFunction, ty.mat2x3(ty.f16())); | |
| b.Var("f32_valid", AddressSpace::kFunction, ty.mat4x4(ty.f32())); | |
| b.Var("void_invalid", AddressSpace::kFunction, ty.mat3x3(ty.void_())); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:5 error: var: matrix elements must be float scalars | |
| %u32_invalid:ptr<function, mat2x2<u32>, read_write> = var | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| :4:5 error: var: matrix elements must be float scalars | |
| %i32_invalid:ptr<function, mat3x2<i32>, read_write> = var | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| :5:5 error: var: matrix elements must be float scalars | |
| %bool_invalid:ptr<function, mat4x2<bool>, read_write> = var | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| :8:5 error: var: matrix elements must be float scalars | |
| %void_invalid:ptr<function, mat3x3<void>, read_write> = var | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %u32_invalid:ptr<function, mat2x2<u32>, read_write> = var | |
| %i32_invalid:ptr<function, mat3x2<i32>, read_write> = var | |
| %bool_invalid:ptr<function, mat4x2<bool>, read_write> = var | |
| %f16_valid:ptr<function, mat2x3<f16>, read_write> = var | |
| %f32_valid:ptr<function, mat4x4<f32>, read_write> = var | |
| %void_invalid:ptr<function, mat3x3<void>, read_write> = var | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Type_StorageTextureDimension) { | |
| auto* valid = | |
| b.Var("valid", AddressSpace::kStorage, | |
| ty.storage_texture(core::type::TextureDimension::k2d, core::TexelFormat::kRgba32Float, | |
| core::Access::kReadWrite), | |
| read_write); | |
| valid->SetBindingPoint(0, 0); | |
| mod.root_block->Append(valid); | |
| auto* cube = | |
| b.Var("cube_invalid", AddressSpace::kStorage, | |
| ty.storage_texture(core::type::TextureDimension::kCube, | |
| core::TexelFormat::kRgba32Float, core::Access::kReadWrite), | |
| read_write); | |
| cube->SetBindingPoint(1, 1); | |
| mod.root_block->Append(cube); | |
| auto* cube_array = | |
| b.Var("cube_array_invalid", AddressSpace::kStorage, | |
| ty.storage_texture(core::type::TextureDimension::kCubeArray, | |
| core::TexelFormat::kRgba32Float, core::Access::kReadWrite), | |
| read_write); | |
| cube_array->SetBindingPoint(2, 2); | |
| mod.root_block->Append(cube_array); | |
| auto* none = | |
| b.Var("none_invalid", AddressSpace::kStorage, | |
| ty.storage_texture(core::type::TextureDimension::kNone, | |
| core::TexelFormat::kRgba32Float, core::Access::kReadWrite), | |
| read_write); | |
| none->SetBindingPoint(3, 3); | |
| mod.root_block->Append(none); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:3 error: var: dimension 'cube' for storage textures does not in WGSL yet | |
| %cube_invalid:ptr<storage, texture_storage_cube<rgba32float, read_write>, read_write> = var @binding_point(1, 1) | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| :4:3 error: var: dimension 'cube_array' for storage textures does not in WGSL yet | |
| %cube_array_invalid:ptr<storage, texture_storage_cube_array<rgba32float, read_write>, read_write> = var @binding_point(2, 2) | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| :5:3 error: var: invalid texture dimension 'none' | |
| %none_invalid:ptr<storage, texture_storage_none<rgba32float, read_write>, read_write> = var @binding_point(3, 3) | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %valid:ptr<storage, texture_storage_2d<rgba32float, read_write>, read_write> = var @binding_point(0, 0) | |
| %cube_invalid:ptr<storage, texture_storage_cube<rgba32float, read_write>, read_write> = var @binding_point(1, 1) | |
| %cube_array_invalid:ptr<storage, texture_storage_cube_array<rgba32float, read_write>, read_write> = var @binding_point(2, 2) | |
| %none_invalid:ptr<storage, texture_storage_none<rgba32float, read_write>, read_write> = var @binding_point(3, 3) | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_RootBlock_NullResult) { | |
| auto* v = mod.CreateInstruction<ir::Var>(nullptr); | |
| v->SetInitializer(b.Constant(0_i)); | |
| mod.root_block->Append(v); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:2:3 error: var: result is undefined | |
| undef = var, 0i | |
| ^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| undef = var, 0i | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_VoidType) { | |
| mod.root_block->Append(b.Var(ty.ptr(private_, ty.void_()))); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:2:3 error: var: pointers to void are not permitted | |
| %1:ptr<private, void, read_write> = var | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:ptr<private, void, read_write> = var | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_Function_NullResult) { | |
| auto* v = mod.CreateInstruction<ir::Var>(nullptr); | |
| v->SetInitializer(b.Constant(0_i)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(v); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:5 error: var: result is undefined | |
| undef = var, 0i | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| undef = var, 0i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_Function_NoResult) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* v = b.Var<function, f32>(); | |
| v->SetInitializer(b.Constant(1_i)); | |
| v->ClearResults(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:13 error: var: expected exactly 1 results, got 0 | |
| undef = var, 1i | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| undef = var, 1i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_Function_NonPtrResult) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* v = b.Var<function, f32>(); | |
| v->Result(0)->SetType(ty.f32()); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:14 error: var: result type must be a pointer or a reference | |
| %2:f32 = var | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:f32 = var | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_Function_UnexpectedInputAttachmentIndex) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* v = b.Var<function, f32>(); | |
| v->SetInputAttachmentIndex(0); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:41 error: var: '@input_attachment_index' is not valid for non-handle var | |
| %2:ptr<function, f32, read_write> = var @input_attachment_index(0) | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, f32, read_write> = var @input_attachment_index(0) | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_Function_OutsideFunctionScope) { | |
| auto* v = b.Var<function, f32>(); | |
| mod.root_block->Append(v); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:39 error: var: vars in the 'function' address space must be in a function scope | |
| %1:ptr<function, f32, read_write> = var | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:ptr<function, f32, read_write> = var | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_NonFunction_InsideFunctionScope) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Var<private_, f32>(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:40 error: var: vars in a function scope must be in the 'function' address space | |
| %2:ptr<private, f32, read_write> = var | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<private, f32, read_write> = var | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_Private_InsideFunctionScopeWithCapability) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Var<private_, f32>(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod, Capabilities{Capability::kAllowPrivateVarsInFunctions}); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_Private_UnexpectedInputAttachmentIndex) { | |
| auto* v = b.Var<private_, f32>(); | |
| v->SetInputAttachmentIndex(0); | |
| mod.root_block->Append(v); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:38 error: var: '@input_attachment_index' is not valid for non-handle var | |
| %1:ptr<private, f32, read_write> = var @input_attachment_index(0) | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:ptr<private, f32, read_write> = var @input_attachment_index(0) | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_PushConstant_UnexpectedInputAttachmentIndex) { | |
| auto* v = b.Var<push_constant, f32>(); | |
| v->SetInputAttachmentIndex(0); | |
| mod.root_block->Append(v); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:38 error: var: '@input_attachment_index' is not valid for non-handle var | |
| %1:ptr<push_constant, f32, read> = var @input_attachment_index(0) | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:ptr<push_constant, f32, read> = var @input_attachment_index(0) | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_Storage_UnexpectedInputAttachmentIndex) { | |
| auto* v = b.Var<storage, f32>(); | |
| v->SetBindingPoint(0, 0); | |
| v->SetInputAttachmentIndex(0); | |
| mod.root_block->Append(v); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:38 error: var: '@input_attachment_index' is not valid for non-handle var | |
| %1:ptr<storage, f32, read_write> = var @binding_point(0, 0) @input_attachment_index(0) | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:ptr<storage, f32, read_write> = var @binding_point(0, 0) @input_attachment_index(0) | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_Uniform_UnexpectedInputAttachmentIndex) { | |
| auto* v = b.Var<uniform, f32>(); | |
| v->SetBindingPoint(0, 0); | |
| v->SetInputAttachmentIndex(0); | |
| mod.root_block->Append(v); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:32 error: var: '@input_attachment_index' is not valid for non-handle var | |
| %1:ptr<uniform, f32, read> = var @binding_point(0, 0) @input_attachment_index(0) | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:ptr<uniform, f32, read> = var @binding_point(0, 0) @input_attachment_index(0) | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_Workgroup_UnexpectedInputAttachmentIndex) { | |
| auto* v = b.Var<workgroup, f32>(); | |
| v->SetInputAttachmentIndex(0); | |
| mod.root_block->Append(v); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:40 error: var: '@input_attachment_index' is not valid for non-handle var | |
| %1:ptr<workgroup, f32, read_write> = var @input_attachment_index(0) | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:ptr<workgroup, f32, read_write> = var @input_attachment_index(0) | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_Init_WrongType) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* v = b.Var<function, f32>(); | |
| v->SetInitializer(b.Constant(1_i)); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:41 error: var: initializer type 'i32' does not match store type 'f32' | |
| %2:ptr<function, f32, read_write> = var, 1i | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, f32, read_write> = var, 1i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_Init_NullType) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* i = b.Var<function, f32>("i"); | |
| i->SetInitializer(b.Constant(0_f)); | |
| auto* load = b.Load(i); | |
| auto* load_ret = load->Result(0); | |
| auto* j = b.Var<function, f32>("j"); | |
| j->SetInitializer(load_ret); | |
| load_ret->SetType(nullptr); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:5 error: load: result type is undefined | |
| %3:undef = load %i | |
| ^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| :5:46 error: var: operand type is undefined | |
| %j:ptr<function, f32, read_write> = var, %3 | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %i:ptr<function, f32, read_write> = var, 0.0f | |
| %3:undef = load %i | |
| %j:ptr<function, f32, read_write> = var, %3 | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_Init_FunctionTypeInit) { | |
| auto* invalid = b.Function("invalid_init", ty.void_()); | |
| b.Append(invalid->Block(), [&] { b.Return(invalid); }); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* i = b.Var<function, f32>("i"); | |
| i->SetInitializer(invalid); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:41 error: var: initializer type '<function>' does not match store type 'f32' | |
| %i:ptr<function, f32, read_write> = var, %invalid_init | |
| ^^^ | |
| :7:3 note: in block | |
| $B2: { | |
| ^^^ | |
| note: # Disassembly | |
| %invalid_init = func():void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| %my_func = func():void { | |
| $B2: { | |
| %i:ptr<function, f32, read_write> = var, %invalid_init | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_Init_InvalidAddressSpace) { | |
| auto* p = b.Var<private_, f32>("p"); | |
| p->SetInitializer(b.Constant(1_f)); | |
| mod.root_block->Append(p); | |
| auto* s = b.Var<storage, f32>("s"); | |
| s->SetInitializer(b.Constant(1_f)); | |
| mod.root_block->Append(s); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* v = b.Var<function, f32>("v"); | |
| v->SetInitializer(b.Constant(1_f)); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:3:38 error: var: only variables in the function or private address space may be initialized | |
| %s:ptr<storage, f32, read_write> = var, 1.0f | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %p:ptr<private, f32, read_write> = var, 1.0f | |
| %s:ptr<storage, f32, read_write> = var, 1.0f | |
| } | |
| %my_func = func():void { | |
| $B2: { | |
| %v:ptr<function, f32, read_write> = var, 1.0f | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_HandleMissingBindingPoint) { | |
| auto* v = b.Var(ty.ptr<handle, i32>()); | |
| mod.root_block->Append(v); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:31 error: var: a resource variable is missing binding point | |
| %1:ptr<handle, i32, read> = var | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:ptr<handle, i32, read> = var | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_StorageMissingBindingPoint) { | |
| auto* v = b.Var(ty.ptr<storage, i32>()); | |
| mod.root_block->Append(v); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:38 error: var: a resource variable is missing binding point | |
| %1:ptr<storage, i32, read_write> = var | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:ptr<storage, i32, read_write> = var | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_UniformMissingBindingPoint) { | |
| auto* v = b.Var(ty.ptr<uniform, i32>()); | |
| mod.root_block->Append(v); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:32 error: var: a resource variable is missing binding point | |
| %1:ptr<uniform, i32, read> = var | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:ptr<uniform, i32, read> = var | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_NonResourceWithBindingPoint) { | |
| auto* v = b.Var(ty.ptr<private_, i32>()); | |
| v->SetBindingPoint(0, 0); | |
| mod.root_block->Append(v); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:38 error: var: a non-resource variable has binding point | |
| %1:ptr<private, i32, read_write> = var @binding_point(0, 0) | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:ptr<private, i32, read_write> = var @binding_point(0, 0) | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_MultipleIOAnnotations) { | |
| auto* v = b.Var<AddressSpace::kIn, vec4<f32>>(); | |
| IOAttributes attr; | |
| attr.builtin = BuiltinValue::kPosition; | |
| attr.location = 0; | |
| v->SetAttributes(attr); | |
| mod.root_block->Append(v); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:2:35 error: var: module scope variable has more than one IO annotation, [ @location, built-in ] | |
| %1:ptr<__in, vec4<f32>, read> = var @location(0) @builtin(position) | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:ptr<__in, vec4<f32>, read> = var @location(0) @builtin(position) | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_Struct_MultipleIOAnnotations) { | |
| IOAttributes attr; | |
| attr.builtin = BuiltinValue::kPosition; | |
| attr.color = 0; | |
| auto* str_ty = | |
| ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.f32(), attr}, | |
| }); | |
| auto* v = b.Var(ty.ptr(AddressSpace::kOut, str_ty, read_write)); | |
| mod.root_block->Append(v); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:6:41 error: var: module scope variable struct member has more than one IO annotation, [ built-in, @color ] | |
| %1:ptr<__out, MyStruct, read_write> = var | |
| ^^^ | |
| :5:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(4) { | |
| a:f32 @offset(0), @color(0), @builtin(position) | |
| } | |
| $B1: { # root | |
| %1:ptr<__out, MyStruct, read_write> = var | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_MissingIOAnnotations) { | |
| auto* v = b.Var<AddressSpace::kIn, vec4<f32>>(); | |
| mod.root_block->Append(v); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:2:35 error: var: module scope variable must have at least one IO annotation, e.g. a binding point, a location, etc | |
| %1:ptr<__in, vec4<f32>, read> = var | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:ptr<__in, vec4<f32>, read> = var | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Var_Struct_MissingIOAnnotations) { | |
| auto* str_ty = ty.Struct(mod.symbols.New("MyStruct"), { | |
| {mod.symbols.New("a"), ty.f32(), {}}, | |
| }); | |
| auto* v = b.Var(ty.ptr(AddressSpace::kOut, str_ty, read_write)); | |
| mod.root_block->Append(v); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:6:41 error: var: module scope variable struct members must have at least one IO annotation, e.g. a binding point, a location, etc | |
| %1:ptr<__out, MyStruct, read_write> = var | |
| ^^^ | |
| :5:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| MyStruct = struct @align(4) { | |
| a:f32 @offset(0) | |
| } | |
| $B1: { # root | |
| %1:ptr<__out, MyStruct, read_write> = var | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Let_NullResult) { | |
| auto* v = mod.CreateInstruction<ir::Let>(nullptr, b.Constant(1_i)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(v); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:5 error: let: result is undefined | |
| undef = let 1i | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| undef = let 1i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Let_EmptyResults) { | |
| auto* v = mod.CreateInstruction<ir::Let>(b.InstructionResult(ty.i32()), b.Constant(1_i)); | |
| v->ClearResults(); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(v); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:13 error: let: expected exactly 1 results, got 0 | |
| undef = let 1i | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| undef = let 1i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Let_NullValue) { | |
| auto* v = mod.CreateInstruction<ir::Let>(b.InstructionResult(ty.f32()), nullptr); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(v); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:18 error: let: operand is undefined | |
| %2:f32 = let undef | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:f32 = let undef | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Let_EmptyValue) { | |
| auto* v = mod.CreateInstruction<ir::Let>(b.InstructionResult(ty.i32()), b.Constant(1_i)); | |
| v->ClearOperands(); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(v); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:14 error: let: expected exactly 1 operands, got 0 | |
| %2:i32 = let | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32 = let | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Let_WrongType) { | |
| auto* v = mod.CreateInstruction<ir::Let>(b.InstructionResult(ty.f32()), b.Constant(1_i)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(v); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:14 error: let: result type 'f32' does not match value type 'i32' | |
| %2:f32 = let 1i | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:f32 = let 1i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Let_VoidResult) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* l = mod.CreateInstruction<ir::Let>(b.InstructionResult(ty.void_()), b.Constant(1_i)); | |
| b.Append(l); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:15 error: let: result type cannot be void | |
| %2:void = let 1i | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:void = let 1i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Let_VoidValue) { | |
| auto* v = b.Function("void_func", ty.void_()); | |
| b.Append(v->Block(), [&] { b.Return(v); }); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* l = mod.CreateInstruction<ir::Let>(b.InstructionResult(ty.i32()), b.Value(b.Call(v))); | |
| b.Append(l); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:9:14 error: let: value type cannot be void | |
| %4:i32 = let %3 | |
| ^^^ | |
| :7:3 note: in block | |
| $B2: { | |
| ^^^ | |
| note: # Disassembly | |
| %void_func = func():void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| %my_func = func():void { | |
| $B2: { | |
| %3:void = call %void_func | |
| %4:i32 = let %3 | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Instruction_AppendedDead) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| auto* v = sb.Var(ty.ptr<function, f32>()); | |
| auto* ret = sb.Return(f); | |
| v->Destroy(); | |
| v->InsertBefore(ret); | |
| auto addr = tint::ToString(v); | |
| auto arrows = std::string(addr.length(), '^'); | |
| std::string expected = R"(:3:5 error: var: destroyed instruction found in instruction list | |
| <destroyed tint::core::ir::Var $ADDRESS> | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^$ARROWS^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| <destroyed tint::core::ir::Var $ADDRESS> | |
| ret | |
| } | |
| } | |
| )"; | |
| expected = tint::ReplaceAll(expected, "$ADDRESS", addr); | |
| expected = tint::ReplaceAll(expected, "$ARROWS", arrows); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), expected); | |
| } | |
| TEST_F(IR_ValidatorTest, Instruction_NullInstruction) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| auto* v = sb.Var(ty.ptr<function, f32>()); | |
| sb.Return(f); | |
| v->Result(0)->SetInstruction(nullptr); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:5 error: var: result instruction is undefined | |
| %2:ptr<function, f32, read_write> = var | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, f32, read_write> = var | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Instruction_DeadOperand) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| auto* v = sb.Var(ty.ptr<function, f32>()); | |
| sb.Return(f); | |
| auto* result = sb.InstructionResult(ty.f32()); | |
| result->Destroy(); | |
| v->SetInitializer(result); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:46 error: var: operand is not alive | |
| %2:ptr<function, f32, read_write> = var, %3 | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, f32, read_write> = var, %3 | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Instruction_OperandUsageRemoved) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| auto* v = sb.Var(ty.ptr<function, f32>()); | |
| sb.Return(f); | |
| auto* result = sb.InstructionResult(ty.f32()); | |
| v->SetInitializer(result); | |
| result->RemoveUsage({v, 0u}); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:46 error: var: operand missing usage | |
| %2:ptr<function, f32, read_write> = var, %3 | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, f32, read_write> = var, %3 | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Instruction_OrphanedInstruction) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| auto* v = sb.Var(ty.ptr<function, f32>()); | |
| auto* load = sb.Load(v); | |
| sb.Return(f); | |
| load->Remove(); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(error: load: orphaned instruction: load | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, f32, read_write> = var | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Binary_LHS_Nullptr) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Add(ty.i32(), nullptr, sb.Constant(2_i)); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:18 error: binary: operand is undefined | |
| %2:i32 = add undef, 2i | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32 = add undef, 2i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Binary_RHS_Nullptr) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Add(ty.i32(), sb.Constant(2_i), nullptr); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:22 error: binary: operand is undefined | |
| %2:i32 = add 2i, undef | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32 = add 2i, undef | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Binary_Result_Nullptr) { | |
| auto* bin = mod.CreateInstruction<ir::CoreBinary>(nullptr, BinaryOp::kAdd, b.Constant(3_i), | |
| b.Constant(2_i)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(bin); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:5 error: binary: result is undefined | |
| undef = add 3i, 2i | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| undef = add 3i, 2i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Binary_MissingOperands) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| auto* add = sb.Add(ty.i32(), sb.Constant(1_i), sb.Constant(2_i)); | |
| add->ClearOperands(); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:5 error: binary: expected at least 2 operands, got 0 | |
| %2:i32 = add | |
| ^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32 = add | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Binary_MissingResult) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| auto* add = sb.Add(ty.i32(), sb.Constant(1_i), sb.Constant(2_i)); | |
| add->ClearResults(); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:5 error: binary: expected exactly 1 results, got 0 | |
| undef = add 1i, 2i | |
| ^^^^^^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| undef = add 1i, 2i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Unary_Value_Nullptr) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Negation(ty.i32(), nullptr); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:23 error: unary: operand is undefined | |
| %2:i32 = negation undef | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32 = negation undef | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Unary_Result_Nullptr) { | |
| auto* bin = mod.CreateInstruction<ir::CoreUnary>(nullptr, UnaryOp::kNegation, b.Constant(2_i)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(bin); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:5 error: unary: result is undefined | |
| undef = negation 2i | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| undef = negation 2i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Unary_ResultTypeNotMatchValueType) { | |
| auto* bin = b.Complement(ty.f32(), 2_i); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(bin); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:3:5 error: unary: result value type 'f32' does not match complement result type 'i32' | |
| %2:f32 = complement 2i | |
| ^^^^^^^^^^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:f32 = complement 2i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Unary_MissingOperands) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| auto* u = b.Negation(ty.f32(), 2_f); | |
| u->ClearOperands(); | |
| sb.Append(u); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:5 error: unary: expected at least 1 operands, got 0 | |
| %2:f32 = negation | |
| ^^^^^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:f32 = negation | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Unary_MissingResults) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| auto* u = b.Negation(ty.f32(), 2_f); | |
| u->ClearResults(); | |
| sb.Append(u); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:5 error: unary: expected exactly 1 results, got 0 | |
| undef = negation 2.0f | |
| ^^^^^^^^^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| undef = negation 2.0f | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitIf) { | |
| auto* if_ = b.If(true); | |
| if_->True()->Append(b.ExitIf(if_)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(if_); | |
| sb.Return(f); | |
| EXPECT_EQ(ir::Validate(mod), Success); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitIf_NullIf) { | |
| auto* if_ = b.If(true); | |
| if_->True()->Append(mod.CreateInstruction<ExitIf>(nullptr)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(if_); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:5:9 error: exit_if: has no parent control instruction | |
| exit_if # undef | |
| ^^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # true | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| if true [t: $B2] { # if_1 | |
| $B2: { # true | |
| exit_if # undef | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitIf_LessOperandsThenIfParams) { | |
| auto* if_ = b.If(true); | |
| if_->True()->Append(b.ExitIf(if_, 1_i)); | |
| auto* r1 = b.InstructionResult(ty.i32()); | |
| auto* r2 = b.InstructionResult(ty.f32()); | |
| if_->SetResults(Vector{r1, r2}); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(if_); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:9 error: exit_if: provides 1 value but 'if' expects 2 values | |
| exit_if 1i # if_1 | |
| ^^^^^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # true | |
| ^^^ | |
| :3:5 note: 'if' declared here | |
| %2:i32, %3:f32 = if true [t: $B2] { # if_1 | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32, %3:f32 = if true [t: $B2] { # if_1 | |
| $B2: { # true | |
| exit_if 1i # if_1 | |
| } | |
| # implicit false block: exit_if undef, undef | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitIf_MoreOperandsThenIfParams) { | |
| auto* if_ = b.If(true); | |
| if_->True()->Append(b.ExitIf(if_, 1_i, 2_f, 3_i)); | |
| auto* r1 = b.InstructionResult(ty.i32()); | |
| auto* r2 = b.InstructionResult(ty.f32()); | |
| if_->SetResults(Vector{r1, r2}); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(if_); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:9 error: exit_if: provides 3 values but 'if' expects 2 values | |
| exit_if 1i, 2.0f, 3i # if_1 | |
| ^^^^^^^^^^^^^^^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # true | |
| ^^^ | |
| :3:5 note: 'if' declared here | |
| %2:i32, %3:f32 = if true [t: $B2] { # if_1 | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32, %3:f32 = if true [t: $B2] { # if_1 | |
| $B2: { # true | |
| exit_if 1i, 2.0f, 3i # if_1 | |
| } | |
| # implicit false block: exit_if undef, undef | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitIf_WithResult) { | |
| auto* if_ = b.If(true); | |
| if_->True()->Append(b.ExitIf(if_, 1_i, 2_f)); | |
| auto* r1 = b.InstructionResult(ty.i32()); | |
| auto* r2 = b.InstructionResult(ty.f32()); | |
| if_->SetResults(Vector{r1, r2}); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(if_); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitIf_IncorrectResultType) { | |
| auto* if_ = b.If(true); | |
| if_->True()->Append(b.ExitIf(if_, 1_i, 2_i)); | |
| auto* r1 = b.InstructionResult(ty.i32()); | |
| auto* r2 = b.InstructionResult(ty.f32()); | |
| if_->SetResults(Vector{r1, r2}); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(if_); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:21 error: exit_if: operand with type 'i32' does not match 'if' target type 'f32' | |
| exit_if 1i, 2i # if_1 | |
| ^^ | |
| :4:7 note: in block | |
| $B2: { # true | |
| ^^^ | |
| :3:13 note: %3 declared here | |
| %2:i32, %3:f32 = if true [t: $B2] { # if_1 | |
| ^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32, %3:f32 = if true [t: $B2] { # if_1 | |
| $B2: { # true | |
| exit_if 1i, 2i # if_1 | |
| } | |
| # implicit false block: exit_if undef, undef | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitIf_NotInParentIf) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* if_ = b.If(true); | |
| if_->True()->Append(b.Return(f)); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(if_); | |
| sb.ExitIf(if_); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:5 error: exit_if: found outside all control instructions | |
| exit_if # if_1 | |
| ^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| if true [t: $B2] { # if_1 | |
| $B2: { # true | |
| ret | |
| } | |
| } | |
| exit_if # if_1 | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitIf_InvalidJumpsOverIf) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* if_inner = b.If(true); | |
| auto* if_outer = b.If(true); | |
| b.Append(if_outer->True(), [&] { | |
| b.Append(if_inner); | |
| b.ExitIf(if_outer); | |
| }); | |
| b.Append(if_inner->True(), [&] { b.ExitIf(if_outer); }); | |
| b.Append(f->Block(), [&] { | |
| b.Append(if_outer); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:7:13 error: exit_if: if target jumps over other control instructions | |
| exit_if # if_1 | |
| ^^^^^^^ | |
| :6:11 note: in block | |
| $B3: { # true | |
| ^^^ | |
| :5:9 note: first control instruction jumped | |
| if true [t: $B3] { # if_2 | |
| ^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| if true [t: $B2] { # if_1 | |
| $B2: { # true | |
| if true [t: $B3] { # if_2 | |
| $B3: { # true | |
| exit_if # if_1 | |
| } | |
| } | |
| exit_if # if_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitIf_InvalidJumpOverSwitch) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* switch_inner = b.Switch(1_i); | |
| auto* if_outer = b.If(true); | |
| b.Append(if_outer->True(), [&] { | |
| b.Append(switch_inner); | |
| b.ExitIf(if_outer); | |
| }); | |
| auto* c = b.Case(switch_inner, {b.Constant(1_i), nullptr}); | |
| b.Append(c, [&] { b.ExitIf(if_outer); }); | |
| b.Append(f->Block(), [&] { | |
| b.Append(if_outer); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:7:13 error: exit_if: if target jumps over other control instructions | |
| exit_if # if_1 | |
| ^^^^^^^ | |
| :6:11 note: in block | |
| $B3: { # case | |
| ^^^ | |
| :5:9 note: first control instruction jumped | |
| switch 1i [c: (1i default, $B3)] { # switch_1 | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| if true [t: $B2] { # if_1 | |
| $B2: { # true | |
| switch 1i [c: (1i default, $B3)] { # switch_1 | |
| $B3: { # case | |
| exit_if # if_1 | |
| } | |
| } | |
| exit_if # if_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitIf_InvalidJumpOverLoop) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* loop = b.Loop(); | |
| auto* if_outer = b.If(true); | |
| b.Append(if_outer->True(), [&] { | |
| b.Append(loop); | |
| b.ExitIf(if_outer); | |
| }); | |
| b.Append(loop->Body(), [&] { b.ExitIf(if_outer); }); | |
| b.Append(f->Block(), [&] { | |
| b.Append(if_outer); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:7:13 error: exit_if: if target jumps over other control instructions | |
| exit_if # if_1 | |
| ^^^^^^^ | |
| :6:11 note: in block | |
| $B3: { # body | |
| ^^^ | |
| :5:9 note: first control instruction jumped | |
| loop [b: $B3] { # loop_1 | |
| ^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| if true [t: $B2] { # if_1 | |
| $B2: { # true | |
| loop [b: $B3] { # loop_1 | |
| $B3: { # body | |
| exit_if # if_1 | |
| } | |
| } | |
| exit_if # if_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitSwitch) { | |
| auto* switch_ = b.Switch(1_i); | |
| auto* def = b.DefaultCase(switch_); | |
| def->Append(b.ExitSwitch(switch_)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(switch_); | |
| sb.Return(f); | |
| EXPECT_EQ(ir::Validate(mod), Success); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitSwitch_NullSwitch) { | |
| auto* switch_ = b.Switch(1_i); | |
| auto* def = b.DefaultCase(switch_); | |
| def->Append(mod.CreateInstruction<ExitSwitch>(nullptr)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(switch_); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:9 error: exit_switch: has no parent control instruction | |
| exit_switch # undef | |
| ^^^^^^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # case | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| switch 1i [c: (default, $B2)] { # switch_1 | |
| $B2: { # case | |
| exit_switch # undef | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitSwitch_LessOperandsThenSwitchParams) { | |
| auto* switch_ = b.Switch(1_i); | |
| auto* r1 = b.InstructionResult(ty.i32()); | |
| auto* r2 = b.InstructionResult(ty.f32()); | |
| switch_->SetResults(Vector{r1, r2}); | |
| auto* def = b.DefaultCase(switch_); | |
| def->Append(b.ExitSwitch(switch_, 1_i)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(switch_); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:9 error: exit_switch: provides 1 value but 'switch' expects 2 values | |
| exit_switch 1i # switch_1 | |
| ^^^^^^^^^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # case | |
| ^^^ | |
| :3:5 note: 'switch' declared here | |
| %2:i32, %3:f32 = switch 1i [c: (default, $B2)] { # switch_1 | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32, %3:f32 = switch 1i [c: (default, $B2)] { # switch_1 | |
| $B2: { # case | |
| exit_switch 1i # switch_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitSwitch_MoreOperandsThenSwitchParams) { | |
| auto* switch_ = b.Switch(1_i); | |
| auto* r1 = b.InstructionResult(ty.i32()); | |
| auto* r2 = b.InstructionResult(ty.f32()); | |
| switch_->SetResults(Vector{r1, r2}); | |
| auto* def = b.DefaultCase(switch_); | |
| def->Append(b.ExitSwitch(switch_, 1_i, 2_f, 3_i)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(switch_); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:9 error: exit_switch: provides 3 values but 'switch' expects 2 values | |
| exit_switch 1i, 2.0f, 3i # switch_1 | |
| ^^^^^^^^^^^^^^^^^^^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # case | |
| ^^^ | |
| :3:5 note: 'switch' declared here | |
| %2:i32, %3:f32 = switch 1i [c: (default, $B2)] { # switch_1 | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32, %3:f32 = switch 1i [c: (default, $B2)] { # switch_1 | |
| $B2: { # case | |
| exit_switch 1i, 2.0f, 3i # switch_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitSwitch_WithResult) { | |
| auto* switch_ = b.Switch(1_i); | |
| auto* r1 = b.InstructionResult(ty.i32()); | |
| auto* r2 = b.InstructionResult(ty.f32()); | |
| switch_->SetResults(Vector{r1, r2}); | |
| auto* def = b.DefaultCase(switch_); | |
| def->Append(b.ExitSwitch(switch_, 1_i, 2_f)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(switch_); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitSwitch_IncorrectResultType) { | |
| auto* switch_ = b.Switch(1_i); | |
| auto* r1 = b.InstructionResult(ty.i32()); | |
| auto* r2 = b.InstructionResult(ty.f32()); | |
| switch_->SetResults(Vector{r1, r2}); | |
| auto* def = b.DefaultCase(switch_); | |
| def->Append(b.ExitSwitch(switch_, 1_i, 2_i)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(switch_); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:5:25 error: exit_switch: operand with type 'i32' does not match 'switch' target type 'f32' | |
| exit_switch 1i, 2i # switch_1 | |
| ^^ | |
| :4:7 note: in block | |
| $B2: { # case | |
| ^^^ | |
| :3:13 note: %3 declared here | |
| %2:i32, %3:f32 = switch 1i [c: (default, $B2)] { # switch_1 | |
| ^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32, %3:f32 = switch 1i [c: (default, $B2)] { # switch_1 | |
| $B2: { # case | |
| exit_switch 1i, 2i # switch_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitSwitch_NotInParentSwitch) { | |
| auto* switch_ = b.Switch(1_i); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* def = b.DefaultCase(switch_); | |
| def->Append(b.Return(f)); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(switch_); | |
| auto* if_ = sb.Append(b.If(true)); | |
| b.Append(if_->True(), [&] { b.ExitSwitch(switch_); }); | |
| sb.Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:10:9 error: exit_switch: switch not found in parent control instructions | |
| exit_switch # switch_1 | |
| ^^^^^^^^^^^ | |
| :9:7 note: in block | |
| $B3: { # true | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| switch 1i [c: (default, $B2)] { # switch_1 | |
| $B2: { # case | |
| ret | |
| } | |
| } | |
| if true [t: $B3] { # if_1 | |
| $B3: { # true | |
| exit_switch # switch_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitSwitch_JumpsOverIfs) { | |
| // switch(true) { | |
| // default: { | |
| // if (true) { | |
| // if (false) { | |
| // break; | |
| // } | |
| // } | |
| // break; | |
| // } | |
| auto* switch_ = b.Switch(1_i); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* def = b.DefaultCase(switch_); | |
| b.Append(def, [&] { | |
| auto* if_ = b.If(true); | |
| b.Append(if_->True(), [&] { | |
| auto* inner_if_ = b.If(false); | |
| b.Append(inner_if_->True(), [&] { b.ExitSwitch(switch_); }); | |
| b.Return(f); | |
| }); | |
| b.ExitSwitch(switch_); | |
| }); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(switch_); | |
| sb.Return(f); | |
| EXPECT_EQ(ir::Validate(mod), Success); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitSwitch_InvalidJumpOverSwitch) { | |
| auto* switch_ = b.Switch(1_i); | |
| auto* def = b.DefaultCase(switch_); | |
| b.Append(def, [&] { | |
| auto* inner = b.Switch(0_i); | |
| b.ExitSwitch(switch_); | |
| auto* inner_def = b.DefaultCase(inner); | |
| b.Append(inner_def, [&] { b.ExitSwitch(switch_); }); | |
| }); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Append(switch_); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:7:13 error: exit_switch: switch target jumps over other control instructions | |
| exit_switch # switch_1 | |
| ^^^^^^^^^^^ | |
| :6:11 note: in block | |
| $B3: { # case | |
| ^^^ | |
| :5:9 note: first control instruction jumped | |
| switch 0i [c: (default, $B3)] { # switch_2 | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| switch 1i [c: (default, $B2)] { # switch_1 | |
| $B2: { # case | |
| switch 0i [c: (default, $B3)] { # switch_2 | |
| $B3: { # case | |
| exit_switch # switch_1 | |
| } | |
| } | |
| exit_switch # switch_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitSwitch_InvalidJumpOverLoop) { | |
| auto* switch_ = b.Switch(1_i); | |
| auto* def = b.DefaultCase(switch_); | |
| b.Append(def, [&] { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Body(), [&] { b.ExitSwitch(switch_); }); | |
| b.ExitSwitch(switch_); | |
| }); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Append(switch_); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:7:13 error: exit_switch: switch target jumps over other control instructions | |
| exit_switch # switch_1 | |
| ^^^^^^^^^^^ | |
| :6:11 note: in block | |
| $B3: { # body | |
| ^^^ | |
| :5:9 note: first control instruction jumped | |
| loop [b: $B3] { # loop_1 | |
| ^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| switch 1i [c: (default, $B2)] { # switch_1 | |
| $B2: { # case | |
| loop [b: $B3] { # loop_1 | |
| $B3: { # body | |
| exit_switch # switch_1 | |
| } | |
| } | |
| exit_switch # switch_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Continue_OutsideOfLoop) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Body(), [&] { b.ExitLoop(loop); }); | |
| b.Continue(loop); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:5 error: continue: called outside of associated loop | |
| continue # -> $B3 | |
| ^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2] { # loop_1 | |
| $B2: { # body | |
| exit_loop # loop_1 | |
| } | |
| } | |
| continue # -> $B3 | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Continue_InLoopInit) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Initializer(), [&] { b.Continue(loop); }); | |
| b.Append(loop->Body(), [&] { b.ExitLoop(loop); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:9 error: continue: must only be called from loop body | |
| continue # -> $B4 | |
| ^^^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # initializer | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [i: $B2, b: $B3] { # loop_1 | |
| $B2: { # initializer | |
| continue # -> $B4 | |
| } | |
| $B3: { # body | |
| exit_loop # loop_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Continue_InLoopBody) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Body(), [&] { b.Continue(loop); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Continue_InLoopContinuing) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Body(), [&] { b.ExitLoop(loop); }); | |
| b.Append(loop->Continuing(), [&] { b.Continue(loop); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:9 error: continue: must only be called from loop body | |
| continue # -> $B3 | |
| ^^^^^^^^ | |
| :7:7 note: in block | |
| $B3: { # continuing | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| exit_loop # loop_1 | |
| } | |
| $B3: { # continuing | |
| continue # -> $B3 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Continue_UnexpectedValues) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Body(), [&] { b.Continue(loop, 1_i, 2_f); }); | |
| b.Append(loop->Continuing(), [&] { b.BreakIf(loop, true); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:9 error: continue: provides 2 values but 'loop' block $B3 expects 0 values | |
| continue 1i, 2.0f # -> $B3 | |
| ^^^^^^^^^^^^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # body | |
| ^^^ | |
| :7:7 note: 'loop' block $B3 declared here | |
| $B3: { # continuing | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| continue 1i, 2.0f # -> $B3 | |
| } | |
| $B3: { # continuing | |
| break_if true # -> [t: exit_loop loop_1, f: $B2] | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Continue_MissingValues) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| loop->Continuing()->SetParams({b.BlockParam<i32>(), b.BlockParam<i32>()}); | |
| b.Append(loop->Body(), [&] { b.Continue(loop); }); | |
| b.Append(loop->Continuing(), [&] { b.BreakIf(loop, true); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:9 error: continue: provides 0 values but 'loop' block $B3 expects 2 values | |
| continue # -> $B3 | |
| ^^^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # body | |
| ^^^ | |
| :7:7 note: 'loop' block $B3 declared here | |
| $B3 (%2:i32, %3:i32): { # continuing | |
| ^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| continue # -> $B3 | |
| } | |
| $B3 (%2:i32, %3:i32): { # continuing | |
| break_if true # -> [t: exit_loop loop_1, f: $B2] | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Continue_MismatchedTypes) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| loop->Continuing()->SetParams( | |
| {b.BlockParam<i32>(), b.BlockParam<f32>(), b.BlockParam<u32>(), b.BlockParam<bool>()}); | |
| b.Append(loop->Body(), [&] { b.Continue(loop, 1_i, 2_i, 3_f, false); }); | |
| b.Append(loop->Continuing(), [&] { b.BreakIf(loop, true); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:5:22 error: continue: operand with type 'i32' does not match 'loop' block $B3 target type 'f32' | |
| continue 1i, 2i, 3.0f, false # -> $B3 | |
| ^^ | |
| :4:7 note: in block | |
| $B2: { # body | |
| ^^^ | |
| :7:20 note: %3 declared here | |
| $B3 (%2:i32, %3:f32, %4:u32, %5:bool): { # continuing | |
| ^^ | |
| :5:26 error: continue: operand with type 'f32' does not match 'loop' block $B3 target type 'u32' | |
| continue 1i, 2i, 3.0f, false # -> $B3 | |
| ^^^^ | |
| :4:7 note: in block | |
| $B2: { # body | |
| ^^^ | |
| :7:28 note: %4 declared here | |
| $B3 (%2:i32, %3:f32, %4:u32, %5:bool): { # continuing | |
| ^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| continue 1i, 2i, 3.0f, false # -> $B3 | |
| } | |
| $B3 (%2:i32, %3:f32, %4:u32, %5:bool): { # continuing | |
| break_if true # -> [t: exit_loop loop_1, f: $B2] | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Continue_MatchedTypes) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| loop->Continuing()->SetParams( | |
| {b.BlockParam<i32>(), b.BlockParam<f32>(), b.BlockParam<u32>(), b.BlockParam<bool>()}); | |
| b.Append(loop->Body(), [&] { b.Continue(loop, 1_i, 2_f, 3_u, false); }); | |
| b.Append(loop->Continuing(), [&] { b.BreakIf(loop, true); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, NextIteration_OutsideOfLoop) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Body(), [&] { b.ExitLoop(loop); }); | |
| b.NextIteration(loop); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:5 error: next_iteration: called outside of associated loop | |
| next_iteration # -> $B2 | |
| ^^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2] { # loop_1 | |
| $B2: { # body | |
| exit_loop # loop_1 | |
| } | |
| } | |
| next_iteration # -> $B2 | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, NextIteration_InLoopInit) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Initializer(), [&] { b.NextIteration(loop); }); | |
| b.Append(loop->Body(), [&] { b.ExitLoop(loop); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, NextIteration_InLoopBody) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Body(), [&] { b.NextIteration(loop); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:9 error: next_iteration: must only be called from loop initializer or continuing | |
| next_iteration # -> $B2 | |
| ^^^^^^^^^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # body | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2] { # loop_1 | |
| $B2: { # body | |
| next_iteration # -> $B2 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, NextIteration_InLoopContinuing) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Body(), [&] { b.ExitLoop(loop); }); | |
| b.Append(loop->Continuing(), [&] { b.NextIteration(loop); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, NextIteration_UnexpectedValues) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Initializer(), [&] { b.NextIteration(loop, 1_i, 2_f); }); | |
| b.Append(loop->Body(), [&] { b.ExitLoop(loop); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:9 error: next_iteration: provides 2 values but 'loop' block $B3 expects 0 values | |
| next_iteration 1i, 2.0f # -> $B3 | |
| ^^^^^^^^^^^^^^^^^^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # initializer | |
| ^^^ | |
| :7:7 note: 'loop' block $B3 declared here | |
| $B3: { # body | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [i: $B2, b: $B3] { # loop_1 | |
| $B2: { # initializer | |
| next_iteration 1i, 2.0f # -> $B3 | |
| } | |
| $B3: { # body | |
| exit_loop # loop_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, NextIteration_MissingValues) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| loop->Body()->SetParams({b.BlockParam<i32>(), b.BlockParam<i32>()}); | |
| b.Append(loop->Initializer(), [&] { b.NextIteration(loop); }); | |
| b.Append(loop->Body(), [&] { b.ExitLoop(loop); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:9 error: next_iteration: provides 0 values but 'loop' block $B3 expects 2 values | |
| next_iteration # -> $B3 | |
| ^^^^^^^^^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # initializer | |
| ^^^ | |
| :7:7 note: 'loop' block $B3 declared here | |
| $B3 (%2:i32, %3:i32): { # body | |
| ^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [i: $B2, b: $B3] { # loop_1 | |
| $B2: { # initializer | |
| next_iteration # -> $B3 | |
| } | |
| $B3 (%2:i32, %3:i32): { # body | |
| exit_loop # loop_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, NextIteration_MismatchedTypes) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| loop->Body()->SetParams( | |
| {b.BlockParam<i32>(), b.BlockParam<f32>(), b.BlockParam<u32>(), b.BlockParam<bool>()}); | |
| b.Append(loop->Initializer(), [&] { b.NextIteration(loop, 1_i, 2_i, 3_f, false); }); | |
| b.Append(loop->Body(), [&] { b.ExitLoop(loop); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:5:28 error: next_iteration: operand with type 'i32' does not match 'loop' block $B3 target type 'f32' | |
| next_iteration 1i, 2i, 3.0f, false # -> $B3 | |
| ^^ | |
| :4:7 note: in block | |
| $B2: { # initializer | |
| ^^^ | |
| :7:20 note: %3 declared here | |
| $B3 (%2:i32, %3:f32, %4:u32, %5:bool): { # body | |
| ^^ | |
| :5:32 error: next_iteration: operand with type 'f32' does not match 'loop' block $B3 target type 'u32' | |
| next_iteration 1i, 2i, 3.0f, false # -> $B3 | |
| ^^^^ | |
| :4:7 note: in block | |
| $B2: { # initializer | |
| ^^^ | |
| :7:28 note: %4 declared here | |
| $B3 (%2:i32, %3:f32, %4:u32, %5:bool): { # body | |
| ^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [i: $B2, b: $B3] { # loop_1 | |
| $B2: { # initializer | |
| next_iteration 1i, 2i, 3.0f, false # -> $B3 | |
| } | |
| $B3 (%2:i32, %3:f32, %4:u32, %5:bool): { # body | |
| exit_loop # loop_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, NextIteration_MatchedTypes) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| loop->Body()->SetParams( | |
| {b.BlockParam<i32>(), b.BlockParam<f32>(), b.BlockParam<u32>(), b.BlockParam<bool>()}); | |
| b.Append(loop->Initializer(), [&] { b.NextIteration(loop, 1_i, 2_f, 3_u, false); }); | |
| b.Append(loop->Body(), [&] { b.ExitLoop(loop); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, LoopBodyParamsWithoutInitializer) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| loop->Body()->SetParams({b.BlockParam<i32>(), b.BlockParam<i32>()}); | |
| b.Append(loop->Body(), [&] { b.ExitLoop(loop); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:5 error: loop: loop with body block parameters must have an initializer | |
| loop [b: $B2] { # loop_1 | |
| ^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2] { # loop_1 | |
| $B2 (%2:i32, %3:i32): { # body | |
| exit_loop # loop_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ContinuingUseValueBeforeContinue) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* value = b.Let("value", 1_i); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Body(), [&] { | |
| b.Append(value); | |
| b.Append(b.If(true)->True(), [&] { b.Continue(loop); }); | |
| b.ExitLoop(loop); | |
| }); | |
| b.Append(loop->Continuing(), [&] { | |
| b.Let("use", value); | |
| b.NextIteration(loop); | |
| }); | |
| b.Return(f); | |
| }); | |
| ASSERT_EQ(ir::Validate(mod), Success); | |
| } | |
| TEST_F(IR_ValidatorTest, ContinuingUseValueAfterContinue) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* value = b.Let("value", 1_i); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Body(), [&] { | |
| b.Append(b.If(true)->True(), [&] { b.Continue(loop); }); | |
| b.Append(value); | |
| b.ExitLoop(loop); | |
| }); | |
| b.Append(loop->Continuing(), [&] { | |
| b.Let("use", value); | |
| b.NextIteration(loop); | |
| }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:14:24 error: let: %value cannot be used in continuing block as it is declared after the first 'continue' in the loop's body | |
| %use:i32 = let %value | |
| ^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # body | |
| ^^^ | |
| :10:9 note: %value declared here | |
| %value:i32 = let 1i | |
| ^^^^^^^^^^ | |
| :7:13 note: loop body's first 'continue' | |
| continue # -> $B3 | |
| ^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| if true [t: $B4] { # if_1 | |
| $B4: { # true | |
| continue # -> $B3 | |
| } | |
| } | |
| %value:i32 = let 1i | |
| exit_loop # loop_1 | |
| } | |
| $B3: { # continuing | |
| %use:i32 = let %value | |
| next_iteration # -> $B2 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, BreakIf_NextIterUnexpectedValues) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Body(), [&] { b.Continue(loop); }); | |
| b.Append(loop->Continuing(), [&] { b.BreakIf(loop, true, b.Values(1_i, 2_i), Empty); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:9 error: break_if: provides 2 values but 'loop' block $B2 expects 0 values | |
| break_if true next_iteration: [ 1i, 2i ] # -> [t: exit_loop loop_1, f: $B2] | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| :7:7 note: in block | |
| $B3: { # continuing | |
| ^^^ | |
| :4:7 note: 'loop' block $B2 declared here | |
| $B2: { # body | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| continue # -> $B3 | |
| } | |
| $B3: { # continuing | |
| break_if true next_iteration: [ 1i, 2i ] # -> [t: exit_loop loop_1, f: $B2] | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, BreakIf_NextIterMissingValues) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| loop->Body()->SetParams({b.BlockParam<i32>(), b.BlockParam<i32>()}); | |
| b.Append(loop->Initializer(), [&] { b.NextIteration(loop, nullptr, nullptr); }); | |
| b.Append(loop->Body(), [&] { b.Continue(loop); }); | |
| b.Append(loop->Continuing(), [&] { b.BreakIf(loop, true, Empty, Empty); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:11:9 error: break_if: provides 0 values but 'loop' block $B3 expects 2 values | |
| break_if true # -> [t: exit_loop loop_1, f: $B3] | |
| ^^^^^^^^^^^^^ | |
| :10:7 note: in block | |
| $B4: { # continuing | |
| ^^^ | |
| :7:7 note: 'loop' block $B3 declared here | |
| $B3 (%2:i32, %3:i32): { # body | |
| ^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [i: $B2, b: $B3, c: $B4] { # loop_1 | |
| $B2: { # initializer | |
| next_iteration undef, undef # -> $B3 | |
| } | |
| $B3 (%2:i32, %3:i32): { # body | |
| continue # -> $B4 | |
| } | |
| $B4: { # continuing | |
| break_if true # -> [t: exit_loop loop_1, f: $B3] | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, BreakIf_NextIterMismatchedTypes) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| loop->Body()->SetParams( | |
| {b.BlockParam<i32>(), b.BlockParam<f32>(), b.BlockParam<u32>(), b.BlockParam<bool>()}); | |
| b.Append(loop->Initializer(), | |
| [&] { b.NextIteration(loop, nullptr, nullptr, nullptr, nullptr); }); | |
| b.Append(loop->Body(), [&] { b.Continue(loop); }); | |
| b.Append(loop->Continuing(), | |
| [&] { b.BreakIf(loop, true, b.Values(1_i, 2_i, 3_f, false), Empty); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:11:45 error: break_if: operand with type 'i32' does not match 'loop' block $B3 target type 'f32' | |
| break_if true next_iteration: [ 1i, 2i, 3.0f, false ] # -> [t: exit_loop loop_1, f: $B3] | |
| ^^ | |
| :10:7 note: in block | |
| $B4: { # continuing | |
| ^^^ | |
| :7:20 note: %3 declared here | |
| $B3 (%2:i32, %3:f32, %4:u32, %5:bool): { # body | |
| ^^ | |
| :11:49 error: break_if: operand with type 'f32' does not match 'loop' block $B3 target type 'u32' | |
| break_if true next_iteration: [ 1i, 2i, 3.0f, false ] # -> [t: exit_loop loop_1, f: $B3] | |
| ^^^^ | |
| :10:7 note: in block | |
| $B4: { # continuing | |
| ^^^ | |
| :7:28 note: %4 declared here | |
| $B3 (%2:i32, %3:f32, %4:u32, %5:bool): { # body | |
| ^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [i: $B2, b: $B3, c: $B4] { # loop_1 | |
| $B2: { # initializer | |
| next_iteration undef, undef, undef, undef # -> $B3 | |
| } | |
| $B3 (%2:i32, %3:f32, %4:u32, %5:bool): { # body | |
| continue # -> $B4 | |
| } | |
| $B4: { # continuing | |
| break_if true next_iteration: [ 1i, 2i, 3.0f, false ] # -> [t: exit_loop loop_1, f: $B3] | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, BreakIf_NextIterMatchedTypes) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| loop->Body()->SetParams( | |
| {b.BlockParam<i32>(), b.BlockParam<f32>(), b.BlockParam<u32>(), b.BlockParam<bool>()}); | |
| b.Append(loop->Initializer(), | |
| [&] { b.NextIteration(loop, nullptr, nullptr, nullptr, nullptr); }); | |
| b.Append(loop->Body(), [&] { b.Continue(loop); }); | |
| b.Append(loop->Continuing(), | |
| [&] { b.BreakIf(loop, true, b.Values(1_i, 2_f, 3_u, false), Empty); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, BreakIf_ExitUnexpectedValues) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Body(), [&] { b.Continue(loop); }); | |
| b.Append(loop->Continuing(), [&] { b.BreakIf(loop, true, Empty, b.Values(1_i, 2_i)); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:9 error: break_if: provides 2 values but 'loop' expects 0 values | |
| break_if true exit_loop: [ 1i, 2i ] # -> [t: exit_loop loop_1, f: $B2] | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| :7:7 note: in block | |
| $B3: { # continuing | |
| ^^^ | |
| :3:5 note: 'loop' declared here | |
| loop [b: $B2, c: $B3] { # loop_1 | |
| ^^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| continue # -> $B3 | |
| } | |
| $B3: { # continuing | |
| break_if true exit_loop: [ 1i, 2i ] # -> [t: exit_loop loop_1, f: $B2] | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, BreakIf_ExitMissingValues) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| loop->SetResults(b.InstructionResult<i32>(), b.InstructionResult<i32>()); | |
| b.Append(loop->Body(), [&] { b.Continue(loop); }); | |
| b.Append(loop->Continuing(), [&] { b.BreakIf(loop, true, Empty, Empty); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:9 error: break_if: provides 0 values but 'loop' expects 2 values | |
| break_if true # -> [t: exit_loop loop_1, f: $B2] | |
| ^^^^^^^^^^^^^ | |
| :7:7 note: in block | |
| $B3: { # continuing | |
| ^^^ | |
| :3:5 note: 'loop' declared here | |
| %2:i32, %3:i32 = loop [b: $B2, c: $B3] { # loop_1 | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32, %3:i32 = loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| continue # -> $B3 | |
| } | |
| $B3: { # continuing | |
| break_if true # -> [t: exit_loop loop_1, f: $B2] | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, BreakIf_ExitMismatchedTypes) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| loop->SetResults(b.InstructionResult<i32>(), b.InstructionResult<f32>(), | |
| b.InstructionResult<u32>(), b.InstructionResult<bool>()); | |
| b.Append(loop->Body(), [&] { b.Continue(loop); }); | |
| b.Append(loop->Continuing(), | |
| [&] { b.BreakIf(loop, true, Empty, b.Values(1_i, 2_i, 3_f, false)); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:8:40 error: break_if: operand with type 'i32' does not match 'loop' target type 'f32' | |
| break_if true exit_loop: [ 1i, 2i, 3.0f, false ] # -> [t: exit_loop loop_1, f: $B2] | |
| ^^ | |
| :7:7 note: in block | |
| $B3: { # continuing | |
| ^^^ | |
| :3:13 note: %3 declared here | |
| %2:i32, %3:f32, %4:u32, %5:bool = loop [b: $B2, c: $B3] { # loop_1 | |
| ^^^^^^ | |
| :8:44 error: break_if: operand with type 'f32' does not match 'loop' target type 'u32' | |
| break_if true exit_loop: [ 1i, 2i, 3.0f, false ] # -> [t: exit_loop loop_1, f: $B2] | |
| ^^^^ | |
| :7:7 note: in block | |
| $B3: { # continuing | |
| ^^^ | |
| :3:21 note: %4 declared here | |
| %2:i32, %3:f32, %4:u32, %5:bool = loop [b: $B2, c: $B3] { # loop_1 | |
| ^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32, %3:f32, %4:u32, %5:bool = loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| continue # -> $B3 | |
| } | |
| $B3: { # continuing | |
| break_if true exit_loop: [ 1i, 2i, 3.0f, false ] # -> [t: exit_loop loop_1, f: $B2] | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, BreakIf_ExitMatchedTypes) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| loop->SetResults(b.InstructionResult<i32>(), b.InstructionResult<f32>(), | |
| b.InstructionResult<u32>(), b.InstructionResult<bool>()); | |
| b.Append(loop->Body(), [&] { b.Continue(loop); }); | |
| b.Append(loop->Continuing(), | |
| [&] { b.BreakIf(loop, true, Empty, b.Values(1_i, 2_f, 3_u, false)); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitLoop) { | |
| auto* loop = b.Loop(); | |
| loop->Continuing()->Append(b.NextIteration(loop)); | |
| loop->Body()->Append(b.ExitLoop(loop)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(loop); | |
| sb.Return(f); | |
| EXPECT_EQ(ir::Validate(mod), Success); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitLoop_NullLoop) { | |
| auto* loop = b.Loop(); | |
| loop->Continuing()->Append(b.NextIteration(loop)); | |
| loop->Body()->Append(mod.CreateInstruction<ExitLoop>(nullptr)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(loop); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:9 error: exit_loop: has no parent control instruction | |
| exit_loop # undef | |
| ^^^^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # body | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| exit_loop # undef | |
| } | |
| $B3: { # continuing | |
| next_iteration # -> $B2 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitLoop_LessOperandsThenLoopParams) { | |
| auto* loop = b.Loop(); | |
| auto* r1 = b.InstructionResult(ty.i32()); | |
| auto* r2 = b.InstructionResult(ty.f32()); | |
| loop->SetResults(Vector{r1, r2}); | |
| loop->Continuing()->Append(b.NextIteration(loop)); | |
| loop->Body()->Append(b.ExitLoop(loop, 1_i)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(loop); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:9 error: exit_loop: provides 1 value but 'loop' expects 2 values | |
| exit_loop 1i # loop_1 | |
| ^^^^^^^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # body | |
| ^^^ | |
| :3:5 note: 'loop' declared here | |
| %2:i32, %3:f32 = loop [b: $B2, c: $B3] { # loop_1 | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32, %3:f32 = loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| exit_loop 1i # loop_1 | |
| } | |
| $B3: { # continuing | |
| next_iteration # -> $B2 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitLoop_MoreOperandsThenLoopParams) { | |
| auto* loop = b.Loop(); | |
| auto* r1 = b.InstructionResult(ty.i32()); | |
| auto* r2 = b.InstructionResult(ty.f32()); | |
| loop->SetResults(Vector{r1, r2}); | |
| loop->Continuing()->Append(b.NextIteration(loop)); | |
| loop->Body()->Append(b.ExitLoop(loop, 1_i, 2_f, 3_i)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(loop); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:9 error: exit_loop: provides 3 values but 'loop' expects 2 values | |
| exit_loop 1i, 2.0f, 3i # loop_1 | |
| ^^^^^^^^^^^^^^^^^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # body | |
| ^^^ | |
| :3:5 note: 'loop' declared here | |
| %2:i32, %3:f32 = loop [b: $B2, c: $B3] { # loop_1 | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32, %3:f32 = loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| exit_loop 1i, 2.0f, 3i # loop_1 | |
| } | |
| $B3: { # continuing | |
| next_iteration # -> $B2 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitLoop_WithResult) { | |
| auto* loop = b.Loop(); | |
| auto* r1 = b.InstructionResult(ty.i32()); | |
| auto* r2 = b.InstructionResult(ty.f32()); | |
| loop->SetResults(Vector{r1, r2}); | |
| loop->Continuing()->Append(b.NextIteration(loop)); | |
| loop->Body()->Append(b.ExitLoop(loop, 1_i, 2_f)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(loop); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitLoop_IncorrectResultType) { | |
| auto* loop = b.Loop(); | |
| auto* r1 = b.InstructionResult(ty.i32()); | |
| auto* r2 = b.InstructionResult(ty.f32()); | |
| loop->SetResults(Vector{r1, r2}); | |
| loop->Continuing()->Append(b.NextIteration(loop)); | |
| loop->Body()->Append(b.ExitLoop(loop, 1_i, 2_i)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(loop); | |
| sb.Return(f); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:5:23 error: exit_loop: operand with type 'i32' does not match 'loop' target type 'f32' | |
| exit_loop 1i, 2i # loop_1 | |
| ^^ | |
| :4:7 note: in block | |
| $B2: { # body | |
| ^^^ | |
| :3:13 note: %3 declared here | |
| %2:i32, %3:f32 = loop [b: $B2, c: $B3] { # loop_1 | |
| ^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32, %3:f32 = loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| exit_loop 1i, 2i # loop_1 | |
| } | |
| $B3: { # continuing | |
| next_iteration # -> $B2 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitLoop_NotInParentLoop) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* loop = b.Loop(); | |
| loop->Continuing()->Append(b.NextIteration(loop)); | |
| loop->Body()->Append(b.Return(f)); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(loop); | |
| auto* if_ = sb.Append(b.If(true)); | |
| b.Append(if_->True(), [&] { b.ExitLoop(loop); }); | |
| sb.Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:13:9 error: exit_loop: loop not found in parent control instructions | |
| exit_loop # loop_1 | |
| ^^^^^^^^^ | |
| :12:7 note: in block | |
| $B4: { # true | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| ret | |
| } | |
| $B3: { # continuing | |
| next_iteration # -> $B2 | |
| } | |
| } | |
| if true [t: $B4] { # if_1 | |
| $B4: { # true | |
| exit_loop # loop_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitLoop_JumpsOverIfs) { | |
| // loop { | |
| // if (true) { | |
| // if (false) { | |
| // break; | |
| // } | |
| // } | |
| // break; | |
| // } | |
| auto* loop = b.Loop(); | |
| loop->Continuing()->Append(b.NextIteration(loop)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(loop->Body(), [&] { | |
| auto* if_ = b.If(true); | |
| b.Append(if_->True(), [&] { | |
| auto* inner_if_ = b.If(false); | |
| b.Append(inner_if_->True(), [&] { b.ExitLoop(loop); }); | |
| b.Return(f); | |
| }); | |
| b.ExitLoop(loop); | |
| }); | |
| auto sb = b.Append(f->Block()); | |
| sb.Append(loop); | |
| sb.Return(f); | |
| EXPECT_EQ(ir::Validate(mod), Success); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitLoop_InvalidJumpOverSwitch) { | |
| auto* loop = b.Loop(); | |
| loop->Continuing()->Append(b.NextIteration(loop)); | |
| b.Append(loop->Body(), [&] { | |
| auto* inner = b.Switch(1_i); | |
| b.ExitLoop(loop); | |
| auto* inner_def = b.DefaultCase(inner); | |
| b.Append(inner_def, [&] { b.ExitLoop(loop); }); | |
| }); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Append(loop); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:7:13 error: exit_loop: loop target jumps over other control instructions | |
| exit_loop # loop_1 | |
| ^^^^^^^^^ | |
| :6:11 note: in block | |
| $B4: { # case | |
| ^^^ | |
| :5:9 note: first control instruction jumped | |
| switch 1i [c: (default, $B4)] { # switch_1 | |
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| switch 1i [c: (default, $B4)] { # switch_1 | |
| $B4: { # case | |
| exit_loop # loop_1 | |
| } | |
| } | |
| exit_loop # loop_1 | |
| } | |
| $B3: { # continuing | |
| next_iteration # -> $B2 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitLoop_InvalidJumpOverLoop) { | |
| auto* outer_loop = b.Loop(); | |
| outer_loop->Continuing()->Append(b.NextIteration(outer_loop)); | |
| b.Append(outer_loop->Body(), [&] { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Body(), [&] { b.ExitLoop(outer_loop); }); | |
| b.ExitLoop(outer_loop); | |
| }); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Append(outer_loop); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:7:13 error: exit_loop: loop target jumps over other control instructions | |
| exit_loop # loop_1 | |
| ^^^^^^^^^ | |
| :6:11 note: in block | |
| $B4: { # body | |
| ^^^ | |
| :5:9 note: first control instruction jumped | |
| loop [b: $B4] { # loop_2 | |
| ^^^^^^^^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| loop [b: $B4] { # loop_2 | |
| $B4: { # body | |
| exit_loop # loop_1 | |
| } | |
| } | |
| exit_loop # loop_1 | |
| } | |
| $B3: { # continuing | |
| next_iteration # -> $B2 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitLoop_InvalidInsideContinuing) { | |
| auto* loop = b.Loop(); | |
| loop->Continuing()->Append(b.ExitLoop(loop)); | |
| loop->Body()->Append(b.Continue(loop)); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Append(loop); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:8:9 error: exit_loop: loop exit jumps out of continuing block | |
| exit_loop # loop_1 | |
| ^^^^^^^^^ | |
| :7:7 note: in block | |
| $B3: { # continuing | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| continue # -> $B3 | |
| } | |
| $B3: { # continuing | |
| exit_loop # loop_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitLoop_InvalidInsideContinuingNested) { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Continuing(), [&]() { | |
| auto* if_ = b.If(true); | |
| b.Append(if_->True(), [&]() { b.ExitLoop(loop); }); | |
| b.NextIteration(loop); | |
| }); | |
| b.Append(loop->Body(), [&] { b.Continue(loop); }); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Append(loop); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:10:13 error: exit_loop: loop exit jumps out of continuing block | |
| exit_loop # loop_1 | |
| ^^^^^^^^^ | |
| :9:11 note: in block | |
| $B4: { # true | |
| ^^^ | |
| :7:7 note: in continuing block | |
| $B3: { # continuing | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [b: $B2, c: $B3] { # loop_1 | |
| $B2: { # body | |
| continue # -> $B3 | |
| } | |
| $B3: { # continuing | |
| if true [t: $B4] { # if_1 | |
| $B4: { # true | |
| exit_loop # loop_1 | |
| } | |
| } | |
| next_iteration # -> $B2 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitLoop_InvalidInsideInitializer) { | |
| auto* loop = b.Loop(); | |
| loop->Initializer()->Append(b.ExitLoop(loop)); | |
| loop->Continuing()->Append(b.NextIteration(loop)); | |
| b.Append(loop->Body(), [&] { b.Continue(loop); }); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Append(loop); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:5:9 error: exit_loop: loop exit not permitted in loop initializer | |
| exit_loop # loop_1 | |
| ^^^^^^^^^ | |
| :4:7 note: in block | |
| $B2: { # initializer | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [i: $B2, b: $B3, c: $B4] { # loop_1 | |
| $B2: { # initializer | |
| exit_loop # loop_1 | |
| } | |
| $B3: { # body | |
| continue # -> $B4 | |
| } | |
| $B4: { # continuing | |
| next_iteration # -> $B3 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, ExitLoop_InvalidInsideInitializerNested) { | |
| auto* loop = b.Loop(); | |
| b.Append(loop->Initializer(), [&]() { | |
| auto* if_ = b.If(true); | |
| b.Append(if_->True(), [&]() { b.ExitLoop(loop); }); | |
| b.NextIteration(loop); | |
| }); | |
| loop->Continuing()->Append(b.NextIteration(loop)); | |
| b.Append(loop->Body(), [&] { b.Continue(loop); }); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Append(loop); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:7:13 error: exit_loop: loop exit not permitted in loop initializer | |
| exit_loop # loop_1 | |
| ^^^^^^^^^ | |
| :6:11 note: in block | |
| $B5: { # true | |
| ^^^ | |
| :4:7 note: in initializer block | |
| $B2: { # initializer | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| loop [i: $B2, b: $B3, c: $B4] { # loop_1 | |
| $B2: { # initializer | |
| if true [t: $B5] { # if_1 | |
| $B5: { # true | |
| exit_loop # loop_1 | |
| } | |
| } | |
| next_iteration # -> $B3 | |
| } | |
| $B3: { # body | |
| continue # -> $B4 | |
| } | |
| $B4: { # continuing | |
| next_iteration # -> $B3 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Return) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { // | |
| b.Return(f); | |
| }); | |
| EXPECT_EQ(ir::Validate(mod), Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Return_WithValue) { | |
| auto* f = b.Function("my_func", ty.i32()); | |
| b.Append(f->Block(), [&] { // | |
| b.Return(f, 42_i); | |
| }); | |
| EXPECT_EQ(ir::Validate(mod), Success); | |
| } | |
| TEST_F(IR_ValidatorTest, Return_UnexpectedResult) { | |
| auto* f = b.Function("my_func", ty.i32()); | |
| b.Append(f->Block(), [&] { // | |
| auto* r = b.Return(f, 42_i); | |
| r->SetResults(Vector{b.InstructionResult(ty.i32())}); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:5 error: return: expected exactly 0 results, got 1 | |
| ret 42i | |
| ^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():i32 { | |
| $B1: { | |
| ret 42i | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Return_NotFunction) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { // | |
| auto* var = b.Var(ty.ptr<function, f32>()); | |
| auto* r = b.Return(nullptr); | |
| r->SetOperand(0, var->Result(0)); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:4:5 error: return: expected function for first operand | |
| ret | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, f32, read_write> = var | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Return_MissingFunction) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* r = b.Return(f); | |
| r->ClearOperands(); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:5 error: return: expected between 1 and 2 operands, got 0 | |
| ret | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Return_UnexpectedValue) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { // | |
| b.Return(f, 42_i); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:5 error: return: unexpected return value | |
| ret 42i | |
| ^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| ret 42i | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Return_MissingValue) { | |
| auto* f = b.Function("my_func", ty.i32()); | |
| b.Append(f->Block(), [&] { // | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:5 error: return: expected return value | |
| ret | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():i32 { | |
| $B1: { | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Return_WrongValueType) { | |
| auto* f = b.Function("my_func", ty.i32()); | |
| b.Append(f->Block(), [&] { // | |
| b.Return(f, 42_f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:3:5 error: return: return value type 'f32' does not match function return type 'i32' | |
| ret 42.0f | |
| ^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():i32 { | |
| $B1: { | |
| ret 42.0f | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Unreachable_UnexpectedResult) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { // | |
| auto* u = b.Unreachable(); | |
| u->SetResults(Vector{b.InstructionResult(ty.i32())}); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:5 error: unreachable: expected exactly 0 results, got 1 | |
| unreachable | |
| ^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Unreachable_UnexpectedOperand) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { // | |
| auto* u = b.Unreachable(); | |
| u->SetOperands(Vector{b.Value(0_i)}); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:5 error: unreachable: expected exactly 0 operands, got 1 | |
| unreachable | |
| ^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| unreachable | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Load_NullFrom) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Append(mod.CreateInstruction<ir::Load>(b.InstructionResult(ty.i32()), nullptr)); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:19 error: load: operand is undefined | |
| %2:i32 = load undef | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32 = load undef | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Load_SourceNotMemoryView) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* let = b.Let("l", 1_i); | |
| b.Append(mod.CreateInstruction<ir::Load>(b.InstructionResult(ty.f32()), let->Result(0))); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:19 error: load: load source operand is not a memory view | |
| %3:f32 = load %l | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %l:i32 = let 1i | |
| %3:f32 = load %l | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Load_TypeMismatch) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr<function, i32>()); | |
| b.Append(mod.CreateInstruction<ir::Load>(b.InstructionResult(ty.f32()), var->Result(0))); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:19 error: load: result type 'f32' does not match source store type 'i32' | |
| %3:f32 = load %2 | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, i32, read_write> = var | |
| %3:f32 = load %2 | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Load_MissingResult) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr<function, i32>()); | |
| auto* load = mod.CreateInstruction<ir::Load>(nullptr, var->Result(0)); | |
| load->ClearResults(); | |
| b.Append(load); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:13 error: load: expected exactly 1 results, got 0 | |
| undef = load %2 | |
| ^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, i32, read_write> = var | |
| undef = load %2 | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Load_NonReadableSource) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr<function, i32, core::Access::kWrite>()); | |
| b.Append(mod.CreateInstruction<ir::Load>(b.InstructionResult(ty.i32()), var->Result(0))); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:19 error: load: load source operand has a non-readable access type, 'write' | |
| %3:i32 = load %2 | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, i32, write> = var | |
| %3:i32 = load %2 | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Store_NullTo) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Append(mod.CreateInstruction<ir::Store>(nullptr, b.Constant(42_i))); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:11 error: store: operand is undefined | |
| store undef, 42i | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| store undef, 42i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Store_NullFrom) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr<function, i32>()); | |
| b.Append(mod.CreateInstruction<ir::Store>(var->Result(0), nullptr)); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:4:15 error: store: operand is undefined | |
| store %2, undef | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, i32, read_write> = var | |
| store %2, undef | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Store_NullToAndFrom) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Append(mod.CreateInstruction<ir::Store>(nullptr, nullptr)); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:11 error: store: operand is undefined | |
| store undef, undef | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| :3:18 error: store: operand is undefined | |
| store undef, undef | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| store undef, undef | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Store_NonEmptyResult) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr<function, i32>()); | |
| auto* store = mod.CreateInstruction<ir::Store>(var->Result(0), b.Constant(42_i)); | |
| store->SetResults(Vector{b.InstructionResult(ty.i32())}); | |
| b.Append(store); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:4:5 error: store: expected exactly 0 results, got 1 | |
| store %2, 42i | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, i32, read_write> = var | |
| store %2, 42i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Store_TargetNotMemoryView) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* let = b.Let("l", 1_i); | |
| b.Append(mod.CreateInstruction<ir::Store>(let->Result(0), b.Constant(42_u))); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:11 error: store: store target operand is not a memory view | |
| store %l, 42u | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %l:i32 = let 1i | |
| store %l, 42u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Store_TypeMismatch) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr<function, i32>()); | |
| b.Append(mod.CreateInstruction<ir::Store>(var->Result(0), b.Constant(42_u))); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:15 error: store: value type 'u32' does not match store type 'i32' | |
| store %2, 42u | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, i32, read_write> = var | |
| store %2, 42u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Store_NoStoreType) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* result = b.InstructionResult(ty.u32()); | |
| result->SetType(nullptr); | |
| b.Append(mod.CreateInstruction<ir::Store>(result, b.Constant(42_u))); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:11 error: store: operand type is undefined | |
| store %2, 42u | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| store %2, 42u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Store_NoValueType) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr<function, i32>()); | |
| auto* val = b.Construct(ty.u32(), 42_u); | |
| val->Result(0)->SetType(nullptr); | |
| b.Append(mod.CreateInstruction<ir::Store>(var->Result(0), val->Result(0))); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:5 error: construct: result type is undefined | |
| %3:undef = construct 42u | |
| ^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| :5:15 error: store: operand type is undefined | |
| store %2, %3 | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, i32, read_write> = var | |
| %3:undef = construct 42u | |
| store %2, %3 | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Store_NonWriteableTarget) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr<function, i32, core::Access::kRead>()); | |
| b.Append(mod.CreateInstruction<ir::Store>(var->Result(0), b.Constant(42_i))); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:11 error: store: store target operand has a non-writeable access type, 'read' | |
| store %2, 42i | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, i32, read> = var | |
| store %2, 42i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, LoadVectorElement_NullResult) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr<function, vec3<f32>>()); | |
| b.Append( | |
| mod.CreateInstruction<ir::LoadVectorElement>(nullptr, var->Result(0), b.Constant(1_i))); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:5 error: load_vector_element: result is undefined | |
| undef = load_vector_element %2, 1i | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, vec3<f32>, read_write> = var | |
| undef = load_vector_element %2, 1i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, LoadVectorElement_NullFrom) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Append(mod.CreateInstruction<ir::LoadVectorElement>(b.InstructionResult(ty.f32()), | |
| nullptr, b.Constant(1_i))); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:34 error: load_vector_element: operand is undefined | |
| %2:f32 = load_vector_element undef, 1i | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:f32 = load_vector_element undef, 1i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, LoadVectorElement_NullIndex) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr<function, vec3<f32>>()); | |
| b.Append(mod.CreateInstruction<ir::LoadVectorElement>(b.InstructionResult(ty.f32()), | |
| var->Result(0), nullptr)); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:4:38 error: load_vector_element: operand is undefined | |
| %3:f32 = load_vector_element %2, undef | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, vec3<f32>, read_write> = var | |
| %3:f32 = load_vector_element %2, undef | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, LoadVectorElement_MissingResult) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr<function, vec3<f32>>()); | |
| auto* load = b.LoadVectorElement(var, b.Constant(1_i)); | |
| load->ClearResults(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:13 error: load_vector_element: expected exactly 1 results, got 0 | |
| undef = load_vector_element %2, 1i | |
| ^^^^^^^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, vec3<f32>, read_write> = var | |
| undef = load_vector_element %2, 1i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, LoadVectorElement_MissingOperands) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr<function, vec3<f32>>()); | |
| auto* load = b.LoadVectorElement(var, b.Constant(1_i)); | |
| load->ClearOperands(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:14 error: load_vector_element: expected exactly 2 operands, got 0 | |
| %3:f32 = load_vector_element | |
| ^^^^^^^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, vec3<f32>, read_write> = var | |
| %3:f32 = load_vector_element | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, StoreVectorElement_NullTo) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Append(mod.CreateInstruction<ir::StoreVectorElement>(nullptr, b.Constant(1_i), | |
| b.Constant(2_f))); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:3:26 error: store_vector_element: operand is undefined | |
| store_vector_element undef, 1i, 2.0f | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| store_vector_element undef, 1i, 2.0f | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, StoreVectorElement_NullIndex) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr<function, vec3<f32>>()); | |
| b.Append(mod.CreateInstruction<ir::StoreVectorElement>(var->Result(0), nullptr, | |
| b.Constant(2_f))); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:4:30 error: store_vector_element: operand is undefined | |
| store_vector_element %2, undef, 2.0f | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, vec3<f32>, read_write> = var | |
| store_vector_element %2, undef, 2.0f | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, StoreVectorElement_NullValue) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr<function, vec3<f32>>()); | |
| b.Append(mod.CreateInstruction<ir::StoreVectorElement>(var->Result(0), b.Constant(1_i), | |
| nullptr)); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(:4:34 error: store_vector_element: operand is undefined | |
| store_vector_element %2, 1i, undef | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, vec3<f32>, read_write> = var | |
| store_vector_element %2, 1i, undef | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, StoreVectorElement_MissingOperands) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr<function, vec3<f32>>()); | |
| auto* store = b.StoreVectorElement(var, b.Constant(1_i), b.Constant(2_f)); | |
| store->ClearOperands(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:5 error: store_vector_element: expected exactly 3 operands, got 0 | |
| store_vector_element | |
| ^^^^^^^^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, vec3<f32>, read_write> = var | |
| store_vector_element | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, StoreVectorElement_UnexpectedResult) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr<function, vec3<f32>>()); | |
| auto* store = b.StoreVectorElement(var, b.Constant(1_i), b.Constant(2_f)); | |
| store->SetResults(Vector{b.InstructionResult(ty.f32())}); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:5 error: store_vector_element: expected exactly 0 results, got 1 | |
| store_vector_element %2, 1i, 2.0f | |
| ^^^^^^^^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, vec3<f32>, read_write> = var | |
| store_vector_element %2, 1i, 2.0f | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Scoping_UseBeforeDecl) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* y = b.Add<i32>(2_i, 3_i); | |
| auto* x = b.Add<i32>(y, 1_i); | |
| f->Block()->Append(x); | |
| f->Block()->Append(y); | |
| f->Block()->Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:18 error: binary: %3 is not in scope | |
| %2:i32 = add %3, 1i | |
| ^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| :4:5 note: %3 declared here | |
| %3:i32 = add 2i, 3i | |
| ^^^^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32 = add %3, 1i | |
| %3:i32 = add 2i, 3i | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| template <typename T> | |
| static const core::type::Type* TypeBuilder(core::type::Manager& m) { | |
| return m.Get<T>(); | |
| } | |
| template <typename T> | |
| static const core::type::Type* RefTypeBuilder(core::type::Manager& m) { | |
| return m.ref<AddressSpace::kFunction, T>(); | |
| } | |
| using TypeBuilderFn = decltype(&TypeBuilder<i32>); | |
| using IR_ValidatorRefTypeTest = IRTestParamHelper<std::tuple</* holds_ref */ bool, | |
| /* refs_allowed */ bool, | |
| /* type_builder */ TypeBuilderFn>>; | |
| TEST_P(IR_ValidatorRefTypeTest, Var) { | |
| bool holds_ref = std::get<0>(GetParam()); | |
| bool refs_allowed = std::get<1>(GetParam()); | |
| auto* type = std::get<2>(GetParam())(ty); | |
| auto* fn = b.Function("my_func", ty.void_()); | |
| b.Append(fn->Block(), [&] { | |
| if (auto* view = type->As<core::type::MemoryView>()) { | |
| b.Var(view); | |
| } else { | |
| b.Var(ty.ptr<function>(type)); | |
| } | |
| b.Return(fn); | |
| }); | |
| Capabilities caps; | |
| if (refs_allowed) { | |
| caps.Add(Capability::kAllowRefTypes); | |
| } | |
| auto res = ir::Validate(mod, caps); | |
| if (!holds_ref || refs_allowed) { | |
| ASSERT_EQ(res, Success) << res.Failure(); | |
| } else { | |
| ASSERT_NE(res, Success); | |
| EXPECT_THAT(res.Failure().reason.Str(), | |
| testing::HasSubstr("3:5 error: var: reference types are not permitted")); | |
| } | |
| } | |
| TEST_P(IR_ValidatorRefTypeTest, FnParam) { | |
| bool holds_ref = std::get<0>(GetParam()); | |
| bool refs_allowed = std::get<1>(GetParam()); | |
| auto* type = std::get<2>(GetParam())(ty); | |
| auto* fn = b.Function("my_func", ty.void_()); | |
| fn->SetParams(Vector{b.FunctionParam(type)}); | |
| b.Append(fn->Block(), [&] { b.Return(fn); }); | |
| Capabilities caps; | |
| if (refs_allowed) { | |
| caps.Add(Capability::kAllowRefTypes); | |
| } | |
| auto res = ir::Validate(mod, caps); | |
| if (!holds_ref) { | |
| ASSERT_EQ(res, Success) << res.Failure(); | |
| } else { | |
| ASSERT_NE(res, Success); | |
| EXPECT_THAT(res.Failure().reason.Str(), | |
| testing::HasSubstr("reference types are not permitted")); | |
| } | |
| } | |
| TEST_P(IR_ValidatorRefTypeTest, FnRet) { | |
| bool holds_ref = std::get<0>(GetParam()); | |
| bool refs_allowed = std::get<1>(GetParam()); | |
| auto* type = std::get<2>(GetParam())(ty); | |
| auto* fn = b.Function("my_func", type); | |
| b.Append(fn->Block(), [&] { b.Unreachable(); }); | |
| Capabilities caps; | |
| if (refs_allowed) { | |
| caps.Add(Capability::kAllowRefTypes); | |
| } | |
| auto res = ir::Validate(mod, caps); | |
| if (!holds_ref) { | |
| ASSERT_EQ(res, Success) << res.Failure(); | |
| } else { | |
| ASSERT_NE(res, Success); | |
| EXPECT_THAT(res.Failure().reason.Str(), | |
| testing::HasSubstr("reference types are not permitted")); | |
| } | |
| } | |
| TEST_P(IR_ValidatorRefTypeTest, BlockParam) { | |
| bool holds_ref = std::get<0>(GetParam()); | |
| bool refs_allowed = std::get<1>(GetParam()); | |
| auto* type = std::get<2>(GetParam())(ty); | |
| auto* fn = b.Function("my_func", ty.void_()); | |
| b.Append(fn->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| loop->Continuing()->SetParams({b.BlockParam(type)}); | |
| b.Append(loop->Body(), [&] { // | |
| b.Continue(loop, nullptr); | |
| }); | |
| b.Append(loop->Continuing(), [&] { // | |
| b.NextIteration(loop); | |
| }); | |
| b.Unreachable(); | |
| }); | |
| Capabilities caps; | |
| if (refs_allowed) { | |
| caps.Add(Capability::kAllowRefTypes); | |
| } | |
| auto res = ir::Validate(mod, caps); | |
| if (!holds_ref) { | |
| ASSERT_EQ(res, Success) << res.Failure(); | |
| } else { | |
| ASSERT_NE(res, Success); | |
| EXPECT_THAT(res.Failure().reason.Str(), | |
| testing::HasSubstr("reference types are not permitted")); | |
| } | |
| } | |
| INSTANTIATE_TEST_SUITE_P(NonRefTypes, | |
| IR_ValidatorRefTypeTest, | |
| testing::Combine(/* holds_ref */ testing::Values(false), | |
| /* refs_allowed */ testing::Values(false, true), | |
| /* type_builder */ | |
| testing::Values(TypeBuilder<i32>, | |
| TypeBuilder<bool>, | |
| TypeBuilder<vec4<f32>>, | |
| TypeBuilder<array<f32, 3>>))); | |
| INSTANTIATE_TEST_SUITE_P(RefTypes, | |
| IR_ValidatorRefTypeTest, | |
| testing::Combine(/* holds_ref */ testing::Values(true), | |
| /* refs_allowed */ testing::Values(false, true), | |
| /* type_builder */ | |
| testing::Values(RefTypeBuilder<i32>, | |
| RefTypeBuilder<bool>, | |
| RefTypeBuilder<vec4<f32>>))); | |
| TEST_F(IR_ValidatorTest, PointerToPointer) { | |
| auto* type = ty.ptr<function, ptr<function, i32>>(); | |
| auto* fn = b.Function("my_func", ty.void_()); | |
| fn->SetParams(Vector{b.FunctionParam(type)}); | |
| b.Append(fn->Block(), [&] { // | |
| b.Return(fn); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_THAT(res.Failure().reason.Str(), | |
| testing::HasSubstr("nested pointer types are not permitted")); | |
| } | |
| TEST_F(IR_ValidatorTest, PointerToVoid) { | |
| auto* type = ty.ptr(AddressSpace::kFunction, ty.void_()); | |
| auto* fn = b.Function("my_func", ty.void_()); | |
| fn->SetParams(Vector{b.FunctionParam(type)}); | |
| b.Append(fn->Block(), [&] { // | |
| b.Return(fn); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_THAT(res.Failure().reason.Str(), | |
| testing::HasSubstr("pointers to void are not permitted")); | |
| } | |
| TEST_F(IR_ValidatorTest, ReferenceToReference) { | |
| auto* type = ty.ref<function>(ty.ref<function, i32>()); | |
| auto* fn = b.Function("my_func", ty.void_()); | |
| b.Append(fn->Block(), [&] { // | |
| b.Var(type); | |
| b.Return(fn); | |
| }); | |
| Capabilities caps; | |
| caps.Add(Capability::kAllowRefTypes); | |
| auto res = ir::Validate(mod, caps); | |
| ASSERT_NE(res, Success); | |
| EXPECT_THAT(res.Failure().reason.Str(), | |
| testing::HasSubstr("nested reference types are not permitted")); | |
| } | |
| TEST_F(IR_ValidatorTest, ReferenceToVoid) { | |
| auto* type = ty.ref(AddressSpace::kFunction, ty.void_()); | |
| auto* fn = b.Function("my_func", ty.void_()); | |
| b.Append(fn->Block(), [&] { // | |
| b.Var(type); | |
| b.Return(fn); | |
| }); | |
| Capabilities caps; | |
| caps.Add(Capability::kAllowRefTypes); | |
| auto res = ir::Validate(mod, caps); | |
| ASSERT_NE(res, Success); | |
| EXPECT_THAT(res.Failure().reason.Str(), | |
| testing::HasSubstr("references to void are not permitted")); | |
| } | |
| TEST_F(IR_ValidatorTest, PointerInStructure_WithoutCapability) { | |
| auto* str_ty = | |
| ty.Struct(mod.symbols.New("S"), { | |
| {mod.symbols.New("a"), ty.ptr<private_, i32>()}, | |
| }); | |
| mod.root_block->Append(b.Var("my_struct", private_, str_ty)); | |
| auto* fn = b.Function("F", ty.void_()); | |
| b.Append(fn->Block(), [&] { b.Return(fn); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_THAT(res.Failure().reason.Str(), | |
| testing::HasSubstr("nested pointer types are not permitted")); | |
| } | |
| TEST_F(IR_ValidatorTest, PointerInStructure_WithCapability) { | |
| auto* str_ty = | |
| ty.Struct(mod.symbols.New("S"), { | |
| {mod.symbols.New("a"), ty.ptr<private_, i32>()}, | |
| }); | |
| auto* fn = b.Function("F", ty.void_()); | |
| auto* param = b.FunctionParam("param", str_ty); | |
| fn->SetParams({param}); | |
| b.Append(fn->Block(), [&] { b.Return(fn); }); | |
| auto res = ir::Validate(mod, Capabilities{Capability::kAllowPointersAndHandlesInStructures}); | |
| EXPECT_EQ(res, Success) << res.Failure(); | |
| } | |
| using IR_Validator8BitIntTypeTest = IRTestParamHelper<std::tuple< | |
| /* int8_allowed */ bool, | |
| /* type_builder */ TypeBuilderFn>>; | |
| TEST_P(IR_Validator8BitIntTypeTest, Var) { | |
| bool int8_allowed = std::get<0>(GetParam()); | |
| auto* type = std::get<1>(GetParam())(ty); | |
| auto* fn = b.Function("my_func", ty.void_()); | |
| b.Append(fn->Block(), [&] { | |
| b.Var(ty.ptr<function>(type)); | |
| b.Return(fn); | |
| }); | |
| Capabilities caps; | |
| if (int8_allowed) { | |
| caps.Add(Capability::kAllow8BitIntegers); | |
| } | |
| auto res = ir::Validate(mod, caps); | |
| if (int8_allowed) { | |
| ASSERT_EQ(res, Success) << res.Failure(); | |
| } else { | |
| ASSERT_NE(res, Success); | |
| EXPECT_THAT(res.Failure().reason.Str(), | |
| testing::HasSubstr("3:5 error: var: 8-bit integer types are not permitted")); | |
| } | |
| } | |
| TEST_P(IR_Validator8BitIntTypeTest, FnParam) { | |
| bool int8_allowed = std::get<0>(GetParam()); | |
| auto* type = std::get<1>(GetParam())(ty); | |
| auto* fn = b.Function("my_func", ty.void_()); | |
| fn->SetParams(Vector{b.FunctionParam(type)}); | |
| b.Append(fn->Block(), [&] { b.Return(fn); }); | |
| Capabilities caps; | |
| if (int8_allowed) { | |
| caps.Add(Capability::kAllow8BitIntegers); | |
| } | |
| auto res = ir::Validate(mod, caps); | |
| if (int8_allowed) { | |
| ASSERT_EQ(res, Success) << res.Failure(); | |
| } else { | |
| ASSERT_NE(res, Success); | |
| EXPECT_THAT(res.Failure().reason.Str(), | |
| testing::HasSubstr("8-bit integer types are not permitted")); | |
| } | |
| } | |
| TEST_P(IR_Validator8BitIntTypeTest, FnRet) { | |
| bool int8_allowed = std::get<0>(GetParam()); | |
| auto* type = std::get<1>(GetParam())(ty); | |
| auto* fn = b.Function("my_func", type); | |
| b.Append(fn->Block(), [&] { b.Unreachable(); }); | |
| Capabilities caps; | |
| if (int8_allowed) { | |
| caps.Add(Capability::kAllow8BitIntegers); | |
| } | |
| auto res = ir::Validate(mod, caps); | |
| if (int8_allowed) { | |
| ASSERT_EQ(res, Success) << res.Failure(); | |
| } else { | |
| ASSERT_NE(res, Success); | |
| EXPECT_THAT(res.Failure().reason.Str(), | |
| testing::HasSubstr("8-bit integer types are not permitted")); | |
| } | |
| } | |
| TEST_P(IR_Validator8BitIntTypeTest, BlockParam) { | |
| bool int8_allowed = std::get<0>(GetParam()); | |
| auto* type = std::get<1>(GetParam())(ty); | |
| auto* fn = b.Function("my_func", ty.void_()); | |
| b.Append(fn->Block(), [&] { | |
| auto* loop = b.Loop(); | |
| loop->Continuing()->SetParams({b.BlockParam(type)}); | |
| b.Append(loop->Body(), [&] { // | |
| b.Continue(loop, nullptr); | |
| }); | |
| b.Append(loop->Continuing(), [&] { // | |
| b.NextIteration(loop); | |
| }); | |
| b.Unreachable(); | |
| }); | |
| Capabilities caps; | |
| if (int8_allowed) { | |
| caps.Add(Capability::kAllow8BitIntegers); | |
| } | |
| auto res = ir::Validate(mod, caps); | |
| if (int8_allowed) { | |
| ASSERT_EQ(res, Success) << res.Failure(); | |
| } else { | |
| ASSERT_NE(res, Success); | |
| EXPECT_THAT(res.Failure().reason.Str(), | |
| testing::HasSubstr("8-bit integer types are not permitted")); | |
| } | |
| } | |
| INSTANTIATE_TEST_SUITE_P(Int8Types, | |
| IR_Validator8BitIntTypeTest, | |
| testing::Combine( | |
| /* int8_allowed */ testing::Values(false, true), | |
| /* type_builder */ | |
| testing::Values(TypeBuilder<i8>, | |
| TypeBuilder<u8>, | |
| TypeBuilder<vec4<i8>>, | |
| TypeBuilder<array<u8, 4>>))); | |
| TEST_F(IR_ValidatorTest, Int8Type_InstructionOperand_NotAllowed) { | |
| auto* fn = b.Function("my_func", ty.void_()); | |
| b.Append(fn->Block(), [&] { | |
| b.Convert(ty.i32(), u8(1)); | |
| b.Return(fn); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:22 error: convert: 8-bit integer types are not permitted | |
| %2:i32 = convert 1u8 | |
| ^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:i32 = convert 1u8 | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Int8Type_InstructionOperand_Allowed) { | |
| auto* fn = b.Function("my_func", ty.void_()); | |
| b.Append(fn->Block(), [&] { | |
| b.Convert(ty.i32(), u8(1)); | |
| b.Return(fn); | |
| }); | |
| auto res = ir::Validate(mod, Capabilities{Capability::kAllow8BitIntegers}); | |
| ASSERT_EQ(res, Success) << res.Failure(); | |
| } | |
| TEST_F(IR_ValidatorTest, Switch_NoCondition) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| auto* s = b.ir.CreateInstruction<ir::Switch>(); | |
| f->Block()->Append(s); | |
| b.Append(b.DefaultCase(s), [&] { b.ExitSwitch(s); }); | |
| f->Block()->Append(b.Return(f)); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), R"(error: switch: operand is undefined | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| switch undef [c: (default, $B2)] { # switch_1 | |
| $B2: { # case | |
| exit_switch # switch_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Switch_ConditionPointer) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* s = b.Switch(b.Var("a", b.Zero<i32>())); | |
| b.Append(b.DefaultCase(s), [&] { b.ExitSwitch(s); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(error: switch: condition type must be an integer scalar | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %a:ptr<function, i32, read_write> = var, 0i | |
| switch %a [c: (default, $B2)] { # switch_1 | |
| $B2: { # case | |
| exit_switch # switch_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Switch_NoCases) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Switch(1_i); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:5 error: switch: missing default case for switch | |
| switch 1i [] { # switch_1 | |
| ^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| switch 1i [] { # switch_1 | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Switch_NoDefaultCase) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* s = b.Switch(1_i); | |
| b.Append(b.Case(s, {b.Constant(0_i)}), [&] { b.ExitSwitch(s); }); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:5 error: switch: missing default case for switch | |
| switch 1i [c: (0i, $B2)] { # switch_1 | |
| ^^^^^^^^^^^^^^^^^^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| switch 1i [c: (0i, $B2)] { # switch_1 | |
| $B2: { # case | |
| exit_switch # switch_1 | |
| } | |
| } | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Swizzle_MissingValue) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr(function, ty.vec4<f32>())); | |
| auto* swizzle = b.Swizzle(ty.vec4<f32>(), var, {3, 2, 1, 0}); | |
| swizzle->ClearOperands(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:20 error: swizzle: expected exactly 1 operands, got 0 | |
| %3:vec4<f32> = swizzle undef, wzyx | |
| ^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, vec4<f32>, read_write> = var | |
| %3:vec4<f32> = swizzle undef, wzyx | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Swizzle_NullValue) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr(function, ty.vec4<f32>())); | |
| auto* swizzle = b.Swizzle(ty.vec4<f32>(), var, {3, 2, 1, 0}); | |
| swizzle->SetOperand(0, nullptr); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(error: swizzle: operand is undefined | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, vec4<f32>, read_write> = var | |
| %3:vec4<f32> = swizzle undef, wzyx | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Swizzle_MissingResult) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr(function, ty.vec4<f32>())); | |
| auto* swizzle = b.Swizzle(ty.vec4<f32>(), var, {3, 2, 1, 0}); | |
| swizzle->ClearResults(); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:13 error: swizzle: expected exactly 1 results, got 0 | |
| undef = swizzle %2, wzyx | |
| ^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, vec4<f32>, read_write> = var | |
| undef = swizzle %2, wzyx | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Swizzle_NullResult) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr(function, ty.vec4<f32>())); | |
| auto* swizzle = b.Swizzle(ty.vec4<f32>(), var, {3, 2, 1, 0}); | |
| swizzle->SetResults(Vector<ir::InstructionResult*, 1>{nullptr}); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:5 error: swizzle: result is undefined | |
| undef = swizzle %2, wzyx | |
| ^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, vec4<f32>, read_write> = var | |
| undef = swizzle %2, wzyx | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Swizzle_NoIndices) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr(function, ty.vec4<f32>())); | |
| auto* swizzle = b.Swizzle(ty.vec4<f32>(), var, {3, 2, 1, 0}); | |
| auto indices = Vector<uint32_t, 0>(); | |
| swizzle->SetIndices(std::move(indices)); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:20 error: swizzle: expected at least 1 indices | |
| %3:vec4<f32> = swizzle %2, | |
| ^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, vec4<f32>, read_write> = var | |
| %3:vec4<f32> = swizzle %2, | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Swizzle_TooManyIndices) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr(function, ty.vec4<f32>())); | |
| auto* swizzle = b.Swizzle(ty.vec4<f32>(), var, {3, 2, 1, 0}); | |
| auto indices = Vector<uint32_t, 5>{1, 1, 1, 1, 1}; | |
| swizzle->SetIndices(std::move(indices)); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:20 error: swizzle: expected at most 4 indices | |
| %3:vec4<f32> = swizzle %2, yyyyy | |
| ^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, vec4<f32>, read_write> = var | |
| %3:vec4<f32> = swizzle %2, yyyyy | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, Swizzle_InvalidIndices) { | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| auto* var = b.Var(ty.ptr(function, ty.vec4<f32>())); | |
| auto* swizzle = b.Swizzle(ty.vec4<f32>(), var, {3, 2, 1, 0}); | |
| auto indices = Vector<uint32_t, 4>{4, 3, 2, 1}; | |
| swizzle->SetIndices(std::move(indices)); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:4:20 error: swizzle: invalid index value | |
| %3:vec4<f32> = swizzle %2, wzy | |
| ^^^^^^^ | |
| :2:3 note: in block | |
| $B1: { | |
| ^^^ | |
| note: # Disassembly | |
| %my_func = func():void { | |
| $B1: { | |
| %2:ptr<function, vec4<f32>, read_write> = var | |
| %3:vec4<f32> = swizzle %2, wzy | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, OverrideWithoutCapability) { | |
| b.Append(mod.root_block, [&] { b.Override("a", 1_u); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:12 error: override: root block: invalid instruction: tint::core::ir::Override | |
| %a:u32 = override, 1u @id(0) | |
| ^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %a:u32 = override, 1u @id(0) | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, InstructionInRootBlockWithoutOverrideCap) { | |
| b.Append(mod.root_block, [&] { b.Add(ty.u32(), 3_u, 2_u); }); | |
| auto res = ir::Validate(mod); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:3 error: binary: root block: invalid instruction: tint::core::ir::CoreBinary | |
| %1:u32 = add 3u, 2u | |
| ^^^^^^^^^^^^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:u32 = add 3u, 2u | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, OverrideWithCapability) { | |
| b.Append(mod.root_block, [&] { b.Override(ty.u32()); }); | |
| auto res = ir::Validate(mod, core::ir::Capabilities{core::ir::Capability::kAllowOverrides}); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, OverrideWithValue) { | |
| b.Append(mod.root_block, [&] { | |
| auto* z = b.Override(ty.u32()); | |
| z->SetOverrideId(OverrideId{2}); | |
| auto* init = b.Add(ty.u32(), z, 2_u); | |
| b.Override("a", init); | |
| }); | |
| auto res = ir::Validate(mod, core::ir::Capabilities{core::ir::Capability::kAllowOverrides}); | |
| ASSERT_EQ(res, Success); | |
| } | |
| TEST_F(IR_ValidatorTest, OverrideWithInvalidType) { | |
| b.Append(mod.root_block, [&] { b.Override(ty.vec3<u32>()); }); | |
| auto res = ir::Validate(mod, core::ir::Capabilities{core::ir::Capability::kAllowOverrides}); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:18 error: override: override type 'vec3<u32>' is not a scalar | |
| %1:vec3<u32> = override @id(0) | |
| ^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:vec3<u32> = override @id(0) | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, OverrideWithMismatchedInitializerType) { | |
| b.Append(mod.root_block, [&] { | |
| auto* init = b.Constant(1_i); | |
| auto* o = b.Override(ty.u32()); | |
| o->SetInitializer(init); | |
| }); | |
| auto res = ir::Validate(mod, core::ir::Capabilities{core::ir::Capability::kAllowOverrides}); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:12 error: override: override type 'u32' does not match initializer type 'i32' | |
| %1:u32 = override, 1i @id(0) | |
| ^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:u32 = override, 1i @id(0) | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, OverrideDuplicateId) { | |
| b.Append(mod.root_block, [&] { | |
| auto* o = b.Override(ty.u32()); | |
| o->SetOverrideId(OverrideId{2}); | |
| auto* o2 = b.Override(ty.i32()); | |
| o2->SetOverrideId(OverrideId{2}); | |
| }); | |
| auto res = ir::Validate(mod, core::ir::Capabilities{core::ir::Capability::kAllowOverrides}); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:3:12 error: override: duplicate override id encountered: 2 | |
| %2:i32 = override @id(2) | |
| ^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:u32 = override @id(2) | |
| %2:i32 = override @id(2) | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, InstructionInRootBlockOnlyUsedInRootBlock) { | |
| core::ir::Value* init = nullptr; | |
| b.Append(mod.root_block, [&] { | |
| auto* z = b.Override(ty.u32()); | |
| z->SetOverrideId(OverrideId{2}); | |
| init = b.Add(ty.u32(), z, 2_u)->Result(0); | |
| b.Override("a", init); | |
| }); | |
| auto* f = b.Function("my_func", ty.void_()); | |
| b.Append(f->Block(), [&] { | |
| b.Add(ty.u32(), init, 2_u); | |
| b.Return(f); | |
| }); | |
| auto res = ir::Validate(mod, core::ir::Capabilities{core::ir::Capability::kAllowOverrides}); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ( | |
| res.Failure().reason.Str(), | |
| R"(:3:3 error: binary: root block: instruction used outside of root block tint::core::ir::CoreBinary | |
| %2:u32 = add %1, 2u | |
| ^^^^^^^^^^^^^^^^^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %1:u32 = override @id(2) | |
| %2:u32 = add %1, 2u | |
| %a:u32 = override, %2 @id(0) | |
| } | |
| %my_func = func():void { | |
| $B2: { | |
| %5:u32 = add %2, 2u | |
| ret | |
| } | |
| } | |
| )"); | |
| } | |
| TEST_F(IR_ValidatorTest, OverrideArrayInvalidValue) { | |
| core::ir::Override* o = nullptr; | |
| b.Append(mod.root_block, [&] { | |
| o = b.Override(ty.u32()); | |
| auto* c1 = ty.Get<core::ir::type::ValueArrayCount>(o->Result(0)); | |
| auto* a1 = ty.Get<core::type::Array>(ty.i32(), c1, 4u, 4u, 4u, 4u); | |
| b.Var("a", ty.ptr(workgroup, a1, read_write)); | |
| }); | |
| o->Destroy(); | |
| auto res = ir::Validate(mod, core::ir::Capabilities{core::ir::Capability::kAllowOverrides}); | |
| ASSERT_NE(res, Success); | |
| EXPECT_EQ(res.Failure().reason.Str(), | |
| R"(:2:51 error: var: %2 is not in scope | |
| %a:ptr<workgroup, array<i32, %2>, read_write> = var | |
| ^^^ | |
| :1:1 note: in block | |
| $B1: { # root | |
| ^^^ | |
| note: # Disassembly | |
| $B1: { # root | |
| %a:ptr<workgroup, array<i32, %2>, read_write> = var | |
| } | |
| )"); | |
| } | |
| } // namespace | |
| } // namespace tint::core::ir |