Skip to content

A
angle
Commit c7c38731 by Shahbaz Youssefi Committed by Commit Bot
Options

Vulkan: Move SpirvBlob definition to common/

For use by the translator. Bug: angleproject:4889 Change-Id: Ie95cafd3cfcdde50acc5d26d3c00e6574186a805 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2737276 Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org> Reviewed-by: 's avatarTim Van Patten <timvp@google.com> Reviewed-by: 's avatarJamie Madill <jmadill@chromium.org>
parent 8844599f
Showing with 612 additions and 823 deletions
scripts/code_generation_hashes/SPIR-V_helpers.json
{ {
"src/common/spirv/gen_spirv_builder_and_parser.py": "src/common/spirv/gen_spirv_builder_and_parser.py":
"ac2db108072c8c12c7817fd923e22bde", "5ddd90060971e4cb7f8867e488e3d73a",
"src/common/spirv/spirv_instruction_builder_autogen.cpp": "src/common/spirv/spirv_instruction_builder_autogen.cpp":
"52f80a4b5b549ff5568be9f74dd2e3c1", "ec0ed8f398906dc49c35100fe1ac7a4a",
"src/common/spirv/spirv_instruction_builder_autogen.h": "src/common/spirv/spirv_instruction_builder_autogen.h":
"54ff9094108732d4b10c4c33b4fb38e0", "e704ce45c18d87996e8a920bb92e505a",
"src/common/spirv/spirv_instruction_parser_autogen.cpp": "src/common/spirv/spirv_instruction_parser_autogen.cpp":
"55d28bb4b003dbecf31e162ff996fc4f", "55d28bb4b003dbecf31e162ff996fc4f",
"src/common/spirv/spirv_instruction_parser_autogen.h": "src/common/spirv/spirv_instruction_parser_autogen.h":
"c35834942632d4cd1587bf7d66721df7", "d1e45755f704b7bd587be379e5eabd67",
"third_party/vulkan-deps/spirv-headers/src/include/spirv/1.0/spirv.core.grammar.json": "third_party/vulkan-deps/spirv-headers/src/include/spirv/1.0/spirv.core.grammar.json":
"a8c4239344b2fc10bfc4ace7ddee1867" "a8c4239344b2fc10bfc4ace7ddee1867"
} }
\ No newline at end of file
src/common/spirv/angle_spirv_utils.cpp
...@@ -27,7 +27,7 @@ void ValidateSpirvMessage(spv_message_level_t level, ...@@ -27,7 +27,7 @@ void ValidateSpirvMessage(spv_message_level_t level,
} }
} // anonymous namespace } // anonymous namespace
bool Validate(const std::vector<uint32_t> &blob) bool Validate(const Blob &blob)
{ {
spvtools::SpirvTools spirvTools(SPV_ENV_VULKAN_1_1); spvtools::SpirvTools spirvTools(SPV_ENV_VULKAN_1_1);
...@@ -44,7 +44,7 @@ bool Validate(const std::vector<uint32_t> &blob) ...@@ -44,7 +44,7 @@ bool Validate(const std::vector<uint32_t> &blob)
return result; return result;
} }
#else // ANGLE_ENABLE_ASSERTS #else // ANGLE_ENABLE_ASSERTS
bool Validate(const std::vector<uint32_t> &blob) bool Validate(const Blob &blob)
{ {
// Placeholder implementation since this is only used inside an ASSERT(). // Placeholder implementation since this is only used inside an ASSERT().
// Return false to indicate an error in case this is ever accidentally used somewhere else. // Return false to indicate an error in case this is ever accidentally used somewhere else.
......
src/common/spirv/gen_spirv_builder_and_parser.py
...@@ -41,6 +41,8 @@ HEADER_TEMPLATE = """// GENERATED FILE - DO NOT EDIT. ...@@ -41,6 +41,8 @@ HEADER_TEMPLATE = """// GENERATED FILE - DO NOT EDIT.
#ifndef COMMON_SPIRV_{file_name_capitalized}AUTOGEN_H_ #ifndef COMMON_SPIRV_{file_name_capitalized}AUTOGEN_H_
#define COMMON_SPIRV_{file_name_capitalized}AUTOGEN_H_ #define COMMON_SPIRV_{file_name_capitalized}AUTOGEN_H_
#include <spirv/unified1/spirv.hpp>
#include "spirv_types.h" #include "spirv_types.h"
namespace angle namespace angle
...@@ -132,7 +134,7 @@ PARSER_FIXED_FUNCTIONS = """void GetInstructionOpAndLength(const uint32_t *_inst ...@@ -132,7 +134,7 @@ PARSER_FIXED_FUNCTIONS = """void GetInstructionOpAndLength(const uint32_t *_inst
} }
""" """
TEMPLATE_BUILDER_FUNCTION_PROTOTYPE = """void Write{op}(std::vector<uint32_t> *blob {param_list})""" TEMPLATE_BUILDER_FUNCTION_PROTOTYPE = """void Write{op}(Blob *blob {param_list})"""
TEMPLATE_BUILDER_FUNCTION_BODY = """{{ TEMPLATE_BUILDER_FUNCTION_BODY = """{{
const size_t startSize = blob->size(); const size_t startSize = blob->size();
blob->push_back(0); blob->push_back(0);
......
src/common/spirv/spirv_instruction_builder_autogen.cpp
This source diff could not be displayed because it is too large. You can view the blob instead.
src/common/spirv/spirv_instruction_builder_autogen.h
...@@ -11,6 +11,8 @@ ...@@ -11,6 +11,8 @@
#ifndef COMMON_SPIRV_SPIRVINSTRUCTIONBUILDERAUTOGEN_H_ #ifndef COMMON_SPIRV_SPIRVINSTRUCTIONBUILDERAUTOGEN_H_
#define COMMON_SPIRV_SPIRVINSTRUCTIONBUILDERAUTOGEN_H_ #define COMMON_SPIRV_SPIRVINSTRUCTIONBUILDERAUTOGEN_H_
#include <spirv/unified1/spirv.hpp>
#include "spirv_types.h" #include "spirv_types.h"
namespace angle namespace angle
...@@ -19,56 +21,47 @@ namespace spirv ...@@ -19,56 +21,47 @@ namespace spirv
{ {
void WriteSpirvHeader(std::vector<uint32_t> *blob, uint32_t idCount); void WriteSpirvHeader(std::vector<uint32_t> *blob, uint32_t idCount);
void WriteNop(std::vector<uint32_t> *blob); void WriteNop(Blob *blob);
void WriteUndef(std::vector<uint32_t> *blob, IdResultType idResultType, IdResult idResult); void WriteUndef(Blob *blob, IdResultType idResultType, IdResult idResult);
void WriteSourceContinued(std::vector<uint32_t> *blob, LiteralString continuedSource); void WriteSourceContinued(Blob *blob, LiteralString continuedSource);
void WriteSource(std::vector<uint32_t> *blob, void WriteSource(Blob *blob,
spv::SourceLanguage sourceLanguage, spv::SourceLanguage sourceLanguage,
LiteralInteger version, LiteralInteger version,
const IdRef *file, const IdRef *file,
const LiteralString *source); const LiteralString *source);
void WriteSourceExtension(std::vector<uint32_t> *blob, LiteralString extension); void WriteSourceExtension(Blob *blob, LiteralString extension);
void WriteName(std::vector<uint32_t> *blob, IdRef target, LiteralString name); void WriteName(Blob *blob, IdRef target, LiteralString name);
void WriteMemberName(std::vector<uint32_t> *blob, void WriteMemberName(Blob *blob, IdRef type, LiteralInteger member, LiteralString name);
IdRef type, void WriteString(Blob *blob, IdResult idResult, LiteralString string);
LiteralInteger member, void WriteLine(Blob *blob, IdRef file, LiteralInteger line, LiteralInteger column);
LiteralString name); void WriteExtension(Blob *blob, LiteralString name);
void WriteString(std::vector<uint32_t> *blob, IdResult idResult, LiteralString string); void WriteExtInstImport(Blob *blob, IdResult idResult, LiteralString name);
void WriteLine(std::vector<uint32_t> *blob, IdRef file, LiteralInteger line, LiteralInteger column); void WriteExtInst(Blob *blob,
void WriteExtension(std::vector<uint32_t> *blob, LiteralString name);
void WriteExtInstImport(std::vector<uint32_t> *blob, IdResult idResult, LiteralString name);
void WriteExtInst(std::vector<uint32_t> *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef set, IdRef set,
LiteralExtInstInteger instruction, LiteralExtInstInteger instruction,
const IdRefList &operandList); const IdRefList &operandList);
void WriteMemoryModel(std::vector<uint32_t> *blob, void WriteMemoryModel(Blob *blob,
spv::AddressingModel addressingModel, spv::AddressingModel addressingModel,
spv::MemoryModel memoryModel); spv::MemoryModel memoryModel);
void WriteEntryPoint(std::vector<uint32_t> *blob, void WriteEntryPoint(Blob *blob,
spv::ExecutionModel executionModel, spv::ExecutionModel executionModel,
IdRef entryPoint, IdRef entryPoint,
LiteralString name, LiteralString name,
const IdRefList &interfaceList); const IdRefList &interfaceList);
void WriteExecutionMode(std::vector<uint32_t> *blob, IdRef entryPoint, spv::ExecutionMode mode); void WriteExecutionMode(Blob *blob, IdRef entryPoint, spv::ExecutionMode mode);
void WriteCapability(std::vector<uint32_t> *blob, spv::Capability capability); void WriteCapability(Blob *blob, spv::Capability capability);
void WriteTypeVoid(std::vector<uint32_t> *blob, IdResult idResult); void WriteTypeVoid(Blob *blob, IdResult idResult);
void WriteTypeBool(std::vector<uint32_t> *blob, IdResult idResult); void WriteTypeBool(Blob *blob, IdResult idResult);
void WriteTypeInt(std::vector<uint32_t> *blob, void WriteTypeInt(Blob *blob, IdResult idResult, LiteralInteger width, LiteralInteger signedness);
IdResult idResult, void WriteTypeFloat(Blob *blob, IdResult idResult, LiteralInteger width);
LiteralInteger width, void WriteTypeVector(Blob *blob,
LiteralInteger signedness);
void WriteTypeFloat(std::vector<uint32_t> *blob, IdResult idResult, LiteralInteger width);
void WriteTypeVector(std::vector<uint32_t> *blob,
IdResult idResult, IdResult idResult,
IdRef componentType, IdRef componentType,
LiteralInteger componentCount); LiteralInteger componentCount);
void WriteTypeMatrix(std::vector<uint32_t> *blob, void WriteTypeMatrix(Blob *blob, IdResult idResult, IdRef columnType, LiteralInteger columnCount);
IdResult idResult, void WriteTypeImage(Blob *blob,
IdRef columnType,
LiteralInteger columnCount);
void WriteTypeImage(std::vector<uint32_t> *blob,
IdResult idResult, IdResult idResult,
IdRef sampledType, IdRef sampledType,
spv::Dim dim, spv::Dim dim,
...@@ -78,190 +71,165 @@ void WriteTypeImage(std::vector<uint32_t> *blob, ...@@ -78,190 +71,165 @@ void WriteTypeImage(std::vector<uint32_t> *blob,
LiteralInteger sampled, LiteralInteger sampled,
spv::ImageFormat imageFormat, spv::ImageFormat imageFormat,
const spv::AccessQualifier *accessQualifier); const spv::AccessQualifier *accessQualifier);
void WriteTypeSampler(std::vector<uint32_t> *blob, IdResult idResult); void WriteTypeSampler(Blob *blob, IdResult idResult);
void WriteTypeSampledImage(std::vector<uint32_t> *blob, IdResult idResult, IdRef imageType); void WriteTypeSampledImage(Blob *blob, IdResult idResult, IdRef imageType);
void WriteTypeArray(std::vector<uint32_t> *blob, void WriteTypeArray(Blob *blob, IdResult idResult, IdRef elementType, IdRef length);
IdResult idResult, void WriteTypeRuntimeArray(Blob *blob, IdResult idResult, IdRef elementType);
IdRef elementType, void WriteTypeStruct(Blob *blob, IdResult idResult, const IdRefList &memberList);
IdRef length); void WriteTypePointer(Blob *blob, IdResult idResult, spv::StorageClass storageClass, IdRef type);
void WriteTypeRuntimeArray(std::vector<uint32_t> *blob, IdResult idResult, IdRef elementType); void WriteTypeFunction(Blob *blob,
void WriteTypeStruct(std::vector<uint32_t> *blob, IdResult idResult, const IdRefList &memberList);
void WriteTypePointer(std::vector<uint32_t> *blob,
IdResult idResult,
spv::StorageClass storageClass,
IdRef type);
void WriteTypeFunction(std::vector<uint32_t> *blob,
IdResult idResult, IdResult idResult,
IdRef returnType, IdRef returnType,
const IdRefList &parameterList); const IdRefList &parameterList);
void WriteTypeForwardPointer(std::vector<uint32_t> *blob, void WriteTypeForwardPointer(Blob *blob, IdRef pointerType, spv::StorageClass storageClass);
IdRef pointerType, void WriteConstantTrue(Blob *blob, IdResultType idResultType, IdResult idResult);
spv::StorageClass storageClass); void WriteConstantFalse(Blob *blob, IdResultType idResultType, IdResult idResult);
void WriteConstantTrue(std::vector<uint32_t> *blob, IdResultType idResultType, IdResult idResult); void WriteConstant(Blob *blob,
void WriteConstantFalse(std::vector<uint32_t> *blob, IdResultType idResultType, IdResult idResult);
void WriteConstant(std::vector<uint32_t> *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
LiteralContextDependentNumber value); LiteralContextDependentNumber value);
void WriteConstantComposite(std::vector<uint32_t> *blob, void WriteConstantComposite(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
const IdRefList &constituentsList); const IdRefList &constituentsList);
void WriteConstantNull(std::vector<uint32_t> *blob, IdResultType idResultType, IdResult idResult); void WriteConstantNull(Blob *blob, IdResultType idResultType, IdResult idResult);
void WriteSpecConstantTrue(std::vector<uint32_t> *blob, void WriteSpecConstantTrue(Blob *blob, IdResultType idResultType, IdResult idResult);
IdResultType idResultType, void WriteSpecConstantFalse(Blob *blob, IdResultType idResultType, IdResult idResult);
IdResult idResult); void WriteSpecConstant(Blob *blob,
void WriteSpecConstantFalse(std::vector<uint32_t> *blob,
IdResultType idResultType,
IdResult idResult);
void WriteSpecConstant(std::vector<uint32_t> *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
LiteralContextDependentNumber value); LiteralContextDependentNumber value);
void WriteSpecConstantComposite(std::vector<uint32_t> *blob, void WriteSpecConstantComposite(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
const IdRefList &constituentsList); const IdRefList &constituentsList);
void WriteFunction(std::vector<uint32_t> *blob, void WriteFunction(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
spv::FunctionControlMask functionControl, spv::FunctionControlMask functionControl,
IdRef functionType); IdRef functionType);
void WriteFunctionParameter(std::vector<uint32_t> *blob, void WriteFunctionParameter(Blob *blob, IdResultType idResultType, IdResult idResult);
IdResultType idResultType, void WriteFunctionEnd(Blob *blob);
IdResult idResult); void WriteFunctionCall(Blob *blob,
void WriteFunctionEnd(std::vector<uint32_t> *blob);
void WriteFunctionCall(std::vector<uint32_t> *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef function, IdRef function,
const IdRefList &argumentList); const IdRefList &argumentList);
void WriteVariable(std::vector<uint32_t> *blob, void WriteVariable(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
spv::StorageClass storageClass, spv::StorageClass storageClass,
const IdRef *initializer); const IdRef *initializer);
void WriteImageTexelPointer(std::vector<uint32_t> *blob, void WriteImageTexelPointer(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef image, IdRef image,
IdRef coordinate, IdRef coordinate,
IdRef sample); IdRef sample);
void WriteLoad(std::vector<uint32_t> *blob, void WriteLoad(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef pointer, IdRef pointer,
const spv::MemoryAccessMask *memoryAccess); const spv::MemoryAccessMask *memoryAccess);
void WriteStore(std::vector<uint32_t> *blob, void WriteStore(Blob *blob, IdRef pointer, IdRef object, const spv::MemoryAccessMask *memoryAccess);
IdRef pointer, void WriteCopyMemory(Blob *blob,
IdRef object,
const spv::MemoryAccessMask *memoryAccess);
void WriteCopyMemory(std::vector<uint32_t> *blob,
IdRef target, IdRef target,
IdRef source, IdRef source,
const spv::MemoryAccessMask *memoryAccess); const spv::MemoryAccessMask *memoryAccess);
void WriteCopyMemorySized(std::vector<uint32_t> *blob, void WriteCopyMemorySized(Blob *blob,
IdRef target, IdRef target,
IdRef source, IdRef source,
IdRef size, IdRef size,
const spv::MemoryAccessMask *memoryAccess); const spv::MemoryAccessMask *memoryAccess);
void WriteAccessChain(std::vector<uint32_t> *blob, void WriteAccessChain(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef base, IdRef base,
const IdRefList &indexesList); const IdRefList &indexesList);
void WriteInBoundsAccessChain(std::vector<uint32_t> *blob, void WriteInBoundsAccessChain(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef base, IdRef base,
const IdRefList &indexesList); const IdRefList &indexesList);
void WriteArrayLength(std::vector<uint32_t> *blob, void WriteArrayLength(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef structure, IdRef structure,
LiteralInteger arraymember); LiteralInteger arraymember);
void WriteInBoundsPtrAccessChain(std::vector<uint32_t> *blob, void WriteInBoundsPtrAccessChain(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef base, IdRef base,
IdRef element, IdRef element,
const IdRefList &indexesList); const IdRefList &indexesList);
void WriteDecorate(std::vector<uint32_t> *blob, void WriteDecorate(Blob *blob,
IdRef target, IdRef target,
spv::Decoration decoration, spv::Decoration decoration,
const LiteralIntegerList &valuesPairList); const LiteralIntegerList &valuesPairList);
void WriteMemberDecorate(std::vector<uint32_t> *blob, void WriteMemberDecorate(Blob *blob,
IdRef structureType, IdRef structureType,
LiteralInteger member, LiteralInteger member,
spv::Decoration decoration, spv::Decoration decoration,
const LiteralIntegerList &valuesPairList); const LiteralIntegerList &valuesPairList);
void WriteDecorationGroup(std::vector<uint32_t> *blob, IdResult idResult); void WriteDecorationGroup(Blob *blob, IdResult idResult);
void WriteGroupDecorate(std::vector<uint32_t> *blob, void WriteGroupDecorate(Blob *blob, IdRef decorationGroup, const IdRefList &targetsList);
IdRef decorationGroup, void WriteGroupMemberDecorate(Blob *blob,
const IdRefList &targetsList);
void WriteGroupMemberDecorate(std::vector<uint32_t> *blob,
IdRef decorationGroup, IdRef decorationGroup,
const PairIdRefLiteralIntegerList &targetsPairList); const PairIdRefLiteralIntegerList &targetsPairList);
void WriteVectorExtractDynamic(std::vector<uint32_t> *blob, void WriteVectorExtractDynamic(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef vector, IdRef vector,
IdRef index); IdRef index);
void WriteVectorInsertDynamic(std::vector<uint32_t> *blob, void WriteVectorInsertDynamic(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef vector, IdRef vector,
IdRef component, IdRef component,
IdRef index); IdRef index);
void WriteVectorShuffle(std::vector<uint32_t> *blob, void WriteVectorShuffle(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef vector1, IdRef vector1,
IdRef vector2, IdRef vector2,
const LiteralIntegerList &componentsPairList); const LiteralIntegerList &componentsPairList);
void WriteCompositeConstruct(std::vector<uint32_t> *blob, void WriteCompositeConstruct(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
const IdRefList &constituentsList); const IdRefList &constituentsList);
void WriteCompositeExtract(std::vector<uint32_t> *blob, void WriteCompositeExtract(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef composite, IdRef composite,
const LiteralIntegerList &indexesPairList); const LiteralIntegerList &indexesPairList);
void WriteCompositeInsert(std::vector<uint32_t> *blob, void WriteCompositeInsert(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef object, IdRef object,
IdRef composite, IdRef composite,
const LiteralIntegerList &indexesPairList); const LiteralIntegerList &indexesPairList);
void WriteCopyObject(std::vector<uint32_t> *blob, void WriteCopyObject(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef operand);
IdResultType idResultType, void WriteTranspose(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef matrix);
IdResult idResult, void WriteSampledImage(Blob *blob,
IdRef operand);
void WriteTranspose(std::vector<uint32_t> *blob,
IdResultType idResultType,
IdResult idResult,
IdRef matrix);
void WriteSampledImage(std::vector<uint32_t> *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef image, IdRef image,
IdRef sampler); IdRef sampler);
void WriteImageSampleImplicitLod(std::vector<uint32_t> *blob, void WriteImageSampleImplicitLod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
IdRef coordinate, IdRef coordinate,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSampleExplicitLod(std::vector<uint32_t> *blob, void WriteImageSampleExplicitLod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
IdRef coordinate, IdRef coordinate,
spv::ImageOperandsMask imageOperands, spv::ImageOperandsMask imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSampleDrefImplicitLod(std::vector<uint32_t> *blob, void WriteImageSampleDrefImplicitLod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
...@@ -269,7 +237,7 @@ void WriteImageSampleDrefImplicitLod(std::vector<uint32_t> *blob, ...@@ -269,7 +237,7 @@ void WriteImageSampleDrefImplicitLod(std::vector<uint32_t> *blob,
IdRef dref, IdRef dref,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSampleDrefExplicitLod(std::vector<uint32_t> *blob, void WriteImageSampleDrefExplicitLod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
...@@ -277,21 +245,21 @@ void WriteImageSampleDrefExplicitLod(std::vector<uint32_t> *blob, ...@@ -277,21 +245,21 @@ void WriteImageSampleDrefExplicitLod(std::vector<uint32_t> *blob,
IdRef dref, IdRef dref,
spv::ImageOperandsMask imageOperands, spv::ImageOperandsMask imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSampleProjImplicitLod(std::vector<uint32_t> *blob, void WriteImageSampleProjImplicitLod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
IdRef coordinate, IdRef coordinate,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSampleProjExplicitLod(std::vector<uint32_t> *blob, void WriteImageSampleProjExplicitLod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
IdRef coordinate, IdRef coordinate,
spv::ImageOperandsMask imageOperands, spv::ImageOperandsMask imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSampleProjDrefImplicitLod(std::vector<uint32_t> *blob, void WriteImageSampleProjDrefImplicitLod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
...@@ -299,7 +267,7 @@ void WriteImageSampleProjDrefImplicitLod(std::vector<uint32_t> *blob, ...@@ -299,7 +267,7 @@ void WriteImageSampleProjDrefImplicitLod(std::vector<uint32_t> *blob,
IdRef dref, IdRef dref,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSampleProjDrefExplicitLod(std::vector<uint32_t> *blob, void WriteImageSampleProjDrefExplicitLod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
...@@ -307,14 +275,14 @@ void WriteImageSampleProjDrefExplicitLod(std::vector<uint32_t> *blob, ...@@ -307,14 +275,14 @@ void WriteImageSampleProjDrefExplicitLod(std::vector<uint32_t> *blob,
IdRef dref, IdRef dref,
spv::ImageOperandsMask imageOperands, spv::ImageOperandsMask imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageFetch(std::vector<uint32_t> *blob, void WriteImageFetch(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef image, IdRef image,
IdRef coordinate, IdRef coordinate,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageGather(std::vector<uint32_t> *blob, void WriteImageGather(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
...@@ -322,7 +290,7 @@ void WriteImageGather(std::vector<uint32_t> *blob, ...@@ -322,7 +290,7 @@ void WriteImageGather(std::vector<uint32_t> *blob,
IdRef component, IdRef component,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageDrefGather(std::vector<uint32_t> *blob, void WriteImageDrefGather(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
...@@ -330,474 +298,399 @@ void WriteImageDrefGather(std::vector<uint32_t> *blob, ...@@ -330,474 +298,399 @@ void WriteImageDrefGather(std::vector<uint32_t> *blob,
IdRef dref, IdRef dref,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageRead(std::vector<uint32_t> *blob, void WriteImageRead(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef image, IdRef image,
IdRef coordinate, IdRef coordinate,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageWrite(std::vector<uint32_t> *blob, void WriteImageWrite(Blob *blob,
IdRef image, IdRef image,
IdRef coordinate, IdRef coordinate,
IdRef texel, IdRef texel,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImage(std::vector<uint32_t> *blob, void WriteImage(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef sampledImage);
IdResultType idResultType, void WriteImageQueryLod(Blob *blob,
IdResult idResult,
IdRef sampledImage);
void WriteImageQueryLod(std::vector<uint32_t> *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
IdRef coordinate); IdRef coordinate);
void WriteConvertFToU(std::vector<uint32_t> *blob, void WriteConvertFToU(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef floatValue);
IdResultType idResultType, void WriteConvertFToS(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef floatValue);
IdResult idResult, void WriteConvertSToF(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef signedValue);
IdRef floatValue); void WriteConvertUToF(Blob *blob,
void WriteConvertFToS(std::vector<uint32_t> *blob,
IdResultType idResultType,
IdResult idResult,
IdRef floatValue);
void WriteConvertSToF(std::vector<uint32_t> *blob,
IdResultType idResultType,
IdResult idResult,
IdRef signedValue);
void WriteConvertUToF(std::vector<uint32_t> *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef unsignedValue); IdRef unsignedValue);
void WriteUConvert(std::vector<uint32_t> *blob, void WriteUConvert(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef unsignedValue);
IdResultType idResultType, void WriteSConvert(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef signedValue);
IdResult idResult, void WriteFConvert(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef floatValue);
IdRef unsignedValue); void WriteQuantizeToF16(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef value);
void WriteSConvert(std::vector<uint32_t> *blob, void WriteConvertPtrToU(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef pointer);
IdResultType idResultType, void WriteConvertUToPtr(Blob *blob,
IdResult idResult,
IdRef signedValue);
void WriteFConvert(std::vector<uint32_t> *blob,
IdResultType idResultType,
IdResult idResult,
IdRef floatValue);
void WriteQuantizeToF16(std::vector<uint32_t> *blob,
IdResultType idResultType,
IdResult idResult,
IdRef value);
void WriteConvertPtrToU(std::vector<uint32_t> *blob,
IdResultType idResultType,
IdResult idResult,
IdRef pointer);
void WriteConvertUToPtr(std::vector<uint32_t> *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef integerValue); IdRef integerValue);
void WriteBitcast(std::vector<uint32_t> *blob, void WriteBitcast(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef operand);
IdResultType idResultType, void WriteSNegate(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef operand);
IdResult idResult, void WriteFNegate(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef operand);
IdRef operand); void WriteIAdd(Blob *blob,
void WriteSNegate(std::vector<uint32_t> *blob,
IdResultType idResultType,
IdResult idResult,
IdRef operand);
void WriteFNegate(std::vector<uint32_t> *blob,
IdResultType idResultType,
IdResult idResult,
IdRef operand);
void WriteIAdd(std::vector<uint32_t> *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFAdd(std::vector<uint32_t> *blob, void WriteFAdd(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteISub(std::vector<uint32_t> *blob, void WriteISub(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFSub(std::vector<uint32_t> *blob, void WriteFSub(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteIMul(std::vector<uint32_t> *blob, void WriteIMul(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFMul(std::vector<uint32_t> *blob, void WriteFMul(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteUDiv(std::vector<uint32_t> *blob, void WriteUDiv(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteSDiv(std::vector<uint32_t> *blob, void WriteSDiv(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFDiv(std::vector<uint32_t> *blob, void WriteFDiv(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteUMod(std::vector<uint32_t> *blob, void WriteUMod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteSRem(std::vector<uint32_t> *blob, void WriteSRem(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteSMod(std::vector<uint32_t> *blob, void WriteSMod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFRem(std::vector<uint32_t> *blob, void WriteFRem(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFMod(std::vector<uint32_t> *blob, void WriteFMod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteVectorTimesScalar(std::vector<uint32_t> *blob, void WriteVectorTimesScalar(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef vector, IdRef vector,
IdRef scalar); IdRef scalar);
void WriteMatrixTimesScalar(std::vector<uint32_t> *blob, void WriteMatrixTimesScalar(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef matrix, IdRef matrix,
IdRef scalar); IdRef scalar);
void WriteVectorTimesMatrix(std::vector<uint32_t> *blob, void WriteVectorTimesMatrix(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef vector, IdRef vector,
IdRef matrix); IdRef matrix);
void WriteMatrixTimesVector(std::vector<uint32_t> *blob, void WriteMatrixTimesVector(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef matrix, IdRef matrix,
IdRef vector); IdRef vector);
void WriteMatrixTimesMatrix(std::vector<uint32_t> *blob, void WriteMatrixTimesMatrix(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef leftMatrix, IdRef leftMatrix,
IdRef rightMatrix); IdRef rightMatrix);
void WriteOuterProduct(std::vector<uint32_t> *blob, void WriteOuterProduct(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef vector1, IdRef vector1,
IdRef vector2); IdRef vector2);
void WriteDot(std::vector<uint32_t> *blob, void WriteDot(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef vector1, IdRef vector1,
IdRef vector2); IdRef vector2);
void WriteIAddCarry(std::vector<uint32_t> *blob, void WriteIAddCarry(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteISubBorrow(std::vector<uint32_t> *blob, void WriteISubBorrow(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteUMulExtended(std::vector<uint32_t> *blob, void WriteUMulExtended(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteSMulExtended(std::vector<uint32_t> *blob, void WriteSMulExtended(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteAny(std::vector<uint32_t> *blob, void WriteAny(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef vector);
IdResultType idResultType, void WriteAll(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef vector);
IdResult idResult, void WriteIsNan(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef x);
IdRef vector); void WriteIsInf(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef x);
void WriteAll(std::vector<uint32_t> *blob, void WriteLogicalEqual(Blob *blob,
IdResultType idResultType,
IdResult idResult,
IdRef vector);
void WriteIsNan(std::vector<uint32_t> *blob, IdResultType idResultType, IdResult idResult, IdRef x);
void WriteIsInf(std::vector<uint32_t> *blob, IdResultType idResultType, IdResult idResult, IdRef x);
void WriteLogicalEqual(std::vector<uint32_t> *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteLogicalNotEqual(std::vector<uint32_t> *blob, void WriteLogicalNotEqual(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteLogicalOr(std::vector<uint32_t> *blob, void WriteLogicalOr(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteLogicalAnd(std::vector<uint32_t> *blob, void WriteLogicalAnd(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteLogicalNot(std::vector<uint32_t> *blob, void WriteLogicalNot(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef operand);
IdResultType idResultType, void WriteSelect(Blob *blob,
IdResult idResult,
IdRef operand);
void WriteSelect(std::vector<uint32_t> *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef condition, IdRef condition,
IdRef object1, IdRef object1,
IdRef object2); IdRef object2);
void WriteIEqual(std::vector<uint32_t> *blob, void WriteIEqual(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteINotEqual(std::vector<uint32_t> *blob, void WriteINotEqual(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteUGreaterThan(std::vector<uint32_t> *blob, void WriteUGreaterThan(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteSGreaterThan(std::vector<uint32_t> *blob, void WriteSGreaterThan(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteUGreaterThanEqual(std::vector<uint32_t> *blob, void WriteUGreaterThanEqual(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteSGreaterThanEqual(std::vector<uint32_t> *blob, void WriteSGreaterThanEqual(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteULessThan(std::vector<uint32_t> *blob, void WriteULessThan(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteSLessThan(std::vector<uint32_t> *blob, void WriteSLessThan(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteULessThanEqual(std::vector<uint32_t> *blob, void WriteULessThanEqual(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteSLessThanEqual(std::vector<uint32_t> *blob, void WriteSLessThanEqual(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFOrdEqual(std::vector<uint32_t> *blob, void WriteFOrdEqual(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFUnordEqual(std::vector<uint32_t> *blob, void WriteFUnordEqual(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFOrdNotEqual(std::vector<uint32_t> *blob, void WriteFOrdNotEqual(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFUnordNotEqual(std::vector<uint32_t> *blob, void WriteFUnordNotEqual(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFOrdLessThan(std::vector<uint32_t> *blob, void WriteFOrdLessThan(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFUnordLessThan(std::vector<uint32_t> *blob, void WriteFUnordLessThan(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFOrdGreaterThan(std::vector<uint32_t> *blob, void WriteFOrdGreaterThan(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFUnordGreaterThan(std::vector<uint32_t> *blob, void WriteFUnordGreaterThan(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFOrdLessThanEqual(std::vector<uint32_t> *blob, void WriteFOrdLessThanEqual(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFUnordLessThanEqual(std::vector<uint32_t> *blob, void WriteFUnordLessThanEqual(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFOrdGreaterThanEqual(std::vector<uint32_t> *blob, void WriteFOrdGreaterThanEqual(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteFUnordGreaterThanEqual(std::vector<uint32_t> *blob, void WriteFUnordGreaterThanEqual(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteShiftRightLogical(std::vector<uint32_t> *blob, void WriteShiftRightLogical(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef base, IdRef base,
IdRef shift); IdRef shift);
void WriteShiftRightArithmetic(std::vector<uint32_t> *blob, void WriteShiftRightArithmetic(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef base, IdRef base,
IdRef shift); IdRef shift);
void WriteShiftLeftLogical(std::vector<uint32_t> *blob, void WriteShiftLeftLogical(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef base, IdRef base,
IdRef shift); IdRef shift);
void WriteBitwiseOr(std::vector<uint32_t> *blob, void WriteBitwiseOr(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteBitwiseXor(std::vector<uint32_t> *blob, void WriteBitwiseXor(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteBitwiseAnd(std::vector<uint32_t> *blob, void WriteBitwiseAnd(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef operand1, IdRef operand1,
IdRef operand2); IdRef operand2);
void WriteNot(std::vector<uint32_t> *blob, void WriteNot(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef operand);
IdResultType idResultType, void WriteBitFieldInsert(Blob *blob,
IdResult idResult,
IdRef operand);
void WriteBitFieldInsert(std::vector<uint32_t> *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef base, IdRef base,
IdRef insert, IdRef insert,
IdRef offset, IdRef offset,
IdRef count); IdRef count);
void WriteBitFieldSExtract(std::vector<uint32_t> *blob, void WriteBitFieldSExtract(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef base, IdRef base,
IdRef offset, IdRef offset,
IdRef count); IdRef count);
void WriteBitFieldUExtract(std::vector<uint32_t> *blob, void WriteBitFieldUExtract(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef base, IdRef base,
IdRef offset, IdRef offset,
IdRef count); IdRef count);
void WriteBitReverse(std::vector<uint32_t> *blob, void WriteBitReverse(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef base);
IdResultType idResultType, void WriteBitCount(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef base);
IdResult idResult, void WriteDPdx(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef p);
IdRef base); void WriteDPdy(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef p);
void WriteBitCount(std::vector<uint32_t> *blob, void WriteFwidth(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef p);
IdResultType idResultType, void WriteDPdxFine(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef p);
IdResult idResult, void WriteDPdyFine(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef p);
IdRef base); void WriteFwidthFine(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef p);
void WriteDPdx(std::vector<uint32_t> *blob, IdResultType idResultType, IdResult idResult, IdRef p); void WriteDPdxCoarse(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef p);
void WriteDPdy(std::vector<uint32_t> *blob, IdResultType idResultType, IdResult idResult, IdRef p); void WriteDPdyCoarse(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef p);
void WriteFwidth(std::vector<uint32_t> *blob, void WriteFwidthCoarse(Blob *blob, IdResultType idResultType, IdResult idResult, IdRef p);
IdResultType idResultType, void WriteEmitVertex(Blob *blob);
IdResult idResult, void WriteEndPrimitive(Blob *blob);
IdRef p); void WriteEmitStreamVertex(Blob *blob, IdRef stream);
void WriteDPdxFine(std::vector<uint32_t> *blob, void WriteEndStreamPrimitive(Blob *blob, IdRef stream);
IdResultType idResultType, void WriteControlBarrier(Blob *blob,
IdResult idResult,
IdRef p);
void WriteDPdyFine(std::vector<uint32_t> *blob,
IdResultType idResultType,
IdResult idResult,
IdRef p);
void WriteFwidthFine(std::vector<uint32_t> *blob,
IdResultType idResultType,
IdResult idResult,
IdRef p);
void WriteDPdxCoarse(std::vector<uint32_t> *blob,
IdResultType idResultType,
IdResult idResult,
IdRef p);
void WriteDPdyCoarse(std::vector<uint32_t> *blob,
IdResultType idResultType,
IdResult idResult,
IdRef p);
void WriteFwidthCoarse(std::vector<uint32_t> *blob,
IdResultType idResultType,
IdResult idResult,
IdRef p);
void WriteEmitVertex(std::vector<uint32_t> *blob);
void WriteEndPrimitive(std::vector<uint32_t> *blob);
void WriteEmitStreamVertex(std::vector<uint32_t> *blob, IdRef stream);
void WriteEndStreamPrimitive(std::vector<uint32_t> *blob, IdRef stream);
void WriteControlBarrier(std::vector<uint32_t> *blob,
IdScope execution, IdScope execution,
IdScope memory, IdScope memory,
IdMemorySemantics semantics); IdMemorySemantics semantics);
void WriteMemoryBarrier(std::vector<uint32_t> *blob, IdScope memory, IdMemorySemantics semantics); void WriteMemoryBarrier(Blob *blob, IdScope memory, IdMemorySemantics semantics);
void WriteAtomicLoad(std::vector<uint32_t> *blob, void WriteAtomicLoad(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef pointer, IdRef pointer,
IdScope scope, IdScope scope,
IdMemorySemantics semantics); IdMemorySemantics semantics);
void WriteAtomicStore(std::vector<uint32_t> *blob, void WriteAtomicStore(Blob *blob,
IdRef pointer, IdRef pointer,
IdScope scope, IdScope scope,
IdMemorySemantics semantics, IdMemorySemantics semantics,
IdRef value); IdRef value);
void WriteAtomicExchange(std::vector<uint32_t> *blob, void WriteAtomicExchange(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef pointer, IdRef pointer,
IdScope scope, IdScope scope,
IdMemorySemantics semantics, IdMemorySemantics semantics,
IdRef value); IdRef value);
void WriteAtomicCompareExchange(std::vector<uint32_t> *blob, void WriteAtomicCompareExchange(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef pointer, IdRef pointer,
...@@ -806,186 +699,184 @@ void WriteAtomicCompareExchange(std::vector<uint32_t> *blob, ...@@ -806,186 +699,184 @@ void WriteAtomicCompareExchange(std::vector<uint32_t> *blob,
IdMemorySemantics unequal, IdMemorySemantics unequal,
IdRef value, IdRef value,
IdRef comparator); IdRef comparator);
void WriteAtomicIIncrement(std::vector<uint32_t> *blob, void WriteAtomicIIncrement(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef pointer, IdRef pointer,
IdScope scope, IdScope scope,
IdMemorySemantics semantics); IdMemorySemantics semantics);
void WriteAtomicIDecrement(std::vector<uint32_t> *blob, void WriteAtomicIDecrement(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef pointer, IdRef pointer,
IdScope scope, IdScope scope,
IdMemorySemantics semantics); IdMemorySemantics semantics);
void WriteAtomicIAdd(std::vector<uint32_t> *blob, void WriteAtomicIAdd(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef pointer, IdRef pointer,
IdScope scope, IdScope scope,
IdMemorySemantics semantics, IdMemorySemantics semantics,
IdRef value); IdRef value);
void WriteAtomicISub(std::vector<uint32_t> *blob, void WriteAtomicISub(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef pointer, IdRef pointer,
IdScope scope, IdScope scope,
IdMemorySemantics semantics, IdMemorySemantics semantics,
IdRef value); IdRef value);
void WriteAtomicSMin(std::vector<uint32_t> *blob, void WriteAtomicSMin(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef pointer, IdRef pointer,
IdScope scope, IdScope scope,
IdMemorySemantics semantics, IdMemorySemantics semantics,
IdRef value); IdRef value);
void WriteAtomicUMin(std::vector<uint32_t> *blob, void WriteAtomicUMin(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef pointer, IdRef pointer,
IdScope scope, IdScope scope,
IdMemorySemantics semantics, IdMemorySemantics semantics,
IdRef value); IdRef value);
void WriteAtomicSMax(std::vector<uint32_t> *blob, void WriteAtomicSMax(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef pointer, IdRef pointer,
IdScope scope, IdScope scope,
IdMemorySemantics semantics, IdMemorySemantics semantics,
IdRef value); IdRef value);
void WriteAtomicUMax(std::vector<uint32_t> *blob, void WriteAtomicUMax(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef pointer, IdRef pointer,
IdScope scope, IdScope scope,
IdMemorySemantics semantics, IdMemorySemantics semantics,
IdRef value); IdRef value);
void WriteAtomicAnd(std::vector<uint32_t> *blob, void WriteAtomicAnd(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef pointer, IdRef pointer,
IdScope scope, IdScope scope,
IdMemorySemantics semantics, IdMemorySemantics semantics,
IdRef value); IdRef value);
void WriteAtomicOr(std::vector<uint32_t> *blob, void WriteAtomicOr(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef pointer, IdRef pointer,
IdScope scope, IdScope scope,
IdMemorySemantics semantics, IdMemorySemantics semantics,
IdRef value); IdRef value);
void WriteAtomicXor(std::vector<uint32_t> *blob, void WriteAtomicXor(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef pointer, IdRef pointer,
IdScope scope, IdScope scope,
IdMemorySemantics semantics, IdMemorySemantics semantics,
IdRef value); IdRef value);
void WritePhi(std::vector<uint32_t> *blob, void WritePhi(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
const PairIdRefIdRefList &variableParentPairList); const PairIdRefIdRefList &variableParentPairList);
void WriteLoopMerge(std::vector<uint32_t> *blob, void WriteLoopMerge(Blob *blob,
IdRef mergeBlock, IdRef mergeBlock,
IdRef continueTarget, IdRef continueTarget,
spv::LoopControlMask loopControl); spv::LoopControlMask loopControl);
void WriteSelectionMerge(std::vector<uint32_t> *blob, void WriteSelectionMerge(Blob *blob, IdRef mergeBlock, spv::SelectionControlMask selectionControl);
IdRef mergeBlock, void WriteLabel(Blob *blob, IdResult idResult);
spv::SelectionControlMask selectionControl); void WriteBranch(Blob *blob, IdRef targetLabel);
void WriteLabel(std::vector<uint32_t> *blob, IdResult idResult); void WriteBranchConditional(Blob *blob,
void WriteBranch(std::vector<uint32_t> *blob, IdRef targetLabel);
void WriteBranchConditional(std::vector<uint32_t> *blob,
IdRef condition, IdRef condition,
IdRef trueLabel, IdRef trueLabel,
IdRef falseLabel, IdRef falseLabel,
const LiteralIntegerList &branchweightsPairList); const LiteralIntegerList &branchweightsPairList);
void WriteSwitch(std::vector<uint32_t> *blob, void WriteSwitch(Blob *blob,
IdRef selector, IdRef selector,
IdRef default_, IdRef default_,
const PairLiteralIntegerIdRefList &targetPairList); const PairLiteralIntegerIdRefList &targetPairList);
void WriteKill(std::vector<uint32_t> *blob); void WriteKill(Blob *blob);
void WriteReturn(std::vector<uint32_t> *blob); void WriteReturn(Blob *blob);
void WriteReturnValue(std::vector<uint32_t> *blob, IdRef value); void WriteReturnValue(Blob *blob, IdRef value);
void WriteUnreachable(std::vector<uint32_t> *blob); void WriteUnreachable(Blob *blob);
void WriteGroupAll(std::vector<uint32_t> *blob, void WriteGroupAll(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
IdRef predicate); IdRef predicate);
void WriteGroupAny(std::vector<uint32_t> *blob, void WriteGroupAny(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
IdRef predicate); IdRef predicate);
void WriteGroupBroadcast(std::vector<uint32_t> *blob, void WriteGroupBroadcast(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
IdRef value, IdRef value,
IdRef localId); IdRef localId);
void WriteGroupIAdd(std::vector<uint32_t> *blob, void WriteGroupIAdd(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
spv::GroupOperation operation, spv::GroupOperation operation,
IdRef x); IdRef x);
void WriteGroupFAdd(std::vector<uint32_t> *blob, void WriteGroupFAdd(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
spv::GroupOperation operation, spv::GroupOperation operation,
IdRef x); IdRef x);
void WriteGroupFMin(std::vector<uint32_t> *blob, void WriteGroupFMin(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
spv::GroupOperation operation, spv::GroupOperation operation,
IdRef x); IdRef x);
void WriteGroupUMin(std::vector<uint32_t> *blob, void WriteGroupUMin(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
spv::GroupOperation operation, spv::GroupOperation operation,
IdRef x); IdRef x);
void WriteGroupSMin(std::vector<uint32_t> *blob, void WriteGroupSMin(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
spv::GroupOperation operation, spv::GroupOperation operation,
IdRef x); IdRef x);
void WriteGroupFMax(std::vector<uint32_t> *blob, void WriteGroupFMax(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
spv::GroupOperation operation, spv::GroupOperation operation,
IdRef x); IdRef x);
void WriteGroupUMax(std::vector<uint32_t> *blob, void WriteGroupUMax(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
spv::GroupOperation operation, spv::GroupOperation operation,
IdRef x); IdRef x);
void WriteGroupSMax(std::vector<uint32_t> *blob, void WriteGroupSMax(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
spv::GroupOperation operation, spv::GroupOperation operation,
IdRef x); IdRef x);
void WriteImageSparseSampleImplicitLod(std::vector<uint32_t> *blob, void WriteImageSparseSampleImplicitLod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
IdRef coordinate, IdRef coordinate,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSparseSampleExplicitLod(std::vector<uint32_t> *blob, void WriteImageSparseSampleExplicitLod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
IdRef coordinate, IdRef coordinate,
spv::ImageOperandsMask imageOperands, spv::ImageOperandsMask imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSparseSampleDrefImplicitLod(std::vector<uint32_t> *blob, void WriteImageSparseSampleDrefImplicitLod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
...@@ -993,7 +884,7 @@ void WriteImageSparseSampleDrefImplicitLod(std::vector<uint32_t> *blob, ...@@ -993,7 +884,7 @@ void WriteImageSparseSampleDrefImplicitLod(std::vector<uint32_t> *blob,
IdRef dref, IdRef dref,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSparseSampleDrefExplicitLod(std::vector<uint32_t> *blob, void WriteImageSparseSampleDrefExplicitLod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
...@@ -1001,21 +892,21 @@ void WriteImageSparseSampleDrefExplicitLod(std::vector<uint32_t> *blob, ...@@ -1001,21 +892,21 @@ void WriteImageSparseSampleDrefExplicitLod(std::vector<uint32_t> *blob,
IdRef dref, IdRef dref,
spv::ImageOperandsMask imageOperands, spv::ImageOperandsMask imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSparseSampleProjImplicitLod(std::vector<uint32_t> *blob, void WriteImageSparseSampleProjImplicitLod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
IdRef coordinate, IdRef coordinate,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSparseSampleProjExplicitLod(std::vector<uint32_t> *blob, void WriteImageSparseSampleProjExplicitLod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
IdRef coordinate, IdRef coordinate,
spv::ImageOperandsMask imageOperands, spv::ImageOperandsMask imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSparseSampleProjDrefImplicitLod(std::vector<uint32_t> *blob, void WriteImageSparseSampleProjDrefImplicitLod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
...@@ -1023,7 +914,7 @@ void WriteImageSparseSampleProjDrefImplicitLod(std::vector<uint32_t> *blob, ...@@ -1023,7 +914,7 @@ void WriteImageSparseSampleProjDrefImplicitLod(std::vector<uint32_t> *blob,
IdRef dref, IdRef dref,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSparseSampleProjDrefExplicitLod(std::vector<uint32_t> *blob, void WriteImageSparseSampleProjDrefExplicitLod(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
...@@ -1031,14 +922,14 @@ void WriteImageSparseSampleProjDrefExplicitLod(std::vector<uint32_t> *blob, ...@@ -1031,14 +922,14 @@ void WriteImageSparseSampleProjDrefExplicitLod(std::vector<uint32_t> *blob,
IdRef dref, IdRef dref,
spv::ImageOperandsMask imageOperands, spv::ImageOperandsMask imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSparseFetch(std::vector<uint32_t> *blob, void WriteImageSparseFetch(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef image, IdRef image,
IdRef coordinate, IdRef coordinate,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSparseGather(std::vector<uint32_t> *blob, void WriteImageSparseGather(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
...@@ -1046,7 +937,7 @@ void WriteImageSparseGather(std::vector<uint32_t> *blob, ...@@ -1046,7 +937,7 @@ void WriteImageSparseGather(std::vector<uint32_t> *blob,
IdRef component, IdRef component,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSparseDrefGather(std::vector<uint32_t> *blob, void WriteImageSparseDrefGather(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef sampledImage, IdRef sampledImage,
...@@ -1054,61 +945,61 @@ void WriteImageSparseDrefGather(std::vector<uint32_t> *blob, ...@@ -1054,61 +945,61 @@ void WriteImageSparseDrefGather(std::vector<uint32_t> *blob,
IdRef dref, IdRef dref,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteImageSparseTexelsResident(std::vector<uint32_t> *blob, void WriteImageSparseTexelsResident(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef residentCode); IdRef residentCode);
void WriteNoLine(std::vector<uint32_t> *blob); void WriteNoLine(Blob *blob);
void WriteImageSparseRead(std::vector<uint32_t> *blob, void WriteImageSparseRead(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdRef image, IdRef image,
IdRef coordinate, IdRef coordinate,
const spv::ImageOperandsMask *imageOperands, const spv::ImageOperandsMask *imageOperands,
const IdRefList &imageOperandIdsList); const IdRefList &imageOperandIdsList);
void WriteGroupIAddNonUniformAMD(std::vector<uint32_t> *blob, void WriteGroupIAddNonUniformAMD(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
spv::GroupOperation operation, spv::GroupOperation operation,
IdRef x); IdRef x);
void WriteGroupFAddNonUniformAMD(std::vector<uint32_t> *blob, void WriteGroupFAddNonUniformAMD(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
spv::GroupOperation operation, spv::GroupOperation operation,
IdRef x); IdRef x);
void WriteGroupFMinNonUniformAMD(std::vector<uint32_t> *blob, void WriteGroupFMinNonUniformAMD(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
spv::GroupOperation operation, spv::GroupOperation operation,
IdRef x); IdRef x);
void WriteGroupUMinNonUniformAMD(std::vector<uint32_t> *blob, void WriteGroupUMinNonUniformAMD(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
spv::GroupOperation operation, spv::GroupOperation operation,
IdRef x); IdRef x);
void WriteGroupSMinNonUniformAMD(std::vector<uint32_t> *blob, void WriteGroupSMinNonUniformAMD(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
spv::GroupOperation operation, spv::GroupOperation operation,
IdRef x); IdRef x);
void WriteGroupFMaxNonUniformAMD(std::vector<uint32_t> *blob, void WriteGroupFMaxNonUniformAMD(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
spv::GroupOperation operation, spv::GroupOperation operation,
IdRef x); IdRef x);
void WriteGroupUMaxNonUniformAMD(std::vector<uint32_t> *blob, void WriteGroupUMaxNonUniformAMD(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
spv::GroupOperation operation, spv::GroupOperation operation,
IdRef x); IdRef x);
void WriteGroupSMaxNonUniformAMD(std::vector<uint32_t> *blob, void WriteGroupSMaxNonUniformAMD(Blob *blob,
IdResultType idResultType, IdResultType idResultType,
IdResult idResult, IdResult idResult,
IdScope execution, IdScope execution,
......
src/common/spirv/spirv_instruction_parser_autogen.h
...@@ -11,6 +11,8 @@ ...@@ -11,6 +11,8 @@
#ifndef COMMON_SPIRV_SPIRVINSTRUCTIONPARSERAUTOGEN_H_ #ifndef COMMON_SPIRV_SPIRVINSTRUCTIONPARSERAUTOGEN_H_
#define COMMON_SPIRV_SPIRVINSTRUCTIONPARSERAUTOGEN_H_ #define COMMON_SPIRV_SPIRVINSTRUCTIONPARSERAUTOGEN_H_
#include <spirv/unified1/spirv.hpp>
#include "spirv_types.h" #include "spirv_types.h"
namespace angle namespace angle
......
src/common/spirv/spirv_types.h
...@@ -10,8 +10,6 @@ ...@@ -10,8 +10,6 @@
#ifndef COMMON_SPIRV_TYPES_H_ #ifndef COMMON_SPIRV_TYPES_H_
#define COMMON_SPIRV_TYPES_H_ #define COMMON_SPIRV_TYPES_H_
#include <spirv/unified1/spirv.hpp>
#include "common/FastVector.h" #include "common/FastVector.h"
#include <vector> #include <vector>
...@@ -44,7 +42,7 @@ class BoxedUint32 ...@@ -44,7 +42,7 @@ class BoxedUint32
struct IdRefHelper struct IdRefHelper
{ {
spv::Id value; uint32_t value;
}; };
struct LiteralIntegerHelper struct LiteralIntegerHelper
{ {
...@@ -109,9 +107,12 @@ using PairIdRefIdRefList = FastVectorHelper<PairIdRefIdRef>; ...@@ -109,9 +107,12 @@ using PairIdRefIdRefList = FastVectorHelper<PairIdRefIdRef>;
// Id 0 is invalid in SPIR-V. // Id 0 is invalid in SPIR-V.
constexpr uint32_t kMinValidId = 1; constexpr uint32_t kMinValidId = 1;
// The SPIR-V blob is a sequence of uint32_t's
using Blob = std::vector<uint32_t>;
// Returns whether SPIR-V is valid. Useful for ASSERTs. Automatically generates a warning if // Returns whether SPIR-V is valid. Useful for ASSERTs. Automatically generates a warning if
// SPIR-V is not valid. // SPIR-V is not valid.
bool Validate(const std::vector<uint32_t> &blob); bool Validate(const Blob &blob);
} // namespace spirv } // namespace spirv
} // namespace angle } // namespace angle
......
src/libANGLE/renderer/glslang_wrapper_utils.cpp
...@@ -1066,9 +1066,9 @@ angle::Result LinkProgram(const GlslangErrorCallback &callback, glslang::TProgra ...@@ -1066,9 +1066,9 @@ angle::Result LinkProgram(const GlslangErrorCallback &callback, glslang::TProgra
class SpirvTransformerBase : angle::NonCopyable class SpirvTransformerBase : angle::NonCopyable
{ {
public: public:
SpirvTransformerBase(const std::vector<uint32_t> &spirvBlobIn, SpirvTransformerBase(const spirv::Blob &spirvBlobIn,
const ShaderInterfaceVariableInfoMap &variableInfoMap, const ShaderInterfaceVariableInfoMap &variableInfoMap,
SpirvBlob *spirvBlobOut) spirv::Blob *spirvBlobOut)
: mSpirvBlobIn(spirvBlobIn), mVariableInfoMap(variableInfoMap), mSpirvBlobOut(spirvBlobOut) : mSpirvBlobIn(spirvBlobIn), mVariableInfoMap(variableInfoMap), mSpirvBlobOut(spirvBlobOut)
{ {
gl::ShaderBitSet allStages; gl::ShaderBitSet allStages;
...@@ -1081,7 +1081,7 @@ class SpirvTransformerBase : angle::NonCopyable ...@@ -1081,7 +1081,7 @@ class SpirvTransformerBase : angle::NonCopyable
return mVariableInfoById; return mVariableInfoById;
} }
static spirv::IdRef GetNewId(SpirvBlob *blob); static spirv::IdRef GetNewId(spirv::Blob *blob);
spirv::IdRef getNewId(); spirv::IdRef getNewId();
protected: protected:
...@@ -1102,13 +1102,13 @@ class SpirvTransformerBase : angle::NonCopyable ...@@ -1102,13 +1102,13 @@ class SpirvTransformerBase : angle::NonCopyable
void copyInstruction(const uint32_t *instruction, size_t wordCount); void copyInstruction(const uint32_t *instruction, size_t wordCount);
// SPIR-V to transform: // SPIR-V to transform:
const SpirvBlob &mSpirvBlobIn; const spirv::Blob &mSpirvBlobIn;
// Input shader variable info map: // Input shader variable info map:
const ShaderInterfaceVariableInfoMap &mVariableInfoMap; const ShaderInterfaceVariableInfoMap &mVariableInfoMap;
// Transformed SPIR-V: // Transformed SPIR-V:
SpirvBlob *mSpirvBlobOut; spirv::Blob *mSpirvBlobOut;
// Traversal state: // Traversal state:
size_t mCurrentWord = 0; size_t mCurrentWord = 0;
...@@ -1133,10 +1133,10 @@ void SpirvTransformerBase::onTransformBegin() ...@@ -1133,10 +1133,10 @@ void SpirvTransformerBase::onTransformBegin()
ASSERT(mCurrentWord == 0); ASSERT(mCurrentWord == 0);
ASSERT(mIsInFunctionSection == false); ASSERT(mIsInFunctionSection == false);
// Make sure the SpirvBlob is not reused. // Make sure the spirv::Blob is not reused.
ASSERT(mSpirvBlobOut->empty()); ASSERT(mSpirvBlobOut->empty());
// Copy the header to SpirvBlob, we need that to be defined for SpirvTransformerBase::getNewId // Copy the header to SPIR-V blob, we need that to be defined for SpirvTransformerBase::getNewId
// to work. // to work.
mSpirvBlobOut->assign(mSpirvBlobIn.begin(), mSpirvBlobIn.begin() + kHeaderIndexInstructions); mSpirvBlobOut->assign(mSpirvBlobIn.begin(), mSpirvBlobIn.begin() + kHeaderIndexInstructions);
...@@ -1162,7 +1162,7 @@ void SpirvTransformerBase::copyInstruction(const uint32_t *instruction, size_t w ...@@ -1162,7 +1162,7 @@ void SpirvTransformerBase::copyInstruction(const uint32_t *instruction, size_t w
mSpirvBlobOut->insert(mSpirvBlobOut->end(), instruction, instruction + wordCount); mSpirvBlobOut->insert(mSpirvBlobOut->end(), instruction, instruction + wordCount);
} }
spirv::IdRef SpirvTransformerBase::GetNewId(SpirvBlob *blob) spirv::IdRef SpirvTransformerBase::GetNewId(spirv::Blob *blob)
{ {
return spirv::IdRef((*blob)[kHeaderIndexIndexBound]++); return spirv::IdRef((*blob)[kHeaderIndexIndexBound]++);
} }
...@@ -1217,7 +1217,7 @@ class SpirvIDDiscoverer final : angle::NonCopyable ...@@ -1217,7 +1217,7 @@ class SpirvIDDiscoverer final : angle::NonCopyable
// Helpers: // Helpers:
void visitTypeHelper(spirv::IdResult id, spirv::IdRef typeId); void visitTypeHelper(spirv::IdResult id, spirv::IdRef typeId);
void writePendingDeclarations(SpirvBlob *blobOut); void writePendingDeclarations(spirv::Blob *blobOut);
// Getters: // Getters:
const spirv::LiteralString &getName(spirv::IdRef id) const { return mNamesById[id]; } const spirv::LiteralString &getName(spirv::IdRef id) const { return mNamesById[id]; }
...@@ -1515,7 +1515,7 @@ SpirvVariableType SpirvIDDiscoverer::visitVariable(spirv::IdResultType typeId, ...@@ -1515,7 +1515,7 @@ SpirvVariableType SpirvIDDiscoverer::visitVariable(spirv::IdResultType typeId,
return SpirvVariableType::InterfaceVariable; return SpirvVariableType::InterfaceVariable;
} }
void SpirvIDDiscoverer::writePendingDeclarations(SpirvBlob *blobOut) void SpirvIDDiscoverer::writePendingDeclarations(spirv::Blob *blobOut)
{ {
if (!mFloatId.valid()) if (!mFloatId.valid())
{ {
...@@ -1570,7 +1570,7 @@ class SpirvPerVertexTrimmer final : angle::NonCopyable ...@@ -1570,7 +1570,7 @@ class SpirvPerVertexTrimmer final : angle::NonCopyable
TransformationState transformTypeStruct(const SpirvIDDiscoverer &ids, TransformationState transformTypeStruct(const SpirvIDDiscoverer &ids,
spirv::IdResult id, spirv::IdResult id,
spirv::IdRefList *memberList, spirv::IdRefList *memberList,
SpirvBlob *blobOut); spirv::Blob *blobOut);
}; };
TransformationState SpirvPerVertexTrimmer::transformMemberDecorate(const SpirvIDDiscoverer &ids, TransformationState SpirvPerVertexTrimmer::transformMemberDecorate(const SpirvIDDiscoverer &ids,
...@@ -1603,7 +1603,7 @@ TransformationState SpirvPerVertexTrimmer::transformMemberName(const SpirvIDDisc ...@@ -1603,7 +1603,7 @@ TransformationState SpirvPerVertexTrimmer::transformMemberName(const SpirvIDDisc
TransformationState SpirvPerVertexTrimmer::transformTypeStruct(const SpirvIDDiscoverer &ids, TransformationState SpirvPerVertexTrimmer::transformTypeStruct(const SpirvIDDiscoverer &ids,
spirv::IdResult id, spirv::IdResult id,
spirv::IdRefList *memberList, spirv::IdRefList *memberList,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
if (!ids.isPerVertex(id)) if (!ids.isPerVertex(id))
{ {
...@@ -1633,22 +1633,22 @@ class SpirvInactiveVaryingRemover final : angle::NonCopyable ...@@ -1633,22 +1633,22 @@ class SpirvInactiveVaryingRemover final : angle::NonCopyable
spirv::IdResult id, spirv::IdResult id,
spirv::IdRef baseId, spirv::IdRef baseId,
const spirv::IdRefList &indexList, const spirv::IdRefList &indexList,
SpirvBlob *blobOut); spirv::Blob *blobOut);
TransformationState transformDecorate(const ShaderInterfaceVariableInfo &info, TransformationState transformDecorate(const ShaderInterfaceVariableInfo &info,
gl::ShaderType shaderType, gl::ShaderType shaderType,
spirv::IdRef id, spirv::IdRef id,
spv::Decoration decoration, spv::Decoration decoration,
const spirv::LiteralIntegerList &decorationValues, const spirv::LiteralIntegerList &decorationValues,
SpirvBlob *blobOut); spirv::Blob *blobOut);
TransformationState transformTypePointer(const SpirvIDDiscoverer &ids, TransformationState transformTypePointer(const SpirvIDDiscoverer &ids,
spirv::IdResult id, spirv::IdResult id,
spv::StorageClass storageClass, spv::StorageClass storageClass,
spirv::IdRef typeId, spirv::IdRef typeId,
SpirvBlob *blobOut); spirv::Blob *blobOut);
TransformationState transformVariable(spirv::IdResultType typeId, TransformationState transformVariable(spirv::IdResultType typeId,
spirv::IdResult id, spirv::IdResult id,
spv::StorageClass storageClass, spv::StorageClass storageClass,
SpirvBlob *blobOut); spirv::Blob *blobOut);
void modifyEntryPointInterfaceList( void modifyEntryPointInterfaceList(
const std::vector<const ShaderInterfaceVariableInfo *> &variableInfoById, const std::vector<const ShaderInterfaceVariableInfo *> &variableInfoById,
...@@ -1675,7 +1675,7 @@ TransformationState SpirvInactiveVaryingRemover::transformAccessChain( ...@@ -1675,7 +1675,7 @@ TransformationState SpirvInactiveVaryingRemover::transformAccessChain(
spirv::IdResult id, spirv::IdResult id,
spirv::IdRef baseId, spirv::IdRef baseId,
const spirv::IdRefList &indexList, const spirv::IdRefList &indexList,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
// Modifiy the instruction to use the private type. // Modifiy the instruction to use the private type.
ASSERT(typeId < mTypePointerTransformedId.size()); ASSERT(typeId < mTypePointerTransformedId.size());
...@@ -1692,7 +1692,7 @@ TransformationState SpirvInactiveVaryingRemover::transformDecorate( ...@@ -1692,7 +1692,7 @@ TransformationState SpirvInactiveVaryingRemover::transformDecorate(
spirv::IdRef id, spirv::IdRef id,
spv::Decoration decoration, spv::Decoration decoration,
const spirv::LiteralIntegerList &decorationValues, const spirv::LiteralIntegerList &decorationValues,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
// If it's an inactive varying, remove the decoration altogether. // If it's an inactive varying, remove the decoration altogether.
return info.activeStages[shaderType] ? TransformationState::Unchanged return info.activeStages[shaderType] ? TransformationState::Unchanged
...@@ -1731,7 +1731,7 @@ TransformationState SpirvInactiveVaryingRemover::transformTypePointer( ...@@ -1731,7 +1731,7 @@ TransformationState SpirvInactiveVaryingRemover::transformTypePointer(
spirv::IdResult id, spirv::IdResult id,
spv::StorageClass storageClass, spv::StorageClass storageClass,
spirv::IdRef typeId, spirv::IdRef typeId,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
// If the storage class is output, this may be used to create a variable corresponding to an // If the storage class is output, this may be used to create a variable corresponding to an
// inactive varying, or if that varying is a struct, an Op*AccessChain retrieving a field of // inactive varying, or if that varying is a struct, an Op*AccessChain retrieving a field of
...@@ -1770,7 +1770,7 @@ TransformationState SpirvInactiveVaryingRemover::transformTypePointer( ...@@ -1770,7 +1770,7 @@ TransformationState SpirvInactiveVaryingRemover::transformTypePointer(
TransformationState SpirvInactiveVaryingRemover::transformVariable(spirv::IdResultType typeId, TransformationState SpirvInactiveVaryingRemover::transformVariable(spirv::IdResultType typeId,
spirv::IdResult id, spirv::IdResult id,
spv::StorageClass storageClass, spv::StorageClass storageClass,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
ASSERT(storageClass == spv::StorageClassOutput || storageClass == spv::StorageClassInput); ASSERT(storageClass == spv::StorageClassOutput || storageClass == spv::StorageClassInput);
...@@ -1796,24 +1796,24 @@ class SpirvVaryingPrecisionFixer final : angle::NonCopyable ...@@ -1796,24 +1796,24 @@ class SpirvVaryingPrecisionFixer final : angle::NonCopyable
spirv::IdResultType typeId, spirv::IdResultType typeId,
spirv::IdResult id, spirv::IdResult id,
spv::StorageClass storageClass, spv::StorageClass storageClass,
SpirvBlob *blobOut); spirv::Blob *blobOut);
TransformationState transformVariable(const ShaderInterfaceVariableInfo &info, TransformationState transformVariable(const ShaderInterfaceVariableInfo &info,
spirv::IdResultType typeId, spirv::IdResultType typeId,
spirv::IdResult id, spirv::IdResult id,
spv::StorageClass storageClass, spv::StorageClass storageClass,
SpirvBlob *blobOut); spirv::Blob *blobOut);
void modifyEntryPointInterfaceList(spirv::IdRefList *interfaceList); void modifyEntryPointInterfaceList(spirv::IdRefList *interfaceList);
void addDecorate(spirv::IdRef replacedId, SpirvBlob *blobOut); void addDecorate(spirv::IdRef replacedId, spirv::Blob *blobOut);
void writeInputPreamble( void writeInputPreamble(
const std::vector<const ShaderInterfaceVariableInfo *> &variableInfoById, const std::vector<const ShaderInterfaceVariableInfo *> &variableInfoById,
gl::ShaderType shaderType, gl::ShaderType shaderType,
SpirvBlob *blobOut); spirv::Blob *blobOut);
void writeOutputPrologue( void writeOutputPrologue(
const std::vector<const ShaderInterfaceVariableInfo *> &variableInfoById, const std::vector<const ShaderInterfaceVariableInfo *> &variableInfoById,
gl::ShaderType shaderType, gl::ShaderType shaderType,
SpirvBlob *blobOut); spirv::Blob *blobOut);
bool isReplaced(spirv::IdRef id) const { return mFixedVaryingId[id].valid(); } bool isReplaced(spirv::IdRef id) const { return mFixedVaryingId[id].valid(); }
spirv::IdRef getReplacementId(spirv::IdRef id) const spirv::IdRef getReplacementId(spirv::IdRef id) const
...@@ -1847,7 +1847,7 @@ void SpirvVaryingPrecisionFixer::visitVariable(const ShaderInterfaceVariableInfo ...@@ -1847,7 +1847,7 @@ void SpirvVaryingPrecisionFixer::visitVariable(const ShaderInterfaceVariableInfo
spirv::IdResultType typeId, spirv::IdResultType typeId,
spirv::IdResult id, spirv::IdResult id,
spv::StorageClass storageClass, spv::StorageClass storageClass,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
if (info.useRelaxedPrecision && info.activeStages[shaderType] && !mFixedVaryingId[id].valid()) if (info.useRelaxedPrecision && info.activeStages[shaderType] && !mFixedVaryingId[id].valid())
{ {
...@@ -1861,7 +1861,7 @@ TransformationState SpirvVaryingPrecisionFixer::transformVariable( ...@@ -1861,7 +1861,7 @@ TransformationState SpirvVaryingPrecisionFixer::transformVariable(
spirv::IdResultType typeId, spirv::IdResultType typeId,
spirv::IdResult id, spirv::IdResult id,
spv::StorageClass storageClass, spv::StorageClass storageClass,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
if (info.useRelaxedPrecision && if (info.useRelaxedPrecision &&
(storageClass == spv::StorageClassOutput || storageClass == spv::StorageClassInput)) (storageClass == spv::StorageClassOutput || storageClass == spv::StorageClassInput))
...@@ -1878,7 +1878,7 @@ TransformationState SpirvVaryingPrecisionFixer::transformVariable( ...@@ -1878,7 +1878,7 @@ TransformationState SpirvVaryingPrecisionFixer::transformVariable(
void SpirvVaryingPrecisionFixer::writeInputPreamble( void SpirvVaryingPrecisionFixer::writeInputPreamble(
const std::vector<const ShaderInterfaceVariableInfo *> &variableInfoById, const std::vector<const ShaderInterfaceVariableInfo *> &variableInfoById,
gl::ShaderType shaderType, gl::ShaderType shaderType,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
if (shaderType == gl::ShaderType::Vertex || shaderType == gl::ShaderType::Compute) if (shaderType == gl::ShaderType::Vertex || shaderType == gl::ShaderType::Compute)
{ {
...@@ -1920,7 +1920,7 @@ void SpirvVaryingPrecisionFixer::modifyEntryPointInterfaceList(spirv::IdRefList ...@@ -1920,7 +1920,7 @@ void SpirvVaryingPrecisionFixer::modifyEntryPointInterfaceList(spirv::IdRefList
} }
} }
void SpirvVaryingPrecisionFixer::addDecorate(spirv::IdRef replacedId, SpirvBlob *blobOut) void SpirvVaryingPrecisionFixer::addDecorate(spirv::IdRef replacedId, spirv::Blob *blobOut)
{ {
spirv::WriteDecorate(blobOut, replacedId, spv::DecorationRelaxedPrecision, {}); spirv::WriteDecorate(blobOut, replacedId, spv::DecorationRelaxedPrecision, {});
} }
...@@ -1928,7 +1928,7 @@ void SpirvVaryingPrecisionFixer::addDecorate(spirv::IdRef replacedId, SpirvBlob ...@@ -1928,7 +1928,7 @@ void SpirvVaryingPrecisionFixer::addDecorate(spirv::IdRef replacedId, SpirvBlob
void SpirvVaryingPrecisionFixer::writeOutputPrologue( void SpirvVaryingPrecisionFixer::writeOutputPrologue(
const std::vector<const ShaderInterfaceVariableInfo *> &variableInfoById, const std::vector<const ShaderInterfaceVariableInfo *> &variableInfoById,
gl::ShaderType shaderType, gl::ShaderType shaderType,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
if (shaderType == gl::ShaderType::Fragment || shaderType == gl::ShaderType::Compute) if (shaderType == gl::ShaderType::Fragment || shaderType == gl::ShaderType::Compute)
{ {
...@@ -1979,7 +1979,7 @@ class SpirvTransformFeedbackCodeGenerator final : angle::NonCopyable ...@@ -1979,7 +1979,7 @@ class SpirvTransformFeedbackCodeGenerator final : angle::NonCopyable
spirv::IdResult id, spirv::IdResult id,
spv::StorageClass storageClass); spv::StorageClass storageClass);
TransformationState transformCapability(spv::Capability capability, SpirvBlob *blobOut); TransformationState transformCapability(spv::Capability capability, spirv::Blob *blobOut);
TransformationState transformName(spirv::IdRef id, spirv::LiteralString name); TransformationState transformName(spirv::IdRef id, spirv::LiteralString name);
TransformationState transformVariable(const ShaderInterfaceVariableInfo &info, TransformationState transformVariable(const ShaderInterfaceVariableInfo &info,
const ShaderInterfaceVariableInfoMap &variableInfoMap, const ShaderInterfaceVariableInfoMap &variableInfoMap,
...@@ -1991,20 +1991,22 @@ class SpirvTransformFeedbackCodeGenerator final : angle::NonCopyable ...@@ -1991,20 +1991,22 @@ class SpirvTransformFeedbackCodeGenerator final : angle::NonCopyable
void writePendingDeclarations( void writePendingDeclarations(
const std::vector<const ShaderInterfaceVariableInfo *> &variableInfoById, const std::vector<const ShaderInterfaceVariableInfo *> &variableInfoById,
const SpirvIDDiscoverer &ids, const SpirvIDDiscoverer &ids,
SpirvBlob *blobOut); spirv::Blob *blobOut);
void writeTransformFeedbackExtensionOutput(const SpirvIDDiscoverer &ids, void writeTransformFeedbackExtensionOutput(const SpirvIDDiscoverer &ids,
spirv::IdRef positionId, spirv::IdRef positionId,
SpirvBlob *blobOut); spirv::Blob *blobOut);
void writeTransformFeedbackEmulationOutput( void writeTransformFeedbackEmulationOutput(
const SpirvIDDiscoverer &ids, const SpirvIDDiscoverer &ids,
const SpirvVaryingPrecisionFixer &varyingPrecisionFixer, const SpirvVaryingPrecisionFixer &varyingPrecisionFixer,
spirv::IdRef currentFunctionId, spirv::IdRef currentFunctionId,
SpirvBlob *blobOut); spirv::Blob *blobOut);
void addExecutionMode(spirv::IdRef entryPointId, SpirvBlob *blobOut); void addExecutionMode(spirv::IdRef entryPointId, spirv::Blob *blobOut);
void addMemberDecorate(const ShaderInterfaceVariableInfo &info, void addMemberDecorate(const ShaderInterfaceVariableInfo &info,
spirv::IdRef id, spirv::IdRef id,
SpirvBlob *blobOut); spirv::Blob *blobOut);
void addDecorate(const ShaderInterfaceVariableInfo &info, spirv::IdRef id, SpirvBlob *blobOut); void addDecorate(const ShaderInterfaceVariableInfo &info,
spirv::IdRef id,
spirv::Blob *blobOut);
private: private:
void gatherXfbVaryings(const ShaderInterfaceVariableInfo &info, spirv::IdRef id); void gatherXfbVaryings(const ShaderInterfaceVariableInfo &info, spirv::IdRef id);
...@@ -2014,13 +2016,13 @@ class SpirvTransformFeedbackCodeGenerator final : angle::NonCopyable ...@@ -2014,13 +2016,13 @@ class SpirvTransformFeedbackCodeGenerator final : angle::NonCopyable
void writeIntConstant(const SpirvIDDiscoverer &ids, void writeIntConstant(const SpirvIDDiscoverer &ids,
uint32_t value, uint32_t value,
spirv::IdRef intId, spirv::IdRef intId,
SpirvBlob *blobOut); spirv::Blob *blobOut);
void getVaryingTypeIds(const SpirvIDDiscoverer &ids, void getVaryingTypeIds(const SpirvIDDiscoverer &ids,
GLenum componentType, GLenum componentType,
bool isPrivate, bool isPrivate,
spirv::IdRef *typeIdOut, spirv::IdRef *typeIdOut,
spirv::IdRef *typePtrOut); spirv::IdRef *typePtrOut);
void writeGetOffsetsCall(spirv::IdRef xfbOffsets, SpirvBlob *blobOut); void writeGetOffsetsCall(spirv::IdRef xfbOffsets, spirv::Blob *blobOut);
void writeComponentCapture(const SpirvIDDiscoverer &ids, void writeComponentCapture(const SpirvIDDiscoverer &ids,
uint32_t bufferIndex, uint32_t bufferIndex,
spirv::IdRef xfbOffset, spirv::IdRef xfbOffset,
...@@ -2029,7 +2031,7 @@ class SpirvTransformFeedbackCodeGenerator final : angle::NonCopyable ...@@ -2029,7 +2031,7 @@ class SpirvTransformFeedbackCodeGenerator final : angle::NonCopyable
spirv::IdRef varyingBaseId, spirv::IdRef varyingBaseId,
const spirv::IdRefList &accessChainIndices, const spirv::IdRefList &accessChainIndices,
GLenum componentType, GLenum componentType,
SpirvBlob *blobOut); spirv::Blob *blobOut);
static constexpr size_t kXfbDecorationCount = 3; static constexpr size_t kXfbDecorationCount = 3;
static constexpr spv::Decoration kXfbDecorations[kXfbDecorationCount] = { static constexpr spv::Decoration kXfbDecorations[kXfbDecorationCount] = {
...@@ -2179,7 +2181,7 @@ void SpirvTransformFeedbackCodeGenerator::visitVariable(const ShaderInterfaceVar ...@@ -2179,7 +2181,7 @@ void SpirvTransformFeedbackCodeGenerator::visitVariable(const ShaderInterfaceVar
TransformationState SpirvTransformFeedbackCodeGenerator::transformCapability( TransformationState SpirvTransformFeedbackCodeGenerator::transformCapability(
spv::Capability capability, spv::Capability capability,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
if (!mHasTransformFeedbackOutput || mIsEmulated) if (!mHasTransformFeedbackOutput || mIsEmulated)
{ {
...@@ -2276,7 +2278,7 @@ void SpirvTransformFeedbackCodeGenerator::visitXfbVarying(const ShaderInterfaceV ...@@ -2276,7 +2278,7 @@ void SpirvTransformFeedbackCodeGenerator::visitXfbVarying(const ShaderInterfaceV
void SpirvTransformFeedbackCodeGenerator::writeIntConstant(const SpirvIDDiscoverer &ids, void SpirvTransformFeedbackCodeGenerator::writeIntConstant(const SpirvIDDiscoverer &ids,
uint32_t value, uint32_t value,
spirv::IdRef intId, spirv::IdRef intId,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
if (value == ShaderInterfaceVariableXfbInfo::kInvalid) if (value == ShaderInterfaceVariableXfbInfo::kInvalid)
{ {
...@@ -2300,7 +2302,7 @@ void SpirvTransformFeedbackCodeGenerator::writeIntConstant(const SpirvIDDiscover ...@@ -2300,7 +2302,7 @@ void SpirvTransformFeedbackCodeGenerator::writeIntConstant(const SpirvIDDiscover
void SpirvTransformFeedbackCodeGenerator::writePendingDeclarations( void SpirvTransformFeedbackCodeGenerator::writePendingDeclarations(
const std::vector<const ShaderInterfaceVariableInfo *> &variableInfoById, const std::vector<const ShaderInterfaceVariableInfo *> &variableInfoById,
const SpirvIDDiscoverer &ids, const SpirvIDDiscoverer &ids,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
if (!mIsEmulated) if (!mIsEmulated)
{ {
...@@ -2396,7 +2398,7 @@ void SpirvTransformFeedbackCodeGenerator::writePendingDeclarations( ...@@ -2396,7 +2398,7 @@ void SpirvTransformFeedbackCodeGenerator::writePendingDeclarations(
void SpirvTransformFeedbackCodeGenerator::writeTransformFeedbackExtensionOutput( void SpirvTransformFeedbackCodeGenerator::writeTransformFeedbackExtensionOutput(
const SpirvIDDiscoverer &ids, const SpirvIDDiscoverer &ids,
spirv::IdRef positionId, spirv::IdRef positionId,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
if (mIsEmulated) if (mIsEmulated)
{ {
...@@ -2440,7 +2442,7 @@ void SpirvTransformFeedbackCodeGenerator::writeTransformFeedbackEmulationOutput( ...@@ -2440,7 +2442,7 @@ void SpirvTransformFeedbackCodeGenerator::writeTransformFeedbackEmulationOutput(
const SpirvIDDiscoverer &ids, const SpirvIDDiscoverer &ids,
const SpirvVaryingPrecisionFixer &varyingPrecisionFixer, const SpirvVaryingPrecisionFixer &varyingPrecisionFixer,
spirv::IdRef currentFunctionId, spirv::IdRef currentFunctionId,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
if (!mIsEmulated || !mXfbCaptureFuncId.valid() || currentFunctionId != mXfbCaptureFuncId) if (!mIsEmulated || !mXfbCaptureFuncId.valid() || currentFunctionId != mXfbCaptureFuncId)
{ {
...@@ -2649,7 +2651,7 @@ void SpirvTransformFeedbackCodeGenerator::getVaryingTypeIds(const SpirvIDDiscove ...@@ -2649,7 +2651,7 @@ void SpirvTransformFeedbackCodeGenerator::getVaryingTypeIds(const SpirvIDDiscove
} }
void SpirvTransformFeedbackCodeGenerator::writeGetOffsetsCall(spirv::IdRef xfbOffsets, void SpirvTransformFeedbackCodeGenerator::writeGetOffsetsCall(spirv::IdRef xfbOffsets,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
const spirv::IdRef xfbGetOffsetsParam(SpirvTransformerBase::GetNewId(blobOut)); const spirv::IdRef xfbGetOffsetsParam(SpirvTransformerBase::GetNewId(blobOut));
const spirv::IdRef xfbOffsetsResult(SpirvTransformerBase::GetNewId(blobOut)); const spirv::IdRef xfbOffsetsResult(SpirvTransformerBase::GetNewId(blobOut));
...@@ -2685,7 +2687,7 @@ void SpirvTransformFeedbackCodeGenerator::writeComponentCapture( ...@@ -2685,7 +2687,7 @@ void SpirvTransformFeedbackCodeGenerator::writeComponentCapture(
spirv::IdRef varyingBaseId, spirv::IdRef varyingBaseId,
const spirv::IdRefList &accessChainIndices, const spirv::IdRefList &accessChainIndices,
GLenum componentType, GLenum componentType,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
spirv::IdRef component(SpirvTransformerBase::GetNewId(blobOut)); spirv::IdRef component(SpirvTransformerBase::GetNewId(blobOut));
spirv::IdRef xfbOutPtr(SpirvTransformerBase::GetNewId(blobOut)); spirv::IdRef xfbOutPtr(SpirvTransformerBase::GetNewId(blobOut));
...@@ -2723,7 +2725,7 @@ void SpirvTransformFeedbackCodeGenerator::writeComponentCapture( ...@@ -2723,7 +2725,7 @@ void SpirvTransformFeedbackCodeGenerator::writeComponentCapture(
} }
void SpirvTransformFeedbackCodeGenerator::addExecutionMode(spirv::IdRef entryPointId, void SpirvTransformFeedbackCodeGenerator::addExecutionMode(spirv::IdRef entryPointId,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
if (mIsEmulated) if (mIsEmulated)
{ {
...@@ -2738,7 +2740,7 @@ void SpirvTransformFeedbackCodeGenerator::addExecutionMode(spirv::IdRef entryPoi ...@@ -2738,7 +2740,7 @@ void SpirvTransformFeedbackCodeGenerator::addExecutionMode(spirv::IdRef entryPoi
void SpirvTransformFeedbackCodeGenerator::addMemberDecorate(const ShaderInterfaceVariableInfo &info, void SpirvTransformFeedbackCodeGenerator::addMemberDecorate(const ShaderInterfaceVariableInfo &info,
spirv::IdRef id, spirv::IdRef id,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
if (mIsEmulated || info.fieldXfb.empty()) if (mIsEmulated || info.fieldXfb.empty())
{ {
...@@ -2779,7 +2781,7 @@ void SpirvTransformFeedbackCodeGenerator::addMemberDecorate(const ShaderInterfac ...@@ -2779,7 +2781,7 @@ void SpirvTransformFeedbackCodeGenerator::addMemberDecorate(const ShaderInterfac
void SpirvTransformFeedbackCodeGenerator::addDecorate(const ShaderInterfaceVariableInfo &info, void SpirvTransformFeedbackCodeGenerator::addDecorate(const ShaderInterfaceVariableInfo &info,
spirv::IdRef id, spirv::IdRef id,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
if (mIsEmulated || info.xfb.buffer == ShaderInterfaceVariableXfbInfo::kInvalid) if (mIsEmulated || info.xfb.buffer == ShaderInterfaceVariableXfbInfo::kInvalid)
{ {
...@@ -2816,7 +2818,7 @@ class SpirvPositionTransformer final : angle::NonCopyable ...@@ -2816,7 +2818,7 @@ class SpirvPositionTransformer final : angle::NonCopyable
void writePositionTransformation(const SpirvIDDiscoverer &ids, void writePositionTransformation(const SpirvIDDiscoverer &ids,
spirv::IdRef positionPointerId, spirv::IdRef positionPointerId,
spirv::IdRef positionId, spirv::IdRef positionId,
SpirvBlob *blobOut); spirv::Blob *blobOut);
private: private:
void preRotateXY(const SpirvIDDiscoverer &ids, void preRotateXY(const SpirvIDDiscoverer &ids,
...@@ -2824,12 +2826,12 @@ class SpirvPositionTransformer final : angle::NonCopyable ...@@ -2824,12 +2826,12 @@ class SpirvPositionTransformer final : angle::NonCopyable
spirv::IdRef yId, spirv::IdRef yId,
spirv::IdRef *rotatedXIdOut, spirv::IdRef *rotatedXIdOut,
spirv::IdRef *rotatedYIdOut, spirv::IdRef *rotatedYIdOut,
SpirvBlob *blobOut); spirv::Blob *blobOut);
void transformZToVulkanClipSpace(const SpirvIDDiscoverer &ids, void transformZToVulkanClipSpace(const SpirvIDDiscoverer &ids,
spirv::IdRef zId, spirv::IdRef zId,
spirv::IdRef wId, spirv::IdRef wId,
spirv::IdRef *correctedZIdOut, spirv::IdRef *correctedZIdOut,
SpirvBlob *blobOut); spirv::Blob *blobOut);
GlslangSpirvOptions mOptions; GlslangSpirvOptions mOptions;
}; };
...@@ -2837,7 +2839,7 @@ class SpirvPositionTransformer final : angle::NonCopyable ...@@ -2837,7 +2839,7 @@ class SpirvPositionTransformer final : angle::NonCopyable
void SpirvPositionTransformer::writePositionTransformation(const SpirvIDDiscoverer &ids, void SpirvPositionTransformer::writePositionTransformation(const SpirvIDDiscoverer &ids,
spirv::IdRef positionPointerId, spirv::IdRef positionPointerId,
spirv::IdRef positionId, spirv::IdRef positionId,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
// In GL the viewport transformation is slightly different - see the GL 2.0 spec section "2.12.1 // In GL the viewport transformation is slightly different - see the GL 2.0 spec section "2.12.1
// Controlling the Viewport". In Vulkan the corresponding spec section is currently "23.4. // Controlling the Viewport". In Vulkan the corresponding spec section is currently "23.4.
...@@ -2902,7 +2904,7 @@ void SpirvPositionTransformer::preRotateXY(const SpirvIDDiscoverer &ids, ...@@ -2902,7 +2904,7 @@ void SpirvPositionTransformer::preRotateXY(const SpirvIDDiscoverer &ids,
spirv::IdRef yId, spirv::IdRef yId,
spirv::IdRef *rotatedXIdOut, spirv::IdRef *rotatedXIdOut,
spirv::IdRef *rotatedYIdOut, spirv::IdRef *rotatedYIdOut,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
switch (mOptions.preRotation) switch (mOptions.preRotation)
{ {
...@@ -2963,7 +2965,7 @@ void SpirvPositionTransformer::transformZToVulkanClipSpace(const SpirvIDDiscover ...@@ -2963,7 +2965,7 @@ void SpirvPositionTransformer::transformZToVulkanClipSpace(const SpirvIDDiscover
spirv::IdRef zId, spirv::IdRef zId,
spirv::IdRef wId, spirv::IdRef wId,
spirv::IdRef *correctedZIdOut, spirv::IdRef *correctedZIdOut,
SpirvBlob *blobOut) spirv::Blob *blobOut)
{ {
if (!mOptions.transformPositionToVulkanClipSpace) if (!mOptions.transformPositionToVulkanClipSpace)
{ {
...@@ -2986,10 +2988,10 @@ void SpirvPositionTransformer::transformZToVulkanClipSpace(const SpirvIDDiscover ...@@ -2986,10 +2988,10 @@ void SpirvPositionTransformer::transformZToVulkanClipSpace(const SpirvIDDiscover
class SpirvTransformer final : public SpirvTransformerBase class SpirvTransformer final : public SpirvTransformerBase
{ {
public: public:
SpirvTransformer(const SpirvBlob &spirvBlobIn, SpirvTransformer(const spirv::Blob &spirvBlobIn,
const GlslangSpirvOptions &options, const GlslangSpirvOptions &options,
const ShaderInterfaceVariableInfoMap &variableInfoMap, const ShaderInterfaceVariableInfoMap &variableInfoMap,
SpirvBlob *spirvBlobOut) spirv::Blob *spirvBlobOut)
: SpirvTransformerBase(spirvBlobIn, variableInfoMap, spirvBlobOut), : SpirvTransformerBase(spirvBlobIn, variableInfoMap, spirvBlobOut),
mOptions(options), mOptions(options),
mXfbCodeGenerator(options.isTransformFeedbackEmulated), mXfbCodeGenerator(options.isTransformFeedbackEmulated),
...@@ -3832,10 +3834,10 @@ class SpirvVertexAttributeAliasingTransformer final : public SpirvTransformerBas ...@@ -3832,10 +3834,10 @@ class SpirvVertexAttributeAliasingTransformer final : public SpirvTransformerBas
{ {
public: public:
SpirvVertexAttributeAliasingTransformer( SpirvVertexAttributeAliasingTransformer(
const SpirvBlob &spirvBlobIn, const spirv::Blob &spirvBlobIn,
const ShaderInterfaceVariableInfoMap &variableInfoMap, const ShaderInterfaceVariableInfoMap &variableInfoMap,
std::vector<const ShaderInterfaceVariableInfo *> &&variableInfoById, std::vector<const ShaderInterfaceVariableInfo *> &&variableInfoById,
SpirvBlob *spirvBlobOut) spirv::Blob *spirvBlobOut)
: SpirvTransformerBase(spirvBlobIn, variableInfoMap, spirvBlobOut) : SpirvTransformerBase(spirvBlobIn, variableInfoMap, spirvBlobOut)
{ {
mVariableInfoById = std::move(variableInfoById); mVariableInfoById = std::move(variableInfoById);
...@@ -5042,8 +5044,8 @@ void GlslangGetShaderSource(const GlslangSourceOptions &options, ...@@ -5042,8 +5044,8 @@ void GlslangGetShaderSource(const GlslangSourceOptions &options,
angle::Result GlslangTransformSpirvCode(const GlslangErrorCallback &callback, angle::Result GlslangTransformSpirvCode(const GlslangErrorCallback &callback,
const GlslangSpirvOptions &options, const GlslangSpirvOptions &options,
const ShaderInterfaceVariableInfoMap &variableInfoMap, const ShaderInterfaceVariableInfoMap &variableInfoMap,
const SpirvBlob &initialSpirvBlob, const spirv::Blob &initialSpirvBlob,
SpirvBlob *spirvBlobOut) spirv::Blob *spirvBlobOut)
{ {
if (initialSpirvBlob.empty()) if (initialSpirvBlob.empty())
{ {
...@@ -5065,7 +5067,7 @@ angle::Result GlslangTransformSpirvCode(const GlslangErrorCallback &callback, ...@@ -5065,7 +5067,7 @@ angle::Result GlslangTransformSpirvCode(const GlslangErrorCallback &callback,
// If there are aliasing vertex attributes, transform the SPIR-V again to remove them. // If there are aliasing vertex attributes, transform the SPIR-V again to remove them.
if (options.shaderType == gl::ShaderType::Vertex && HasAliasingAttributes(variableInfoMap)) if (options.shaderType == gl::ShaderType::Vertex && HasAliasingAttributes(variableInfoMap))
{ {
SpirvBlob preTransformBlob = std::move(*spirvBlobOut); spirv::Blob preTransformBlob = std::move(*spirvBlobOut);
SpirvVertexAttributeAliasingTransformer aliasingTransformer( SpirvVertexAttributeAliasingTransformer aliasingTransformer(
preTransformBlob, variableInfoMap, std::move(transformer.getVariableInfoByIdMap()), preTransformBlob, variableInfoMap, std::move(transformer.getVariableInfoByIdMap()),
spirvBlobOut); spirvBlobOut);
...@@ -5081,7 +5083,7 @@ angle::Result GlslangGetShaderSpirvCode(const GlslangErrorCallback &callback, ...@@ -5081,7 +5083,7 @@ angle::Result GlslangGetShaderSpirvCode(const GlslangErrorCallback &callback,
const gl::ShaderBitSet &linkedShaderStages, const gl::ShaderBitSet &linkedShaderStages,
const gl::Caps &glCaps, const gl::Caps &glCaps,
const gl::ShaderMap<std::string> &shaderSources, const gl::ShaderMap<std::string> &shaderSources,
gl::ShaderMap<SpirvBlob> *spirvBlobsOut) gl::ShaderMap<spirv::Blob> *spirvBlobsOut)
{ {
TBuiltInResource builtInResources(glslang::DefaultTBuiltInResource); TBuiltInResource builtInResources(glslang::DefaultTBuiltInResource);
GetBuiltInResourcesFromCaps(glCaps, &builtInResources); GetBuiltInResourcesFromCaps(glCaps, &builtInResources);
......
src/libANGLE/renderer/glslang_wrapper_utils.h
...@@ -11,6 +11,7 @@ ...@@ -11,6 +11,7 @@
#include <functional> #include <functional>
#include "common/spirv/spirv_types.h"
#include "libANGLE/renderer/ProgramImpl.h" #include "libANGLE/renderer/ProgramImpl.h"
#include "libANGLE/renderer/renderer_utils.h" #include "libANGLE/renderer/renderer_utils.h"
...@@ -68,8 +69,6 @@ struct GlslangSpirvOptions ...@@ -68,8 +69,6 @@ struct GlslangSpirvOptions
bool isTransformFeedbackEmulated = false; bool isTransformFeedbackEmulated = false;
}; };
using SpirvBlob = std::vector<uint32_t>;
using GlslangErrorCallback = std::function<angle::Result(GlslangError)>; using GlslangErrorCallback = std::function<angle::Result(GlslangError)>;
struct ShaderInterfaceVariableXfbInfo struct ShaderInterfaceVariableXfbInfo
...@@ -203,14 +202,14 @@ void GlslangGetShaderSource(const GlslangSourceOptions &options, ...@@ -203,14 +202,14 @@ void GlslangGetShaderSource(const GlslangSourceOptions &options,
angle::Result GlslangTransformSpirvCode(const GlslangErrorCallback &callback, angle::Result GlslangTransformSpirvCode(const GlslangErrorCallback &callback,
const GlslangSpirvOptions &options, const GlslangSpirvOptions &options,
const ShaderInterfaceVariableInfoMap &variableInfoMap, const ShaderInterfaceVariableInfoMap &variableInfoMap,
const SpirvBlob &initialSpirvBlob, const angle::spirv::Blob &initialSpirvBlob,
SpirvBlob *spirvBlobOut); angle::spirv::Blob *spirvBlobOut);
angle::Result GlslangGetShaderSpirvCode(const GlslangErrorCallback &callback, angle::Result GlslangGetShaderSpirvCode(const GlslangErrorCallback &callback,
const gl::ShaderBitSet &linkedShaderStages, const gl::ShaderBitSet &linkedShaderStages,
const gl::Caps &glCaps, const gl::Caps &glCaps,
const gl::ShaderMap<std::string> &shaderSources, const gl::ShaderMap<std::string> &shaderSources,
gl::ShaderMap<SpirvBlob> *spirvBlobsOut); gl::ShaderMap<angle::spirv::Blob> *spirvBlobsOut);
} // namespace rx } // namespace rx
......
src/libANGLE/renderer/metal/ProgramMtl.mm
...@@ -323,8 +323,8 @@ angle::Result ProgramMtl::linkImpl(const gl::Context *glContext, ...@@ -323,8 +323,8 @@ angle::Result ProgramMtl::linkImpl(const gl::Context *glContext,
&xfbOnlyVariableInfoMap); &xfbOnlyVariableInfoMap);
// Convert GLSL to spirv code // Convert GLSL to spirv code
gl::ShaderMap<std::vector<uint32_t>> shaderCodes; gl::ShaderMap<angle::spirv::Blob> shaderCodes;
gl::ShaderMap<std::vector<uint32_t>> xfbOnlyShaderCodes; // only vertex shader is needed. gl::ShaderMap<angle::spirv::Blob> xfbOnlyShaderCodes; // only vertex shader is needed.
ANGLE_TRY(mtl::GlslangGetShaderSpirvCode( ANGLE_TRY(mtl::GlslangGetShaderSpirvCode(
contextMtl, mState.getExecutable().getLinkedShaderStages(), contextMtl->getCaps(), contextMtl, mState.getExecutable().getLinkedShaderStages(), contextMtl->getCaps(),
shaderSources, false, variableInfoMap, &shaderCodes)); shaderSources, false, variableInfoMap, &shaderCodes));
......
src/libANGLE/renderer/metal/mtl_glslang_utils.h
...@@ -54,7 +54,7 @@ angle::Result GlslangGetShaderSpirvCode(ErrorHandler *context, ...@@ -54,7 +54,7 @@ angle::Result GlslangGetShaderSpirvCode(ErrorHandler *context,
const gl::ShaderMap<std::string> &shaderSources, const gl::ShaderMap<std::string> &shaderSources,
bool isTransformFeedbackEnabled, bool isTransformFeedbackEnabled,
const ShaderInterfaceVariableInfoMap &variableInfoMap, const ShaderInterfaceVariableInfoMap &variableInfoMap,
gl::ShaderMap<std::vector<uint32_t>> *shaderCodeOut); gl::ShaderMap<angle::spirv::Blob> *shaderCodeOut);
// Translate from SPIR-V code to Metal shader source code. // Translate from SPIR-V code to Metal shader source code.
// - spirvShaderCode is SPIRV code per shader stage when XFB emulation is turned off. // - spirvShaderCode is SPIRV code per shader stage when XFB emulation is turned off.
...@@ -64,8 +64,8 @@ angle::Result GlslangGetShaderSpirvCode(ErrorHandler *context, ...@@ -64,8 +64,8 @@ angle::Result GlslangGetShaderSpirvCode(ErrorHandler *context,
angle::Result SpirvCodeToMsl(Context *context, angle::Result SpirvCodeToMsl(Context *context,
const gl::ProgramState &programState, const gl::ProgramState &programState,
const ShaderInterfaceVariableInfoMap &xfbVSVariableInfoMap, const ShaderInterfaceVariableInfoMap &xfbVSVariableInfoMap,
gl::ShaderMap<std::vector<uint32_t>> *spirvShaderCode, gl::ShaderMap<angle::spirv::Blob> *spirvShaderCode,
std::vector<uint32_t> *xfbOnlySpirvCode /** nullable */, angle::spirv::Blob *xfbOnlySpirvCode /** nullable */,
gl::ShaderMap<TranslatedShaderInfo> *mslShaderInfoOut, gl::ShaderMap<TranslatedShaderInfo> *mslShaderInfoOut,
TranslatedShaderInfo *mslXfbOnlyShaderInfoOut /** nullable */); TranslatedShaderInfo *mslXfbOnlyShaderInfoOut /** nullable */);
......
src/libANGLE/renderer/metal/mtl_glslang_utils.mm
...@@ -272,7 +272,7 @@ std::string PostProcessTranslatedMsl(const std::string &translatedSource) ...@@ -272,7 +272,7 @@ std::string PostProcessTranslatedMsl(const std::string &translatedSource)
class SpirvToMslCompiler : public spirv_cross::CompilerMSL class SpirvToMslCompiler : public spirv_cross::CompilerMSL
{ {
public: public:
SpirvToMslCompiler(std::vector<uint32_t> &&spriv) : spirv_cross::CompilerMSL(spriv) {} SpirvToMslCompiler(angle::spirv::Blob &&spriv) : spirv_cross::CompilerMSL(spriv) {}
void compileEx(gl::ShaderType shaderType, void compileEx(gl::ShaderType shaderType,
const angle::HashMap<std::string, uint32_t> &uboOriginalBindings, const angle::HashMap<std::string, uint32_t> &uboOriginalBindings,
...@@ -358,7 +358,7 @@ angle::Result ConvertSpirvToMsl(Context *context, ...@@ -358,7 +358,7 @@ angle::Result ConvertSpirvToMsl(Context *context,
const angle::HashMap<uint32_t, uint32_t> &xfbOriginalBindings, const angle::HashMap<uint32_t, uint32_t> &xfbOriginalBindings,
const OriginalSamplerBindingMap &originalSamplerBindings, const OriginalSamplerBindingMap &originalSamplerBindings,
bool disableRasterization, bool disableRasterization,
std::vector<uint32_t> *sprivCode, angle::spirv::Blob *sprivCode,
TranslatedShaderInfo *translatedShaderInfoOut) TranslatedShaderInfo *translatedShaderInfoOut)
{ {
if (!sprivCode || sprivCode->empty()) if (!sprivCode || sprivCode->empty())
...@@ -439,9 +439,9 @@ angle::Result GlslangGetShaderSpirvCode(ErrorHandler *context, ...@@ -439,9 +439,9 @@ angle::Result GlslangGetShaderSpirvCode(ErrorHandler *context,
const gl::ShaderMap<std::string> &shaderSources, const gl::ShaderMap<std::string> &shaderSources,
bool isTransformFeedbackEnabled, bool isTransformFeedbackEnabled,
const ShaderInterfaceVariableInfoMap &variableInfoMap, const ShaderInterfaceVariableInfoMap &variableInfoMap,
gl::ShaderMap<std::vector<uint32_t>> *shaderCodeOut) gl::ShaderMap<angle::spirv::Blob> *shaderCodeOut)
{ {
gl::ShaderMap<SpirvBlob> initialSpirvBlobs; gl::ShaderMap<angle::spirv::Blob> initialSpirvBlobs;
ANGLE_TRY(rx::GlslangGetShaderSpirvCode( ANGLE_TRY(rx::GlslangGetShaderSpirvCode(
[context](GlslangError error) { return HandleError(context, error); }, linkedShaderStages, [context](GlslangError error) { return HandleError(context, error); }, linkedShaderStages,
...@@ -471,8 +471,8 @@ angle::Result GlslangGetShaderSpirvCode(ErrorHandler *context, ...@@ -471,8 +471,8 @@ angle::Result GlslangGetShaderSpirvCode(ErrorHandler *context,
angle::Result SpirvCodeToMsl(Context *context, angle::Result SpirvCodeToMsl(Context *context,
const gl::ProgramState &programState, const gl::ProgramState &programState,
const ShaderInterfaceVariableInfoMap &xfbVSVariableInfoMap, const ShaderInterfaceVariableInfoMap &xfbVSVariableInfoMap,
gl::ShaderMap<std::vector<uint32_t>> *spirvShaderCode, gl::ShaderMap<angle::spirv::Blob> *spirvShaderCode,
std::vector<uint32_t> *xfbOnlySpirvCode /** nullable */, angle::spirv::Blob *xfbOnlySpirvCode /** nullable */,
gl::ShaderMap<TranslatedShaderInfo> *mslShaderInfoOut, gl::ShaderMap<TranslatedShaderInfo> *mslShaderInfoOut,
TranslatedShaderInfo *mslXfbOnlyShaderInfoOut /** nullable */) TranslatedShaderInfo *mslXfbOnlyShaderInfoOut /** nullable */)
{ {
...@@ -518,7 +518,7 @@ angle::Result SpirvCodeToMsl(Context *context, ...@@ -518,7 +518,7 @@ angle::Result SpirvCodeToMsl(Context *context,
// Do the actual translation // Do the actual translation
for (gl::ShaderType shaderType : gl::kAllGLES2ShaderTypes) for (gl::ShaderType shaderType : gl::kAllGLES2ShaderTypes)
{ {
std::vector<uint32_t> &sprivCode = spirvShaderCode->at(shaderType); angle::spirv::Blob &sprivCode = spirvShaderCode->at(shaderType);
ANGLE_TRY(ConvertSpirvToMsl(context, shaderType, uboOriginalBindings, xfbOriginalBindings, ANGLE_TRY(ConvertSpirvToMsl(context, shaderType, uboOriginalBindings, xfbOriginalBindings,
originalSamplerBindings, /* disableRasterization */ false, originalSamplerBindings, /* disableRasterization */ false,
&sprivCode, &mslShaderInfoOut->at(shaderType))); &sprivCode, &mslShaderInfoOut->at(shaderType)));
......
src/libANGLE/renderer/vulkan/GlslangWrapperVk.cpp
...@@ -86,8 +86,8 @@ angle::Result GlslangWrapperVk::TransformSpirV( ...@@ -86,8 +86,8 @@ angle::Result GlslangWrapperVk::TransformSpirV(
vk::Context *context, vk::Context *context,
const GlslangSpirvOptions &options, const GlslangSpirvOptions &options,
const ShaderInterfaceVariableInfoMap &variableInfoMap, const ShaderInterfaceVariableInfoMap &variableInfoMap,
const SpirvBlob &initialSpirvBlob, const angle::spirv::Blob &initialSpirvBlob,
SpirvBlob *shaderCodeOut) angle::spirv::Blob *shaderCodeOut)
{ {
return GlslangTransformSpirvCode( return GlslangTransformSpirvCode(
[context](GlslangError error) { return ErrorHandler(context, error); }, options, [context](GlslangError error) { return ErrorHandler(context, error); }, options,
......
src/libANGLE/renderer/vulkan/GlslangWrapperVk.h
...@@ -46,8 +46,8 @@ class GlslangWrapperVk ...@@ -46,8 +46,8 @@ class GlslangWrapperVk
static angle::Result TransformSpirV(vk::Context *context, static angle::Result TransformSpirV(vk::Context *context,
const GlslangSpirvOptions &options, const GlslangSpirvOptions &options,
const ShaderInterfaceVariableInfoMap &variableInfoMap, const ShaderInterfaceVariableInfoMap &variableInfoMap,
const SpirvBlob &initialSpirvBlob, const angle::spirv::Blob &initialSpirvBlob,
SpirvBlob *shaderCodeOut); angle::spirv::Blob *shaderCodeOut);
}; };
} // namespace rx } // namespace rx
......
src/libANGLE/renderer/vulkan/ProgramExecutableVk.cpp
...@@ -63,7 +63,7 @@ void SaveShaderInterfaceVariableXfbInfo(const ShaderInterfaceVariableXfbInfo &xf ...@@ -63,7 +63,7 @@ void SaveShaderInterfaceVariableXfbInfo(const ShaderInterfaceVariableXfbInfo &xf
bool ValidateTransformedSpirV(ContextVk *contextVk, bool ValidateTransformedSpirV(ContextVk *contextVk,
const gl::ShaderBitSet &linkedShaderStages, const gl::ShaderBitSet &linkedShaderStages,
const ShaderInterfaceVariableInfoMap &variableInfoMap, const ShaderInterfaceVariableInfoMap &variableInfoMap,
const gl::ShaderMap<SpirvBlob> &spirvBlobs) const gl::ShaderMap<angle::spirv::Blob> &spirvBlobs)
{ {
const gl::ShaderType lastPreFragmentStage = gl::GetLastPreFragmentStage(linkedShaderStages); const gl::ShaderType lastPreFragmentStage = gl::GetLastPreFragmentStage(linkedShaderStages);
...@@ -78,7 +78,7 @@ bool ValidateTransformedSpirV(ContextVk *contextVk, ...@@ -78,7 +78,7 @@ bool ValidateTransformedSpirV(ContextVk *contextVk,
options.removeDebugInfo = true; options.removeDebugInfo = true;
options.isTransformFeedbackStage = shaderType == lastPreFragmentStage; options.isTransformFeedbackStage = shaderType == lastPreFragmentStage;
SpirvBlob transformed; angle::spirv::Blob transformed;
if (GlslangWrapperVk::TransformSpirV(contextVk, options, variableInfoMap, if (GlslangWrapperVk::TransformSpirV(contextVk, options, variableInfoMap,
spirvBlobs[shaderType], spirvBlobs[shaderType],
&transformed) != angle::Result::Continue) &transformed) != angle::Result::Continue)
...@@ -118,7 +118,7 @@ angle::Result ShaderInfo::initShaders(ContextVk *contextVk, ...@@ -118,7 +118,7 @@ angle::Result ShaderInfo::initShaders(ContextVk *contextVk,
void ShaderInfo::release(ContextVk *contextVk) void ShaderInfo::release(ContextVk *contextVk)
{ {
for (SpirvBlob &spirvBlob : mSpirvBlobs) for (angle::spirv::Blob &spirvBlob : mSpirvBlobs)
{ {
spirvBlob.clear(); spirvBlob.clear();
} }
...@@ -130,7 +130,7 @@ void ShaderInfo::load(gl::BinaryInputStream *stream) ...@@ -130,7 +130,7 @@ void ShaderInfo::load(gl::BinaryInputStream *stream)
// Read in shader codes for all shader types // Read in shader codes for all shader types
for (const gl::ShaderType shaderType : gl::AllShaderTypes()) for (const gl::ShaderType shaderType : gl::AllShaderTypes())
{ {
SpirvBlob *spirvBlob = &mSpirvBlobs[shaderType]; angle::spirv::Blob *spirvBlob = &mSpirvBlobs[shaderType];
// Read the SPIR-V // Read the SPIR-V
stream->readIntVector<uint32_t>(spirvBlob); stream->readIntVector<uint32_t>(spirvBlob);
...@@ -146,7 +146,7 @@ void ShaderInfo::save(gl::BinaryOutputStream *stream) ...@@ -146,7 +146,7 @@ void ShaderInfo::save(gl::BinaryOutputStream *stream)
// Write out shader codes for all shader types // Write out shader codes for all shader types
for (const gl::ShaderType shaderType : gl::AllShaderTypes()) for (const gl::ShaderType shaderType : gl::AllShaderTypes())
{ {
const SpirvBlob &spirvBlob = mSpirvBlobs[shaderType]; const angle::spirv::Blob &spirvBlob = mSpirvBlobs[shaderType];
// Write the SPIR-V // Write the SPIR-V
stream->writeIntVector(spirvBlob); stream->writeIntVector(spirvBlob);
...@@ -166,10 +166,10 @@ angle::Result ProgramInfo::initProgram(ContextVk *contextVk, ...@@ -166,10 +166,10 @@ angle::Result ProgramInfo::initProgram(ContextVk *contextVk,
ProgramTransformOptions optionBits, ProgramTransformOptions optionBits,
const ShaderInterfaceVariableInfoMap &variableInfoMap) const ShaderInterfaceVariableInfoMap &variableInfoMap)
{ {
const gl::ShaderMap<SpirvBlob> &originalSpirvBlobs = shaderInfo.getSpirvBlobs(); const gl::ShaderMap<angle::spirv::Blob> &originalSpirvBlobs = shaderInfo.getSpirvBlobs();
const SpirvBlob &originalSpirvBlob = originalSpirvBlobs[shaderType]; const angle::spirv::Blob &originalSpirvBlob = originalSpirvBlobs[shaderType];
gl::ShaderMap<SpirvBlob> transformedSpirvBlobs; gl::ShaderMap<angle::spirv::Blob> transformedSpirvBlobs;
SpirvBlob &transformedSpirvBlob = transformedSpirvBlobs[shaderType]; angle::spirv::Blob &transformedSpirvBlob = transformedSpirvBlobs[shaderType];
GlslangSpirvOptions options; GlslangSpirvOptions options;
options.shaderType = shaderType; options.shaderType = shaderType;
......
src/libANGLE/renderer/vulkan/ProgramExecutableVk.h
...@@ -37,14 +37,14 @@ class ShaderInfo final : angle::NonCopyable ...@@ -37,14 +37,14 @@ class ShaderInfo final : angle::NonCopyable
ANGLE_INLINE bool valid() const { return mIsInitialized; } ANGLE_INLINE bool valid() const { return mIsInitialized; }
const gl::ShaderMap<SpirvBlob> &getSpirvBlobs() const { return mSpirvBlobs; } const gl::ShaderMap<angle::spirv::Blob> &getSpirvBlobs() const { return mSpirvBlobs; }
// Save and load implementation for GLES Program Binary support. // Save and load implementation for GLES Program Binary support.
void load(gl::BinaryInputStream *stream); void load(gl::BinaryInputStream *stream);
void save(gl::BinaryOutputStream *stream); void save(gl::BinaryOutputStream *stream);
private: private:
gl::ShaderMap<SpirvBlob> mSpirvBlobs; gl::ShaderMap<angle::spirv::Blob> mSpirvBlobs;
bool mIsInitialized = false; bool mIsInitialized = false;
}; };
......
src/libANGLE/renderer/vulkan/UtilsVk.cpp
...@@ -621,7 +621,7 @@ enum ...@@ -621,7 +621,7 @@ enum
void InsertPreamble(uint32_t colorAttachmentCount, void InsertPreamble(uint32_t colorAttachmentCount,
bool unresolveDepth, bool unresolveDepth,
bool unresolveStencil, bool unresolveStencil,
SpirvBlob *blobOut) angle::spirv::Blob *blobOut)
{ {
spirv::WriteCapability(blobOut, spv::CapabilityShader); spirv::WriteCapability(blobOut, spv::CapabilityShader);
spirv::WriteCapability(blobOut, spv::CapabilityInputAttachment); spirv::WriteCapability(blobOut, spv::CapabilityInputAttachment);
...@@ -663,7 +663,7 @@ void InsertPreamble(uint32_t colorAttachmentCount, ...@@ -663,7 +663,7 @@ void InsertPreamble(uint32_t colorAttachmentCount,
void InsertInputDecorations(spirv::IdRef id, void InsertInputDecorations(spirv::IdRef id,
uint32_t attachmentIndex, uint32_t attachmentIndex,
uint32_t binding, uint32_t binding,
SpirvBlob *blobOut) angle::spirv::Blob *blobOut)
{ {
spirv::WriteDecorate(blobOut, id, spv::DecorationDescriptorSet, spirv::WriteDecorate(blobOut, id, spv::DecorationDescriptorSet,
{spirv::LiteralInteger(DescriptorSetIndex::InternalShader)}); {spirv::LiteralInteger(DescriptorSetIndex::InternalShader)});
...@@ -672,7 +672,7 @@ void InsertInputDecorations(spirv::IdRef id, ...@@ -672,7 +672,7 @@ void InsertInputDecorations(spirv::IdRef id,
{spirv::LiteralInteger(attachmentIndex)}); {spirv::LiteralInteger(attachmentIndex)});
} }
void InsertColorDecorations(uint32_t colorIndex, SpirvBlob *blobOut) void InsertColorDecorations(uint32_t colorIndex, angle::spirv::Blob *blobOut)
{ {
// Decorate the output color attachment with Location // Decorate the output color attachment with Location
spirv::WriteDecorate(blobOut, spirv::IdRef(kIdColor0Out + colorIndex), spv::DecorationLocation, spirv::WriteDecorate(blobOut, spirv::IdRef(kIdColor0Out + colorIndex), spv::DecorationLocation,
...@@ -685,7 +685,7 @@ void InsertDepthStencilDecorations(uint32_t depthStencilInputIndex, ...@@ -685,7 +685,7 @@ void InsertDepthStencilDecorations(uint32_t depthStencilInputIndex,
uint32_t depthStencilBindingIndex, uint32_t depthStencilBindingIndex,
bool unresolveDepth, bool unresolveDepth,
bool unresolveStencil, bool unresolveStencil,
SpirvBlob *blobOut) angle::spirv::Blob *blobOut)
{ {
if (unresolveDepth) if (unresolveDepth)
{ {
...@@ -716,7 +716,7 @@ void InsertDerivativeTypes(spirv::IdRef baseId, ...@@ -716,7 +716,7 @@ void InsertDerivativeTypes(spirv::IdRef baseId,
spirv::IdRef vec4OutId, spirv::IdRef vec4OutId,
spirv::IdRef imageTypeId, spirv::IdRef imageTypeId,
spirv::IdRef inputTypeId, spirv::IdRef inputTypeId,
SpirvBlob *blobOut) angle::spirv::Blob *blobOut)
{ {
spirv::WriteTypeVector(blobOut, vec4Id, baseId, spirv::LiteralInteger(4)); spirv::WriteTypeVector(blobOut, vec4Id, baseId, spirv::LiteralInteger(4));
spirv::WriteTypePointer(blobOut, vec4OutId, spv::StorageClassOutput, vec4Id); spirv::WriteTypePointer(blobOut, vec4OutId, spv::StorageClassOutput, vec4Id);
...@@ -732,7 +732,7 @@ void InsertDerivativeTypes(spirv::IdRef baseId, ...@@ -732,7 +732,7 @@ void InsertDerivativeTypes(spirv::IdRef baseId,
spirv::WriteTypePointer(blobOut, inputTypeId, spv::StorageClassUniformConstant, imageTypeId); spirv::WriteTypePointer(blobOut, inputTypeId, spv::StorageClassUniformConstant, imageTypeId);
} }
void InsertCommonTypes(SpirvBlob *blobOut) void InsertCommonTypes(angle::spirv::Blob *blobOut)
{ {
// Types to support main(). // Types to support main().
spirv::WriteTypeVoid(blobOut, spirv::IdRef(kIdVoid)); spirv::WriteTypeVoid(blobOut, spirv::IdRef(kIdVoid));
...@@ -777,7 +777,7 @@ void InsertVariableDecl(spirv::IdRef outType, ...@@ -777,7 +777,7 @@ void InsertVariableDecl(spirv::IdRef outType,
spirv::IdRef outId, spirv::IdRef outId,
spirv::IdRef inType, spirv::IdRef inType,
spirv::IdRef inId, spirv::IdRef inId,
SpirvBlob *blobOut) angle::spirv::Blob *blobOut)
{ {
// Declare both the output and subpass input variables. // Declare both the output and subpass input variables.
spirv::WriteVariable(blobOut, outType, outId, spv::StorageClassOutput, nullptr); spirv::WriteVariable(blobOut, outType, outId, spv::StorageClassOutput, nullptr);
...@@ -786,7 +786,7 @@ void InsertVariableDecl(spirv::IdRef outType, ...@@ -786,7 +786,7 @@ void InsertVariableDecl(spirv::IdRef outType,
void InsertColorVariableDecl(uint32_t colorIndex, void InsertColorVariableDecl(uint32_t colorIndex,
UnresolveColorAttachmentType type, UnresolveColorAttachmentType type,
SpirvBlob *blobOut) angle::spirv::Blob *blobOut)
{ {
// Find the correct types for color variable declarations. // Find the correct types for color variable declarations.
spirv::IdRef outType(kIdFloat4OutType); spirv::IdRef outType(kIdFloat4OutType);
...@@ -809,7 +809,9 @@ void InsertColorVariableDecl(uint32_t colorIndex, ...@@ -809,7 +809,9 @@ void InsertColorVariableDecl(uint32_t colorIndex,
InsertVariableDecl(outType, outId, inType, inId, blobOut); InsertVariableDecl(outType, outId, inType, inId, blobOut);
} }
void InsertDepthStencilVariableDecl(bool unresolveDepth, bool unresolveStencil, SpirvBlob *blobOut) void InsertDepthStencilVariableDecl(bool unresolveDepth,
bool unresolveStencil,
angle::spirv::Blob *blobOut)
{ {
if (unresolveDepth) if (unresolveDepth)
{ {
...@@ -825,7 +827,7 @@ void InsertDepthStencilVariableDecl(bool unresolveDepth, bool unresolveStencil, ...@@ -825,7 +827,7 @@ void InsertDepthStencilVariableDecl(bool unresolveDepth, bool unresolveStencil,
} }
} }
void InsertTopOfMain(SpirvBlob *blobOut) void InsertTopOfMain(angle::spirv::Blob *blobOut)
{ {
spirv::WriteFunction(blobOut, spirv::IdRef(kIdVoid), spirv::IdRef(kIdMain), spirv::WriteFunction(blobOut, spirv::IdRef(kIdVoid), spirv::IdRef(kIdMain),
spv::FunctionControlMaskNone, spirv::IdRef(kIdMainType)); spv::FunctionControlMaskNone, spirv::IdRef(kIdMainType));
...@@ -834,7 +836,7 @@ void InsertTopOfMain(SpirvBlob *blobOut) ...@@ -834,7 +836,7 @@ void InsertTopOfMain(SpirvBlob *blobOut)
void InsertColorUnresolveLoadStore(uint32_t colorIndex, void InsertColorUnresolveLoadStore(uint32_t colorIndex,
UnresolveColorAttachmentType type, UnresolveColorAttachmentType type,
SpirvBlob *blobOut) angle::spirv::Blob *blobOut)
{ {
spirv::IdRef loadResult(kIdColor0Load + colorIndex * 2); spirv::IdRef loadResult(kIdColor0Load + colorIndex * 2);
spirv::IdRef imageReadResult(loadResult + 1); spirv::IdRef imageReadResult(loadResult + 1);
...@@ -867,7 +869,7 @@ void InsertColorUnresolveLoadStore(uint32_t colorIndex, ...@@ -867,7 +869,7 @@ void InsertColorUnresolveLoadStore(uint32_t colorIndex,
void InsertDepthStencilUnresolveLoadStore(bool unresolveDepth, void InsertDepthStencilUnresolveLoadStore(bool unresolveDepth,
bool unresolveStencil, bool unresolveStencil,
SpirvBlob *blobOut) angle::spirv::Blob *blobOut)
{ {
if (unresolveDepth) if (unresolveDepth)
{ {
...@@ -913,19 +915,19 @@ void InsertDepthStencilUnresolveLoadStore(bool unresolveDepth, ...@@ -913,19 +915,19 @@ void InsertDepthStencilUnresolveLoadStore(bool unresolveDepth,
} }
} }
void InsertBottomOfMain(SpirvBlob *blobOut) void InsertBottomOfMain(angle::spirv::Blob *blobOut)
{ {
spirv::WriteReturn(blobOut); spirv::WriteReturn(blobOut);
spirv::WriteFunctionEnd(blobOut); spirv::WriteFunctionEnd(blobOut);
} }
std::vector<uint32_t> MakeFragShader( angle::spirv::Blob MakeFragShader(
uint32_t colorAttachmentCount, uint32_t colorAttachmentCount,
gl::DrawBuffersArray<UnresolveColorAttachmentType> &colorAttachmentTypes, gl::DrawBuffersArray<UnresolveColorAttachmentType> &colorAttachmentTypes,
bool unresolveDepth, bool unresolveDepth,
bool unresolveStencil) bool unresolveStencil)
{ {
SpirvBlob code; angle::spirv::Blob code;
// Reserve a sensible amount of memory. A single-attachment shader is 169 words. // Reserve a sensible amount of memory. A single-attachment shader is 169 words.
code.reserve(169); code.reserve(169);
...@@ -987,7 +989,7 @@ angle::Result GetUnresolveFrag( ...@@ -987,7 +989,7 @@ angle::Result GetUnresolveFrag(
return angle::Result::Continue; return angle::Result::Continue;
} }
std::vector<uint32_t> shaderCode = unresolve::MakeFragShader( angle::spirv::Blob shaderCode = unresolve::MakeFragShader(
colorAttachmentCount, colorAttachmentTypes, unresolveDepth, unresolveStencil); colorAttachmentCount, colorAttachmentTypes, unresolveDepth, unresolveStencil);
ASSERT(spirv::Validate(shaderCode)); ASSERT(spirv::Validate(shaderCode));
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment