diff options
Diffstat (limited to 'meta')
| -rw-r--r-- | meta/recipes-graphics/vulkan/vulkan-samples/0001-Qualify-move-as-std-move.patch | 405 | ||||
| -rw-r--r-- | meta/recipes-graphics/vulkan/vulkan-samples_git.bb | 1 |
2 files changed, 406 insertions, 0 deletions
diff --git a/meta/recipes-graphics/vulkan/vulkan-samples/0001-Qualify-move-as-std-move.patch b/meta/recipes-graphics/vulkan/vulkan-samples/0001-Qualify-move-as-std-move.patch new file mode 100644 index 0000000000..80ee521499 --- /dev/null +++ b/meta/recipes-graphics/vulkan/vulkan-samples/0001-Qualify-move-as-std-move.patch @@ -0,0 +1,405 @@ +From 9e061b12b9305eee96a4d3129b646c244cc02347 Mon Sep 17 00:00:00 2001 +From: Khem Raj <raj.khem@gmail.com> +Date: Sun, 14 Aug 2022 19:16:45 -0700 +Subject: [PATCH] Qualify move as std::move + +Seeing errors like below with clang-15 + +spirv_common.hpp:692:19: error: unqualified call to std::move + +squashed Backport of following upstream commits + +https://github.com/KhronosGroup/SPIRV-Cross/commit/44c3333a1c315ead00c24f7aef5fa8a7ccf49299 +https://github.com/KhronosGroup/SPIRV-Cross/commit/0eda71c40936586ea812d0d20d93c11a3e9af192 + +Upstream-Status: Backport [https://github.com/KhronosGroup/SPIRV-Cross/commit/0eda71c40936586ea812d0d20d93c11a3e9af192] +Signed-off-by: Khem Raj <raj.khem@gmail.com> +--- + main.cpp | 38 +++++++++++++++++++------------------- + spirv_common.hpp | 2 +- + spirv_cpp.hpp | 2 +- + spirv_cross.cpp | 18 +++++++++--------- + spirv_glsl.cpp | 2 +- + spirv_glsl.hpp | 2 +- + spirv_hlsl.cpp | 4 ++-- + spirv_hlsl.hpp | 2 +- + spirv_msl.cpp | 2 +- + spirv_parser.cpp | 4 ++-- + spirv_reflect.hpp | 2 +- + 11 files changed, 39 insertions(+), 39 deletions(-) + +diff --git a/main.cpp b/main.cpp +index 78991094..581c5e3b 100644 +--- a/main.cpp ++++ b/main.cpp +@@ -65,7 +65,7 @@ struct CLICallbacks + struct CLIParser + { + CLIParser(CLICallbacks cbs_, int argc_, char *argv_[]) +- : cbs(move(cbs_)) ++ : cbs(std::move(cbs_)) + , argc(argc_) + , argv(argv_) + { +@@ -722,7 +722,7 @@ static int main_inner(int argc, char *argv[]) + auto old_name = parser.next_string(); + auto new_name = parser.next_string(); + auto model = stage_to_execution_model(parser.next_string()); +- args.entry_point_rename.push_back({ old_name, new_name, move(model) }); ++ args.entry_point_rename.push_back({ old_name, new_name, std::move(model) }); + }); + cbs.add("--entry", [&args](CLIParser &parser) { args.entry = parser.next_string(); }); + cbs.add("--stage", [&args](CLIParser &parser) { args.entry_stage = parser.next_string(); }); +@@ -731,20 +731,20 @@ static int main_inner(int argc, char *argv[]) + HLSLVertexAttributeRemap remap; + remap.location = parser.next_uint(); + remap.semantic = parser.next_string(); +- args.hlsl_attr_remap.push_back(move(remap)); ++ args.hlsl_attr_remap.push_back(std::move(remap)); + }); + + cbs.add("--remap", [&args](CLIParser &parser) { + string src = parser.next_string(); + string dst = parser.next_string(); + uint32_t components = parser.next_uint(); +- args.remaps.push_back({ move(src), move(dst), components }); ++ args.remaps.push_back({ std::move(src), std::move(dst), components }); + }); + + cbs.add("--remap-variable-type", [&args](CLIParser &parser) { + string var_name = parser.next_string(); + string new_type = parser.next_string(); +- args.variable_type_remaps.push_back({ move(var_name), move(new_type) }); ++ args.variable_type_remaps.push_back({ std::move(var_name), std::move(new_type) }); + }); + + cbs.add("--rename-interface-variable", [&args](CLIParser &parser) { +@@ -757,18 +757,18 @@ static int main_inner(int argc, char *argv[]) + + uint32_t loc = parser.next_uint(); + string var_name = parser.next_string(); +- args.interface_variable_renames.push_back({ cls, loc, move(var_name) }); ++ args.interface_variable_renames.push_back({ cls, loc, std::move(var_name) }); + }); + + cbs.add("--pls-in", [&args](CLIParser &parser) { + auto fmt = pls_format(parser.next_string()); + auto name = parser.next_string(); +- args.pls_in.push_back({ move(fmt), move(name) }); ++ args.pls_in.push_back({ std::move(fmt), std::move(name) }); + }); + cbs.add("--pls-out", [&args](CLIParser &parser) { + auto fmt = pls_format(parser.next_string()); + auto name = parser.next_string(); +- args.pls_out.push_back({ move(fmt), move(name) }); ++ args.pls_out.push_back({ std::move(fmt), std::move(name) }); + }); + cbs.add("--shader-model", [&args](CLIParser &parser) { + args.shader_model = parser.next_uint(); +@@ -788,7 +788,7 @@ static int main_inner(int argc, char *argv[]) + cbs.default_handler = [&args](const char *value) { args.input = value; }; + cbs.error_handler = [] { print_help(); }; + +- CLIParser parser{ move(cbs), argc - 1, argv + 1 }; ++ CLIParser parser{ std::move(cbs), argc - 1, argv + 1 }; + if (!parser.parse()) + { + return EXIT_FAILURE; +@@ -808,14 +808,14 @@ static int main_inner(int argc, char *argv[]) + auto spirv_file = read_spirv_file(args.input); + if (spirv_file.empty()) + return EXIT_FAILURE; +- Parser spirv_parser(move(spirv_file)); ++ Parser spirv_parser(std::move(spirv_file)); + + spirv_parser.parse(); + + // Special case reflection because it has little to do with the path followed by code-outputting compilers + if (!args.reflect.empty()) + { +- CompilerReflection compiler(move(spirv_parser.get_parsed_ir())); ++ CompilerReflection compiler(std::move(spirv_parser.get_parsed_ir())); + compiler.set_format(args.reflect); + auto json = compiler.compile(); + if (args.output) +@@ -831,13 +831,13 @@ static int main_inner(int argc, char *argv[]) + + if (args.cpp) + { +- compiler.reset(new CompilerCPP(move(spirv_parser.get_parsed_ir()))); ++ compiler.reset(new CompilerCPP(std::move(spirv_parser.get_parsed_ir()))); + if (args.cpp_interface_name) + static_cast<CompilerCPP *>(compiler.get())->set_interface_name(args.cpp_interface_name); + } + else if (args.msl) + { +- compiler.reset(new CompilerMSL(move(spirv_parser.get_parsed_ir()))); ++ compiler.reset(new CompilerMSL(std::move(spirv_parser.get_parsed_ir()))); + + auto *msl_comp = static_cast<CompilerMSL *>(compiler.get()); + auto msl_opts = msl_comp->get_msl_options(); +@@ -850,13 +850,13 @@ static int main_inner(int argc, char *argv[]) + msl_comp->set_msl_options(msl_opts); + } + else if (args.hlsl) +- compiler.reset(new CompilerHLSL(move(spirv_parser.get_parsed_ir()))); ++ compiler.reset(new CompilerHLSL(std::move(spirv_parser.get_parsed_ir()))); + else + { + combined_image_samplers = !args.vulkan_semantics; + if (!args.vulkan_semantics) + build_dummy_sampler = true; +- compiler.reset(new CompilerGLSL(move(spirv_parser.get_parsed_ir()))); ++ compiler.reset(new CompilerGLSL(std::move(spirv_parser.get_parsed_ir()))); + } + + if (!args.variable_type_remaps.empty()) +@@ -867,7 +867,7 @@ static int main_inner(int argc, char *argv[]) + out = remap.new_variable_type; + }; + +- compiler->set_variable_type_remap_callback(move(remap_cb)); ++ compiler->set_variable_type_remap_callback(std::move(remap_cb)); + } + + for (auto &rename : args.entry_point_rename) +@@ -1019,7 +1019,7 @@ static int main_inner(int argc, char *argv[]) + { + auto active = compiler->get_active_interface_variables(); + res = compiler->get_shader_resources(active); +- compiler->set_enabled_interface_variables(move(active)); ++ compiler->set_enabled_interface_variables(std::move(active)); + } + else + res = compiler->get_shader_resources(); +@@ -1034,7 +1034,7 @@ static int main_inner(int argc, char *argv[]) + + auto pls_inputs = remap_pls(args.pls_in, res.stage_inputs, &res.subpass_inputs); + auto pls_outputs = remap_pls(args.pls_out, res.stage_outputs, nullptr); +- compiler->remap_pixel_local_storage(move(pls_inputs), move(pls_outputs)); ++ compiler->remap_pixel_local_storage(std::move(pls_inputs), std::move(pls_outputs)); + + for (auto &ext : args.extensions) + compiler->require_extension(ext); +@@ -1101,7 +1101,7 @@ static int main_inner(int argc, char *argv[]) + for (uint32_t i = 0; i < args.iterations; i++) + { + if (args.hlsl) +- glsl = static_cast<CompilerHLSL *>(compiler.get())->compile(move(args.hlsl_attr_remap)); ++ glsl = static_cast<CompilerHLSL *>(compiler.get())->compile(std::move(args.hlsl_attr_remap)); + else + glsl = compiler->compile(); + } +diff --git a/spirv_common.hpp b/spirv_common.hpp +index aa32142d..0daf5ad5 100644 +--- a/spirv_common.hpp ++++ b/spirv_common.hpp +@@ -536,7 +536,7 @@ struct SPIRExpression : IVariant + + // Only created by the backend target to avoid creating tons of temporaries. + SPIRExpression(std::string expr, uint32_t expression_type_, bool immutable_) +- : expression(move(expr)) ++ : expression(std::move(expr)) + , expression_type(expression_type_) + , immutable(immutable_) + { +diff --git a/spirv_cpp.hpp b/spirv_cpp.hpp +index bcdb669b..b4da84b9 100644 +--- a/spirv_cpp.hpp ++++ b/spirv_cpp.hpp +@@ -27,7 +27,7 @@ class CompilerCPP : public CompilerGLSL + { + public: + explicit CompilerCPP(std::vector<uint32_t> spirv_) +- : CompilerGLSL(move(spirv_)) ++ : CompilerGLSL(std::move(spirv_)) + { + } + +diff --git a/spirv_cross.cpp b/spirv_cross.cpp +index 19bac301..d21dbd41 100644 +--- a/spirv_cross.cpp ++++ b/spirv_cross.cpp +@@ -28,16 +28,16 @@ using namespace spirv_cross; + + Compiler::Compiler(vector<uint32_t> ir_) + { +- Parser parser(move(ir_)); ++ Parser parser(std::move(ir_)); + parser.parse(); +- set_ir(move(parser.get_parsed_ir())); ++ set_ir(std::move(parser.get_parsed_ir())); + } + + Compiler::Compiler(const uint32_t *ir_, size_t word_count) + { + Parser parser(ir_, word_count); + parser.parse(); +- set_ir(move(parser.get_parsed_ir())); ++ set_ir(std::move(parser.get_parsed_ir())); + } + + Compiler::Compiler(const ParsedIR &ir_) +@@ -47,12 +47,12 @@ Compiler::Compiler(const ParsedIR &ir_) + + Compiler::Compiler(ParsedIR &&ir_) + { +- set_ir(move(ir_)); ++ set_ir(std::move(ir_)); + } + + void Compiler::set_ir(ParsedIR &&ir_) + { +- ir = move(ir_); ++ ir = std::move(ir_); + parse_fixup(); + } + +@@ -716,7 +716,7 @@ unordered_set<uint32_t> Compiler::get_active_interface_variables() const + + void Compiler::set_enabled_interface_variables(std::unordered_set<uint32_t> active_variables) + { +- active_interface_variables = move(active_variables); ++ active_interface_variables = std::move(active_variables); + check_active_interface_variables = true; + } + +@@ -2163,7 +2163,7 @@ void Compiler::CombinedImageSamplerHandler::push_remap_parameters(const SPIRFunc + unordered_map<uint32_t, uint32_t> remapping; + for (uint32_t i = 0; i < length; i++) + remapping[func.arguments[i].id] = remap_parameter(args[i]); +- parameter_remapping.push(move(remapping)); ++ parameter_remapping.push(std::move(remapping)); + } + + void Compiler::CombinedImageSamplerHandler::pop_remap_parameters() +@@ -3611,7 +3611,7 @@ void Compiler::analyze_image_and_sampler_usage() + + CombinedImageSamplerUsageHandler handler(*this, dref_handler.dref_combined_samplers); + traverse_all_reachable_opcodes(get<SPIRFunction>(ir.default_entry_point), handler); +- comparison_ids = move(handler.comparison_ids); ++ comparison_ids = std::move(handler.comparison_ids); + need_subpass_input = handler.need_subpass_input; + + // Forward information from separate images and samplers into combined image samplers. +@@ -3650,7 +3650,7 @@ void Compiler::build_function_control_flow_graphs_and_analyze() + CFGBuilder handler(*this); + handler.function_cfgs[ir.default_entry_point].reset(new CFG(*this, get<SPIRFunction>(ir.default_entry_point))); + traverse_all_reachable_opcodes(get<SPIRFunction>(ir.default_entry_point), handler); +- function_cfgs = move(handler.function_cfgs); ++ function_cfgs = std::move(handler.function_cfgs); + + for (auto &f : function_cfgs) + { +diff --git a/spirv_glsl.cpp b/spirv_glsl.cpp +index a8855987..fabbb105 100644 +--- a/spirv_glsl.cpp ++++ b/spirv_glsl.cpp +@@ -6876,7 +6876,7 @@ void CompilerGLSL::emit_instruction(const Instruction &instruction) + bool ptr_chain = opcode == OpPtrAccessChain; + auto e = access_chain(ops[2], &ops[3], length - 3, get<SPIRType>(ops[0]), &meta, ptr_chain); + +- auto &expr = set<SPIRExpression>(ops[1], move(e), ops[0], should_forward(ops[2])); ++ auto &expr = set<SPIRExpression>(ops[1], std::move(e), ops[0], should_forward(ops[2])); + + auto *backing_variable = maybe_get_backing_variable(ops[2]); + expr.loaded_from = backing_variable ? backing_variable->self : ops[2]; +diff --git a/spirv_glsl.hpp b/spirv_glsl.hpp +index caf0ad3b..aac1196e 100644 +--- a/spirv_glsl.hpp ++++ b/spirv_glsl.hpp +@@ -138,7 +138,7 @@ public: + } + + explicit CompilerGLSL(std::vector<uint32_t> spirv_) +- : Compiler(move(spirv_)) ++ : Compiler(std::move(spirv_)) + { + init(); + } +diff --git a/spirv_hlsl.cpp b/spirv_hlsl.cpp +index a5b6d2dc..0933017e 100644 +--- a/spirv_hlsl.cpp ++++ b/spirv_hlsl.cpp +@@ -2028,7 +2028,7 @@ void CompilerHLSL::emit_function_prototype(SPIRFunction &func, const Bitset &ret + out_argument += " "; + out_argument += "SPIRV_Cross_return_value"; + out_argument += type_to_array_glsl(type); +- arglist.push_back(move(out_argument)); ++ arglist.push_back(std::move(out_argument)); + } + + for (auto &arg : func.arguments) +@@ -4553,7 +4553,7 @@ void CompilerHLSL::require_texture_query_variant(const SPIRType &type) + + string CompilerHLSL::compile(std::vector<HLSLVertexAttributeRemap> vertex_attributes) + { +- remap_vertex_attributes = move(vertex_attributes); ++ remap_vertex_attributes = std::move(vertex_attributes); + return compile(); + } + +diff --git a/spirv_hlsl.hpp b/spirv_hlsl.hpp +index b2b60fca..3503c674 100644 +--- a/spirv_hlsl.hpp ++++ b/spirv_hlsl.hpp +@@ -63,7 +63,7 @@ public: + }; + + explicit CompilerHLSL(std::vector<uint32_t> spirv_) +- : CompilerGLSL(move(spirv_)) ++ : CompilerGLSL(std::move(spirv_)) + { + } + +diff --git a/spirv_msl.cpp b/spirv_msl.cpp +index 0e1e733d..fbfcdba5 100644 +--- a/spirv_msl.cpp ++++ b/spirv_msl.cpp +@@ -32,7 +32,7 @@ static const uint32_t k_aux_mbr_idx_swizzle_const = 0u; + + CompilerMSL::CompilerMSL(vector<uint32_t> spirv_, vector<MSLVertexAttr> *p_vtx_attrs, + vector<MSLResourceBinding> *p_res_bindings) +- : CompilerGLSL(move(spirv_)) ++ : CompilerGLSL(std::move(spirv_)) + { + if (p_vtx_attrs) + for (auto &va : *p_vtx_attrs) +diff --git a/spirv_parser.cpp b/spirv_parser.cpp +index 1725b4ca..0fcd7691 100644 +--- a/spirv_parser.cpp ++++ b/spirv_parser.cpp +@@ -24,7 +24,7 @@ namespace spirv_cross + { + Parser::Parser(std::vector<uint32_t> spirv) + { +- ir.spirv = move(spirv); ++ ir.spirv = std::move(spirv); + } + + Parser::Parser(const uint32_t *spirv_data, size_t word_count) +@@ -223,7 +223,7 @@ void Parser::parse(const Instruction &instruction) + case OpExtension: + { + auto ext = extract_string(ir.spirv, instruction.offset); +- ir.declared_extensions.push_back(move(ext)); ++ ir.declared_extensions.push_back(std::move(ext)); + break; + } + +diff --git a/spirv_reflect.hpp b/spirv_reflect.hpp +index 13b5b431..f5c6a6ff 100644 +--- a/spirv_reflect.hpp ++++ b/spirv_reflect.hpp +@@ -34,7 +34,7 @@ class CompilerReflection : public CompilerGLSL + + public: + explicit CompilerReflection(std::vector<uint32_t> spirv_) +- : Parent(move(spirv_)) ++ : Parent(std::move(spirv_)) + { + options.vulkan_semantics = true; + } +-- +2.37.2 + diff --git a/meta/recipes-graphics/vulkan/vulkan-samples_git.bb b/meta/recipes-graphics/vulkan/vulkan-samples_git.bb index 41cb4a437d..54994c683d 100644 --- a/meta/recipes-graphics/vulkan/vulkan-samples_git.bb +++ b/meta/recipes-graphics/vulkan/vulkan-samples_git.bb @@ -9,6 +9,7 @@ SRC_URI = "gitsm://github.com/KhronosGroup/Vulkan-Samples.git;branch=master;prot file://0001-CMakeLists.txt-do-not-hardcode-lib-as-installation-t.patch \ file://debugfix.patch \ file://0001-framework-core-hpp_vulkan_resource.h-add-header-incl.patch \ + file://0001-Qualify-move-as-std-move.patch;patchdir=third_party/spirv-cross \ " UPSTREAM_CHECK_COMMITS = "1" |