[Spv.Generator] Address dotnet-format issues (#5394)

* dotnet format style --severity info

Some changes were manually reverted.

* Restore a few unused methods and variables

* Silence dotnet format IDE0052 warnings

* Address or silence dotnet format IDE1006 warnings

* Address or silence dotnet format CA1069 warnings

* Address review comments

* Address most dotnet format whitespace warnings

* Run dotnet format after rebase and remove unused usings

- analyzers
- style
- whitespace

* Add comments to disabled warnings

* Simplify properties and array initialization, Use const when possible, Remove trailing commas

* Address IDE0251 warnings

* Revert "Simplify properties and array initialization, Use const when possible, Remove trailing commas"

This reverts commit 9462e4136c0a2100dc28b20cf9542e06790aa67e.

* dotnet format whitespace after rebase

* Rename Operand.cs to IOperand.cs

* Update src/Spv.Generator/Module.cs

Co-authored-by: Ac_K <Acoustik666@gmail.com>

* Remove NotNullWhen attribute and use conditional access to avoid NRE

* Fix duplicated enum values

* Remove unread member

---------

Co-authored-by: Ac_K <Acoustik666@gmail.com>
This commit is contained in:
TSRBerry 2023-06-28 18:54:20 +02:00 committed by GitHub
parent cebfa54467
commit 981e0c082d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
14 changed files with 490 additions and 497 deletions

View file

@ -180,7 +180,7 @@ namespace Spv.Generator
return result; return result;
} }
public Instruction Decorate(Instruction target, Decoration decoration, Operand parameter) public Instruction Decorate(Instruction target, Decoration decoration, IOperand parameter)
{ {
Instruction result = NewInstruction(Op.OpDecorate); Instruction result = NewInstruction(Op.OpDecorate);
@ -192,7 +192,7 @@ namespace Spv.Generator
return result; return result;
} }
public Instruction Decorate(Instruction target, Decoration decoration, params Operand[] parameters) public Instruction Decorate(Instruction target, Decoration decoration, params IOperand[] parameters)
{ {
Instruction result = NewInstruction(Op.OpDecorate); Instruction result = NewInstruction(Op.OpDecorate);
@ -216,7 +216,7 @@ namespace Spv.Generator
return result; return result;
} }
public Instruction MemberDecorate(Instruction structureType, LiteralInteger member, Decoration decoration, Operand parameter) public Instruction MemberDecorate(Instruction structureType, LiteralInteger member, Decoration decoration, IOperand parameter)
{ {
Instruction result = NewInstruction(Op.OpMemberDecorate); Instruction result = NewInstruction(Op.OpMemberDecorate);
@ -229,7 +229,7 @@ namespace Spv.Generator
return result; return result;
} }
public Instruction MemberDecorate(Instruction structureType, LiteralInteger member, Decoration decoration, params Operand[] parameters) public Instruction MemberDecorate(Instruction structureType, LiteralInteger member, Decoration decoration, params IOperand[] parameters)
{ {
Instruction result = NewInstruction(Op.OpMemberDecorate); Instruction result = NewInstruction(Op.OpMemberDecorate);
@ -262,7 +262,7 @@ namespace Spv.Generator
return result; return result;
} }
public Instruction GroupMemberDecorate(Instruction decorationGroup, params Operand[] targets) public Instruction GroupMemberDecorate(Instruction decorationGroup, params IOperand[] targets)
{ {
Instruction result = NewInstruction(Op.OpGroupMemberDecorate); Instruction result = NewInstruction(Op.OpGroupMemberDecorate);
@ -273,7 +273,7 @@ namespace Spv.Generator
return result; return result;
} }
public Instruction DecorateId(Instruction target, Decoration decoration, params Operand[] parameters) public Instruction DecorateId(Instruction target, Decoration decoration, params IOperand[] parameters)
{ {
Instruction result = NewInstruction(Op.OpDecorateId); Instruction result = NewInstruction(Op.OpDecorateId);
@ -285,7 +285,7 @@ namespace Spv.Generator
return result; return result;
} }
public Instruction DecorateString(Instruction target, Decoration decoration, params Operand[] parameters) public Instruction DecorateString(Instruction target, Decoration decoration, params IOperand[] parameters)
{ {
Instruction result = NewInstruction(Op.OpDecorateString); Instruction result = NewInstruction(Op.OpDecorateString);
@ -297,7 +297,7 @@ namespace Spv.Generator
return result; return result;
} }
public Instruction DecorateStringGOOGLE(Instruction target, Decoration decoration, params Operand[] parameters) public Instruction DecorateStringGOOGLE(Instruction target, Decoration decoration, params IOperand[] parameters)
{ {
Instruction result = NewInstruction(Op.OpDecorateStringGOOGLE); Instruction result = NewInstruction(Op.OpDecorateStringGOOGLE);
@ -309,7 +309,7 @@ namespace Spv.Generator
return result; return result;
} }
public Instruction MemberDecorateString(Instruction structType, LiteralInteger member, Decoration decoration, params Operand[] parameters) public Instruction MemberDecorateString(Instruction structType, LiteralInteger member, Decoration decoration, params IOperand[] parameters)
{ {
Instruction result = NewInstruction(Op.OpMemberDecorateString); Instruction result = NewInstruction(Op.OpMemberDecorateString);
@ -322,7 +322,7 @@ namespace Spv.Generator
return result; return result;
} }
public Instruction MemberDecorateStringGOOGLE(Instruction structType, LiteralInteger member, Decoration decoration, params Operand[] parameters) public Instruction MemberDecorateStringGOOGLE(Instruction structType, LiteralInteger member, Decoration decoration, params IOperand[] parameters)
{ {
Instruction result = NewInstruction(Op.OpMemberDecorateStringGOOGLE); Instruction result = NewInstruction(Op.OpMemberDecorateStringGOOGLE);
@ -2815,7 +2815,7 @@ namespace Spv.Generator
return result; return result;
} }
public Instruction Switch(Instruction selector, Instruction defaultObj, params Operand[] target) public Instruction Switch(Instruction selector, Instruction defaultObj, params IOperand[] target)
{ {
Instruction result = NewInstruction(Op.OpSwitch); Instruction result = NewInstruction(Op.OpSwitch);

View file

@ -26,8 +26,6 @@
// IN THE MATERIALS. // IN THE MATERIALS.
#endregion #endregion
using static Spv.Specification;
namespace Spv.Generator namespace Spv.Generator
{ {
public partial class Module public partial class Module
@ -36,406 +34,406 @@ namespace Spv.Generator
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 1, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 1, x);
} }
public Instruction GlslRoundEven(Instruction resultType, Instruction x) public Instruction GlslRoundEven(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 2, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 2, x);
} }
public Instruction GlslTrunc(Instruction resultType, Instruction x) public Instruction GlslTrunc(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 3, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 3, x);
} }
public Instruction GlslFAbs(Instruction resultType, Instruction x) public Instruction GlslFAbs(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 4, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 4, x);
} }
public Instruction GlslSAbs(Instruction resultType, Instruction x) public Instruction GlslSAbs(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 5, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 5, x);
} }
public Instruction GlslFSign(Instruction resultType, Instruction x) public Instruction GlslFSign(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 6, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 6, x);
} }
public Instruction GlslSSign(Instruction resultType, Instruction x) public Instruction GlslSSign(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 7, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 7, x);
} }
public Instruction GlslFloor(Instruction resultType, Instruction x) public Instruction GlslFloor(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 8, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 8, x);
} }
public Instruction GlslCeil(Instruction resultType, Instruction x) public Instruction GlslCeil(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 9, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 9, x);
} }
public Instruction GlslFract(Instruction resultType, Instruction x) public Instruction GlslFract(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 10, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 10, x);
} }
public Instruction GlslRadians(Instruction resultType, Instruction degrees) public Instruction GlslRadians(Instruction resultType, Instruction degrees)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 11, degrees); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 11, degrees);
} }
public Instruction GlslDegrees(Instruction resultType, Instruction radians) public Instruction GlslDegrees(Instruction resultType, Instruction radians)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 12, radians); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 12, radians);
} }
public Instruction GlslSin(Instruction resultType, Instruction x) public Instruction GlslSin(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 13, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 13, x);
} }
public Instruction GlslCos(Instruction resultType, Instruction x) public Instruction GlslCos(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 14, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 14, x);
} }
public Instruction GlslTan(Instruction resultType, Instruction x) public Instruction GlslTan(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 15, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 15, x);
} }
public Instruction GlslAsin(Instruction resultType, Instruction x) public Instruction GlslAsin(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 16, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 16, x);
} }
public Instruction GlslAcos(Instruction resultType, Instruction x) public Instruction GlslAcos(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 17, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 17, x);
} }
public Instruction GlslAtan(Instruction resultType, Instruction y_over_x) public Instruction GlslAtan(Instruction resultType, Instruction y_over_x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 18, y_over_x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 18, y_over_x);
} }
public Instruction GlslSinh(Instruction resultType, Instruction x) public Instruction GlslSinh(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 19, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 19, x);
} }
public Instruction GlslCosh(Instruction resultType, Instruction x) public Instruction GlslCosh(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 20, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 20, x);
} }
public Instruction GlslTanh(Instruction resultType, Instruction x) public Instruction GlslTanh(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 21, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 21, x);
} }
public Instruction GlslAsinh(Instruction resultType, Instruction x) public Instruction GlslAsinh(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 22, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 22, x);
} }
public Instruction GlslAcosh(Instruction resultType, Instruction x) public Instruction GlslAcosh(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 23, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 23, x);
} }
public Instruction GlslAtanh(Instruction resultType, Instruction x) public Instruction GlslAtanh(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 24, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 24, x);
} }
public Instruction GlslAtan2(Instruction resultType, Instruction y, Instruction x) public Instruction GlslAtan2(Instruction resultType, Instruction y, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 25, y, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 25, y, x);
} }
public Instruction GlslPow(Instruction resultType, Instruction x, Instruction y) public Instruction GlslPow(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 26, x, y); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 26, x, y);
} }
public Instruction GlslExp(Instruction resultType, Instruction x) public Instruction GlslExp(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 27, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 27, x);
} }
public Instruction GlslLog(Instruction resultType, Instruction x) public Instruction GlslLog(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 28, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 28, x);
} }
public Instruction GlslExp2(Instruction resultType, Instruction x) public Instruction GlslExp2(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 29, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 29, x);
} }
public Instruction GlslLog2(Instruction resultType, Instruction x) public Instruction GlslLog2(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 30, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 30, x);
} }
public Instruction GlslSqrt(Instruction resultType, Instruction x) public Instruction GlslSqrt(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 31, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 31, x);
} }
public Instruction GlslInverseSqrt(Instruction resultType, Instruction x) public Instruction GlslInverseSqrt(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 32, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 32, x);
} }
public Instruction GlslDeterminant(Instruction resultType, Instruction x) public Instruction GlslDeterminant(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 33, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 33, x);
} }
public Instruction GlslMatrixInverse(Instruction resultType, Instruction x) public Instruction GlslMatrixInverse(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 34, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 34, x);
} }
public Instruction GlslModf(Instruction resultType, Instruction x, Instruction i) public Instruction GlslModf(Instruction resultType, Instruction x, Instruction i)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 35, x, i); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 35, x, i);
} }
public Instruction GlslModfStruct(Instruction resultType, Instruction x) public Instruction GlslModfStruct(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 36, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 36, x);
} }
public Instruction GlslFMin(Instruction resultType, Instruction x, Instruction y) public Instruction GlslFMin(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 37, x, y); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 37, x, y);
} }
public Instruction GlslUMin(Instruction resultType, Instruction x, Instruction y) public Instruction GlslUMin(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 38, x, y); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 38, x, y);
} }
public Instruction GlslSMin(Instruction resultType, Instruction x, Instruction y) public Instruction GlslSMin(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 39, x, y); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 39, x, y);
} }
public Instruction GlslFMax(Instruction resultType, Instruction x, Instruction y) public Instruction GlslFMax(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 40, x, y); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 40, x, y);
} }
public Instruction GlslUMax(Instruction resultType, Instruction x, Instruction y) public Instruction GlslUMax(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 41, x, y); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 41, x, y);
} }
public Instruction GlslSMax(Instruction resultType, Instruction x, Instruction y) public Instruction GlslSMax(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 42, x, y); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 42, x, y);
} }
public Instruction GlslFClamp(Instruction resultType, Instruction x, Instruction minVal, Instruction maxVal) public Instruction GlslFClamp(Instruction resultType, Instruction x, Instruction minVal, Instruction maxVal)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 43, x, minVal, maxVal); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 43, x, minVal, maxVal);
} }
public Instruction GlslUClamp(Instruction resultType, Instruction x, Instruction minVal, Instruction maxVal) public Instruction GlslUClamp(Instruction resultType, Instruction x, Instruction minVal, Instruction maxVal)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 44, x, minVal, maxVal); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 44, x, minVal, maxVal);
} }
public Instruction GlslSClamp(Instruction resultType, Instruction x, Instruction minVal, Instruction maxVal) public Instruction GlslSClamp(Instruction resultType, Instruction x, Instruction minVal, Instruction maxVal)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 45, x, minVal, maxVal); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 45, x, minVal, maxVal);
} }
public Instruction GlslFMix(Instruction resultType, Instruction x, Instruction y, Instruction a) public Instruction GlslFMix(Instruction resultType, Instruction x, Instruction y, Instruction a)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 46, x, y, a); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 46, x, y, a);
} }
public Instruction GlslIMix(Instruction resultType, Instruction x, Instruction y, Instruction a) public Instruction GlslIMix(Instruction resultType, Instruction x, Instruction y, Instruction a)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 47, x, y, a); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 47, x, y, a);
} }
public Instruction GlslStep(Instruction resultType, Instruction edge, Instruction x) public Instruction GlslStep(Instruction resultType, Instruction edge, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 48, edge, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 48, edge, x);
} }
public Instruction GlslSmoothStep(Instruction resultType, Instruction edge0, Instruction edge1, Instruction x) public Instruction GlslSmoothStep(Instruction resultType, Instruction edge0, Instruction edge1, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 49, edge0, edge1, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 49, edge0, edge1, x);
} }
public Instruction GlslFma(Instruction resultType, Instruction a, Instruction b, Instruction c) public Instruction GlslFma(Instruction resultType, Instruction a, Instruction b, Instruction c)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 50, a, b, c); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 50, a, b, c);
} }
public Instruction GlslFrexp(Instruction resultType, Instruction x, Instruction exp) public Instruction GlslFrexp(Instruction resultType, Instruction x, Instruction exp)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 51, x, exp); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 51, x, exp);
} }
public Instruction GlslFrexpStruct(Instruction resultType, Instruction x) public Instruction GlslFrexpStruct(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 52, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 52, x);
} }
public Instruction GlslLdexp(Instruction resultType, Instruction x, Instruction exp) public Instruction GlslLdexp(Instruction resultType, Instruction x, Instruction exp)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 53, x, exp); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 53, x, exp);
} }
public Instruction GlslPackSnorm4x8(Instruction resultType, Instruction v) public Instruction GlslPackSnorm4x8(Instruction resultType, Instruction v)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 54, v); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 54, v);
} }
public Instruction GlslPackUnorm4x8(Instruction resultType, Instruction v) public Instruction GlslPackUnorm4x8(Instruction resultType, Instruction v)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 55, v); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 55, v);
} }
public Instruction GlslPackSnorm2x16(Instruction resultType, Instruction v) public Instruction GlslPackSnorm2x16(Instruction resultType, Instruction v)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 56, v); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 56, v);
} }
public Instruction GlslPackUnorm2x16(Instruction resultType, Instruction v) public Instruction GlslPackUnorm2x16(Instruction resultType, Instruction v)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 57, v); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 57, v);
} }
public Instruction GlslPackHalf2x16(Instruction resultType, Instruction v) public Instruction GlslPackHalf2x16(Instruction resultType, Instruction v)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 58, v); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 58, v);
} }
public Instruction GlslPackDouble2x32(Instruction resultType, Instruction v) public Instruction GlslPackDouble2x32(Instruction resultType, Instruction v)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 59, v); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 59, v);
} }
public Instruction GlslUnpackSnorm2x16(Instruction resultType, Instruction p) public Instruction GlslUnpackSnorm2x16(Instruction resultType, Instruction p)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 60, p); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 60, p);
} }
public Instruction GlslUnpackUnorm2x16(Instruction resultType, Instruction p) public Instruction GlslUnpackUnorm2x16(Instruction resultType, Instruction p)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 61, p); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 61, p);
} }
public Instruction GlslUnpackHalf2x16(Instruction resultType, Instruction v) public Instruction GlslUnpackHalf2x16(Instruction resultType, Instruction v)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 62, v); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 62, v);
} }
public Instruction GlslUnpackSnorm4x8(Instruction resultType, Instruction p) public Instruction GlslUnpackSnorm4x8(Instruction resultType, Instruction p)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 63, p); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 63, p);
} }
public Instruction GlslUnpackUnorm4x8(Instruction resultType, Instruction p) public Instruction GlslUnpackUnorm4x8(Instruction resultType, Instruction p)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 64, p); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 64, p);
} }
public Instruction GlslUnpackDouble2x32(Instruction resultType, Instruction v) public Instruction GlslUnpackDouble2x32(Instruction resultType, Instruction v)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 65, v); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 65, v);
} }
public Instruction GlslLength(Instruction resultType, Instruction x) public Instruction GlslLength(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 66, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 66, x);
} }
public Instruction GlslDistance(Instruction resultType, Instruction p0, Instruction p1) public Instruction GlslDistance(Instruction resultType, Instruction p0, Instruction p1)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 67, p0, p1); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 67, p0, p1);
} }
public Instruction GlslCross(Instruction resultType, Instruction x, Instruction y) public Instruction GlslCross(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 68, x, y); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 68, x, y);
} }
public Instruction GlslNormalize(Instruction resultType, Instruction x) public Instruction GlslNormalize(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 69, x); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 69, x);
} }
public Instruction GlslFaceForward(Instruction resultType, Instruction n, Instruction i, Instruction nref) public Instruction GlslFaceForward(Instruction resultType, Instruction n, Instruction i, Instruction nref)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 70, n, i, nref); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 70, n, i, nref);
} }
public Instruction GlslReflect(Instruction resultType, Instruction i, Instruction n) public Instruction GlslReflect(Instruction resultType, Instruction i, Instruction n)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 71, i, n); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 71, i, n);
} }
public Instruction GlslRefract(Instruction resultType, Instruction i, Instruction n, Instruction eta) public Instruction GlslRefract(Instruction resultType, Instruction i, Instruction n, Instruction eta)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 72, i, n, eta); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 72, i, n, eta);
} }
public Instruction GlslFindILsb(Instruction resultType, Instruction value) public Instruction GlslFindILsb(Instruction resultType, Instruction value)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 73, value); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 73, value);
} }
public Instruction GlslFindSMsb(Instruction resultType, Instruction value) public Instruction GlslFindSMsb(Instruction resultType, Instruction value)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 74, value); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 74, value);
} }
public Instruction GlslFindUMsb(Instruction resultType, Instruction value) public Instruction GlslFindUMsb(Instruction resultType, Instruction value)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 75, value); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 75, value);
} }
public Instruction GlslInterpolateAtCentroid(Instruction resultType, Instruction interpolant) public Instruction GlslInterpolateAtCentroid(Instruction resultType, Instruction interpolant)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 76, interpolant); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 76, interpolant);
} }
public Instruction GlslInterpolateAtSample(Instruction resultType, Instruction interpolant, Instruction sample) public Instruction GlslInterpolateAtSample(Instruction resultType, Instruction interpolant, Instruction sample)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 77, interpolant, sample); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 77, interpolant, sample);
} }
public Instruction GlslInterpolateAtOffset(Instruction resultType, Instruction interpolant, Instruction offset) public Instruction GlslInterpolateAtOffset(Instruction resultType, Instruction interpolant, Instruction offset)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 78, interpolant, offset); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 78, interpolant, offset);
} }
public Instruction GlslNMin(Instruction resultType, Instruction x, Instruction y) public Instruction GlslNMin(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 79, x, y); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 79, x, y);
} }
public Instruction GlslNMax(Instruction resultType, Instruction x, Instruction y) public Instruction GlslNMax(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 80, x, y); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 80, x, y);
} }
public Instruction GlslNClamp(Instruction resultType, Instruction x, Instruction minVal, Instruction maxVal) public Instruction GlslNClamp(Instruction resultType, Instruction x, Instruction minVal, Instruction maxVal)
{ {
return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 81, x, minVal, maxVal); return ExtInst(resultType, AddExtInstImport("GLSL.std.450"), 81, x, minVal, maxVal);
} }
} }
} }

View file

@ -36,806 +36,806 @@ namespace Spv.Generator
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 0, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 0, x);
} }
public Instruction OpenClAcosh(Instruction resultType, Instruction x) public Instruction OpenClAcosh(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 1, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 1, x);
} }
public Instruction OpenClAcospi(Instruction resultType, Instruction x) public Instruction OpenClAcospi(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 2, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 2, x);
} }
public Instruction OpenClAsin(Instruction resultType, Instruction x) public Instruction OpenClAsin(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 3, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 3, x);
} }
public Instruction OpenClAsinh(Instruction resultType, Instruction x) public Instruction OpenClAsinh(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 4, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 4, x);
} }
public Instruction OpenClAsinpi(Instruction resultType, Instruction x) public Instruction OpenClAsinpi(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 5, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 5, x);
} }
public Instruction OpenClAtan(Instruction resultType, Instruction x) public Instruction OpenClAtan(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 6, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 6, x);
} }
public Instruction OpenClAtan2(Instruction resultType, Instruction y, Instruction x) public Instruction OpenClAtan2(Instruction resultType, Instruction y, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 7, y, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 7, y, x);
} }
public Instruction OpenClAtanh(Instruction resultType, Instruction x) public Instruction OpenClAtanh(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 8, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 8, x);
} }
public Instruction OpenClAtanpi(Instruction resultType, Instruction x) public Instruction OpenClAtanpi(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 9, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 9, x);
} }
public Instruction OpenClAtan2pi(Instruction resultType, Instruction y, Instruction x) public Instruction OpenClAtan2pi(Instruction resultType, Instruction y, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 10, y, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 10, y, x);
} }
public Instruction OpenClCbrt(Instruction resultType, Instruction x) public Instruction OpenClCbrt(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 11, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 11, x);
} }
public Instruction OpenClCeil(Instruction resultType, Instruction x) public Instruction OpenClCeil(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 12, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 12, x);
} }
public Instruction OpenClCopysign(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClCopysign(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 13, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 13, x, y);
} }
public Instruction OpenClCos(Instruction resultType, Instruction x) public Instruction OpenClCos(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 14, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 14, x);
} }
public Instruction OpenClCosh(Instruction resultType, Instruction x) public Instruction OpenClCosh(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 15, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 15, x);
} }
public Instruction OpenClCospi(Instruction resultType, Instruction x) public Instruction OpenClCospi(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 16, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 16, x);
} }
public Instruction OpenClErfc(Instruction resultType, Instruction x) public Instruction OpenClErfc(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 17, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 17, x);
} }
public Instruction OpenClErf(Instruction resultType, Instruction x) public Instruction OpenClErf(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 18, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 18, x);
} }
public Instruction OpenClExp(Instruction resultType, Instruction x) public Instruction OpenClExp(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 19, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 19, x);
} }
public Instruction OpenClExp2(Instruction resultType, Instruction x) public Instruction OpenClExp2(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 20, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 20, x);
} }
public Instruction OpenClExp10(Instruction resultType, Instruction x) public Instruction OpenClExp10(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 21, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 21, x);
} }
public Instruction OpenClExpm1(Instruction resultType, Instruction x) public Instruction OpenClExpm1(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 22, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 22, x);
} }
public Instruction OpenClFabs(Instruction resultType, Instruction x) public Instruction OpenClFabs(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 23, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 23, x);
} }
public Instruction OpenClFdim(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClFdim(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 24, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 24, x, y);
} }
public Instruction OpenClFloor(Instruction resultType, Instruction x) public Instruction OpenClFloor(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 25, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 25, x);
} }
public Instruction OpenClFma(Instruction resultType, Instruction a, Instruction b, Instruction c) public Instruction OpenClFma(Instruction resultType, Instruction a, Instruction b, Instruction c)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 26, a, b, c); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 26, a, b, c);
} }
public Instruction OpenClFmax(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClFmax(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 27, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 27, x, y);
} }
public Instruction OpenClFmin(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClFmin(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 28, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 28, x, y);
} }
public Instruction OpenClFmod(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClFmod(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 29, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 29, x, y);
} }
public Instruction OpenClFract(Instruction resultType, Instruction x, Instruction ptr) public Instruction OpenClFract(Instruction resultType, Instruction x, Instruction ptr)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 30, x, ptr); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 30, x, ptr);
} }
public Instruction OpenClFrexp(Instruction resultType, Instruction x, Instruction exp) public Instruction OpenClFrexp(Instruction resultType, Instruction x, Instruction exp)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 31, x, exp); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 31, x, exp);
} }
public Instruction OpenClHypot(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClHypot(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 32, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 32, x, y);
} }
public Instruction OpenClIlogb(Instruction resultType, Instruction x) public Instruction OpenClIlogb(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 33, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 33, x);
} }
public Instruction OpenClLdexp(Instruction resultType, Instruction x, Instruction k) public Instruction OpenClLdexp(Instruction resultType, Instruction x, Instruction k)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 34, x, k); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 34, x, k);
} }
public Instruction OpenClLgamma(Instruction resultType, Instruction x) public Instruction OpenClLgamma(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 35, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 35, x);
} }
public Instruction OpenClLgamma_r(Instruction resultType, Instruction x, Instruction signp) public Instruction OpenClLgamma_r(Instruction resultType, Instruction x, Instruction signp)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 36, x, signp); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 36, x, signp);
} }
public Instruction OpenClLog(Instruction resultType, Instruction x) public Instruction OpenClLog(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 37, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 37, x);
} }
public Instruction OpenClLog2(Instruction resultType, Instruction x) public Instruction OpenClLog2(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 38, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 38, x);
} }
public Instruction OpenClLog10(Instruction resultType, Instruction x) public Instruction OpenClLog10(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 39, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 39, x);
} }
public Instruction OpenClLog1p(Instruction resultType, Instruction x) public Instruction OpenClLog1p(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 40, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 40, x);
} }
public Instruction OpenClLogb(Instruction resultType, Instruction x) public Instruction OpenClLogb(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 41, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 41, x);
} }
public Instruction OpenClMad(Instruction resultType, Instruction a, Instruction b, Instruction c) public Instruction OpenClMad(Instruction resultType, Instruction a, Instruction b, Instruction c)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 42, a, b, c); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 42, a, b, c);
} }
public Instruction OpenClMaxmag(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClMaxmag(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 43, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 43, x, y);
} }
public Instruction OpenClMinmag(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClMinmag(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 44, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 44, x, y);
} }
public Instruction OpenClModf(Instruction resultType, Instruction x, Instruction iptr) public Instruction OpenClModf(Instruction resultType, Instruction x, Instruction iptr)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 45, x, iptr); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 45, x, iptr);
} }
public Instruction OpenClNan(Instruction resultType, Instruction nancode) public Instruction OpenClNan(Instruction resultType, Instruction nancode)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 46, nancode); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 46, nancode);
} }
public Instruction OpenClNextafter(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClNextafter(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 47, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 47, x, y);
} }
public Instruction OpenClPow(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClPow(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 48, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 48, x, y);
} }
public Instruction OpenClPown(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClPown(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 49, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 49, x, y);
} }
public Instruction OpenClPowr(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClPowr(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 50, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 50, x, y);
} }
public Instruction OpenClRemainder(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClRemainder(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 51, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 51, x, y);
} }
public Instruction OpenClRemquo(Instruction resultType, Instruction x, Instruction y, Instruction quo) public Instruction OpenClRemquo(Instruction resultType, Instruction x, Instruction y, Instruction quo)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 52, x, y, quo); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 52, x, y, quo);
} }
public Instruction OpenClRint(Instruction resultType, Instruction x) public Instruction OpenClRint(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 53, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 53, x);
} }
public Instruction OpenClRootn(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClRootn(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 54, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 54, x, y);
} }
public Instruction OpenClRound(Instruction resultType, Instruction x) public Instruction OpenClRound(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 55, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 55, x);
} }
public Instruction OpenClRsqrt(Instruction resultType, Instruction x) public Instruction OpenClRsqrt(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 56, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 56, x);
} }
public Instruction OpenClSin(Instruction resultType, Instruction x) public Instruction OpenClSin(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 57, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 57, x);
} }
public Instruction OpenClSincos(Instruction resultType, Instruction x, Instruction cosval) public Instruction OpenClSincos(Instruction resultType, Instruction x, Instruction cosval)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 58, x, cosval); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 58, x, cosval);
} }
public Instruction OpenClSinh(Instruction resultType, Instruction x) public Instruction OpenClSinh(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 59, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 59, x);
} }
public Instruction OpenClSinpi(Instruction resultType, Instruction x) public Instruction OpenClSinpi(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 60, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 60, x);
} }
public Instruction OpenClSqrt(Instruction resultType, Instruction x) public Instruction OpenClSqrt(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 61, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 61, x);
} }
public Instruction OpenClTan(Instruction resultType, Instruction x) public Instruction OpenClTan(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 62, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 62, x);
} }
public Instruction OpenClTanh(Instruction resultType, Instruction x) public Instruction OpenClTanh(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 63, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 63, x);
} }
public Instruction OpenClTanpi(Instruction resultType, Instruction x) public Instruction OpenClTanpi(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 64, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 64, x);
} }
public Instruction OpenClTgamma(Instruction resultType, Instruction x) public Instruction OpenClTgamma(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 65, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 65, x);
} }
public Instruction OpenClTrunc(Instruction resultType, Instruction x) public Instruction OpenClTrunc(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 66, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 66, x);
} }
public Instruction OpenClHalf_cos(Instruction resultType, Instruction x) public Instruction OpenClHalf_cos(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 67, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 67, x);
} }
public Instruction OpenClHalf_divide(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClHalf_divide(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 68, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 68, x, y);
} }
public Instruction OpenClHalf_exp(Instruction resultType, Instruction x) public Instruction OpenClHalf_exp(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 69, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 69, x);
} }
public Instruction OpenClHalf_exp2(Instruction resultType, Instruction x) public Instruction OpenClHalf_exp2(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 70, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 70, x);
} }
public Instruction OpenClHalf_exp10(Instruction resultType, Instruction x) public Instruction OpenClHalf_exp10(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 71, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 71, x);
} }
public Instruction OpenClHalf_log(Instruction resultType, Instruction x) public Instruction OpenClHalf_log(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 72, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 72, x);
} }
public Instruction OpenClHalf_log2(Instruction resultType, Instruction x) public Instruction OpenClHalf_log2(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 73, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 73, x);
} }
public Instruction OpenClHalf_log10(Instruction resultType, Instruction x) public Instruction OpenClHalf_log10(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 74, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 74, x);
} }
public Instruction OpenClHalf_powr(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClHalf_powr(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 75, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 75, x, y);
} }
public Instruction OpenClHalf_recip(Instruction resultType, Instruction x) public Instruction OpenClHalf_recip(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 76, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 76, x);
} }
public Instruction OpenClHalf_rsqrt(Instruction resultType, Instruction x) public Instruction OpenClHalf_rsqrt(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 77, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 77, x);
} }
public Instruction OpenClHalf_sin(Instruction resultType, Instruction x) public Instruction OpenClHalf_sin(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 78, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 78, x);
} }
public Instruction OpenClHalf_sqrt(Instruction resultType, Instruction x) public Instruction OpenClHalf_sqrt(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 79, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 79, x);
} }
public Instruction OpenClHalf_tan(Instruction resultType, Instruction x) public Instruction OpenClHalf_tan(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 80, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 80, x);
} }
public Instruction OpenClNative_cos(Instruction resultType, Instruction x) public Instruction OpenClNative_cos(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 81, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 81, x);
} }
public Instruction OpenClNative_divide(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClNative_divide(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 82, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 82, x, y);
} }
public Instruction OpenClNative_exp(Instruction resultType, Instruction x) public Instruction OpenClNative_exp(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 83, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 83, x);
} }
public Instruction OpenClNative_exp2(Instruction resultType, Instruction x) public Instruction OpenClNative_exp2(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 84, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 84, x);
} }
public Instruction OpenClNative_exp10(Instruction resultType, Instruction x) public Instruction OpenClNative_exp10(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 85, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 85, x);
} }
public Instruction OpenClNative_log(Instruction resultType, Instruction x) public Instruction OpenClNative_log(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 86, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 86, x);
} }
public Instruction OpenClNative_log2(Instruction resultType, Instruction x) public Instruction OpenClNative_log2(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 87, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 87, x);
} }
public Instruction OpenClNative_log10(Instruction resultType, Instruction x) public Instruction OpenClNative_log10(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 88, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 88, x);
} }
public Instruction OpenClNative_powr(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClNative_powr(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 89, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 89, x, y);
} }
public Instruction OpenClNative_recip(Instruction resultType, Instruction x) public Instruction OpenClNative_recip(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 90, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 90, x);
} }
public Instruction OpenClNative_rsqrt(Instruction resultType, Instruction x) public Instruction OpenClNative_rsqrt(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 91, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 91, x);
} }
public Instruction OpenClNative_sin(Instruction resultType, Instruction x) public Instruction OpenClNative_sin(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 92, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 92, x);
} }
public Instruction OpenClNative_sqrt(Instruction resultType, Instruction x) public Instruction OpenClNative_sqrt(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 93, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 93, x);
} }
public Instruction OpenClNative_tan(Instruction resultType, Instruction x) public Instruction OpenClNative_tan(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 94, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 94, x);
} }
public Instruction OpenClS_abs(Instruction resultType, Instruction x) public Instruction OpenClS_abs(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 141, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 141, x);
} }
public Instruction OpenClS_abs_diff(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClS_abs_diff(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 142, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 142, x, y);
} }
public Instruction OpenClS_add_sat(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClS_add_sat(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 143, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 143, x, y);
} }
public Instruction OpenClU_add_sat(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClU_add_sat(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 144, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 144, x, y);
} }
public Instruction OpenClS_hadd(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClS_hadd(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 145, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 145, x, y);
} }
public Instruction OpenClU_hadd(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClU_hadd(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 146, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 146, x, y);
} }
public Instruction OpenClS_rhadd(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClS_rhadd(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 147, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 147, x, y);
} }
public Instruction OpenClU_rhadd(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClU_rhadd(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 148, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 148, x, y);
} }
public Instruction OpenClS_clamp(Instruction resultType, Instruction x, Instruction minval, Instruction maxval) public Instruction OpenClS_clamp(Instruction resultType, Instruction x, Instruction minval, Instruction maxval)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 149, x, minval, maxval); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 149, x, minval, maxval);
} }
public Instruction OpenClU_clamp(Instruction resultType, Instruction x, Instruction minval, Instruction maxval) public Instruction OpenClU_clamp(Instruction resultType, Instruction x, Instruction minval, Instruction maxval)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 150, x, minval, maxval); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 150, x, minval, maxval);
} }
public Instruction OpenClClz(Instruction resultType, Instruction x) public Instruction OpenClClz(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 151, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 151, x);
} }
public Instruction OpenClCtz(Instruction resultType, Instruction x) public Instruction OpenClCtz(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 152, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 152, x);
} }
public Instruction OpenClS_mad_hi(Instruction resultType, Instruction a, Instruction b, Instruction c) public Instruction OpenClS_mad_hi(Instruction resultType, Instruction a, Instruction b, Instruction c)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 153, a, b, c); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 153, a, b, c);
} }
public Instruction OpenClU_mad_sat(Instruction resultType, Instruction x, Instruction y, Instruction z) public Instruction OpenClU_mad_sat(Instruction resultType, Instruction x, Instruction y, Instruction z)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 154, x, y, z); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 154, x, y, z);
} }
public Instruction OpenClS_mad_sat(Instruction resultType, Instruction x, Instruction y, Instruction z) public Instruction OpenClS_mad_sat(Instruction resultType, Instruction x, Instruction y, Instruction z)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 155, x, y, z); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 155, x, y, z);
} }
public Instruction OpenClS_max(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClS_max(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 156, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 156, x, y);
} }
public Instruction OpenClU_max(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClU_max(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 157, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 157, x, y);
} }
public Instruction OpenClS_min(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClS_min(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 158, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 158, x, y);
} }
public Instruction OpenClU_min(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClU_min(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 159, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 159, x, y);
} }
public Instruction OpenClS_mul_hi(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClS_mul_hi(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 160, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 160, x, y);
} }
public Instruction OpenClRotate(Instruction resultType, Instruction v, Instruction i) public Instruction OpenClRotate(Instruction resultType, Instruction v, Instruction i)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 161, v, i); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 161, v, i);
} }
public Instruction OpenClS_sub_sat(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClS_sub_sat(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 162, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 162, x, y);
} }
public Instruction OpenClU_sub_sat(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClU_sub_sat(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 163, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 163, x, y);
} }
public Instruction OpenClU_upsample(Instruction resultType, Instruction hi, Instruction lo) public Instruction OpenClU_upsample(Instruction resultType, Instruction hi, Instruction lo)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 164, hi, lo); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 164, hi, lo);
} }
public Instruction OpenClS_upsample(Instruction resultType, Instruction hi, Instruction lo) public Instruction OpenClS_upsample(Instruction resultType, Instruction hi, Instruction lo)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 165, hi, lo); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 165, hi, lo);
} }
public Instruction OpenClPopcount(Instruction resultType, Instruction x) public Instruction OpenClPopcount(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 166, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 166, x);
} }
public Instruction OpenClS_mad24(Instruction resultType, Instruction x, Instruction y, Instruction z) public Instruction OpenClS_mad24(Instruction resultType, Instruction x, Instruction y, Instruction z)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 167, x, y, z); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 167, x, y, z);
} }
public Instruction OpenClU_mad24(Instruction resultType, Instruction x, Instruction y, Instruction z) public Instruction OpenClU_mad24(Instruction resultType, Instruction x, Instruction y, Instruction z)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 168, x, y, z); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 168, x, y, z);
} }
public Instruction OpenClS_mul24(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClS_mul24(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 169, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 169, x, y);
} }
public Instruction OpenClU_mul24(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClU_mul24(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 170, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 170, x, y);
} }
public Instruction OpenClU_abs(Instruction resultType, Instruction x) public Instruction OpenClU_abs(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 201, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 201, x);
} }
public Instruction OpenClU_abs_diff(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClU_abs_diff(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 202, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 202, x, y);
} }
public Instruction OpenClU_mul_hi(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClU_mul_hi(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 203, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 203, x, y);
} }
public Instruction OpenClU_mad_hi(Instruction resultType, Instruction a, Instruction b, Instruction c) public Instruction OpenClU_mad_hi(Instruction resultType, Instruction a, Instruction b, Instruction c)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 204, a, b, c); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 204, a, b, c);
} }
public Instruction OpenClFclamp(Instruction resultType, Instruction x, Instruction minval, Instruction maxval) public Instruction OpenClFclamp(Instruction resultType, Instruction x, Instruction minval, Instruction maxval)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 95, x, minval, maxval); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 95, x, minval, maxval);
} }
public Instruction OpenClDegrees(Instruction resultType, Instruction radians) public Instruction OpenClDegrees(Instruction resultType, Instruction radians)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 96, radians); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 96, radians);
} }
public Instruction OpenClFmax_common(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClFmax_common(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 97, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 97, x, y);
} }
public Instruction OpenClFmin_common(Instruction resultType, Instruction x, Instruction y) public Instruction OpenClFmin_common(Instruction resultType, Instruction x, Instruction y)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 98, x, y); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 98, x, y);
} }
public Instruction OpenClMix(Instruction resultType, Instruction x, Instruction y, Instruction a) public Instruction OpenClMix(Instruction resultType, Instruction x, Instruction y, Instruction a)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 99, x, y, a); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 99, x, y, a);
} }
public Instruction OpenClRadians(Instruction resultType, Instruction degrees) public Instruction OpenClRadians(Instruction resultType, Instruction degrees)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 100, degrees); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 100, degrees);
} }
public Instruction OpenClStep(Instruction resultType, Instruction edge, Instruction x) public Instruction OpenClStep(Instruction resultType, Instruction edge, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 101, edge, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 101, edge, x);
} }
public Instruction OpenClSmoothstep(Instruction resultType, Instruction edge0, Instruction edge1, Instruction x) public Instruction OpenClSmoothstep(Instruction resultType, Instruction edge0, Instruction edge1, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 102, edge0, edge1, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 102, edge0, edge1, x);
} }
public Instruction OpenClSign(Instruction resultType, Instruction x) public Instruction OpenClSign(Instruction resultType, Instruction x)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 103, x); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 103, x);
} }
public Instruction OpenClCross(Instruction resultType, Instruction p0, Instruction p1) public Instruction OpenClCross(Instruction resultType, Instruction p0, Instruction p1)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 104, p0, p1); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 104, p0, p1);
} }
public Instruction OpenClDistance(Instruction resultType, Instruction p0, Instruction p1) public Instruction OpenClDistance(Instruction resultType, Instruction p0, Instruction p1)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 105, p0, p1); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 105, p0, p1);
} }
public Instruction OpenClLength(Instruction resultType, Instruction p) public Instruction OpenClLength(Instruction resultType, Instruction p)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 106, p); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 106, p);
} }
public Instruction OpenClNormalize(Instruction resultType, Instruction p) public Instruction OpenClNormalize(Instruction resultType, Instruction p)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 107, p); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 107, p);
} }
public Instruction OpenClFast_distance(Instruction resultType, Instruction p0, Instruction p1) public Instruction OpenClFast_distance(Instruction resultType, Instruction p0, Instruction p1)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 108, p0, p1); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 108, p0, p1);
} }
public Instruction OpenClFast_length(Instruction resultType, Instruction p) public Instruction OpenClFast_length(Instruction resultType, Instruction p)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 109, p); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 109, p);
} }
public Instruction OpenClFast_normalize(Instruction resultType, Instruction p) public Instruction OpenClFast_normalize(Instruction resultType, Instruction p)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 110, p); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 110, p);
} }
public Instruction OpenClBitselect(Instruction resultType, Instruction a, Instruction b, Instruction c) public Instruction OpenClBitselect(Instruction resultType, Instruction a, Instruction b, Instruction c)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 186, a, b, c); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 186, a, b, c);
} }
public Instruction OpenClSelect(Instruction resultType, Instruction a, Instruction b, Instruction c) public Instruction OpenClSelect(Instruction resultType, Instruction a, Instruction b, Instruction c)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 187, a, b, c); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 187, a, b, c);
} }
public Instruction OpenClVloadn(Instruction resultType, Instruction offset, Instruction p, LiteralInteger n) public Instruction OpenClVloadn(Instruction resultType, Instruction offset, Instruction p, LiteralInteger n)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 171, offset, p, n); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 171, offset, p, n);
} }
public Instruction OpenClVstoren(Instruction resultType, Instruction data, Instruction offset, Instruction p) public Instruction OpenClVstoren(Instruction resultType, Instruction data, Instruction offset, Instruction p)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 172, data, offset, p); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 172, data, offset, p);
} }
public Instruction OpenClVload_half(Instruction resultType, Instruction offset, Instruction p) public Instruction OpenClVload_half(Instruction resultType, Instruction offset, Instruction p)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 173, offset, p); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 173, offset, p);
} }
public Instruction OpenClVload_halfn(Instruction resultType, Instruction offset, Instruction p, LiteralInteger n) public Instruction OpenClVload_halfn(Instruction resultType, Instruction offset, Instruction p, LiteralInteger n)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 174, offset, p, n); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 174, offset, p, n);
} }
public Instruction OpenClVstore_half(Instruction resultType, Instruction data, Instruction offset, Instruction p) public Instruction OpenClVstore_half(Instruction resultType, Instruction data, Instruction offset, Instruction p)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 175, data, offset, p); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 175, data, offset, p);
} }
public Instruction OpenClVstore_half_r(Instruction resultType, Instruction data, Instruction offset, Instruction p, FPRoundingMode mode) public Instruction OpenClVstore_half_r(Instruction resultType, Instruction data, Instruction offset, Instruction p, FPRoundingMode mode)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 176, data, offset, p, LiteralInteger.CreateForEnum(mode)); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 176, data, offset, p, LiteralInteger.CreateForEnum(mode));
} }
public Instruction OpenClVstore_halfn(Instruction resultType, Instruction data, Instruction offset, Instruction p) public Instruction OpenClVstore_halfn(Instruction resultType, Instruction data, Instruction offset, Instruction p)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 177, data, offset, p); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 177, data, offset, p);
} }
public Instruction OpenClVstore_halfn_r(Instruction resultType, Instruction data, Instruction offset, Instruction p, FPRoundingMode mode) public Instruction OpenClVstore_halfn_r(Instruction resultType, Instruction data, Instruction offset, Instruction p, FPRoundingMode mode)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 178, data, offset, p, LiteralInteger.CreateForEnum(mode)); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 178, data, offset, p, LiteralInteger.CreateForEnum(mode));
} }
public Instruction OpenClVloada_halfn(Instruction resultType, Instruction offset, Instruction p, LiteralInteger n) public Instruction OpenClVloada_halfn(Instruction resultType, Instruction offset, Instruction p, LiteralInteger n)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 179, offset, p, n); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 179, offset, p, n);
} }
public Instruction OpenClVstorea_halfn(Instruction resultType, Instruction data, Instruction offset, Instruction p) public Instruction OpenClVstorea_halfn(Instruction resultType, Instruction data, Instruction offset, Instruction p)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 180, data, offset, p); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 180, data, offset, p);
} }
public Instruction OpenClVstorea_halfn_r(Instruction resultType, Instruction data, Instruction offset, Instruction p, FPRoundingMode mode) public Instruction OpenClVstorea_halfn_r(Instruction resultType, Instruction data, Instruction offset, Instruction p, FPRoundingMode mode)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 181, data, offset, p, LiteralInteger.CreateForEnum(mode)); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 181, data, offset, p, LiteralInteger.CreateForEnum(mode));
} }
public Instruction OpenClShuffle(Instruction resultType, Instruction x, Instruction shufflemask) public Instruction OpenClShuffle(Instruction resultType, Instruction x, Instruction shufflemask)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 182, x, shufflemask); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 182, x, shufflemask);
} }
public Instruction OpenClShuffle2(Instruction resultType, Instruction x, Instruction y, Instruction shufflemask) public Instruction OpenClShuffle2(Instruction resultType, Instruction x, Instruction y, Instruction shufflemask)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 183, x, y, shufflemask); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 183, x, y, shufflemask);
} }
public Instruction OpenClPrefetch(Instruction resultType, Instruction ptr, Instruction numelements) public Instruction OpenClPrefetch(Instruction resultType, Instruction ptr, Instruction numelements)
{ {
return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 185, ptr, numelements); return ExtInst(resultType, AddExtInstImport("OpenCL.std"), 185, ptr, numelements);
} }
} }
} }

View file

@ -3,7 +3,7 @@ using System.Diagnostics.CodeAnalysis;
namespace Spv.Generator namespace Spv.Generator
{ {
internal struct ConstantKey : IEquatable<ConstantKey> internal readonly struct ConstantKey : IEquatable<ConstantKey>
{ {
private readonly Instruction _constant; private readonly Instruction _constant;
@ -24,7 +24,7 @@ namespace Spv.Generator
public override bool Equals([NotNullWhen(true)] object obj) public override bool Equals([NotNullWhen(true)] object obj)
{ {
return obj is ConstantKey && Equals((ConstantKey)obj); return obj is ConstantKey key && Equals(key);
} }
} }
} }

View file

@ -1,5 +1,4 @@
using System; using System;
using System.Diagnostics.CodeAnalysis;
namespace Spv.Generator namespace Spv.Generator
{ {
@ -19,12 +18,12 @@ namespace Spv.Generator
public bool Equals(DeterministicStringKey other) public bool Equals(DeterministicStringKey other)
{ {
return _value == other._value; return _value == other?._value;
} }
public override bool Equals([NotNullWhen(true)] object obj) public override bool Equals(object obj)
{ {
return obj is DeterministicStringKey && Equals((DeterministicStringKey)obj); return obj is DeterministicStringKey key && Equals(key);
} }
} }
} }

