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