mirror of
https://github.com/KhronosGroup/SPIRV-Tools
synced 2024-11-22 19:50:05 +00:00
edaf51038b
* linker: Recalculate interface variables By resolving extern symbols Entry Points might access variables they hadn't declared before. * test/linker: add test to verify linked spir-vs importing functions validate Without the fix Validate will complain about: "ERROR: 9: Interface variable id <5> is used by entry point 'bar' id <1>, but is not listed as an interface\n %5 = OpVariable %_ptr_Input_v3uint Input\n"
827 lines
34 KiB
C++
827 lines
34 KiB
C++
// Copyright (c) 2017 Pierre Moreau
|
||
//
|
||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||
// you may not use this file except in compliance with the License.
|
||
// You may obtain a copy of the License at
|
||
//
|
||
// http://www.apache.org/licenses/LICENSE-2.0
|
||
//
|
||
// Unless required by applicable law or agreed to in writing, software
|
||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
// See the License for the specific language governing permissions and
|
||
// limitations under the License.
|
||
|
||
#include "spirv-tools/linker.hpp"
|
||
|
||
#include <algorithm>
|
||
#include <cstdio>
|
||
#include <cstring>
|
||
#include <iostream>
|
||
#include <memory>
|
||
#include <numeric>
|
||
#include <string>
|
||
#include <unordered_map>
|
||
#include <unordered_set>
|
||
#include <utility>
|
||
#include <vector>
|
||
|
||
#include "source/assembly_grammar.h"
|
||
#include "source/diagnostic.h"
|
||
#include "source/opt/build_module.h"
|
||
#include "source/opt/compact_ids_pass.h"
|
||
#include "source/opt/decoration_manager.h"
|
||
#include "source/opt/ir_loader.h"
|
||
#include "source/opt/pass_manager.h"
|
||
#include "source/opt/remove_duplicates_pass.h"
|
||
#include "source/opt/remove_unused_interface_variables_pass.h"
|
||
#include "source/opt/type_manager.h"
|
||
#include "source/spirv_constant.h"
|
||
#include "source/spirv_target_env.h"
|
||
#include "source/util/make_unique.h"
|
||
#include "source/util/string_utils.h"
|
||
#include "spirv-tools/libspirv.hpp"
|
||
|
||
namespace spvtools {
|
||
namespace {
|
||
|
||
using opt::Instruction;
|
||
using opt::IRContext;
|
||
using opt::Module;
|
||
using opt::PassManager;
|
||
using opt::RemoveDuplicatesPass;
|
||
using opt::analysis::DecorationManager;
|
||
using opt::analysis::DefUseManager;
|
||
using opt::analysis::Type;
|
||
using opt::analysis::TypeManager;
|
||
|
||
// Stores various information about an imported or exported symbol.
|
||
struct LinkageSymbolInfo {
|
||
SpvId id; // ID of the symbol
|
||
SpvId type_id; // ID of the type of the symbol
|
||
std::string name; // unique name defining the symbol and used for matching
|
||
// imports and exports together
|
||
std::vector<SpvId> parameter_ids; // ID of the parameters of the symbol, if
|
||
// it is a function
|
||
};
|
||
struct LinkageEntry {
|
||
LinkageSymbolInfo imported_symbol;
|
||
LinkageSymbolInfo exported_symbol;
|
||
|
||
LinkageEntry(const LinkageSymbolInfo& import_info,
|
||
const LinkageSymbolInfo& export_info)
|
||
: imported_symbol(import_info), exported_symbol(export_info) {}
|
||
};
|
||
using LinkageTable = std::vector<LinkageEntry>;
|
||
|
||
// Shifts the IDs used in each binary of |modules| so that they occupy a
|
||
// disjoint range from the other binaries, and compute the new ID bound which
|
||
// is returned in |max_id_bound|.
|
||
//
|
||
// Both |modules| and |max_id_bound| should not be null, and |modules| should
|
||
// not be empty either. Furthermore |modules| should not contain any null
|
||
// pointers.
|
||
spv_result_t ShiftIdsInModules(const MessageConsumer& consumer,
|
||
std::vector<opt::Module*>* modules,
|
||
uint32_t* max_id_bound);
|
||
|
||
// Generates the header for the linked module and returns it in |header|.
|
||
//
|
||
// |header| should not be null, |modules| should not be empty and pointers
|
||
// should be non-null. |max_id_bound| should be strictly greater than 0.
|
||
spv_result_t GenerateHeader(const MessageConsumer& consumer,
|
||
const std::vector<opt::Module*>& modules,
|
||
uint32_t max_id_bound, opt::ModuleHeader* header);
|
||
|
||
// Merge all the modules from |in_modules| into a single module owned by
|
||
// |linked_context|.
|
||
//
|
||
// |linked_context| should not be null.
|
||
spv_result_t MergeModules(const MessageConsumer& consumer,
|
||
const std::vector<Module*>& in_modules,
|
||
const AssemblyGrammar& grammar,
|
||
IRContext* linked_context);
|
||
|
||
// Compute all pairs of import and export and return it in |linkings_to_do|.
|
||
//
|
||
// |linkings_to_do should not be null. Built-in symbols will be ignored.
|
||
//
|
||
// TODO(pierremoreau): Linkage attributes applied by a group decoration are
|
||
// currently not handled. (You could have a group being
|
||
// applied to a single ID.)
|
||
// TODO(pierremoreau): What should be the proper behaviour with built-in
|
||
// symbols?
|
||
spv_result_t GetImportExportPairs(const MessageConsumer& consumer,
|
||
const opt::IRContext& linked_context,
|
||
const DefUseManager& def_use_manager,
|
||
const DecorationManager& decoration_manager,
|
||
bool allow_partial_linkage,
|
||
LinkageTable* linkings_to_do);
|
||
|
||
// Checks that for each pair of import and export, the import and export have
|
||
// the same type as well as the same decorations.
|
||
//
|
||
// TODO(pierremoreau): Decorations on functions parameters are currently not
|
||
// checked.
|
||
spv_result_t CheckImportExportCompatibility(const MessageConsumer& consumer,
|
||
const LinkageTable& linkings_to_do,
|
||
opt::IRContext* context);
|
||
|
||
// Remove linkage specific instructions, such as prototypes of imported
|
||
// functions, declarations of imported variables, import (and export if
|
||
// necessary) linkage attributes.
|
||
//
|
||
// |linked_context| and |decoration_manager| should not be null, and the
|
||
// 'RemoveDuplicatePass' should be run first.
|
||
//
|
||
// TODO(pierremoreau): Linkage attributes applied by a group decoration are
|
||
// currently not handled. (You could have a group being
|
||
// applied to a single ID.)
|
||
spv_result_t RemoveLinkageSpecificInstructions(
|
||
const MessageConsumer& consumer, const LinkerOptions& options,
|
||
const LinkageTable& linkings_to_do, DecorationManager* decoration_manager,
|
||
opt::IRContext* linked_context);
|
||
|
||
// Verify that the unique ids of each instruction in |linked_context| (i.e. the
|
||
// merged module) are truly unique. Does not check the validity of other ids
|
||
spv_result_t VerifyIds(const MessageConsumer& consumer,
|
||
opt::IRContext* linked_context);
|
||
|
||
// Verify that the universal limits are not crossed, and warn the user
|
||
// otherwise.
|
||
//
|
||
// TODO(pierremoreau):
|
||
// - Verify against the limits of the environment (e.g. Vulkan limits if
|
||
// consuming vulkan1.x)
|
||
spv_result_t VerifyLimits(const MessageConsumer& consumer,
|
||
const opt::IRContext& linked_context);
|
||
|
||
spv_result_t ShiftIdsInModules(const MessageConsumer& consumer,
|
||
std::vector<opt::Module*>* modules,
|
||
uint32_t* max_id_bound) {
|
||
spv_position_t position = {};
|
||
|
||
if (modules == nullptr)
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA)
|
||
<< "|modules| of ShiftIdsInModules should not be null.";
|
||
if (modules->empty())
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA)
|
||
<< "|modules| of ShiftIdsInModules should not be empty.";
|
||
if (max_id_bound == nullptr)
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA)
|
||
<< "|max_id_bound| of ShiftIdsInModules should not be null.";
|
||
|
||
const size_t id_bound =
|
||
std::accumulate(modules->begin(), modules->end(), static_cast<size_t>(1),
|
||
[](const size_t& accumulation, opt::Module* module) {
|
||
return accumulation + module->IdBound() - 1u;
|
||
});
|
||
if (id_bound > std::numeric_limits<uint32_t>::max())
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA)
|
||
<< "Too many IDs (" << id_bound
|
||
<< "): combining all modules would overflow the 32-bit word of the "
|
||
"SPIR-V header.";
|
||
|
||
*max_id_bound = static_cast<uint32_t>(id_bound);
|
||
|
||
uint32_t id_offset = modules->front()->IdBound() - 1u;
|
||
for (auto module_iter = modules->begin() + 1; module_iter != modules->end();
|
||
++module_iter) {
|
||
Module* module = *module_iter;
|
||
module->ForEachInst([&id_offset](Instruction* insn) {
|
||
insn->ForEachId([&id_offset](uint32_t* id) { *id += id_offset; });
|
||
});
|
||
id_offset += module->IdBound() - 1u;
|
||
|
||
// Invalidate the DefUseManager
|
||
module->context()->InvalidateAnalyses(opt::IRContext::kAnalysisDefUse);
|
||
}
|
||
|
||
return SPV_SUCCESS;
|
||
}
|
||
|
||
spv_result_t GenerateHeader(const MessageConsumer& consumer,
|
||
const std::vector<opt::Module*>& modules,
|
||
uint32_t max_id_bound, opt::ModuleHeader* header) {
|
||
spv_position_t position = {};
|
||
|
||
if (modules.empty())
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA)
|
||
<< "|modules| of GenerateHeader should not be empty.";
|
||
if (max_id_bound == 0u)
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA)
|
||
<< "|max_id_bound| of GenerateHeader should not be null.";
|
||
|
||
const uint32_t linked_version = modules.front()->version();
|
||
for (std::size_t i = 1; i < modules.size(); ++i) {
|
||
const uint32_t module_version = modules[i]->version();
|
||
if (module_version != linked_version)
|
||
return DiagnosticStream({0, 0, 1}, consumer, "", SPV_ERROR_INTERNAL)
|
||
<< "Conflicting SPIR-V versions: "
|
||
<< SPV_SPIRV_VERSION_MAJOR_PART(linked_version) << "."
|
||
<< SPV_SPIRV_VERSION_MINOR_PART(linked_version)
|
||
<< " (input modules 1 through " << i << ") vs "
|
||
<< SPV_SPIRV_VERSION_MAJOR_PART(module_version) << "."
|
||
<< SPV_SPIRV_VERSION_MINOR_PART(module_version)
|
||
<< " (input module " << (i + 1) << ").";
|
||
}
|
||
|
||
header->magic_number = SpvMagicNumber;
|
||
header->version = linked_version;
|
||
header->generator = SPV_GENERATOR_WORD(SPV_GENERATOR_KHRONOS_LINKER, 0);
|
||
header->bound = max_id_bound;
|
||
header->schema = 0u;
|
||
|
||
return SPV_SUCCESS;
|
||
}
|
||
|
||
spv_result_t MergeModules(const MessageConsumer& consumer,
|
||
const std::vector<Module*>& input_modules,
|
||
const AssemblyGrammar& grammar,
|
||
IRContext* linked_context) {
|
||
spv_position_t position = {};
|
||
|
||
if (linked_context == nullptr)
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA)
|
||
<< "|linked_module| of MergeModules should not be null.";
|
||
Module* linked_module = linked_context->module();
|
||
|
||
if (input_modules.empty()) return SPV_SUCCESS;
|
||
|
||
for (const auto& module : input_modules)
|
||
for (const auto& inst : module->capabilities())
|
||
linked_module->AddCapability(
|
||
std::unique_ptr<Instruction>(inst.Clone(linked_context)));
|
||
|
||
for (const auto& module : input_modules)
|
||
for (const auto& inst : module->extensions())
|
||
linked_module->AddExtension(
|
||
std::unique_ptr<Instruction>(inst.Clone(linked_context)));
|
||
|
||
for (const auto& module : input_modules)
|
||
for (const auto& inst : module->ext_inst_imports())
|
||
linked_module->AddExtInstImport(
|
||
std::unique_ptr<Instruction>(inst.Clone(linked_context)));
|
||
|
||
const Instruction* linked_memory_model_inst =
|
||
input_modules.front()->GetMemoryModel();
|
||
if (linked_memory_model_inst == nullptr) {
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY)
|
||
<< "Input module 1 is lacking an OpMemoryModel instruction.";
|
||
}
|
||
const uint32_t linked_addressing_model =
|
||
linked_memory_model_inst->GetSingleWordOperand(0u);
|
||
const uint32_t linked_memory_model =
|
||
linked_memory_model_inst->GetSingleWordOperand(1u);
|
||
|
||
for (std::size_t i = 1; i < input_modules.size(); ++i) {
|
||
const Module* module = input_modules[i];
|
||
const Instruction* memory_model_inst = module->GetMemoryModel();
|
||
if (memory_model_inst == nullptr)
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY)
|
||
<< "Input module " << (i + 1)
|
||
<< " is lacking an OpMemoryModel instruction.";
|
||
|
||
const uint32_t module_addressing_model =
|
||
memory_model_inst->GetSingleWordOperand(0u);
|
||
if (module_addressing_model != linked_addressing_model) {
|
||
spv_operand_desc linked_desc = nullptr, module_desc = nullptr;
|
||
grammar.lookupOperand(SPV_OPERAND_TYPE_ADDRESSING_MODEL,
|
||
linked_addressing_model, &linked_desc);
|
||
grammar.lookupOperand(SPV_OPERAND_TYPE_ADDRESSING_MODEL,
|
||
module_addressing_model, &module_desc);
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INTERNAL)
|
||
<< "Conflicting addressing models: " << linked_desc->name
|
||
<< " (input modules 1 through " << i << ") vs "
|
||
<< module_desc->name << " (input module " << (i + 1) << ").";
|
||
}
|
||
|
||
const uint32_t module_memory_model =
|
||
memory_model_inst->GetSingleWordOperand(1u);
|
||
if (module_memory_model != linked_memory_model) {
|
||
spv_operand_desc linked_desc = nullptr, module_desc = nullptr;
|
||
grammar.lookupOperand(SPV_OPERAND_TYPE_MEMORY_MODEL, linked_memory_model,
|
||
&linked_desc);
|
||
grammar.lookupOperand(SPV_OPERAND_TYPE_MEMORY_MODEL, module_memory_model,
|
||
&module_desc);
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INTERNAL)
|
||
<< "Conflicting memory models: " << linked_desc->name
|
||
<< " (input modules 1 through " << i << ") vs "
|
||
<< module_desc->name << " (input module " << (i + 1) << ").";
|
||
}
|
||
}
|
||
linked_module->SetMemoryModel(std::unique_ptr<Instruction>(
|
||
linked_memory_model_inst->Clone(linked_context)));
|
||
|
||
std::vector<std::pair<uint32_t, std::string>> entry_points;
|
||
for (const auto& module : input_modules)
|
||
for (const auto& inst : module->entry_points()) {
|
||
const uint32_t model = inst.GetSingleWordInOperand(0);
|
||
const std::string name = inst.GetInOperand(2).AsString();
|
||
const auto i = std::find_if(
|
||
entry_points.begin(), entry_points.end(),
|
||
[model, name](const std::pair<uint32_t, std::string>& v) {
|
||
return v.first == model && v.second == name;
|
||
});
|
||
if (i != entry_points.end()) {
|
||
spv_operand_desc desc = nullptr;
|
||
grammar.lookupOperand(SPV_OPERAND_TYPE_EXECUTION_MODEL, model, &desc);
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INTERNAL)
|
||
<< "The entry point \"" << name << "\", with execution model "
|
||
<< desc->name << ", was already defined.";
|
||
}
|
||
linked_module->AddEntryPoint(
|
||
std::unique_ptr<Instruction>(inst.Clone(linked_context)));
|
||
entry_points.emplace_back(model, name);
|
||
}
|
||
|
||
for (const auto& module : input_modules)
|
||
for (const auto& inst : module->execution_modes())
|
||
linked_module->AddExecutionMode(
|
||
std::unique_ptr<Instruction>(inst.Clone(linked_context)));
|
||
|
||
for (const auto& module : input_modules)
|
||
for (const auto& inst : module->debugs1())
|
||
linked_module->AddDebug1Inst(
|
||
std::unique_ptr<Instruction>(inst.Clone(linked_context)));
|
||
|
||
for (const auto& module : input_modules)
|
||
for (const auto& inst : module->debugs2())
|
||
linked_module->AddDebug2Inst(
|
||
std::unique_ptr<Instruction>(inst.Clone(linked_context)));
|
||
|
||
for (const auto& module : input_modules)
|
||
for (const auto& inst : module->debugs3())
|
||
linked_module->AddDebug3Inst(
|
||
std::unique_ptr<Instruction>(inst.Clone(linked_context)));
|
||
|
||
for (const auto& module : input_modules)
|
||
for (const auto& inst : module->ext_inst_debuginfo())
|
||
linked_module->AddExtInstDebugInfo(
|
||
std::unique_ptr<Instruction>(inst.Clone(linked_context)));
|
||
|
||
// If the generated module uses SPIR-V 1.1 or higher, add an
|
||
// OpModuleProcessed instruction about the linking step.
|
||
if (linked_module->version() >= SPV_SPIRV_VERSION_WORD(1, 1)) {
|
||
const std::string processed_string("Linked by SPIR-V Tools Linker");
|
||
std::vector<uint32_t> processed_words =
|
||
spvtools::utils::MakeVector(processed_string);
|
||
linked_module->AddDebug3Inst(std::unique_ptr<Instruction>(
|
||
new Instruction(linked_context, SpvOpModuleProcessed, 0u, 0u,
|
||
{{SPV_OPERAND_TYPE_LITERAL_STRING, processed_words}})));
|
||
}
|
||
|
||
for (const auto& module : input_modules)
|
||
for (const auto& inst : module->annotations())
|
||
linked_module->AddAnnotationInst(
|
||
std::unique_ptr<Instruction>(inst.Clone(linked_context)));
|
||
|
||
// TODO(pierremoreau): Since the modules have not been validate, should we
|
||
// expect SpvStorageClassFunction variables outside
|
||
// functions?
|
||
for (const auto& module : input_modules) {
|
||
for (const auto& inst : module->types_values()) {
|
||
linked_module->AddType(
|
||
std::unique_ptr<Instruction>(inst.Clone(linked_context)));
|
||
}
|
||
}
|
||
|
||
// Process functions and their basic blocks
|
||
for (const auto& module : input_modules) {
|
||
for (const auto& func : *module) {
|
||
std::unique_ptr<opt::Function> cloned_func(func.Clone(linked_context));
|
||
linked_module->AddFunction(std::move(cloned_func));
|
||
}
|
||
}
|
||
|
||
return SPV_SUCCESS;
|
||
}
|
||
|
||
spv_result_t GetImportExportPairs(const MessageConsumer& consumer,
|
||
const opt::IRContext& linked_context,
|
||
const DefUseManager& def_use_manager,
|
||
const DecorationManager& decoration_manager,
|
||
bool allow_partial_linkage,
|
||
LinkageTable* linkings_to_do) {
|
||
spv_position_t position = {};
|
||
|
||
if (linkings_to_do == nullptr)
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA)
|
||
<< "|linkings_to_do| of GetImportExportPairs should not be empty.";
|
||
|
||
std::vector<LinkageSymbolInfo> imports;
|
||
std::unordered_map<std::string, std::vector<LinkageSymbolInfo>> exports;
|
||
|
||
// Figure out the imports and exports
|
||
for (const auto& decoration : linked_context.annotations()) {
|
||
if (decoration.opcode() != SpvOpDecorate ||
|
||
decoration.GetSingleWordInOperand(1u) != SpvDecorationLinkageAttributes)
|
||
continue;
|
||
|
||
const SpvId id = decoration.GetSingleWordInOperand(0u);
|
||
// Ignore if the targeted symbol is a built-in
|
||
bool is_built_in = false;
|
||
for (const auto& id_decoration :
|
||
decoration_manager.GetDecorationsFor(id, false)) {
|
||
if (id_decoration->GetSingleWordInOperand(1u) == SpvDecorationBuiltIn) {
|
||
is_built_in = true;
|
||
break;
|
||
}
|
||
}
|
||
if (is_built_in) {
|
||
continue;
|
||
}
|
||
|
||
const uint32_t type = decoration.GetSingleWordInOperand(3u);
|
||
|
||
LinkageSymbolInfo symbol_info;
|
||
symbol_info.name = decoration.GetInOperand(2u).AsString();
|
||
symbol_info.id = id;
|
||
symbol_info.type_id = 0u;
|
||
|
||
// Retrieve the type of the current symbol. This information will be used
|
||
// when checking that the imported and exported symbols have the same
|
||
// types.
|
||
const Instruction* def_inst = def_use_manager.GetDef(id);
|
||
if (def_inst == nullptr)
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY)
|
||
<< "ID " << id << " is never defined:\n";
|
||
|
||
if (def_inst->opcode() == SpvOpVariable) {
|
||
symbol_info.type_id = def_inst->type_id();
|
||
} else if (def_inst->opcode() == SpvOpFunction) {
|
||
symbol_info.type_id = def_inst->GetSingleWordInOperand(1u);
|
||
|
||
// range-based for loop calls begin()/end(), but never cbegin()/cend(),
|
||
// which will not work here.
|
||
for (auto func_iter = linked_context.module()->cbegin();
|
||
func_iter != linked_context.module()->cend(); ++func_iter) {
|
||
if (func_iter->result_id() != id) continue;
|
||
func_iter->ForEachParam([&symbol_info](const Instruction* inst) {
|
||
symbol_info.parameter_ids.push_back(inst->result_id());
|
||
});
|
||
}
|
||
} else {
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY)
|
||
<< "Only global variables and functions can be decorated using"
|
||
<< " LinkageAttributes; " << id << " is neither of them.\n";
|
||
}
|
||
|
||
if (type == SpvLinkageTypeImport)
|
||
imports.push_back(symbol_info);
|
||
else if (type == SpvLinkageTypeExport)
|
||
exports[symbol_info.name].push_back(symbol_info);
|
||
}
|
||
|
||
// Find the import/export pairs
|
||
for (const auto& import : imports) {
|
||
std::vector<LinkageSymbolInfo> possible_exports;
|
||
const auto& exp = exports.find(import.name);
|
||
if (exp != exports.end()) possible_exports = exp->second;
|
||
if (possible_exports.empty() && !allow_partial_linkage)
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY)
|
||
<< "Unresolved external reference to \"" << import.name << "\".";
|
||
else if (possible_exports.size() > 1u)
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY)
|
||
<< "Too many external references, " << possible_exports.size()
|
||
<< ", were found for \"" << import.name << "\".";
|
||
|
||
if (!possible_exports.empty())
|
||
linkings_to_do->emplace_back(import, possible_exports.front());
|
||
}
|
||
|
||
return SPV_SUCCESS;
|
||
}
|
||
|
||
spv_result_t CheckImportExportCompatibility(const MessageConsumer& consumer,
|
||
const LinkageTable& linkings_to_do,
|
||
opt::IRContext* context) {
|
||
spv_position_t position = {};
|
||
|
||
// Ensure the import and export types are the same.
|
||
const DecorationManager& decoration_manager = *context->get_decoration_mgr();
|
||
const TypeManager& type_manager = *context->get_type_mgr();
|
||
for (const auto& linking_entry : linkings_to_do) {
|
||
Type* imported_symbol_type =
|
||
type_manager.GetType(linking_entry.imported_symbol.type_id);
|
||
Type* exported_symbol_type =
|
||
type_manager.GetType(linking_entry.exported_symbol.type_id);
|
||
if (!(*imported_symbol_type == *exported_symbol_type))
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY)
|
||
<< "Type mismatch on symbol \""
|
||
<< linking_entry.imported_symbol.name
|
||
<< "\" between imported variable/function %"
|
||
<< linking_entry.imported_symbol.id
|
||
<< " and exported variable/function %"
|
||
<< linking_entry.exported_symbol.id << ".";
|
||
}
|
||
|
||
// Ensure the import and export decorations are similar
|
||
for (const auto& linking_entry : linkings_to_do) {
|
||
if (!decoration_manager.HaveTheSameDecorations(
|
||
linking_entry.imported_symbol.id, linking_entry.exported_symbol.id))
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY)
|
||
<< "Decorations mismatch on symbol \""
|
||
<< linking_entry.imported_symbol.name
|
||
<< "\" between imported variable/function %"
|
||
<< linking_entry.imported_symbol.id
|
||
<< " and exported variable/function %"
|
||
<< linking_entry.exported_symbol.id << ".";
|
||
// TODO(pierremoreau): Decorations on function parameters should probably
|
||
// match, except for FuncParamAttr if I understand the
|
||
// spec correctly.
|
||
// TODO(pierremoreau): Decorations on the function return type should
|
||
// match, except for FuncParamAttr.
|
||
}
|
||
|
||
return SPV_SUCCESS;
|
||
}
|
||
|
||
spv_result_t RemoveLinkageSpecificInstructions(
|
||
const MessageConsumer& consumer, const LinkerOptions& options,
|
||
const LinkageTable& linkings_to_do, DecorationManager* decoration_manager,
|
||
opt::IRContext* linked_context) {
|
||
spv_position_t position = {};
|
||
|
||
if (decoration_manager == nullptr)
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA)
|
||
<< "|decoration_manager| of RemoveLinkageSpecificInstructions "
|
||
"should not be empty.";
|
||
if (linked_context == nullptr)
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_DATA)
|
||
<< "|linked_module| of RemoveLinkageSpecificInstructions should not "
|
||
"be empty.";
|
||
|
||
// TODO(pierremoreau): Remove FuncParamAttr decorations of imported
|
||
// functions' return type.
|
||
|
||
// Remove prototypes of imported functions
|
||
for (const auto& linking_entry : linkings_to_do) {
|
||
for (auto func_iter = linked_context->module()->begin();
|
||
func_iter != linked_context->module()->end();) {
|
||
if (func_iter->result_id() == linking_entry.imported_symbol.id)
|
||
func_iter = func_iter.Erase();
|
||
else
|
||
++func_iter;
|
||
}
|
||
}
|
||
|
||
// Remove declarations of imported variables
|
||
for (const auto& linking_entry : linkings_to_do) {
|
||
auto next = linked_context->types_values_begin();
|
||
for (auto inst = next; inst != linked_context->types_values_end();
|
||
inst = next) {
|
||
++next;
|
||
if (inst->result_id() == linking_entry.imported_symbol.id) {
|
||
linked_context->KillInst(&*inst);
|
||
}
|
||
}
|
||
}
|
||
|
||
// If partial linkage is allowed, we need an efficient way to check whether
|
||
// an imported ID had a corresponding export symbol. As uses of the imported
|
||
// symbol have already been replaced by the exported symbol, use the exported
|
||
// symbol ID.
|
||
// TODO(pierremoreau): This will not work if the decoration is applied
|
||
// through a group, but the linker does not support that
|
||
// either.
|
||
std::unordered_set<SpvId> imports;
|
||
if (options.GetAllowPartialLinkage()) {
|
||
imports.reserve(linkings_to_do.size());
|
||
for (const auto& linking_entry : linkings_to_do)
|
||
imports.emplace(linking_entry.exported_symbol.id);
|
||
}
|
||
|
||
// Remove import linkage attributes
|
||
auto next = linked_context->annotation_begin();
|
||
for (auto inst = next; inst != linked_context->annotation_end();
|
||
inst = next) {
|
||
++next;
|
||
// If this is an import annotation:
|
||
// * if we do not allow partial linkage, remove all import annotations;
|
||
// * otherwise, remove the annotation only if there was a corresponding
|
||
// export.
|
||
if (inst->opcode() == SpvOpDecorate &&
|
||
inst->GetSingleWordOperand(1u) == SpvDecorationLinkageAttributes &&
|
||
inst->GetSingleWordOperand(3u) == SpvLinkageTypeImport &&
|
||
(!options.GetAllowPartialLinkage() ||
|
||
imports.find(inst->GetSingleWordOperand(0u)) != imports.end())) {
|
||
linked_context->KillInst(&*inst);
|
||
}
|
||
}
|
||
|
||
// Remove export linkage attributes if making an executable
|
||
if (!options.GetCreateLibrary()) {
|
||
next = linked_context->annotation_begin();
|
||
for (auto inst = next; inst != linked_context->annotation_end();
|
||
inst = next) {
|
||
++next;
|
||
if (inst->opcode() == SpvOpDecorate &&
|
||
inst->GetSingleWordOperand(1u) == SpvDecorationLinkageAttributes &&
|
||
inst->GetSingleWordOperand(3u) == SpvLinkageTypeExport) {
|
||
linked_context->KillInst(&*inst);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Remove Linkage capability if making an executable and partial linkage is
|
||
// not allowed
|
||
if (!options.GetCreateLibrary() && !options.GetAllowPartialLinkage()) {
|
||
for (auto& inst : linked_context->capabilities())
|
||
if (inst.GetSingleWordInOperand(0u) == SpvCapabilityLinkage) {
|
||
linked_context->KillInst(&inst);
|
||
// The RemoveDuplicatesPass did remove duplicated capabilities, so we
|
||
// now there aren’t more SpvCapabilityLinkage further down.
|
||
break;
|
||
}
|
||
}
|
||
|
||
return SPV_SUCCESS;
|
||
}
|
||
|
||
spv_result_t VerifyIds(const MessageConsumer& consumer,
|
||
opt::IRContext* linked_context) {
|
||
std::unordered_set<uint32_t> ids;
|
||
bool ok = true;
|
||
linked_context->module()->ForEachInst(
|
||
[&ids, &ok](const opt::Instruction* inst) {
|
||
ok &= ids.insert(inst->unique_id()).second;
|
||
});
|
||
|
||
if (!ok) {
|
||
consumer(SPV_MSG_INTERNAL_ERROR, "", {}, "Non-unique id in merged module");
|
||
return SPV_ERROR_INVALID_ID;
|
||
}
|
||
|
||
return SPV_SUCCESS;
|
||
}
|
||
|
||
spv_result_t VerifyLimits(const MessageConsumer& consumer,
|
||
const opt::IRContext& linked_context) {
|
||
spv_position_t position = {};
|
||
|
||
const uint32_t max_id_bound = linked_context.module()->id_bound();
|
||
if (max_id_bound >= SPV_LIMIT_RESULT_ID_BOUND)
|
||
DiagnosticStream({0u, 0u, 4u}, consumer, "", SPV_WARNING)
|
||
<< "The minimum limit of IDs, " << (SPV_LIMIT_RESULT_ID_BOUND - 1)
|
||
<< ", was exceeded:"
|
||
<< " " << max_id_bound << " is the current ID bound.\n"
|
||
<< "The resulting module might not be supported by all "
|
||
"implementations.";
|
||
|
||
size_t num_global_values = 0u;
|
||
for (const auto& inst : linked_context.module()->types_values()) {
|
||
num_global_values += inst.opcode() == SpvOpVariable;
|
||
}
|
||
if (num_global_values >= SPV_LIMIT_GLOBAL_VARIABLES_MAX)
|
||
DiagnosticStream(position, consumer, "", SPV_WARNING)
|
||
<< "The minimum limit of global values, "
|
||
<< (SPV_LIMIT_GLOBAL_VARIABLES_MAX - 1) << ", was exceeded;"
|
||
<< " " << num_global_values << " global values were found.\n"
|
||
<< "The resulting module might not be supported by all "
|
||
"implementations.";
|
||
|
||
return SPV_SUCCESS;
|
||
}
|
||
|
||
} // namespace
|
||
|
||
spv_result_t Link(const Context& context,
|
||
const std::vector<std::vector<uint32_t>>& binaries,
|
||
std::vector<uint32_t>* linked_binary,
|
||
const LinkerOptions& options) {
|
||
std::vector<const uint32_t*> binary_ptrs;
|
||
binary_ptrs.reserve(binaries.size());
|
||
std::vector<size_t> binary_sizes;
|
||
binary_sizes.reserve(binaries.size());
|
||
|
||
for (const auto& binary : binaries) {
|
||
binary_ptrs.push_back(binary.data());
|
||
binary_sizes.push_back(binary.size());
|
||
}
|
||
|
||
return Link(context, binary_ptrs.data(), binary_sizes.data(), binaries.size(),
|
||
linked_binary, options);
|
||
}
|
||
|
||
spv_result_t Link(const Context& context, const uint32_t* const* binaries,
|
||
const size_t* binary_sizes, size_t num_binaries,
|
||
std::vector<uint32_t>* linked_binary,
|
||
const LinkerOptions& options) {
|
||
spv_position_t position = {};
|
||
const spv_context& c_context = context.CContext();
|
||
const MessageConsumer& consumer = c_context->consumer;
|
||
|
||
linked_binary->clear();
|
||
if (num_binaries == 0u)
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY)
|
||
<< "No modules were given.";
|
||
|
||
std::vector<std::unique_ptr<IRContext>> ir_contexts;
|
||
std::vector<Module*> modules;
|
||
modules.reserve(num_binaries);
|
||
for (size_t i = 0u; i < num_binaries; ++i) {
|
||
const uint32_t schema = binaries[i][4u];
|
||
if (schema != 0u) {
|
||
position.index = 4u;
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY)
|
||
<< "Schema is non-zero for module " << i + 1 << ".";
|
||
}
|
||
|
||
std::unique_ptr<IRContext> ir_context = BuildModule(
|
||
c_context->target_env, consumer, binaries[i], binary_sizes[i]);
|
||
if (ir_context == nullptr)
|
||
return DiagnosticStream(position, consumer, "", SPV_ERROR_INVALID_BINARY)
|
||
<< "Failed to build module " << i + 1 << " out of " << num_binaries
|
||
<< ".";
|
||
modules.push_back(ir_context->module());
|
||
ir_contexts.push_back(std::move(ir_context));
|
||
}
|
||
|
||
// Phase 1: Shift the IDs used in each binary so that they occupy a disjoint
|
||
// range from the other binaries, and compute the new ID bound.
|
||
uint32_t max_id_bound = 0u;
|
||
spv_result_t res = ShiftIdsInModules(consumer, &modules, &max_id_bound);
|
||
if (res != SPV_SUCCESS) return res;
|
||
|
||
// Phase 2: Generate the header
|
||
opt::ModuleHeader header;
|
||
res = GenerateHeader(consumer, modules, max_id_bound, &header);
|
||
if (res != SPV_SUCCESS) return res;
|
||
IRContext linked_context(c_context->target_env, consumer);
|
||
linked_context.module()->SetHeader(header);
|
||
|
||
// Phase 3: Merge all the binaries into a single one.
|
||
AssemblyGrammar grammar(c_context);
|
||
res = MergeModules(consumer, modules, grammar, &linked_context);
|
||
if (res != SPV_SUCCESS) return res;
|
||
|
||
if (options.GetVerifyIds()) {
|
||
res = VerifyIds(consumer, &linked_context);
|
||
if (res != SPV_SUCCESS) return res;
|
||
}
|
||
|
||
// Phase 4: Find the import/export pairs
|
||
LinkageTable linkings_to_do;
|
||
res = GetImportExportPairs(consumer, linked_context,
|
||
*linked_context.get_def_use_mgr(),
|
||
*linked_context.get_decoration_mgr(),
|
||
options.GetAllowPartialLinkage(), &linkings_to_do);
|
||
if (res != SPV_SUCCESS) return res;
|
||
|
||
// Phase 5: Ensure the import and export have the same types and decorations.
|
||
res =
|
||
CheckImportExportCompatibility(consumer, linkings_to_do, &linked_context);
|
||
if (res != SPV_SUCCESS) return res;
|
||
|
||
// Phase 6: Remove duplicates
|
||
PassManager manager;
|
||
manager.SetMessageConsumer(consumer);
|
||
manager.AddPass<RemoveDuplicatesPass>();
|
||
opt::Pass::Status pass_res = manager.Run(&linked_context);
|
||
if (pass_res == opt::Pass::Status::Failure) return SPV_ERROR_INVALID_DATA;
|
||
|
||
// Phase 7: Remove all names and decorations of import variables/functions
|
||
for (const auto& linking_entry : linkings_to_do) {
|
||
linked_context.KillNamesAndDecorates(linking_entry.imported_symbol.id);
|
||
for (const auto parameter_id :
|
||
linking_entry.imported_symbol.parameter_ids) {
|
||
linked_context.KillNamesAndDecorates(parameter_id);
|
||
}
|
||
}
|
||
|
||
// Phase 8: Rematch import variables/functions to export variables/functions
|
||
for (const auto& linking_entry : linkings_to_do) {
|
||
linked_context.ReplaceAllUsesWith(linking_entry.imported_symbol.id,
|
||
linking_entry.exported_symbol.id);
|
||
}
|
||
|
||
// Phase 9: Remove linkage specific instructions, such as import/export
|
||
// attributes, linkage capability, etc. if applicable
|
||
res = RemoveLinkageSpecificInstructions(consumer, options, linkings_to_do,
|
||
linked_context.get_decoration_mgr(),
|
||
&linked_context);
|
||
if (res != SPV_SUCCESS) return res;
|
||
|
||
// Phase 10: Compact the IDs used in the module
|
||
manager.AddPass<opt::CompactIdsPass>();
|
||
pass_res = manager.Run(&linked_context);
|
||
if (pass_res == opt::Pass::Status::Failure) return SPV_ERROR_INVALID_DATA;
|
||
|
||
// Phase 11: Recompute EntryPoint variables
|
||
manager.AddPass<opt::RemoveUnusedInterfaceVariablesPass>();
|
||
pass_res = manager.Run(&linked_context);
|
||
if (pass_res == opt::Pass::Status::Failure) return SPV_ERROR_INVALID_DATA;
|
||
|
||
// Phase 12: Warn if SPIR-V limits were exceeded
|
||
res = VerifyLimits(consumer, linked_context);
|
||
if (res != SPV_SUCCESS) return res;
|
||
|
||
// Phase 13: Output the module
|
||
linked_context.module()->ToBinary(linked_binary, true);
|
||
|
||
return SPV_SUCCESS;
|
||
}
|
||
|
||
} // namespace spvtools
|