View file

@ -4,17 +4,15 @@ namespace Spv.Generator
{ {
public class GeneratorPool<T> where T : class, new() public class GeneratorPool<T> where T : class, new()
{ {
private List<T[]> _pool; private readonly List<T[]> _pool;
private int _chunkIndex = -1; private int _chunkIndex = -1;
private int _poolIndex = -1; private int _poolIndex = -1;
private int _initialSize; private readonly int _poolSizeIncrement;
private int _poolSizeIncrement;
public GeneratorPool(): this(1000, 200) { } public GeneratorPool() : this(1000, 200) { }
public GeneratorPool(int chunkSizeLimit, int poolSizeIncrement) public GeneratorPool(int chunkSizeLimit, int poolSizeIncrement)
{ {
_initialSize = chunkSizeLimit;
_poolSizeIncrement = poolSizeIncrement; _poolSizeIncrement = poolSizeIncrement;
_pool = new(chunkSizeLimit * 2); _pool = new(chunkSizeLimit * 2);

View file

@ -3,7 +3,7 @@ using System.IO;
namespace Spv.Generator namespace Spv.Generator
{ {
public interface Operand : IEquatable<Operand> public interface IOperand : IEquatable<IOperand>
{ {
OperandType Type { get; } OperandType Type { get; }

View file

@ -5,7 +5,7 @@ using System.IO;
namespace Spv.Generator namespace Spv.Generator
{ {
public sealed class Instruction : Operand, IEquatable<Instruction> public sealed class Instruction : IOperand, IEquatable<Instruction>
{ {
public const uint InvalidId = uint.MaxValue; public const uint InvalidId = uint.MaxValue;
@ -47,7 +47,7 @@ namespace Spv.Generator
result += _resultType.WordCount; result += _resultType.WordCount;
} }
Span<Operand> operands = _operands.AsSpan(); Span<IOperand> operands = _operands.AsSpan();
for (int i = 0; i < operands.Length; i++) for (int i = 0; i < operands.Length; i++)
{ {
result += operands[i].WordCount; result += operands[i].WordCount;
@ -58,15 +58,15 @@ namespace Spv.Generator
public ushort WordCount => 1; public ushort WordCount => 1;
public void AddOperand(Operand value) public void AddOperand(IOperand value)
{ {
Debug.Assert(value != null); Debug.Assert(value != null);
_operands.Add(value); _operands.Add(value);
} }
public void AddOperand(Operand[] value) public void AddOperand(IOperand[] value)
{ {
foreach (Operand instruction in value) foreach (IOperand instruction in value)
{ {
AddOperand(instruction); AddOperand(instruction);
} }
@ -82,7 +82,7 @@ namespace Spv.Generator
public void AddOperand(LiteralInteger value) public void AddOperand(LiteralInteger value)
{ {
AddOperand((Operand)value); AddOperand((IOperand)value);
} }
public void AddOperand(Instruction[] value) public void AddOperand(Instruction[] value)
@ -95,7 +95,7 @@ namespace Spv.Generator
public void AddOperand(Instruction value) public void AddOperand(Instruction value)
{ {
AddOperand((Operand)value); AddOperand((IOperand)value);
} }
public void AddOperand(string value) public void AddOperand(string value)
@ -103,7 +103,7 @@ namespace Spv.Generator
AddOperand(new LiteralString(value)); AddOperand(new LiteralString(value));
} }
public void AddOperand<T>(T value) where T: Enum public void AddOperand<T>(T value) where T : Enum
{ {
AddOperand(LiteralInteger.CreateForEnum(value)); AddOperand(LiteralInteger.CreateForEnum(value));
} }
@ -121,7 +121,7 @@ namespace Spv.Generator
writer.Write(Id); writer.Write(Id);
} }
Span<Operand> operands = _operands.AsSpan(); Span<IOperand> operands = _operands.AsSpan();
for (int i = 0; i < operands.Length; i++) for (int i = 0; i < operands.Length; i++)
{ {
operands[i].WriteOperand(writer); operands[i].WriteOperand(writer);
@ -186,8 +186,8 @@ namespace Spv.Generator
public bool EqualsContent(Instruction cmpObj) public bool EqualsContent(Instruction cmpObj)
{ {
Span<Operand> thisOperands = _operands.AsSpan(); Span<IOperand> thisOperands = _operands.AsSpan();
Span<Operand> cmpOperands = cmpObj._operands.AsSpan(); Span<IOperand> cmpOperands = cmpObj._operands.AsSpan();
if (thisOperands.Length != cmpOperands.Length) if (thisOperands.Length != cmpOperands.Length)
{ {
@ -212,7 +212,7 @@ namespace Spv.Generator
public int GetHashCodeContent() public int GetHashCodeContent()
{ {
return DeterministicHashCode.Combine<Operand>(_operands.AsSpan()); return DeterministicHashCode.Combine<IOperand>(_operands.AsSpan());
} }
public int GetHashCodeResultType() public int GetHashCodeResultType()
@ -222,14 +222,14 @@ namespace Spv.Generator
public override int GetHashCode() public override int GetHashCode()
{ {
return DeterministicHashCode.Combine(Opcode, Id, _resultType, DeterministicHashCode.Combine<Operand>(_operands.AsSpan())); return DeterministicHashCode.Combine(Opcode, Id, _resultType, DeterministicHashCode.Combine<IOperand>(_operands.AsSpan()));
} }
public bool Equals(Operand obj) public bool Equals(IOperand obj)
{ {
return obj is Instruction instruction && Equals(instruction); return obj is Instruction instruction && Equals(instruction);
} }
private static readonly Dictionary<Specification.Op, string[]> _operandLabels = new() private static readonly Dictionary<Specification.Op, string[]> _operandLabels = new()
{ {
{ Specification.Op.OpConstant, new [] { "Value" } }, { Specification.Op.OpConstant, new [] { "Value" } },

View file

@ -10,14 +10,14 @@ namespace Spv.Generator
private const int InternalCount = 5; private const int InternalCount = 5;
public int Count; public int Count;
public Operand Operand1; public IOperand Operand1;
public Operand Operand2; public IOperand Operand2;
public Operand Operand3; public IOperand Operand3;
public Operand Operand4; public IOperand Operand4;
public Operand Operand5; public IOperand Operand5;
public Operand[] Overflow; public IOperand[] Overflow;
public Span<Operand> AsSpan() public Span<IOperand> AsSpan()
{ {
if (Count > InternalCount) if (Count > InternalCount)
{ {
@ -29,7 +29,7 @@ namespace Spv.Generator
} }
} }
public void Add(Operand operand) public void Add(IOperand operand)
{ {
if (Count < InternalCount) if (Count < InternalCount)
{ {
@ -40,7 +40,7 @@ namespace Spv.Generator
{ {
if (Overflow == null) if (Overflow == null)
{ {
Overflow = new Operand[InternalCount * 2]; Overflow = new IOperand[InternalCount * 2];
MemoryMarshal.CreateSpan(ref this.Operand1, InternalCount).CopyTo(Overflow.AsSpan()); MemoryMarshal.CreateSpan(ref this.Operand1, InternalCount).CopyTo(Overflow.AsSpan());
} }
else if (Count == Overflow.Length) else if (Count == Overflow.Length)
@ -52,16 +52,16 @@ namespace Spv.Generator
} }
} }
private IEnumerable<Operand> AllOperands => new[] { Operand1, Operand2, Operand3, Operand4, Operand5 } private readonly IEnumerable<IOperand> AllOperands => new[] { Operand1, Operand2, Operand3, Operand4, Operand5 }
.Concat(Overflow ?? Array.Empty<Operand>()) .Concat(Overflow ?? Array.Empty<IOperand>())
.Take(Count); .Take(Count);
public override string ToString() public readonly override string ToString()
{ {
return $"({string.Join(", ", AllOperands)})"; return $"({string.Join(", ", AllOperands)})";
} }
public string ToString(string[] labels) public readonly string ToString(string[] labels)
{ {
var labeledParams = AllOperands.Zip(labels, (op, label) => $"{label}: {op}"); var labeledParams = AllOperands.Zip(labels, (op, label) => $"{label}: {op}");
var unlabeledParams = AllOperands.Skip(labels.Length).Select(op => op.ToString()); var unlabeledParams = AllOperands.Skip(labels.Length).Select(op => op.ToString());

View file

@ -3,7 +3,7 @@ using System.IO;
namespace Spv.Generator namespace Spv.Generator
{ {
public class LiteralInteger : Operand, IEquatable<LiteralInteger> public class LiteralInteger : IOperand, IEquatable<LiteralInteger>
{ {
[ThreadStatic] [ThreadStatic]
private static GeneratorPool<LiteralInteger> _pool; private static GeneratorPool<LiteralInteger> _pool;
@ -95,7 +95,7 @@ namespace Spv.Generator
return DeterministicHashCode.Combine(Type, _data); return DeterministicHashCode.Combine(Type, _data);
} }
public bool Equals(Operand obj) public bool Equals(IOperand obj)
{ {
return obj is LiteralInteger literalInteger && Equals(literalInteger); return obj is LiteralInteger literalInteger && Equals(literalInteger);
} }

View file

@ -4,7 +4,7 @@ using System.Text;
namespace Spv.Generator namespace Spv.Generator
{ {
public class LiteralString : Operand, IEquatable<LiteralString> public class LiteralString : IOperand, IEquatable<LiteralString>
{ {
public OperandType Type => OperandType.String; public OperandType Type => OperandType.String;
@ -44,7 +44,7 @@ namespace Spv.Generator
return DeterministicHashCode.Combine(Type, DeterministicHashCode.GetHashCode(_value)); return DeterministicHashCode.Combine(Type, DeterministicHashCode.GetHashCode(_value));
} }
public bool Equals(Operand obj) public bool Equals(IOperand obj)
{ {
return obj is LiteralString literalString && Equals(literalString); return obj is LiteralString literalString && Equals(literalString);
} }

View file

@ -15,30 +15,30 @@ namespace Spv.Generator
private uint _bound; private uint _bound;
// Follow spec order here while keeping it as simple as possible. // Follow spec order here while keeping it as simple as possible.
private List<Capability> _capabilities; private readonly List<Capability> _capabilities;
private List<string> _extensions; private readonly List<string> _extensions;
private Dictionary<DeterministicStringKey, Instruction> _extInstImports; private readonly Dictionary<DeterministicStringKey, Instruction> _extInstImports;
private AddressingModel _addressingModel; private AddressingModel _addressingModel;
private MemoryModel _memoryModel; private MemoryModel _memoryModel;
private List<Instruction> _entrypoints; private readonly List<Instruction> _entrypoints;
private List<Instruction> _executionModes; private readonly List<Instruction> _executionModes;
private List<Instruction> _debug; private readonly List<Instruction> _debug;
private List<Instruction> _annotations; private readonly List<Instruction> _annotations;
// In the declaration block. // In the declaration block.
private Dictionary<TypeDeclarationKey, Instruction> _typeDeclarations; private readonly Dictionary<TypeDeclarationKey, Instruction> _typeDeclarations;
// In the declaration block. // In the declaration block.
private List<Instruction> _globals; private readonly List<Instruction> _globals;
// In the declaration block. // In the declaration block.
private Dictionary<ConstantKey, Instruction> _constants; private readonly Dictionary<ConstantKey, Instruction> _constants;
// In the declaration block, for function that aren't defined in the module. // In the declaration block, for function that aren't defined in the module.
private List<Instruction> _functionsDeclarations; private readonly List<Instruction> _functionsDeclarations;
private List<Instruction> _functionsDefinitions; private readonly List<Instruction> _functionsDefinitions;
private GeneratorPool<Instruction> _instPool; private readonly GeneratorPool<Instruction> _instPool;
private GeneratorPool<LiteralInteger> _integerPool; private readonly GeneratorPool<LiteralInteger> _integerPool;
public Module(uint version, GeneratorPool<Instruction> instPool = null, GeneratorPool<LiteralInteger> integerPool = null) public Module(uint version, GeneratorPool<Instruction> instPool = null, GeneratorPool<LiteralInteger> integerPool = null)
{ {
@ -143,7 +143,7 @@ namespace Spv.Generator
_entrypoints.Add(entryPoint); _entrypoints.Add(entryPoint);
} }
public void AddExecutionMode(Instruction function, ExecutionMode mode, params Operand[] parameters) public void AddExecutionMode(Instruction function, ExecutionMode mode, params IOperand[] parameters)
{ {
Debug.Assert(function.Opcode == Op.OpFunction); Debug.Assert(function.Opcode == Op.OpFunction);
@ -225,7 +225,7 @@ namespace Spv.Generator
_constants.Add(key, constant); _constants.Add(key, constant);
} }
public Instruction ExtInst(Instruction resultType, Instruction set, LiteralInteger instruction, params Operand[] parameters) public Instruction ExtInst(Instruction resultType, Instruction set, LiteralInteger instruction, params IOperand[] parameters)
{ {
Instruction result = NewInstruction(Op.OpExtInst, GetNewId(), resultType); Instruction result = NewInstruction(Op.OpExtInst, GetNewId(), resultType);
@ -262,104 +262,103 @@ namespace Spv.Generator
// Estimate the size needed for the generated code, to avoid expanding the MemoryStream. // Estimate the size needed for the generated code, to avoid expanding the MemoryStream.
int sizeEstimate = 1024 + _functionsDefinitions.Count * 32; int sizeEstimate = 1024 + _functionsDefinitions.Count * 32;
using (MemoryStream stream = new MemoryStream(sizeEstimate)) using MemoryStream stream = new(sizeEstimate);
BinaryWriter writer = new(stream, System.Text.Encoding.ASCII);
// Header
writer.Write(MagicNumber);
writer.Write(_version);
writer.Write(GeneratorId);
writer.Write(_bound);
writer.Write(0u);
// 1.
foreach (Capability capability in _capabilities)
{ {
BinaryWriter writer = new BinaryWriter(stream, System.Text.Encoding.ASCII); Instruction capabilityInstruction = NewInstruction(Op.OpCapability);
// Header capabilityInstruction.AddOperand(capability);
writer.Write(MagicNumber); capabilityInstruction.Write(writer);
writer.Write(_version);
writer.Write(GeneratorId);
writer.Write(_bound);
writer.Write(0u);
// 1.
foreach (Capability capability in _capabilities)
{
Instruction capabilityInstruction = NewInstruction(Op.OpCapability);
capabilityInstruction.AddOperand(capability);
capabilityInstruction.Write(writer);
}
// 2.
foreach (string extension in _extensions)
{
Instruction extensionInstruction = NewInstruction(Op.OpExtension);
extensionInstruction.AddOperand(extension);
extensionInstruction.Write(writer);
}
// 3.
foreach (Instruction extInstImport in _extInstImports.Values)
{
extInstImport.Write(writer);
}
// 4.
Instruction memoryModelInstruction = NewInstruction(Op.OpMemoryModel);
memoryModelInstruction.AddOperand(_addressingModel);
memoryModelInstruction.AddOperand(_memoryModel);
memoryModelInstruction.Write(writer);
// 5.
foreach (Instruction entrypoint in _entrypoints)
{
entrypoint.Write(writer);
}
// 6.
foreach (Instruction executionMode in _executionModes)
{
executionMode.Write(writer);
}
// 7.
// TODO: Order debug information correctly.
foreach (Instruction debug in _debug)
{
debug.Write(writer);
}
// 8.
foreach (Instruction annotation in _annotations)
{
annotation.Write(writer);
}
// Ensure that everything is in the right order in the declarations section.
List<Instruction> declarations = new List<Instruction>();
declarations.AddRange(_typeDeclarations.Values);
declarations.AddRange(_globals);
declarations.AddRange(_constants.Values);
declarations.Sort((Instruction x, Instruction y) => x.Id.CompareTo(y.Id));
// 9.
foreach (Instruction declaration in declarations)
{
declaration.Write(writer);
}
// 10.
foreach (Instruction functionDeclaration in _functionsDeclarations)
{
functionDeclaration.Write(writer);
}
// 11.
foreach (Instruction functionDefinition in _functionsDefinitions)
{
functionDefinition.Write(writer);
}
_instPool.Clear();
_integerPool.Clear();
LiteralInteger.UnregisterPool();
return stream.ToArray();
} }
// 2.
foreach (string extension in _extensions)
{
Instruction extensionInstruction = NewInstruction(Op.OpExtension);
extensionInstruction.AddOperand(extension);
extensionInstruction.Write(writer);
}
// 3.
foreach (Instruction extInstImport in _extInstImports.Values)
{
extInstImport.Write(writer);
}
// 4.
Instruction memoryModelInstruction = NewInstruction(Op.OpMemoryModel);
memoryModelInstruction.AddOperand(_addressingModel);
memoryModelInstruction.AddOperand(_memoryModel);
memoryModelInstruction.Write(writer);
// 5.
foreach (Instruction entrypoint in _entrypoints)
{
entrypoint.Write(writer);
}
// 6.
foreach (Instruction executionMode in _executionModes)
{
executionMode.Write(writer);
}
// 7.
// TODO: Order debug information correctly.
foreach (Instruction debug in _debug)
{
debug.Write(writer);
}
// 8.
foreach (Instruction annotation in _annotations)
{
annotation.Write(writer);
}
// Ensure that everything is in the right order in the declarations section.
List<Instruction> declarations = new();
declarations.AddRange(_typeDeclarations.Values);
declarations.AddRange(_globals);
declarations.AddRange(_constants.Values);
declarations.Sort((Instruction x, Instruction y) => x.Id.CompareTo(y.Id));
// 9.
foreach (Instruction declaration in declarations)
{
declaration.Write(writer);
}
// 10.
foreach (Instruction functionDeclaration in _functionsDeclarations)
{
functionDeclaration.Write(writer);
}
// 11.
foreach (Instruction functionDefinition in _functionsDefinitions)
{
functionDefinition.Write(writer);
}
_instPool.Clear();
_integerPool.Clear();
LiteralInteger.UnregisterPool();
return stream.ToArray();
} }
} }
} }

View file

@ -3,7 +3,7 @@ using System.Diagnostics.CodeAnalysis;
namespace Spv.Generator namespace Spv.Generator
{ {
internal struct TypeDeclarationKey : IEquatable<TypeDeclarationKey> internal readonly struct TypeDeclarationKey : IEquatable<TypeDeclarationKey>
{ {
private readonly Instruction _typeDeclaration; private readonly Instruction _typeDeclaration;
@ -24,7 +24,7 @@ namespace Spv.Generator
public override bool Equals([NotNullWhen(true)] object obj) public override bool Equals([NotNullWhen(true)] object obj)
{ {
return obj is TypeDeclarationKey && Equals((TypeDeclarationKey)obj); return obj is TypeDeclarationKey key && Equals(key);
} }
} }
} }

View file

@ -75,17 +75,17 @@ namespace Spv
TaskNV = 5267, TaskNV = 5267,
MeshNV = 5268, MeshNV = 5268,
RayGenerationKHR = 5313, RayGenerationKHR = 5313,
RayGenerationNV = 5313, RayGenerationNV = RayGenerationKHR,
IntersectionKHR = 5314, IntersectionKHR = 5314,
IntersectionNV = 5314, IntersectionNV = IntersectionKHR,
AnyHitKHR = 5315, AnyHitKHR = 5315,
AnyHitNV = 5315, AnyHitNV = AnyHitKHR,
ClosestHitKHR = 5316, ClosestHitKHR = 5316,
ClosestHitNV = 5316, ClosestHitNV = ClosestHitKHR,
MissKHR = 5317, MissKHR = 5317,
MissNV = 5317, MissNV = MissKHR,
CallableKHR = 5318, CallableKHR = 5318,
CallableNV = 5318, CallableNV = CallableKHR,
} }
public enum AddressingModel public enum AddressingModel
@ -94,7 +94,7 @@ namespace Spv
Physical32 = 1, Physical32 = 1,
Physical64 = 2, Physical64 = 2,
PhysicalStorageBuffer64 = 5348, PhysicalStorageBuffer64 = 5348,
PhysicalStorageBuffer64EXT = 5348, PhysicalStorageBuffer64EXT = PhysicalStorageBuffer64,
} }
public enum MemoryModel public enum MemoryModel
@ -103,7 +103,7 @@ namespace Spv
GLSL450 = 1, GLSL450 = 1,
OpenCL = 2, OpenCL = 2,
Vulkan = 3, Vulkan = 3,
VulkanKHR = 3, VulkanKHR = Vulkan,
} }
public enum ExecutionMode public enum ExecutionMode
@ -186,19 +186,19 @@ namespace Spv
Image = 11, Image = 11,
StorageBuffer = 12, StorageBuffer = 12,
CallableDataKHR = 5328, CallableDataKHR = 5328,
CallableDataNV = 5328, CallableDataNV = CallableDataKHR,
IncomingCallableDataKHR = 5329, IncomingCallableDataKHR = 5329,
IncomingCallableDataNV = 5329, IncomingCallableDataNV = IncomingCallableDataKHR,
RayPayloadKHR = 5338, RayPayloadKHR = 5338,
RayPayloadNV = 5338, RayPayloadNV = RayPayloadKHR,
HitAttributeKHR = 5339, HitAttributeKHR = 5339,
HitAttributeNV = 5339, HitAttributeNV = HitAttributeKHR,
IncomingRayPayloadKHR = 5342, IncomingRayPayloadKHR = 5342,
IncomingRayPayloadNV = 5342, IncomingRayPayloadNV = IncomingRayPayloadKHR,
ShaderRecordBufferKHR = 5343, ShaderRecordBufferKHR = 5343,
ShaderRecordBufferNV = 5343, ShaderRecordBufferNV = ShaderRecordBufferKHR,
PhysicalStorageBuffer = 5349, PhysicalStorageBuffer = 5349,
PhysicalStorageBufferEXT = 5349, PhysicalStorageBufferEXT = PhysicalStorageBuffer,
CodeSectionINTEL = 5605, CodeSectionINTEL = 5605,
} }
@ -330,13 +330,13 @@ namespace Spv
Sample = 6, Sample = 6,
MinLod = 7, MinLod = 7,
MakeTexelAvailable = 8, MakeTexelAvailable = 8,
MakeTexelAvailableKHR = 8, MakeTexelAvailableKHR = MakeTexelAvailable,
MakeTexelVisible = 9, MakeTexelVisible = 9,
MakeTexelVisibleKHR = 9, MakeTexelVisibleKHR = MakeTexelVisible,
NonPrivateTexel = 10, NonPrivateTexel = 10,
NonPrivateTexelKHR = 10, NonPrivateTexelKHR = NonPrivateTexel,
VolatileTexel = 11, VolatileTexel = 11,
VolatileTexelKHR = 11, VolatileTexelKHR = VolatileTexel,
SignExtend = 12, SignExtend = 12,
ZeroExtend = 13, ZeroExtend = 13,
} }
@ -353,13 +353,13 @@ namespace Spv
Sample = 0x00000040, Sample = 0x00000040,
MinLod = 0x00000080, MinLod = 0x00000080,
MakeTexelAvailable = 0x00000100, MakeTexelAvailable = 0x00000100,
MakeTexelAvailableKHR = 0x00000100, MakeTexelAvailableKHR = MakeTexelAvailable,
MakeTexelVisible = 0x00000200, MakeTexelVisible = 0x00000200,
MakeTexelVisibleKHR = 0x00000200, MakeTexelVisibleKHR = MakeTexelVisible,
NonPrivateTexel = 0x00000400, NonPrivateTexel = 0x00000400,
NonPrivateTexelKHR = 0x00000400, NonPrivateTexelKHR = NonPrivateTexel,
VolatileTexel = 0x00000800, VolatileTexel = 0x00000800,
VolatileTexelKHR = 0x00000800, VolatileTexelKHR = VolatileTexel,
SignExtend = 0x00001000, SignExtend = 0x00001000,
ZeroExtend = 0x00002000, ZeroExtend = 0x00002000,
Offsets = 0x00010000, Offsets = 0x00010000,
@ -478,16 +478,16 @@ namespace Spv
PerTaskNV = 5273, PerTaskNV = 5273,
PerVertexNV = 5285, PerVertexNV = 5285,
NonUniform = 5300, NonUniform = 5300,
NonUniformEXT = 5300, NonUniformEXT = NonUniform,
RestrictPointer = 5355, RestrictPointer = 5355,
RestrictPointerEXT = 5355, RestrictPointerEXT = RestrictPointer,
AliasedPointer = 5356, AliasedPointer = 5356,
AliasedPointerEXT = 5356, AliasedPointerEXT = AliasedPointer,
ReferencedIndirectlyINTEL = 5602, ReferencedIndirectlyINTEL = 5602,
CounterBuffer = 5634, CounterBuffer = 5634,
HlslCounterBufferGOOGLE = 5634, HlslCounterBufferGOOGLE = CounterBuffer,
HlslSemanticGOOGLE = 5635, HlslSemanticGOOGLE = 5635,
UserSemantic = 5635, UserSemantic = HlslSemanticGOOGLE,
UserTypeGOOGLE = 5636, UserTypeGOOGLE = 5636,
RegisterINTEL = 5825, RegisterINTEL = 5825,
MemoryINTEL = 5826, MemoryINTEL = 5826,
@ -547,15 +547,15 @@ namespace Spv
VertexIndex = 42, VertexIndex = 42,
InstanceIndex = 43, InstanceIndex = 43,
SubgroupEqMask = 4416, SubgroupEqMask = 4416,
SubgroupEqMaskKHR = 4416, SubgroupEqMaskKHR = SubgroupEqMask,
SubgroupGeMask = 4417, SubgroupGeMask = 4417,
SubgroupGeMaskKHR = 4417, SubgroupGeMaskKHR = SubgroupGeMask,
SubgroupGtMask = 4418, SubgroupGtMask = 4418,
SubgroupGtMaskKHR = 4418, SubgroupGtMaskKHR = SubgroupGtMask,
SubgroupLeMask = 4419, SubgroupLeMask = 4419,
SubgroupLeMaskKHR = 4419, SubgroupLeMaskKHR = SubgroupLeMask,
SubgroupLtMask = 4420, SubgroupLtMask = 4420,
SubgroupLtMaskKHR = 4420, SubgroupLtMaskKHR = SubgroupLtMask,
BaseVertex = 4424, BaseVertex = 4424,
BaseInstance = 4425, BaseInstance = 4425,
DrawIndex = 4426, DrawIndex = 4426,
@ -588,36 +588,36 @@ namespace Spv
BaryCoordNV = 5286, BaryCoordNV = 5286,
BaryCoordNoPerspNV = 5287, BaryCoordNoPerspNV = 5287,
FragSizeEXT = 5292, FragSizeEXT = 5292,
FragmentSizeNV = 5292, FragmentSizeNV = FragSizeEXT,
FragInvocationCountEXT = 5293, FragInvocationCountEXT = 5293,
InvocationsPerPixelNV = 5293, InvocationsPerPixelNV = FragInvocationCountEXT,
LaunchIdKHR = 5319, LaunchIdKHR = 5319,
LaunchIdNV = 5319, LaunchIdNV = LaunchIdKHR,
LaunchSizeKHR = 5320, LaunchSizeKHR = 5320,
LaunchSizeNV = 5320, LaunchSizeNV = LaunchSizeKHR,
WorldRayOriginKHR = 5321, WorldRayOriginKHR = 5321,
WorldRayOriginNV = 5321, WorldRayOriginNV = WorldRayOriginKHR,
WorldRayDirectionKHR = 5322, WorldRayDirectionKHR = 5322,
WorldRayDirectionNV = 5322, WorldRayDirectionNV = WorldRayDirectionKHR,
ObjectRayOriginKHR = 5323, ObjectRayOriginKHR = 5323,
ObjectRayOriginNV = 5323, ObjectRayOriginNV = ObjectRayOriginKHR,
ObjectRayDirectionKHR = 5324, ObjectRayDirectionKHR = 5324,
ObjectRayDirectionNV = 5324, ObjectRayDirectionNV = ObjectRayDirectionKHR,
RayTminKHR = 5325, RayTminKHR = 5325,
RayTminNV = 5325, RayTminNV = RayTminKHR,
RayTmaxKHR = 5326, RayTmaxKHR = 5326,
RayTmaxNV = 5326, RayTmaxNV = RayTmaxKHR,
InstanceCustomIndexKHR = 5327, InstanceCustomIndexKHR = 5327,
InstanceCustomIndexNV = 5327, InstanceCustomIndexNV = InstanceCustomIndexKHR,
ObjectToWorldKHR = 5330, ObjectToWorldKHR = 5330,
ObjectToWorldNV = 5330, ObjectToWorldNV = ObjectToWorldKHR,
WorldToObjectKHR = 5331, WorldToObjectKHR = 5331,
WorldToObjectNV = 5331, WorldToObjectNV = WorldToObjectKHR,
HitTNV = 5332, HitTNV = 5332,
HitKindKHR = 5333, HitKindKHR = 5333,
HitKindNV = 5333, HitKindNV = HitKindKHR,
IncomingRayFlagsKHR = 5351, IncomingRayFlagsKHR = 5351,
IncomingRayFlagsNV = 5351, IncomingRayFlagsNV = IncomingRayFlagsKHR,
RayGeometryIndexKHR = 5352, RayGeometryIndexKHR = 5352,
WarpsPerSMNV = 5374, WarpsPerSMNV = 5374,
SMCountNV = 5375, SMCountNV = 5375,
@ -709,11 +709,11 @@ namespace Spv
AtomicCounterMemory = 10, AtomicCounterMemory = 10,
ImageMemory = 11, ImageMemory = 11,
OutputMemory = 12, OutputMemory = 12,
OutputMemoryKHR = 12, OutputMemoryKHR = OutputMemory,
MakeAvailable = 13, MakeAvailable = 13,
MakeAvailableKHR = 13, MakeAvailableKHR = MakeAvailable,
MakeVisible = 14, MakeVisible = 14,
MakeVisibleKHR = 14, MakeVisibleKHR = MakeVisible,
Volatile = 15, Volatile = 15,
} }
@ -731,11 +731,11 @@ namespace Spv
AtomicCounterMemory = 0x00000400, AtomicCounterMemory = 0x00000400,
ImageMemory = 0x00000800, ImageMemory = 0x00000800,
OutputMemory = 0x00001000, OutputMemory = 0x00001000,
OutputMemoryKHR = 0x00001000, OutputMemoryKHR = OutputMemory,
MakeAvailable = 0x00002000, MakeAvailable = 0x00002000,
MakeAvailableKHR = 0x00002000, MakeAvailableKHR = MakeAvailable,
MakeVisible = 0x00004000, MakeVisible = 0x00004000,
MakeVisibleKHR = 0x00004000, MakeVisibleKHR = MakeVisible,
Volatile = 0x00008000, Volatile = 0x00008000,
} }
@ -745,11 +745,11 @@ namespace Spv
Aligned = 1, Aligned = 1,
Nontemporal = 2, Nontemporal = 2,
MakePointerAvailable = 3, MakePointerAvailable = 3,
MakePointerAvailableKHR = 3, MakePointerAvailableKHR = MakePointerAvailable,
MakePointerVisible = 4, MakePointerVisible = 4,
MakePointerVisibleKHR = 4, MakePointerVisibleKHR = MakePointerVisible,
NonPrivatePointer = 5, NonPrivatePointer = 5,
NonPrivatePointerKHR = 5, NonPrivatePointerKHR = NonPrivatePointer,
} }
public enum MemoryAccessMask public enum MemoryAccessMask
@ -759,11 +759,11 @@ namespace Spv
Aligned = 0x00000002, Aligned = 0x00000002,
Nontemporal = 0x00000004, Nontemporal = 0x00000004,
MakePointerAvailable = 0x00000008, MakePointerAvailable = 0x00000008,
MakePointerAvailableKHR = 0x00000008, MakePointerAvailableKHR = MakePointerAvailable,
MakePointerVisible = 0x00000010, MakePointerVisible = 0x00000010,
MakePointerVisibleKHR = 0x00000010, MakePointerVisibleKHR = MakePointerVisible,
NonPrivatePointer = 0x00000020, NonPrivatePointer = 0x00000020,
NonPrivatePointerKHR = 0x00000020, NonPrivatePointerKHR = NonPrivatePointer,
} }
public enum Scope public enum Scope
@ -774,7 +774,7 @@ namespace Spv
Subgroup = 3, Subgroup = 3,
Invocation = 4, Invocation = 4,
QueueFamily = 5, QueueFamily = 5,
QueueFamilyKHR = 5, QueueFamilyKHR = QueueFamily,
ShaderCallKHR = 6, ShaderCallKHR = 6,
} }
@ -883,9 +883,9 @@ namespace Spv
DrawParameters = 4427, DrawParameters = 4427,
SubgroupVoteKHR = 4431, SubgroupVoteKHR = 4431,
StorageBuffer16BitAccess = 4433, StorageBuffer16BitAccess = 4433,
StorageUniformBufferBlock16 = 4433, StorageUniformBufferBlock16 = StorageBuffer16BitAccess,
StorageUniform16 = 4434, StorageUniform16 = 4434,
UniformAndStorageBuffer16BitAccess = 4434, UniformAndStorageBuffer16BitAccess = StorageUniform16,
StoragePushConstant16 = 4435, StoragePushConstant16 = 4435,
StorageInputOutput16 = 4436, StorageInputOutput16 = 4436,
DeviceGroup = 4437, DeviceGroup = 4437,
@ -916,7 +916,7 @@ namespace Spv
SampleMaskOverrideCoverageNV = 5249, SampleMaskOverrideCoverageNV = 5249,
GeometryShaderPassthroughNV = 5251, GeometryShaderPassthroughNV = 5251,
ShaderViewportIndexLayerEXT = 5254, ShaderViewportIndexLayerEXT = 5254,
ShaderViewportIndexLayerNV = 5254, ShaderViewportIndexLayerNV = ShaderViewportIndexLayerEXT,
ShaderViewportMaskNV = 5255, ShaderViewportMaskNV = 5255,
ShaderStereoViewNV = 5259, ShaderStereoViewNV = 5259,
PerViewAttributesNV = 5260, PerViewAttributesNV = 5260,
@ -926,39 +926,39 @@ namespace Spv
FragmentBarycentricNV = 5284, FragmentBarycentricNV = 5284,
ComputeDerivativeGroupQuadsNV = 5288, ComputeDerivativeGroupQuadsNV = 5288,
FragmentDensityEXT = 5291, FragmentDensityEXT = 5291,
ShadingRateNV = 5291, ShadingRateNV = FragmentDensityEXT,
GroupNonUniformPartitionedNV = 5297, GroupNonUniformPartitionedNV = 5297,
ShaderNonUniform = 5301, ShaderNonUniform = 5301,
ShaderNonUniformEXT = 5301, ShaderNonUniformEXT = ShaderNonUniform,
RuntimeDescriptorArray = 5302, RuntimeDescriptorArray = 5302,
RuntimeDescriptorArrayEXT = 5302, RuntimeDescriptorArrayEXT = RuntimeDescriptorArray,
InputAttachmentArrayDynamicIndexing = 5303, InputAttachmentArrayDynamicIndexing = 5303,
InputAttachmentArrayDynamicIndexingEXT = 5303, InputAttachmentArrayDynamicIndexingEXT = InputAttachmentArrayDynamicIndexing,
UniformTexelBufferArrayDynamicIndexing = 5304, UniformTexelBufferArrayDynamicIndexing = 5304,
UniformTexelBufferArrayDynamicIndexingEXT = 5304, UniformTexelBufferArrayDynamicIndexingEXT = UniformTexelBufferArrayDynamicIndexing,
StorageTexelBufferArrayDynamicIndexing = 5305, StorageTexelBufferArrayDynamicIndexing = 5305,
StorageTexelBufferArrayDynamicIndexingEXT = 5305, StorageTexelBufferArrayDynamicIndexingEXT = StorageTexelBufferArrayDynamicIndexing,
UniformBufferArrayNonUniformIndexing = 5306, UniformBufferArrayNonUniformIndexing = 5306,
UniformBufferArrayNonUniformIndexingEXT = 5306, UniformBufferArrayNonUniformIndexingEXT = UniformBufferArrayNonUniformIndexing,
SampledImageArrayNonUniformIndexing = 5307, SampledImageArrayNonUniformIndexing = 5307,
SampledImageArrayNonUniformIndexingEXT = 5307, SampledImageArrayNonUniformIndexingEXT = SampledImageArrayNonUniformIndexing,
StorageBufferArrayNonUniformIndexing = 5308, StorageBufferArrayNonUniformIndexing = 5308,
StorageBufferArrayNonUniformIndexingEXT = 5308, StorageBufferArrayNonUniformIndexingEXT = StorageBufferArrayNonUniformIndexing,
StorageImageArrayNonUniformIndexing = 5309, StorageImageArrayNonUniformIndexing = 5309,
StorageImageArrayNonUniformIndexingEXT = 5309, StorageImageArrayNonUniformIndexingEXT = StorageImageArrayNonUniformIndexing,
InputAttachmentArrayNonUniformIndexing = 5310, InputAttachmentArrayNonUniformIndexing = 5310,
InputAttachmentArrayNonUniformIndexingEXT = 5310, InputAttachmentArrayNonUniformIndexingEXT = InputAttachmentArrayNonUniformIndexing,
UniformTexelBufferArrayNonUniformIndexing = 5311, UniformTexelBufferArrayNonUniformIndexing = 5311,
UniformTexelBufferArrayNonUniformIndexingEXT = 5311, UniformTexelBufferArrayNonUniformIndexingEXT = UniformTexelBufferArrayNonUniformIndexing,
StorageTexelBufferArrayNonUniformIndexing = 5312, StorageTexelBufferArrayNonUniformIndexing = 5312,
StorageTexelBufferArrayNonUniformIndexingEXT = 5312, StorageTexelBufferArrayNonUniformIndexingEXT = StorageTexelBufferArrayNonUniformIndexing,
RayTracingNV = 5340, RayTracingNV = 5340,
VulkanMemoryModel = 5345, VulkanMemoryModel = 5345,
VulkanMemoryModelKHR = 5345, VulkanMemoryModelKHR = VulkanMemoryModel,
VulkanMemoryModelDeviceScope = 5346, VulkanMemoryModelDeviceScope = 5346,
VulkanMemoryModelDeviceScopeKHR = 5346, VulkanMemoryModelDeviceScopeKHR = VulkanMemoryModelDeviceScope,
PhysicalStorageBufferAddresses = 5347, PhysicalStorageBufferAddresses = 5347,
PhysicalStorageBufferAddressesEXT = 5347, PhysicalStorageBufferAddressesEXT = PhysicalStorageBufferAddresses,
ComputeDerivativeGroupLinearNV = 5350, ComputeDerivativeGroupLinearNV = 5350,
RayTracingProvisionalKHR = 5353, RayTracingProvisionalKHR = 5353,
CooperativeMatrixNV = 5357, CooperativeMatrixNV = 5357,
@ -1433,12 +1433,12 @@ namespace Spv
OpGroupNonUniformPartitionNV = 5296, OpGroupNonUniformPartitionNV = 5296,
OpWritePackedPrimitiveIndices4x8NV = 5299, OpWritePackedPrimitiveIndices4x8NV = 5299,
OpReportIntersectionKHR = 5334, OpReportIntersectionKHR = 5334,
OpReportIntersectionNV = 5334, OpReportIntersectionNV = OpReportIntersectionKHR,
OpIgnoreIntersectionNV = 5335, OpIgnoreIntersectionNV = 5335,
OpTerminateRayNV = 5336, OpTerminateRayNV = 5336,
OpTraceNV = 5337, OpTraceNV = 5337,
OpTypeAccelerationStructureKHR = 5341, OpTypeAccelerationStructureKHR = 5341,
OpTypeAccelerationStructureNV = 5341, OpTypeAccelerationStructureNV = OpTypeAccelerationStructureKHR,
OpExecuteCallableNV = 5344, OpExecuteCallableNV = 5344,
OpTypeCooperativeMatrixNV = 5358, OpTypeCooperativeMatrixNV = 5358,
OpCooperativeMatrixLoadNV = 5359, OpCooperativeMatrixLoadNV = 5359,
@ -1476,9 +1476,9 @@ namespace Spv
OpFunctionPointerINTEL = 5600, OpFunctionPointerINTEL = 5600,
OpFunctionPointerCallINTEL = 5601, OpFunctionPointerCallINTEL = 5601,
OpDecorateString = 5632, OpDecorateString = 5632,
OpDecorateStringGOOGLE = 5632, OpDecorateStringGOOGLE = OpDecorateString,
OpMemberDecorateString = 5633, OpMemberDecorateString = 5633,
OpMemberDecorateStringGOOGLE = 5633, OpMemberDecorateStringGOOGLE = OpMemberDecorateString,
OpVmeImageINTEL = 5699, OpVmeImageINTEL = 5699,
OpTypeVmeImageINTEL = 5700, OpTypeVmeImageINTEL = 5700,
OpTypeAvcImePayloadINTEL = 5701, OpTypeAvcImePayloadINTEL = 5701,
@ -1622,4 +1622,3 @@ namespace Spv
} }
} }
} }