BeeEngine/glslang-zig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Implement extension GL_AMD_gpu_shader_int16

Browse source 
- Add int16 types (int16_t, uint16_t, i16vec, u16vec).
- Add int16 support to GLSL operators.
- Add int16 type conversions (to int16, from int16).
- Add int16 built-in functions.
This commit is contained in:
Rex Xu 2017-03-24 13:41:14 +08:00
parent 4d5bcd3162
commit cabbb788b4
28 changed files with 8560 additions and 5521 deletions
Download patch file Download diff file Expand all files Collapse all files

38
glslang/MachineIndependent/Constant.cpp
View file

@ -193,7 +193,7 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TIntermTyped* right
case EbtUint:
if (rightUnionArray[i] == 0) {
newConstArray[i].setUConst(0xFFFFFFFF);
newConstArray[i].setUConst(0xFFFFFFFFu);
} else
newConstArray[i].setUConst(leftUnionArray[i].getUConst() / rightUnionArray[i].getUConst());
break;
@ -213,6 +213,23 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TIntermTyped* right
} else
newConstArray[i].setU64Const(leftUnionArray[i].getU64Const() / rightUnionArray[i].getU64Const());
break;
#ifdef AMD_EXTENSIONS
case EbtInt16:
if (rightUnionArray[i] == 0)
newConstArray[i].setIConst(0x7FFF);
else if (rightUnionArray[i].getIConst() == -1 && leftUnionArray[i].getIConst() == (int)0x8000)
newConstArray[i].setIConst(0x8000);
else
newConstArray[i].setIConst(leftUnionArray[i].getIConst() / rightUnionArray[i].getIConst());
break;
case EbtUint16:
if (rightUnionArray[i] == 0) {
newConstArray[i].setUConst(0xFFFFu);
} else
newConstArray[i].setUConst(leftUnionArray[i].getUConst() / rightUnionArray[i].getUConst());
break;
#endif
default:
return 0;
}
@ -457,10 +474,16 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType)
case EbtFloat16:
#endif
case EbtFloat: newConstArray[i].setDConst(-unionArray[i].getDConst()); break;
#ifdef AMD_EXTENSIONS
case EbtInt16:
#endif
case EbtInt: newConstArray[i].setIConst(-unionArray[i].getIConst()); break;
#ifdef AMD_EXTENSIONS
case EbtUint16:
#endif
case EbtUint: newConstArray[i].setUConst(static_cast<unsigned int>(-static_cast<int>(unionArray[i].getUConst()))); break;
case EbtInt64: newConstArray[i].setI64Const(-unionArray[i].getI64Const()); break;
case EbtUint64: newConstArray[i].setU64Const(static_cast<unsigned int>(-static_cast<int>(unionArray[i].getU64Const()))); break;
case EbtUint64: newConstArray[i].setU64Const(static_cast<unsigned long long>(-static_cast<long long>(unionArray[i].getU64Const()))); break;
default:
return 0;
}
@ -610,6 +633,14 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType)
case EOpUintBitsToFloat:
case EOpDoubleBitsToInt64:
case EOpDoubleBitsToUint64:
case EOpInt64BitsToDouble:
case EOpUint64BitsToDouble:
#ifdef AMD_EXTENSIONS
case EOpFloat16BitsToInt16:
case EOpFloat16BitsToUint16:
case EOpInt16BitsToFloat16:
case EOpUint16BitsToFloat16:
#endif
default:
return 0;
@ -702,6 +733,9 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode)
#endif
children[0]->getAsTyped()->getBasicType() == EbtDouble;
bool isSigned = children[0]->getAsTyped()->getBasicType() == EbtInt ||
#ifdef AMD_EXTENSIONS
children[0]->getAsTyped()->getBasicType() == EbtInt16 ||
#endif
children[0]->getAsTyped()->getBasicType() == EbtInt64;
bool isInt64 = children[0]->getAsTyped()->getBasicType() == EbtInt64 ||
children[0]->getAsTyped()->getBasicType() == EbtUint64;

169
glslang/MachineIndependent/Initialize.cpp
View file

@ -85,8 +85,6 @@ TBuiltIns::TBuiltIns()
prefixes[EbtFloat] = "";
prefixes[EbtInt] = "i";
prefixes[EbtUint] = "u";
prefixes[EbtInt64] = "i64";
prefixes[EbtUint64] = "u64";
postfixes[2] = "2";
postfixes[3] = "3";
postfixes[4] = "4";
@ -2612,6 +2610,157 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
"\n");
}
// GL_AMD_gpu_shader_int16
if (profile != EEsProfile && version >= 450) {
commonBuiltins.append(
"int16_t abs(int16_t);"
"i16vec2 abs(i16vec2);"
"i16vec3 abs(i16vec3);"
"i16vec4 abs(i16vec4);"
"int16_t sign(int16_t);"
"i16vec2 sign(i16vec2);"
"i16vec3 sign(i16vec3);"
"i16vec4 sign(i16vec4);"
"int16_t min(int16_t, int16_t);"
"i16vec2 min(i16vec2, int16_t);"
"i16vec3 min(i16vec3, int16_t);"
"i16vec4 min(i16vec4, int16_t);"
"i16vec2 min(i16vec2, i16vec2);"
"i16vec3 min(i16vec3, i16vec3);"
"i16vec4 min(i16vec4, i16vec4);"
"uint16_t min(uint16_t, uint16_t);"
"u16vec2 min(u16vec2, uint16_t);"
"u16vec3 min(u16vec3, uint16_t);"
"u16vec4 min(u16vec4, uint16_t);"
"u16vec2 min(u16vec2, u16vec2);"
"u16vec3 min(u16vec3, u16vec3);"
"u16vec4 min(u16vec4, u16vec4);"
"int16_t max(int16_t, int16_t);"
"i16vec2 max(i16vec2, int16_t);"
"i16vec3 max(i16vec3, int16_t);"
"i16vec4 max(i16vec4, int16_t);"
"i16vec2 max(i16vec2, i16vec2);"
"i16vec3 max(i16vec3, i16vec3);"
"i16vec4 max(i16vec4, i16vec4);"
"uint16_t max(uint16_t, uint16_t);"
"u16vec2 max(u16vec2, uint16_t);"
"u16vec3 max(u16vec3, uint16_t);"
"u16vec4 max(u16vec4, uint16_t);"
"u16vec2 max(u16vec2, u16vec2);"
"u16vec3 max(u16vec3, u16vec3);"
"u16vec4 max(u16vec4, u16vec4);"
"int16_t clamp(int16_t, int16_t, int16_t);"
"i16vec2 clamp(i16vec2, int16_t, int16_t);"
"i16vec3 clamp(i16vec3, int16_t, int16_t);"
"i16vec4 clamp(i16vec4, int16_t, int16_t);"
"i16vec2 clamp(i16vec2, i16vec2, i16vec2);"
"i16vec3 clamp(i16vec3, i16vec3, i16vec3);"
"i16vec4 clamp(i16vec4, i16vec4, i16vec4);"
"uint16_t clamp(uint16_t, uint16_t, uint16_t);"
"u16vec2 clamp(u16vec2, uint16_t, uint16_t);"
"u16vec3 clamp(u16vec3, uint16_t, uint16_t);"
"u16vec4 clamp(u16vec4, uint16_t, uint16_t);"
"u16vec2 clamp(u16vec2, u16vec2, u16vec2);"
"u16vec3 clamp(u16vec3, u16vec3, u16vec3);"
"u16vec4 clamp(u16vec4, u16vec4, u16vec4);"
"int16_t mix(int16_t, int16_t, bool);"
"i16vec2 mix(i16vec2, i16vec2, bvec2);"
"i16vec3 mix(i16vec3, i16vec3, bvec3);"
"i16vec4 mix(i16vec4, i16vec4, bvec4);"
"uint16_t mix(uint16_t, uint16_t, bool);"
"u16vec2 mix(u16vec2, u16vec2, bvec2);"
"u16vec3 mix(u16vec3, u16vec3, bvec3);"
"u16vec4 mix(u16vec4, u16vec4, bvec4);"
"float16_t frexp(float16_t, out int16_t);"
"f16vec2 frexp(f16vec2, out i16vec2);"
"f16vec3 frexp(f16vec3, out i16vec3);"
"f16vec4 frexp(f16vec4, out i16vec4);"
"float16_t ldexp(float16_t, int16_t);"
"f16vec2 ldexp(f16vec2, i16vec2);"
"f16vec3 ldexp(f16vec3, i16vec3);"
"f16vec4 ldexp(f16vec4, i16vec4);"
"int16_t float16BitsToInt16(float16_t);"
"i16vec2 float16BitsToInt16(f16vec2);"
"i16vec3 float16BitsToInt16(f16vec3);"
"i16vec4 float16BitsToInt16(f16vec4);"
"uint16_t float16BitsToUint16(float16_t);"
"u16vec2 float16BitsToUint16(f16vec2);"
"u16vec3 float16BitsToUint16(f16vec3);"
"u16vec4 float16BitsToUint16(f16vec4);"
"float16_t int16BitsToFloat16(int16_t);"
"f16vec2 int16BitsToFloat16(i16vec2);"
"f16vec3 int16BitsToFloat16(i16vec3);"
"f16vec4 int16BitsToFloat16(i16vec4);"
"float16_t uint16BitsToFloat16(uint16_t);"
"f16vec2 uint16BitsToFloat16(u16vec2);"
"f16vec3 uint16BitsToFloat16(u16vec3);"
"f16vec4 uint16BitsToFloat16(u16vec4);"
"int packInt2x16(i16vec2);"
"uint packUint2x16(u16vec2);"
"int64_t packInt4x16(i16vec4);"
"uint64_t packUint4x16(u16vec4);"
"i16vec2 unpackInt2x16(int);"
"u16vec2 unpackUint2x16(uint);"
"i16vec4 unpackInt4x16(int64_t);"
"u16vec4 unpackUint4x16(uint64_t);"
"bvec2 lessThan(i16vec2, i16vec2);"
"bvec3 lessThan(i16vec3, i16vec3);"
"bvec4 lessThan(i16vec4, i16vec4);"
"bvec2 lessThan(u16vec2, u16vec2);"
"bvec3 lessThan(u16vec3, u16vec3);"
"bvec4 lessThan(u16vec4, u16vec4);"
"bvec2 lessThanEqual(i16vec2, i16vec2);"
"bvec3 lessThanEqual(i16vec3, i16vec3);"
"bvec4 lessThanEqual(i16vec4, i16vec4);"
"bvec2 lessThanEqual(u16vec2, u16vec2);"
"bvec3 lessThanEqual(u16vec3, u16vec3);"
"bvec4 lessThanEqual(u16vec4, u16vec4);"
"bvec2 greaterThan(i16vec2, i16vec2);"
"bvec3 greaterThan(i16vec3, i16vec3);"
"bvec4 greaterThan(i16vec4, i16vec4);"
"bvec2 greaterThan(u16vec2, u16vec2);"
"bvec3 greaterThan(u16vec3, u16vec3);"
"bvec4 greaterThan(u16vec4, u16vec4);"
"bvec2 greaterThanEqual(i16vec2, i16vec2);"
"bvec3 greaterThanEqual(i16vec3, i16vec3);"
"bvec4 greaterThanEqual(i16vec4, i16vec4);"
"bvec2 greaterThanEqual(u16vec2, u16vec2);"
"bvec3 greaterThanEqual(u16vec3, u16vec3);"
"bvec4 greaterThanEqual(u16vec4, u16vec4);"
"bvec2 equal(i16vec2, i16vec2);"
"bvec3 equal(i16vec3, i16vec3);"
"bvec4 equal(i16vec4, i16vec4);"
"bvec2 equal(u16vec2, u16vec2);"
"bvec3 equal(u16vec3, u16vec3);"
"bvec4 equal(u16vec4, u16vec4);"
"bvec2 notEqual(i16vec2, i16vec2);"
"bvec3 notEqual(i16vec3, i16vec3);"
"bvec4 notEqual(i16vec4, i16vec4);"
"bvec2 notEqual(u16vec2, u16vec2);"
"bvec3 notEqual(u16vec3, u16vec3);"
"bvec4 notEqual(u16vec4, u16vec4);"
"\n");
}
#endif
//============================================================================
@ -5639,6 +5788,12 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
symbolTable.relateToOperator("doubleBitsToUint64", EOpDoubleBitsToUint64);
symbolTable.relateToOperator("int64BitsToDouble", EOpInt64BitsToDouble);
symbolTable.relateToOperator("uint64BitsToDouble", EOpUint64BitsToDouble);
#ifdef AMD_EXTENSIONS
symbolTable.relateToOperator("float16BitsToInt16", EOpFloat16BitsToInt16);
symbolTable.relateToOperator("float16BitsToUint16", EOpFloat16BitsToUint16);
symbolTable.relateToOperator("int16BitsToFloat16", EOpInt16BitsToFloat16);
symbolTable.relateToOperator("uint16BitsToFloat16", EOpUint16BitsToFloat16);
#endif
symbolTable.relateToOperator("packSnorm2x16", EOpPackSnorm2x16);
symbolTable.relateToOperator("unpackSnorm2x16", EOpUnpackSnorm2x16);
@ -5662,6 +5817,16 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
symbolTable.relateToOperator("unpackUint2x32", EOpUnpackUint2x32);
#ifdef AMD_EXTENSIONS
symbolTable.relateToOperator("packInt2x16", EOpPackInt2x16);
symbolTable.relateToOperator("unpackInt2x16", EOpUnpackInt2x16);
symbolTable.relateToOperator("packUint2x16", EOpPackUint2x16);
symbolTable.relateToOperator("unpackUint2x16", EOpUnpackUint2x16);
symbolTable.relateToOperator("packInt4x16", EOpPackInt4x16);
symbolTable.relateToOperator("unpackInt4x16", EOpUnpackInt4x16);
symbolTable.relateToOperator("packUint4x16", EOpPackUint4x16);
symbolTable.relateToOperator("unpackUint4x16", EOpUnpackUint4x16);
symbolTable.relateToOperator("packFloat2x16", EOpPackFloat2x16);
symbolTable.relateToOperator("unpackFloat2x16", EOpUnpackFloat2x16);
#endif

205
glslang/MachineIndependent/Intermediate.cpp
View file

@ -308,6 +308,10 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermTyped* child, TSo
case EOpConstructUint: newType = EbtUint; break;
case EOpConstructInt64: newType = EbtInt64; break;
case EOpConstructUint64: newType = EbtUint64; break;
#ifdef AMD_EXTENSIONS
case EOpConstructInt16: newType = EbtInt16; break;
case EOpConstructUint16: newType = EbtUint16; break;
#endif
case EOpConstructBool: newType = EbtBool; break;
case EOpConstructFloat: newType = EbtFloat; break;
case EOpConstructDouble: newType = EbtDouble; break;
@ -336,6 +340,10 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermTyped* child, TSo
case EOpConstructUint:
case EOpConstructInt64:
case EOpConstructUint64:
#ifdef AMD_EXTENSIONS
case EOpConstructInt16:
case EOpConstructUint16:
#endif
case EOpConstructBool:
case EOpConstructFloat:
case EOpConstructDouble:
@ -528,6 +536,14 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
case EOpConstructUint64:
promoteTo = EbtUint64;
break;
#ifdef AMD_EXTENSIONS
case EOpConstructInt16:
promoteTo = EbtInt16;
break;
case EOpConstructUint16:
promoteTo = EbtUint16;
break;
#endif
//
// List all the binary ops that can implicitly convert one operand to the other's type;
@ -616,10 +632,18 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
case EOpRightShiftAssign:
if ((type.getBasicType() == EbtInt ||
type.getBasicType() == EbtUint ||
#ifdef AMD_EXTENSIONS
type.getBasicType() == EbtInt16 ||
type.getBasicType() == EbtUint16 ||
#endif
type.getBasicType() == EbtInt64 ||
type.getBasicType() == EbtUint64) &&
(node->getType().getBasicType() == EbtInt ||
node->getType().getBasicType() == EbtUint ||
#ifdef AMD_EXTENSIONS
node->getType().getBasicType() == EbtInt16 ||
node->getType().getBasicType() == EbtUint16 ||
#endif
node->getType().getBasicType() == EbtInt64 ||
node->getType().getBasicType() == EbtUint64))
@ -663,6 +687,10 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
#endif
case EbtInt64: newOp = EOpConvInt64ToDouble; break;
case EbtUint64: newOp = EOpConvUint64ToDouble; break;
#ifdef AMD_EXTENSIONS
case EbtInt16: newOp = EOpConvInt16ToDouble; break;
case EbtUint16: newOp = EOpConvUint16ToDouble; break;
#endif
default:
return nullptr;
}
@ -678,6 +706,10 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
#endif
case EbtInt64: newOp = EOpConvInt64ToFloat; break;
case EbtUint64: newOp = EOpConvUint64ToFloat; break;
#ifdef AMD_EXTENSIONS
case EbtInt16: newOp = EOpConvInt16ToFloat; break;
case EbtUint16: newOp = EOpConvUint16ToFloat; break;
#endif
default:
return nullptr;
}
@ -692,6 +724,8 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
case EbtDouble: newOp = EOpConvDoubleToFloat16; break;
case EbtInt64: newOp = EOpConvInt64ToFloat16; break;
case EbtUint64: newOp = EOpConvUint64ToFloat16; break;
case EbtInt16: newOp = EOpConvInt16ToFloat16; break;
case EbtUint16: newOp = EOpConvUint16ToFloat16; break;
default:
return nullptr;
}
@ -708,6 +742,10 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
#endif
case EbtInt64: newOp = EOpConvInt64ToBool; break;
case EbtUint64: newOp = EOpConvUint64ToBool; break;
#ifdef AMD_EXTENSIONS
case EbtInt16: newOp = EOpConvInt16ToBool; break;
case EbtUint16: newOp = EOpConvUint16ToBool; break;
#endif
default:
return nullptr;
}
@ -723,6 +761,10 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
#endif
case EbtInt64: newOp = EOpConvInt64ToInt; break;
case EbtUint64: newOp = EOpConvUint64ToInt; break;
#ifdef AMD_EXTENSIONS
case EbtInt16: newOp = EOpConvInt16ToInt; break;
case EbtUint16: newOp = EOpConvUint16ToInt; break;
#endif
default:
return nullptr;
}
@ -738,6 +780,10 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
#endif
case EbtInt64: newOp = EOpConvInt64ToUint; break;
case EbtUint64: newOp = EOpConvUint64ToUint; break;
#ifdef AMD_EXTENSIONS
case EbtInt16: newOp = EOpConvInt16ToUint; break;
case EbtUint16: newOp = EOpConvUint16ToUint; break;
#endif
default:
return nullptr;
}
@ -753,6 +799,10 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
case EbtFloat16: newOp = EOpConvFloat16ToInt64; break;
#endif
case EbtUint64: newOp = EOpConvUint64ToInt64; break;
#ifdef AMD_EXTENSIONS
case EbtInt16: newOp = EOpConvInt16ToInt64; break;
case EbtUint16: newOp = EOpConvUint16ToInt64; break;
#endif
default:
return nullptr;
}
@ -768,10 +818,46 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
case EbtFloat16: newOp = EOpConvFloat16ToUint64; break;
#endif
case EbtInt64: newOp = EOpConvInt64ToUint64; break;
#ifdef AMD_EXTENSIONS
case EbtInt16: newOp = EOpConvInt16ToUint64; break;
case EbtUint16: newOp = EOpConvUint16ToUint64; break;
#endif
default:
return nullptr;
}
break;
#ifdef AMD_EXTENSIONS
case EbtInt16:
switch (node->getBasicType()) {
case EbtInt: newOp = EOpConvIntToInt16; break;
case EbtUint: newOp = EOpConvUintToInt16; break;
case EbtBool: newOp = EOpConvBoolToInt16; break;
case EbtFloat: newOp = EOpConvFloatToInt16; break;
case EbtDouble: newOp = EOpConvDoubleToInt16; break;
case EbtFloat16: newOp = EOpConvFloat16ToInt16; break;
case EbtInt64: newOp = EOpConvInt64ToInt16; break;
case EbtUint64: newOp = EOpConvUint64ToInt16; break;
case EbtUint16: newOp = EOpConvUint16ToInt16; break;
default:
return nullptr;
}
break;
case EbtUint16:
switch (node->getBasicType()) {
case EbtInt: newOp = EOpConvIntToUint16; break;
case EbtUint: newOp = EOpConvUintToUint16; break;
case EbtBool: newOp = EOpConvBoolToUint16; break;
case EbtFloat: newOp = EOpConvFloatToUint16; break;
case EbtDouble: newOp = EOpConvDoubleToUint16; break;
case EbtFloat16: newOp = EOpConvFloat16ToUint16; break;
case EbtInt64: newOp = EOpConvInt64ToUint16; break;
case EbtUint64: newOp = EOpConvUint64ToUint16; break;
case EbtInt16: newOp = EOpConvInt16ToUint16; break;
default:
return nullptr;
}
break;
#endif
default:
return nullptr;
}
@ -1020,6 +1106,10 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
case EbtUint:
case EbtInt64:
case EbtUint64:
#ifdef AMD_EXTENSIONS
case EbtInt16:
case EbtUint16:
#endif
case EbtFloat:
case EbtDouble:
#ifdef AMD_EXTENSIONS
@ -1033,6 +1123,10 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
switch (from) {
case EbtInt:
case EbtUint:
#ifdef AMD_EXTENSIONS
case EbtInt16:
case EbtUint16:
#endif
case EbtFloat:
#ifdef AMD_EXTENSIONS
case EbtFloat16:
@ -1048,6 +1142,10 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
case EbtInt:
return version >= 400 || (source == EShSourceHlsl);
case EbtUint:
#ifdef AMD_EXTENSIONS
case EbtInt16:
case EbtUint16:
#endif
return true;
case EbtBool:
return (source == EShSourceHlsl);
@ -1057,6 +1155,9 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
case EbtInt:
switch (from) {
case EbtInt:
#ifdef AMD_EXTENSIONS
case EbtInt16:
#endif
return true;
case EbtBool:
return (source == EShSourceHlsl);
@ -1069,6 +1170,10 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
case EbtUint:
case EbtInt64:
case EbtUint64:
#ifdef AMD_EXTENSIONS
case EbtInt16:
case EbtUint16:
#endif
return true;
default:
return false;
@ -1077,10 +1182,32 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
switch (from) {
case EbtInt:
case EbtInt64:
#ifdef AMD_EXTENSIONS
case EbtInt16:
#endif
return true;
default:
return false;
}
#ifdef AMD_EXTENSIONS
case EbtFloat16:
switch (from) {
case EbtInt16:
case EbtUint16:
case EbtFloat16:
return true;
default:
return false;
}
case EbtUint16:
switch (from) {
case EbtInt16:
case EbtUint16:
return true;
default:
return false;
}
#endif
default:
return false;
}
@ -1313,6 +1440,26 @@ TOperator TIntermediate::mapTypeToConstructorOp(const TType& type) const
default: break; // some compilers want this
}
break;
#ifdef AMD_EXTENSIONS
case EbtInt16:
switch(type.getVectorSize()) {
case 1: op = EOpConstructInt16; break;
case 2: op = EOpConstructI16Vec2; break;
case 3: op = EOpConstructI16Vec3; break;
case 4: op = EOpConstructI16Vec4; break;
default: break; // some compilers want this
}
break;
case EbtUint16:
switch(type.getVectorSize()) {
case 1: op = EOpConstructUint16; break;
case 2: op = EOpConstructU16Vec2; break;
case 3: op = EOpConstructU16Vec3; break;
case 4: op = EOpConstructU16Vec4; break;
default: break; // some compilers want this
}
break;
#endif
case EbtBool:
if (type.getMatrixCols()) {
switch (type.getMatrixCols()) {
@ -1620,6 +1767,24 @@ TIntermConstantUnion* TIntermediate::addConstantUnion(unsigned long long u64, co
return addConstantUnion(unionArray, TType(EbtUint64, EvqConst), loc, literal);
}
#ifdef AMD_EXTENSIONS
TIntermConstantUnion* TIntermediate::addConstantUnion(short i16, const TSourceLoc& loc, bool literal) const
{
TConstUnionArray unionArray(1);
unionArray[0].setIConst(i16);
return addConstantUnion(unionArray, TType(EbtInt16, EvqConst), loc, literal);
}
TIntermConstantUnion* TIntermediate::addConstantUnion(unsigned short u16, const TSourceLoc& loc, bool literal) const
{
TConstUnionArray unionArray(1);
unionArray[0].setUConst(u16);
return addConstantUnion(unionArray, TType(EbtUint16, EvqConst), loc, literal);
}
#endif
TIntermConstantUnion* TIntermediate::addConstantUnion(bool b, const TSourceLoc& loc, bool literal) const
{
TConstUnionArray unionArray(1);
@ -1979,6 +2144,30 @@ bool TIntermediate::isSpecializationOperation(const TIntermOperator& node) const
case EOpConvUintToInt64:
case EOpConvUint64ToInt:
case EOpConvIntToUint64:
#ifdef AMD_EXTENSIONS
case EOpConvInt16ToBool:
case EOpConvBoolToInt16:
case EOpConvInt16ToInt:
case EOpConvIntToInt16:
case EOpConvInt16ToUint:
case EOpConvUintToInt16:
case EOpConvInt16ToInt64:
case EOpConvInt64ToInt16:
case EOpConvInt16ToUint64:
case EOpConvUint64ToInt16:
case EOpConvUint16ToBool:
case EOpConvBoolToUint16:
case EOpConvUint16ToInt:
case EOpConvIntToUint16:
case EOpConvUint16ToUint:
case EOpConvUintToUint16:
case EOpConvUint16ToInt64:
case EOpConvInt64ToUint16:
case EOpConvUint16ToUint64:
case EOpConvUint64ToUint16:
case EOpConvInt16ToUint16:
case EOpConvUint16ToInt16:
#endif
// unary operations
case EOpNegative:
@ -2107,6 +2296,10 @@ bool TIntermediate::promoteUnary(TIntermUnary& node)
case EOpBitwiseNot:
if (operand->getBasicType() != EbtInt &&
operand->getBasicType() != EbtUint &&
#ifdef AMD_EXTENSIONS
operand->getBasicType() != EbtInt16 &&
operand->getBasicType() != EbtUint16 &&
#endif
operand->getBasicType() != EbtInt64 &&
operand->getBasicType() != EbtUint64)
@ -2121,6 +2314,10 @@ bool TIntermediate::promoteUnary(TIntermUnary& node)
operand->getBasicType() != EbtUint &&
operand->getBasicType() != EbtInt64 &&
operand->getBasicType() != EbtUint64 &&
#ifdef AMD_EXTENSIONS
operand->getBasicType() != EbtInt16 &&
operand->getBasicType() != EbtUint16 &&
#endif
operand->getBasicType() != EbtFloat &&
#ifdef AMD_EXTENSIONS
operand->getBasicType() != EbtFloat16 &&
@ -2327,8 +2524,14 @@ bool TIntermediate::promoteBinary(TIntermBinary& node)
// Check for integer-only operands.
if ((left->getBasicType() != EbtInt && left->getBasicType() != EbtUint &&
left->getBasicType() != EbtInt64 && left->getBasicType() != EbtUint64) ||
#ifdef AMD_EXTENSIONS
left->getBasicType() != EbtInt16 && left->getBasicType() != EbtUint16 &&
#endif
left->getBasicType() != EbtInt64 && left->getBasicType() != EbtUint64) ||
(right->getBasicType() != EbtInt && right->getBasicType() != EbtUint &&
#ifdef AMD_EXTENSIONS
right->getBasicType() != EbtInt16 && right->getBasicType() != EbtUint16 &&
#endif
right->getBasicType() != EbtInt64 && right->getBasicType() != EbtUint64))
return false;
if (left->isMatrix() || right->isMatrix())

38
glslang/MachineIndependent/ParseHelper.cpp
View file

@ -2220,6 +2220,10 @@ bool TParseContext::constructorError(const TSourceLoc& loc, TIntermNode* node, T
case EOpConstructUint:
case EOpConstructInt64:
case EOpConstructUint64:
#ifdef AMD_EXTENSIONS
case EOpConstructInt16:
case EOpConstructUint16:
#endif
case EOpConstructBool:
case EOpConstructBVec2:
case EOpConstructBVec3:
@ -2236,6 +2240,14 @@ bool TParseContext::constructorError(const TSourceLoc& loc, TIntermNode* node, T
case EOpConstructU64Vec2:
case EOpConstructU64Vec3:
case EOpConstructU64Vec4:
#ifdef AMD_EXTENSIONS
case EOpConstructI16Vec2:
case EOpConstructI16Vec3:
case EOpConstructI16Vec4:
case EOpConstructU16Vec2:
case EOpConstructU16Vec3:
case EOpConstructU16Vec4:
#endif
// This was the list of valid ones, if they aren't converting from float
// and aren't making an array.
makeSpecConst = ! floatArgument && ! type.isArray();
@ -2528,6 +2540,9 @@ void TParseContext::globalQualifierTypeCheck(const TSourceLoc& loc, const TQuali
}
if (publicType.basicType == EbtInt || publicType.basicType == EbtUint ||
#ifdef AMD_EXTENSIONS
publicType.basicType == EbtInt16 || publicType.basicType == EbtUint16 ||
#endif
publicType.basicType == EbtInt64 || publicType.basicType == EbtUint64 ||
publicType.basicType == EbtDouble)
profileRequires(loc, EEsProfile, 300, nullptr, "shader input/output");
@ -2538,6 +2553,9 @@ void TParseContext::globalQualifierTypeCheck(const TSourceLoc& loc, const TQuali
if (!qualifier.flat) {
#endif
if (publicType.basicType == EbtInt || publicType.basicType == EbtUint ||
#ifdef AMD_EXTENSIONS
publicType.basicType == EbtInt16 || publicType.basicType == EbtUint16 ||
#endif
publicType.basicType == EbtInt64 || publicType.basicType == EbtUint64 ||
publicType.basicType == EbtDouble ||
(publicType.userDef && (publicType.userDef->containsBasicType(EbtInt) ||
@ -4634,6 +4652,10 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type)
case EbtUint:
case EbtInt64:
case EbtUint64:
#ifdef AMD_EXTENSIONS
case EbtInt16:
case EbtUint16:
#endif
case EbtBool:
case EbtFloat:
case EbtDouble:
@ -5580,6 +5602,22 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType& type, TOperator op, T
basicOp = EOpConstructUint64;
break;
#ifdef AMD_EXTENSIONS
case EOpConstructI16Vec2:
case EOpConstructI16Vec3:
case EOpConstructI16Vec4:
case EOpConstructInt16:
basicOp = EOpConstructInt16;
break;
case EOpConstructU16Vec2:
case EOpConstructU16Vec3:
case EOpConstructU16Vec4:
case EOpConstructUint16:
basicOp = EOpConstructUint16;
break;
#endif
case EOpConstructBVec2:
case EOpConstructBVec3:
case EOpConstructBVec4:

28
glslang/MachineIndependent/Scan.cpp
View file

@ -464,6 +464,15 @@ void TScanContext::fillInKeywordMap()
(*KeywordMap)["u64vec4"] = U64VEC4;
#ifdef AMD_EXTENSIONS
(*KeywordMap)["int16_t"] = INT16_T;
(*KeywordMap)["uint16_t"] = UINT16_T;
(*KeywordMap)["i16vec2"] = I16VEC2;
(*KeywordMap)["i16vec3"] = I16VEC3;
(*KeywordMap)["i16vec4"] = I16VEC4;
(*KeywordMap)["u16vec2"] = U16VEC2;
(*KeywordMap)["u16vec3"] = U16VEC3;
(*KeywordMap)["u16vec4"] = U16VEC4;
(*KeywordMap)["float16_t"] = FLOAT16_T;
(*KeywordMap)["f16vec2"] = F16VEC2;
(*KeywordMap)["f16vec3"] = F16VEC3;
@ -709,6 +718,10 @@ int TScanContext::tokenize(TPpContext* pp, TParserToken& token)
case PpAtomConstUint: parserToken->sType.lex.i = ppToken.ival; return UINTCONSTANT;
case PpAtomConstInt64: parserToken->sType.lex.i64 = ppToken.i64val; return INT64CONSTANT;
case PpAtomConstUint64: parserToken->sType.lex.i64 = ppToken.i64val; return UINT64CONSTANT;
#ifdef AMD_EXTENSIONS
case PpAtomConstInt16: parserToken->sType.lex.i = ppToken.ival; return INT16CONSTANT;
case PpAtomConstUint16: parserToken->sType.lex.i = ppToken.ival; return UINT16CONSTANT;
#endif
case PpAtomConstFloat: parserToken->sType.lex.d = ppToken.dval; return FLOATCONSTANT;
case PpAtomConstDouble: parserToken->sType.lex.d = ppToken.dval; return DOUBLECONSTANT;
#ifdef AMD_EXTENSIONS
@ -973,6 +986,21 @@ int TScanContext::tokenizeIdentifier()
return identifierOrType();
#ifdef AMD_EXTENSIONS
case INT16_T:
case UINT16_T:
case I16VEC2:
case I16VEC3:
case I16VEC4:
case U16VEC2:
case U16VEC3:
case U16VEC4:
afterType = true;
if (parseContext.symbolTable.atBuiltInLevel() ||
(parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_int16) &&
parseContext.profile != EEsProfile && parseContext.version >= 450))
return keyword;
return identifierOrType();
case FLOAT16_T:
case F16VEC2:
case F16VEC3:

4
glslang/MachineIndependent/SymbolTable.cpp
View file

@ -67,6 +67,10 @@ void TType::buildMangledName(TString& mangledName) const
case EbtUint: mangledName += 'u'; break;
case EbtInt64: mangledName += "i64"; break;
case EbtUint64: mangledName += "u64"; break;
#ifdef AMD_EXTENSIONS
case EbtInt16: mangledName += "i16"; break;
case EbtUint16: mangledName += "u16"; break;
#endif
case EbtBool: mangledName += 'b'; break;
case EbtAtomicUint: mangledName += "au"; break;
case EbtSampler:

17
glslang/MachineIndependent/Versions.cpp
View file

@ -195,6 +195,7 @@ void TParseVersions::initializeExtensionBehavior()
extensionBehavior[E_GL_AMD_gcn_shader] = EBhDisable;
extensionBehavior[E_GL_AMD_gpu_shader_half_float] = EBhDisable;
extensionBehavior[E_GL_AMD_texture_gather_bias_lod] = EBhDisable;
extensionBehavior[E_GL_AMD_gpu_shader_int16] = EBhDisable;
#endif
#ifdef NV_EXTENSIONS
@ -318,6 +319,7 @@ void TParseVersions::getPreamble(std::string& preamble)
"#define GL_AMD_gcn_shader 1\n"
"#define GL_AMD_gpu_shader_half_float 1\n"
"#define GL_AMD_texture_gather_bias_lod 1\n"
"#define GL_AMD_gpu_shader_int16 1\n"
#endif
#ifdef NV_EXTENSIONS
@ -710,10 +712,21 @@ void TParseVersions::doubleCheck(const TSourceLoc& loc, const char* op)
}
#ifdef AMD_EXTENSIONS
// Call for any operation needing float16 data-type support.
// Call for any operation needing GLSL 16-bit integer data-type support.
void TParseVersions::int16Check(const TSourceLoc& loc, const char* op, bool builtIn)
{
if (! builtIn) {
requireExtensions(loc, 1, &E_GL_AMD_gpu_shader_int16, "shader int16");
requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
profileRequires(loc, ECoreProfile, 450, nullptr, op);
profileRequires(loc, ECompatibilityProfile, 450, nullptr, op);
}
}
// Call for any operation needing GLSL float16 data-type support.
void TParseVersions::float16Check(const TSourceLoc& loc, const char* op, bool builtIn)
{
if (!builtIn) {
if (! builtIn) {
requireExtensions(loc, 1, &E_GL_AMD_gpu_shader_half_float, "shader half float");
requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
profileRequires(loc, ECoreProfile, 450, nullptr, op);

2
glslang/MachineIndependent/Versions.h
View file

@ -147,7 +147,9 @@ const char* const E_GL_AMD_shader_explicit_vertex_parameter = "GL_AMD_shader
const char* const E_GL_AMD_gcn_shader = "GL_AMD_gcn_shader";
const char* const E_GL_AMD_gpu_shader_half_float = "GL_AMD_gpu_shader_half_float";
const char* const E_GL_AMD_texture_gather_bias_lod = "GL_AMD_texture_gather_bias_lod";
const char* const E_GL_AMD_gpu_shader_int16 = "GL_AMD_gpu_shader_int16";
#endif
#ifdef NV_EXTENSIONS
const char* const E_GL_NV_sample_mask_override_coverage = "GL_NV_sample_mask_override_coverage";

79
glslang/MachineIndependent/glslang.y
View file

@ -121,7 +121,7 @@ extern int yylex(YYSTYPE*, TParseContext&);
%expect 1 // One shift reduce conflict because of if | else
%token <lex> ATTRIBUTE VARYING
%token <lex> CONST BOOL FLOAT DOUBLE INT UINT INT64_T UINT64_T FLOAT16_T
%token <lex> CONST BOOL FLOAT DOUBLE INT UINT INT64_T UINT64_T INT16_T UINT16_T FLOAT16_T
%token <lex> BREAK CONTINUE DO ELSE FOR IF DISCARD RETURN SWITCH CASE DEFAULT SUBROUTINE
%token <lex> BVEC2 BVEC3 BVEC4 IVEC2 IVEC3 IVEC4 I64VEC2 I64VEC3 I64VEC4 UVEC2 UVEC3 UVEC4 U64VEC2 U64VEC3 U64VEC4 VEC2 VEC3 VEC4
%token <lex> MAT2 MAT3 MAT4 CENTROID IN OUT INOUT
@ -129,6 +129,7 @@ extern int yylex(YYSTYPE*, TParseContext&);
%token <lex> COHERENT VOLATILE RESTRICT READONLY WRITEONLY
%token <lex> DVEC2 DVEC3 DVEC4 DMAT2 DMAT3 DMAT4
%token <lex> F16VEC2 F16VEC3 F16VEC4 F16MAT2 F16MAT3 F16MAT4
%token <lex> I16VEC2 I16VEC3 I16VEC4 U16VEC2 U16VEC3 U16VEC4
%token <lex> NOPERSPECTIVE FLAT SMOOTH LAYOUT __EXPLICITINTERPAMD
%token <lex> MAT2X2 MAT2X3 MAT2X4
@ -188,7 +189,7 @@ extern int yylex(YYSTYPE*, TParseContext&);
%token <lex> STRUCT VOID WHILE
%token <lex> IDENTIFIER TYPE_NAME
%token <lex> FLOATCONSTANT DOUBLECONSTANT INTCONSTANT UINTCONSTANT INT64CONSTANT UINT64CONSTANT BOOLCONSTANT FLOAT16CONSTANT
%token <lex> FLOATCONSTANT DOUBLECONSTANT INTCONSTANT UINTCONSTANT INT64CONSTANT UINT64CONSTANT INT16CONSTANT UINT16CONSTANT BOOLCONSTANT FLOAT16CONSTANT
%token <lex> LEFT_OP RIGHT_OP
%token <lex> INC_OP DEC_OP LE_OP GE_OP EQ_OP NE_OP
%token <lex> AND_OP OR_OP XOR_OP MUL_ASSIGN DIV_ASSIGN ADD_ASSIGN
@ -273,6 +274,18 @@ primary_expression
parseContext.int64Check($1.loc, "64-bit unsigned integer literal");
$$ = parseContext.intermediate.addConstantUnion($1.u64, $1.loc, true);
}
| INT16CONSTANT {
#ifdef AMD_EXTENSIONS
parseContext.int16Check($1.loc, "16-bit integer literal");
$$ = parseContext.intermediate.addConstantUnion((short)$1.i, $1.loc, true);
#endif
}
| UINT16CONSTANT {
#ifdef AMD_EXTENSIONS
parseContext.int16Check($1.loc, "16-bit unsigned integer literal");
$$ = parseContext.intermediate.addConstantUnion((unsigned short)$1.u, $1.loc, true);
#endif
}
| FLOATCONSTANT {
$$ = parseContext.intermediate.addConstantUnion($1.d, EbtFloat, $1.loc, true);
}
@ -1363,6 +1376,20 @@ type_specifier_nonarray
$$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
$$.basicType = EbtUint64;
}
| INT16_T {
#ifdef AMD_EXTENSIONS
parseContext.int16Check($1.loc, "16-bit integer", parseContext.symbolTable.atBuiltInLevel());
$$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
$$.basicType = EbtInt16;
#endif
}
| UINT16_T {
#ifdef AMD_EXTENSIONS
parseContext.int16Check($1.loc, "16-bit unsigned integer", parseContext.symbolTable.atBuiltInLevel());
$$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
$$.basicType = EbtUint16;
#endif
}
| BOOL {
$$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
$$.basicType = EbtBool;
@ -1472,6 +1499,30 @@ type_specifier_nonarray
$$.basicType = EbtInt64;
$$.setVector(4);
}
| I16VEC2 {
#ifdef AMD_EXTENSIONS
parseContext.int16Check($1.loc, "16-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
$$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
$$.basicType = EbtInt16;
$$.setVector(2);
#endif
}
| I16VEC3 {
#ifdef AMD_EXTENSIONS
parseContext.int16Check($1.loc, "16-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
$$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
$$.basicType = EbtInt16;
$$.setVector(3);
#endif
}
| I16VEC4 {
#ifdef AMD_EXTENSIONS
parseContext.int16Check($1.loc, "16-bit integer vector", parseContext.symbolTable.atBuiltInLevel());
$$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
$$.basicType = EbtInt16;
$$.setVector(4);
#endif
}
| UVEC2 {
parseContext.fullIntegerCheck($1.loc, "unsigned integer vector");
$$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
@ -1508,6 +1559,30 @@ type_specifier_nonarray
$$.basicType = EbtUint64;
$$.setVector(4);
}
| U16VEC2 {
#ifdef AMD_EXTENSIONS
parseContext.int16Check($1.loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
$$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
$$.basicType = EbtUint16;
$$.setVector(2);
#endif
}
| U16VEC3 {
#ifdef AMD_EXTENSIONS
parseContext.int16Check($1.loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
$$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
$$.basicType = EbtUint16;
$$.setVector(3);
#endif
}
| U16VEC4 {
#ifdef AMD_EXTENSIONS
parseContext.int16Check($1.loc, "16-bit unsigned integer vector", parseContext.symbolTable.atBuiltInLevel());
$$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
$$.basicType = EbtUint16;
$$.setVector(4);
#endif
}
| MAT2 {
$$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
$$.basicType = EbtFloat;

11227
glslang/MachineIndependent/glslang_tab.cpp
View file

File diff suppressed because it is too large Load diff

634
glslang/MachineIndependent/glslang_tab.cpp.h
View file

@ -1,19 +1,21 @@
/* A Bison parser, made by GNU Bison 3.0.4. */
/* Bison interface for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
/* A Bison parser, made by GNU Bison 2.4.1. */
/* Skeleton interface for Bison's Yacc-like parsers in C
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
@ -26,319 +28,323 @@
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
#ifndef YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
# define YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
/* Debug traces. */
#ifndef YYDEBUG
# define YYDEBUG 1
#endif
#if YYDEBUG
extern int yydebug;
#endif
/* Token type. */
/* Tokens. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
enum yytokentype
{
ATTRIBUTE = 258,
VARYING = 259,
CONST = 260,
BOOL = 261,
FLOAT = 262,
DOUBLE = 263,
INT = 264,
UINT = 265,
INT64_T = 266,
UINT64_T = 267,
FLOAT16_T = 268,
BREAK = 269,
CONTINUE = 270,
DO = 271,
ELSE = 272,
FOR = 273,
IF = 274,
DISCARD = 275,
RETURN = 276,
SWITCH = 277,
CASE = 278,
DEFAULT = 279,
SUBROUTINE = 280,
BVEC2 = 281,
BVEC3 = 282,
BVEC4 = 283,
IVEC2 = 284,
IVEC3 = 285,
IVEC4 = 286,
I64VEC2 = 287,
I64VEC3 = 288,
I64VEC4 = 289,
UVEC2 = 290,
UVEC3 = 291,
UVEC4 = 292,
U64VEC2 = 293,
U64VEC3 = 294,
U64VEC4 = 295,
VEC2 = 296,
VEC3 = 297,
VEC4 = 298,
MAT2 = 299,
MAT3 = 300,
MAT4 = 301,
CENTROID = 302,
IN = 303,
OUT = 304,
INOUT = 305,
UNIFORM = 306,
PATCH = 307,
SAMPLE = 308,
BUFFER = 309,
SHARED = 310,
COHERENT = 311,
VOLATILE = 312,
RESTRICT = 313,
READONLY = 314,
WRITEONLY = 315,
DVEC2 = 316,
DVEC3 = 317,
DVEC4 = 318,
DMAT2 = 319,
DMAT3 = 320,
DMAT4 = 321,
F16VEC2 = 322,
F16VEC3 = 323,
F16VEC4 = 324,
F16MAT2 = 325,
F16MAT3 = 326,
F16MAT4 = 327,
NOPERSPECTIVE = 328,
FLAT = 329,
SMOOTH = 330,
LAYOUT = 331,
__EXPLICITINTERPAMD = 332,
MAT2X2 = 333,
MAT2X3 = 334,
MAT2X4 = 335,
MAT3X2 = 336,
MAT3X3 = 337,
MAT3X4 = 338,
MAT4X2 = 339,
MAT4X3 = 340,
MAT4X4 = 341,
DMAT2X2 = 342,
DMAT2X3 = 343,
DMAT2X4 = 344,
DMAT3X2 = 345,
DMAT3X3 = 346,
DMAT3X4 = 347,
DMAT4X2 = 348,
DMAT4X3 = 349,
DMAT4X4 = 350,
F16MAT2X2 = 351,
F16MAT2X3 = 352,
F16MAT2X4 = 353,
F16MAT3X2 = 354,
F16MAT3X3 = 355,
F16MAT3X4 = 356,
F16MAT4X2 = 357,
F16MAT4X3 = 358,
F16MAT4X4 = 359,
ATOMIC_UINT = 360,
SAMPLER1D = 361,
SAMPLER2D = 362,
SAMPLER3D = 363,
SAMPLERCUBE = 364,
SAMPLER1DSHADOW = 365,
SAMPLER2DSHADOW = 366,
SAMPLERCUBESHADOW = 367,
SAMPLER1DARRAY = 368,
SAMPLER2DARRAY = 369,
SAMPLER1DARRAYSHADOW = 370,
SAMPLER2DARRAYSHADOW = 371,
ISAMPLER1D = 372,
ISAMPLER2D = 373,
ISAMPLER3D = 374,
ISAMPLERCUBE = 375,
ISAMPLER1DARRAY = 376,
ISAMPLER2DARRAY = 377,
USAMPLER1D = 378,
USAMPLER2D = 379,
USAMPLER3D = 380,
USAMPLERCUBE = 381,
USAMPLER1DARRAY = 382,
USAMPLER2DARRAY = 383,
SAMPLER2DRECT = 384,
SAMPLER2DRECTSHADOW = 385,
ISAMPLER2DRECT = 386,
USAMPLER2DRECT = 387,
SAMPLERBUFFER = 388,
ISAMPLERBUFFER = 389,
USAMPLERBUFFER = 390,
SAMPLERCUBEARRAY = 391,
SAMPLERCUBEARRAYSHADOW = 392,
ISAMPLERCUBEARRAY = 393,
USAMPLERCUBEARRAY = 394,
SAMPLER2DMS = 395,
ISAMPLER2DMS = 396,
USAMPLER2DMS = 397,
SAMPLER2DMSARRAY = 398,
ISAMPLER2DMSARRAY = 399,
USAMPLER2DMSARRAY = 400,
SAMPLEREXTERNALOES = 401,
SAMPLER = 402,
SAMPLERSHADOW = 403,
TEXTURE1D = 404,
TEXTURE2D = 405,
TEXTURE3D = 406,
TEXTURECUBE = 407,
TEXTURE1DARRAY = 408,
TEXTURE2DARRAY = 409,
ITEXTURE1D = 410,
ITEXTURE2D = 411,
ITEXTURE3D = 412,
ITEXTURECUBE = 413,
ITEXTURE1DARRAY = 414,
ITEXTURE2DARRAY = 415,
UTEXTURE1D = 416,
UTEXTURE2D = 417,
UTEXTURE3D = 418,
UTEXTURECUBE = 419,
UTEXTURE1DARRAY = 420,
UTEXTURE2DARRAY = 421,
TEXTURE2DRECT = 422,
ITEXTURE2DRECT = 423,
UTEXTURE2DRECT = 424,
TEXTUREBUFFER = 425,
ITEXTUREBUFFER = 426,
UTEXTUREBUFFER = 427,
TEXTURECUBEARRAY = 428,
ITEXTURECUBEARRAY = 429,
UTEXTURECUBEARRAY = 430,
TEXTURE2DMS = 431,
ITEXTURE2DMS = 432,
UTEXTURE2DMS = 433,
TEXTURE2DMSARRAY = 434,
ITEXTURE2DMSARRAY = 435,
UTEXTURE2DMSARRAY = 436,
SUBPASSINPUT = 437,
SUBPASSINPUTMS = 438,
ISUBPASSINPUT = 439,
ISUBPASSINPUTMS = 440,
USUBPASSINPUT = 441,
USUBPASSINPUTMS = 442,
IMAGE1D = 443,
IIMAGE1D = 444,
UIMAGE1D = 445,
IMAGE2D = 446,
IIMAGE2D = 447,
UIMAGE2D = 448,
IMAGE3D = 449,
IIMAGE3D = 450,
UIMAGE3D = 451,
IMAGE2DRECT = 452,
IIMAGE2DRECT = 453,
UIMAGE2DRECT = 454,
IMAGECUBE = 455,
IIMAGECUBE = 456,
UIMAGECUBE = 457,
IMAGEBUFFER = 458,
IIMAGEBUFFER = 459,
UIMAGEBUFFER = 460,
IMAGE1DARRAY = 461,
IIMAGE1DARRAY = 462,
UIMAGE1DARRAY = 463,
IMAGE2DARRAY = 464,
IIMAGE2DARRAY = 465,
UIMAGE2DARRAY = 466,
IMAGECUBEARRAY = 467,
IIMAGECUBEARRAY = 468,
UIMAGECUBEARRAY = 469,
IMAGE2DMS = 470,
IIMAGE2DMS = 471,
UIMAGE2DMS = 472,
IMAGE2DMSARRAY = 473,
IIMAGE2DMSARRAY = 474,
UIMAGE2DMSARRAY = 475,
STRUCT = 476,
VOID = 477,
WHILE = 478,
IDENTIFIER = 479,
TYPE_NAME = 480,
FLOATCONSTANT = 481,
DOUBLECONSTANT = 482,
INTCONSTANT = 483,
UINTCONSTANT = 484,
INT64CONSTANT = 485,
UINT64CONSTANT = 486,
BOOLCONSTANT = 487,
FLOAT16CONSTANT = 488,
LEFT_OP = 489,
RIGHT_OP = 490,
INC_OP = 491,
DEC_OP = 492,
LE_OP = 493,
GE_OP = 494,
EQ_OP = 495,
NE_OP = 496,
AND_OP = 497,
OR_OP = 498,
XOR_OP = 499,
MUL_ASSIGN = 500,
DIV_ASSIGN = 501,
ADD_ASSIGN = 502,
MOD_ASSIGN = 503,
LEFT_ASSIGN = 504,
RIGHT_ASSIGN = 505,
AND_ASSIGN = 506,
XOR_ASSIGN = 507,
OR_ASSIGN = 508,
SUB_ASSIGN = 509,
LEFT_PAREN = 510,
RIGHT_PAREN = 511,
LEFT_BRACKET = 512,
RIGHT_BRACKET = 513,
LEFT_BRACE = 514,
RIGHT_BRACE = 515,
DOT = 516,
COMMA = 517,
COLON = 518,
EQUAL = 519,
SEMICOLON = 520,
BANG = 521,
DASH = 522,
TILDE = 523,
PLUS = 524,
STAR = 525,
SLASH = 526,
PERCENT = 527,
LEFT_ANGLE = 528,
RIGHT_ANGLE = 529,
VERTICAL_BAR = 530,
CARET = 531,
AMPERSAND = 532,
QUESTION = 533,
INVARIANT = 534,
PRECISE = 535,
HIGH_PRECISION = 536,
MEDIUM_PRECISION = 537,
LOW_PRECISION = 538,
PRECISION = 539,
PACKED = 540,
RESOURCE = 541,
SUPERP = 542
};
/* Put the tokens into the symbol table, so that GDB and other debuggers
know about them. */
enum yytokentype {
ATTRIBUTE = 258,
VARYING = 259,
CONST = 260,
BOOL = 261,
FLOAT = 262,
DOUBLE = 263,
INT = 264,
UINT = 265,
INT64_T = 266,
UINT64_T = 267,
INT16_T = 268,
UINT16_T = 269,
FLOAT16_T = 270,
BREAK = 271,
CONTINUE = 272,
DO = 273,
ELSE = 274,
FOR = 275,
IF = 276,
DISCARD = 277,
RETURN = 278,
SWITCH = 279,
CASE = 280,
DEFAULT = 281,
SUBROUTINE = 282,
BVEC2 = 283,
BVEC3 = 284,
BVEC4 = 285,
IVEC2 = 286,
IVEC3 = 287,
IVEC4 = 288,
I64VEC2 = 289,
I64VEC3 = 290,
I64VEC4 = 291,
UVEC2 = 292,
UVEC3 = 293,
UVEC4 = 294,
U64VEC2 = 295,
U64VEC3 = 296,
U64VEC4 = 297,
VEC2 = 298,
VEC3 = 299,
VEC4 = 300,
MAT2 = 301,
MAT3 = 302,
MAT4 = 303,
CENTROID = 304,
IN = 305,
OUT = 306,
INOUT = 307,
UNIFORM = 308,
PATCH = 309,
SAMPLE = 310,
BUFFER = 311,
SHARED = 312,
COHERENT = 313,
VOLATILE = 314,
RESTRICT = 315,
READONLY = 316,
WRITEONLY = 317,
DVEC2 = 318,
DVEC3 = 319,
DVEC4 = 320,
DMAT2 = 321,
DMAT3 = 322,
DMAT4 = 323,
F16VEC2 = 324,
F16VEC3 = 325,
F16VEC4 = 326,
F16MAT2 = 327,
F16MAT3 = 328,
F16MAT4 = 329,
I16VEC2 = 330,
I16VEC3 = 331,
I16VEC4 = 332,
U16VEC2 = 333,
U16VEC3 = 334,
U16VEC4 = 335,
NOPERSPECTIVE = 336,
FLAT = 337,
SMOOTH = 338,
LAYOUT = 339,
__EXPLICITINTERPAMD = 340,
MAT2X2 = 341,
MAT2X3 = 342,
MAT2X4 = 343,
MAT3X2 = 344,
MAT3X3 = 345,
MAT3X4 = 346,
MAT4X2 = 347,
MAT4X3 = 348,
MAT4X4 = 349,
DMAT2X2 = 350,
DMAT2X3 = 351,
DMAT2X4 = 352,
DMAT3X2 = 353,
DMAT3X3 = 354,
DMAT3X4 = 355,
DMAT4X2 = 356,
DMAT4X3 = 357,
DMAT4X4 = 358,
F16MAT2X2 = 359,
F16MAT2X3 = 360,
F16MAT2X4 = 361,
F16MAT3X2 = 362,
F16MAT3X3 = 363,
F16MAT3X4 = 364,
F16MAT4X2 = 365,
F16MAT4X3 = 366,
F16MAT4X4 = 367,
ATOMIC_UINT = 368,
SAMPLER1D = 369,
SAMPLER2D = 370,
SAMPLER3D = 371,
SAMPLERCUBE = 372,
SAMPLER1DSHADOW = 373,
SAMPLER2DSHADOW = 374,
SAMPLERCUBESHADOW = 375,
SAMPLER1DARRAY = 376,
SAMPLER2DARRAY = 377,
SAMPLER1DARRAYSHADOW = 378,
SAMPLER2DARRAYSHADOW = 379,
ISAMPLER1D = 380,
ISAMPLER2D = 381,
ISAMPLER3D = 382,
ISAMPLERCUBE = 383,
ISAMPLER1DARRAY = 384,
ISAMPLER2DARRAY = 385,
USAMPLER1D = 386,
USAMPLER2D = 387,
USAMPLER3D = 388,
USAMPLERCUBE = 389,
USAMPLER1DARRAY = 390,
USAMPLER2DARRAY = 391,
SAMPLER2DRECT = 392,
SAMPLER2DRECTSHADOW = 393,
ISAMPLER2DRECT = 394,
USAMPLER2DRECT = 395,
SAMPLERBUFFER = 396,
ISAMPLERBUFFER = 397,
USAMPLERBUFFER = 398,
SAMPLERCUBEARRAY = 399,
SAMPLERCUBEARRAYSHADOW = 400,
ISAMPLERCUBEARRAY = 401,
USAMPLERCUBEARRAY = 402,
SAMPLER2DMS = 403,
ISAMPLER2DMS = 404,
USAMPLER2DMS = 405,
SAMPLER2DMSARRAY = 406,
ISAMPLER2DMSARRAY = 407,
USAMPLER2DMSARRAY = 408,
SAMPLEREXTERNALOES = 409,
SAMPLER = 410,
SAMPLERSHADOW = 411,
TEXTURE1D = 412,
TEXTURE2D = 413,
TEXTURE3D = 414,
TEXTURECUBE = 415,
TEXTURE1DARRAY = 416,
TEXTURE2DARRAY = 417,
ITEXTURE1D = 418,
ITEXTURE2D = 419,
ITEXTURE3D = 420,
ITEXTURECUBE = 421,
ITEXTURE1DARRAY = 422,
ITEXTURE2DARRAY = 423,
UTEXTURE1D = 424,
UTEXTURE2D = 425,
UTEXTURE3D = 426,
UTEXTURECUBE = 427,
UTEXTURE1DARRAY = 428,
UTEXTURE2DARRAY = 429,
TEXTURE2DRECT = 430,
ITEXTURE2DRECT = 431,
UTEXTURE2DRECT = 432,
TEXTUREBUFFER = 433,
ITEXTUREBUFFER = 434,
UTEXTUREBUFFER = 435,
TEXTURECUBEARRAY = 436,
ITEXTURECUBEARRAY = 437,
UTEXTURECUBEARRAY = 438,
TEXTURE2DMS = 439,
ITEXTURE2DMS = 440,
UTEXTURE2DMS = 441,
TEXTURE2DMSARRAY = 442,
ITEXTURE2DMSARRAY = 443,
UTEXTURE2DMSARRAY = 444,
SUBPASSINPUT = 445,
SUBPASSINPUTMS = 446,
ISUBPASSINPUT = 447,
ISUBPASSINPUTMS = 448,
USUBPASSINPUT = 449,
USUBPASSINPUTMS = 450,
IMAGE1D = 451,
IIMAGE1D = 452,
UIMAGE1D = 453,
IMAGE2D = 454,
IIMAGE2D = 455,
UIMAGE2D = 456,
IMAGE3D = 457,
IIMAGE3D = 458,
UIMAGE3D = 459,
IMAGE2DRECT = 460,
IIMAGE2DRECT = 461,
UIMAGE2DRECT = 462,
IMAGECUBE = 463,
IIMAGECUBE = 464,
UIMAGECUBE = 465,
IMAGEBUFFER = 466,
IIMAGEBUFFER = 467,
UIMAGEBUFFER = 468,
IMAGE1DARRAY = 469,
IIMAGE1DARRAY = 470,
UIMAGE1DARRAY = 471,
IMAGE2DARRAY = 472,
IIMAGE2DARRAY = 473,
UIMAGE2DARRAY = 474,
IMAGECUBEARRAY = 475,
IIMAGECUBEARRAY = 476,
UIMAGECUBEARRAY = 477,
IMAGE2DMS = 478,
IIMAGE2DMS = 479,
UIMAGE2DMS = 480,
IMAGE2DMSARRAY = 481,
IIMAGE2DMSARRAY = 482,
UIMAGE2DMSARRAY = 483,
STRUCT = 484,
VOID = 485,
WHILE = 486,
IDENTIFIER = 487,
TYPE_NAME = 488,
FLOATCONSTANT = 489,
DOUBLECONSTANT = 490,
INTCONSTANT = 491,
UINTCONSTANT = 492,
INT64CONSTANT = 493,
UINT64CONSTANT = 494,
INT16CONSTANT = 495,
UINT16CONSTANT = 496,
BOOLCONSTANT = 497,
FLOAT16CONSTANT = 498,
LEFT_OP = 499,
RIGHT_OP = 500,
INC_OP = 501,
DEC_OP = 502,
LE_OP = 503,
GE_OP = 504,
EQ_OP = 505,
NE_OP = 506,
AND_OP = 507,
OR_OP = 508,
XOR_OP = 509,
MUL_ASSIGN = 510,
DIV_ASSIGN = 511,
ADD_ASSIGN = 512,
MOD_ASSIGN = 513,
LEFT_ASSIGN = 514,
RIGHT_ASSIGN = 515,
AND_ASSIGN = 516,
XOR_ASSIGN = 517,
OR_ASSIGN = 518,
SUB_ASSIGN = 519,
LEFT_PAREN = 520,
RIGHT_PAREN = 521,
LEFT_BRACKET = 522,
RIGHT_BRACKET = 523,
LEFT_BRACE = 524,
RIGHT_BRACE = 525,
DOT = 526,
COMMA = 527,
COLON = 528,
EQUAL = 529,
SEMICOLON = 530,
BANG = 531,
DASH = 532,
TILDE = 533,
PLUS = 534,
STAR = 535,
SLASH = 536,
PERCENT = 537,
LEFT_ANGLE = 538,
RIGHT_ANGLE = 539,
VERTICAL_BAR = 540,
CARET = 541,
AMPERSAND = 542,
QUESTION = 543,
INVARIANT = 544,
PRECISE = 545,
HIGH_PRECISION = 546,
MEDIUM_PRECISION = 547,
LOW_PRECISION = 548,
PRECISION = 549,
PACKED = 550,
RESOURCE = 551,
SUPERP = 552
};
#endif
/* Value type. */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
union YYSTYPE
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef union YYSTYPE
{
#line 68 "MachineIndependent/glslang.y" /* yacc.c:1909 */
/* Line 1676 of yacc.c */
#line 68 "glslang.y"
struct {
glslang::TSourceLoc loc;
@ -372,16 +378,16 @@ union YYSTYPE
};
} interm;
#line 376 "MachineIndependent/glslang_tab.cpp.h" /* yacc.c:1909 */
};
typedef union YYSTYPE YYSTYPE;
/* Line 1676 of yacc.c */
#line 385 "glslang_tab.cpp.h"
} YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1
#endif
int yyparse (glslang::TParseContext* pParseContext);
#endif /* !YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED */

87
glslang/MachineIndependent/intermOut.cpp
View file

@ -308,6 +308,13 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node)
case EOpDoubleBitsToUint64: out.debug << "doubleBitsToUint64"; break;
case EOpInt64BitsToDouble: out.debug << "int64BitsToDouble"; break;
case EOpUint64BitsToDouble: out.debug << "uint64BitsToDouble"; break;
#ifdef AMD_EXTENSIONS
case EOpFloat16BitsToInt16: out.debug << "float16BitsToInt16"; break;
case EOpFloat16BitsToUint16: out.debug << "float16BitsToUint16"; break;
case EOpInt16BitsToFloat16: out.debug << "int16BitsToFloat16"; break;
case EOpUint16BitsToFloat16: out.debug << "uint16BitsToFloat16"; break;
#endif
case EOpPackSnorm2x16: out.debug << "packSnorm2x16"; break;
case EOpUnpackSnorm2x16:out.debug << "unpackSnorm2x16"; break;
case EOpPackUnorm2x16: out.debug << "packUnorm2x16"; break;
@ -328,6 +335,16 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node)
case EOpUnpackUint2x32: out.debug << "unpackUint2x32"; break;
#ifdef AMD_EXTENSIONS
case EOpPackInt2x16: out.debug << "packInt2x16"; break;
case EOpUnpackInt2x16: out.debug << "unpackInt2x16"; break;
case EOpPackUint2x16: out.debug << "packUint2x16"; break;
case EOpUnpackUint2x16: out.debug << "unpackUint2x16"; break;
case EOpPackInt4x16: out.debug << "packInt4x16"; break;
case EOpUnpackInt4x16: out.debug << "unpackInt4x16"; break;
case EOpPackUint4x16: out.debug << "packUint4x16"; break;
case EOpUnpackUint4x16: out.debug << "unpackUint4x16"; break;
case EOpPackFloat2x16: out.debug << "packFloat2x16"; break;
case EOpUnpackFloat2x16: out.debug << "unpackFloat2x16"; break;
#endif
@ -433,6 +450,42 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node)
case EOpConvFloat16ToDouble: out.debug << "Convert float16 to double"; break;
case EOpConvFloat16ToInt64: out.debug << "Convert float16 to int64"; break;
case EOpConvFloat16ToUint64: out.debug << "Convert float16 to uint64"; break;
case EOpConvBoolToInt16: out.debug << "Convert bool to int16"; break;
case EOpConvIntToInt16: out.debug << "Convert int to int16"; break;
case EOpConvUintToInt16: out.debug << "Convert uint to int16"; break;
case EOpConvFloatToInt16: out.debug << "Convert float to int16"; break;
case EOpConvDoubleToInt16: out.debug << "Convert double to int16"; break;
case EOpConvFloat16ToInt16: out.debug << "Convert float16 to int16"; break;
case EOpConvInt64ToInt16: out.debug << "Convert int64 to int16"; break;
case EOpConvUint64ToInt16: out.debug << "Convert uint64 to int16"; break;
case EOpConvUint16ToInt16: out.debug << "Convert uint16 to int16"; break;
case EOpConvInt16ToBool: out.debug << "Convert int16 to bool"; break;
case EOpConvInt16ToInt: out.debug << "Convert int16 to int"; break;
case EOpConvInt16ToUint: out.debug << "Convert int16 to uint"; break;
case EOpConvInt16ToFloat: out.debug << "Convert int16 to float"; break;
case EOpConvInt16ToDouble: out.debug << "Convert int16 to double"; break;
case EOpConvInt16ToFloat16: out.debug << "Convert int16 to float16"; break;
case EOpConvInt16ToInt64: out.debug << "Convert int16 to int64"; break;
case EOpConvInt16ToUint64: out.debug << "Convert int16 to uint64"; break;
case EOpConvBoolToUint16: out.debug << "Convert bool to uint16"; break;
case EOpConvIntToUint16: out.debug << "Convert int to uint16"; break;
case EOpConvUintToUint16: out.debug << "Convert uint to uint16"; break;
case EOpConvFloatToUint16: out.debug << "Convert float to uint16"; break;
case EOpConvDoubleToUint16: out.debug << "Convert double to uint16"; break;
case EOpConvFloat16ToUint16: out.debug << "Convert float16 to uint16"; break;
case EOpConvInt64ToUint16: out.debug << "Convert int64 to uint16"; break;
case EOpConvUint64ToUint16: out.debug << "Convert uint64 to uint16"; break;
case EOpConvInt16ToUint16: out.debug << "Convert int16 to uint16"; break;
case EOpConvUint16ToBool: out.debug << "Convert uint16 to bool"; break;
case EOpConvUint16ToInt: out.debug << "Convert uint16 to int"; break;
case EOpConvUint16ToUint: out.debug << "Convert uint16 to uint"; break;
case EOpConvUint16ToFloat: out.debug << "Convert uint16 to float"; break;
case EOpConvUint16ToDouble: out.debug << "Convert uint16 to double"; break;
case EOpConvUint16ToFloat16: out.debug << "Convert uint16 to float16"; break;
case EOpConvUint16ToInt64: out.debug << "Convert uint16 to int64"; break;
case EOpConvUint16ToUint64: out.debug << "Convert uint16 to uint64"; break;
#endif
default: out.debug.message(EPrefixError, "Bad unary op");
@ -466,9 +519,13 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
case EOpConstructFloat: out.debug << "Construct float"; break;
case EOpConstructDouble:out.debug << "Construct double"; break;
case EOpConstructVec2: out.debug << "Construct vec2"; break;
case EOpConstructVec3: out.debug << "Construct vec3"; break;
case EOpConstructVec4: out.debug << "Construct vec4"; break;
case EOpConstructDVec2: out.debug << "Construct dvec2"; break;
case EOpConstructDVec3: out.debug << "Construct dvec3"; break;
case EOpConstructDVec4: out.debug << "Construct dvec4"; break;
case EOpConstructBool: out.debug << "Construct bool"; break;
case EOpConstructBVec2: out.debug << "Construct bvec2"; break;
case EOpConstructBVec3: out.debug << "Construct bvec3"; break;
@ -489,6 +546,16 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
case EOpConstructU64Vec2: out.debug << "Construct u64vec2"; break;
case EOpConstructU64Vec3: out.debug << "Construct u64vec3"; break;
case EOpConstructU64Vec4: out.debug << "Construct u64vec4"; break;
#ifdef AMD_EXTENSIONS
case EOpConstructInt16: out.debug << "Construct int16_t"; break;
case EOpConstructI16Vec2: out.debug << "Construct i16vec2"; break;
case EOpConstructI16Vec3: out.debug << "Construct i16vec3"; break;
case EOpConstructI16Vec4: out.debug << "Construct i16vec4"; break;
case EOpConstructUint16: out.debug << "Construct uint16_t"; break;
case EOpConstructU16Vec2: out.debug << "Construct u16vec2"; break;
case EOpConstructU16Vec3: out.debug << "Construct u16vec3"; break;
case EOpConstructU16Vec4: out.debug << "Construct u16vec4"; break;
#endif
case EOpConstructMat2x2: out.debug << "Construct mat2"; break;
case EOpConstructMat2x3: out.debug << "Construct mat2x3"; break;
case EOpConstructMat2x4: out.debug << "Construct mat2x4"; break;
@ -827,6 +894,26 @@ static void OutputConstantUnion(TInfoSink& out, const TIntermTyped* node, const
out.debug << buf << "\n";
}
break;
#ifdef AMD_EXTENSIONS
case EbtInt16:
{
const int maxSize = 300;
char buf[maxSize];
snprintf(buf, maxSize, "%d (%s)", constUnion[i].getIConst(), "const int16_t");
out.debug << buf << "\n";
}
break;
case EbtUint16:
{
const int maxSize = 300;
char buf[maxSize];
snprintf(buf, maxSize, "%u (%s)", constUnion[i].getUConst(), "const uint16_t");
out.debug << buf << "\n";
}
break;
#endif
default:
out.info.message(EPrefixInternalError, "Unknown constant", node->getLoc());
break;

2
glslang/MachineIndependent/linkValidate.cpp
View file

@ -1057,6 +1057,8 @@ int TIntermediate::getBaseAlignmentScalar(const TType& type, int& size)
case EbtUint64:
case EbtDouble: size = 8; return 8;
#ifdef AMD_EXTENSIONS
case EbtInt16:
case EbtUint16:
case EbtFloat16: size = 2; return 2;
#endif
default: size = 4; return 4;

5
glslang/MachineIndependent/localintermediate.h
View file

@ -285,6 +285,11 @@ public:
TIntermConstantUnion* addConstantUnion(unsigned int, const TSourceLoc&, bool literal = false) const;
TIntermConstantUnion* addConstantUnion(long long, const TSourceLoc&, bool literal = false) const;
TIntermConstantUnion* addConstantUnion(unsigned long long, const TSourceLoc&, bool literal = false) const;
#ifdef AMD_EXTENSIONS
TIntermConstantUnion* addConstantUnion(short, const TSourceLoc&, bool literal = false) const;
TIntermConstantUnion* addConstantUnion(unsigned short, const TSourceLoc&, bool literal = false) const;
#endif
TIntermConstantUnion* addConstantUnion(bool, const TSourceLoc&, bool literal = false) const;
TIntermConstantUnion* addConstantUnion(double, TBasicType, const TSourceLoc&, bool literal = false) const;
TIntermConstantUnion* addConstantUnion(const TString*, const TSourceLoc&, bool literal = false) const;

1
glslang/MachineIndependent/parseVersions.h
View file

@ -78,6 +78,7 @@ public:
virtual void fullIntegerCheck(const TSourceLoc&, const char* op);
virtual void doubleCheck(const TSourceLoc&, const char* op);
#ifdef AMD_EXTENSIONS
virtual void int16Check(const TSourceLoc& loc, const char* op, bool builtIn = false);
virtual void float16Check(const TSourceLoc&, const char* op, bool builtIn = false);
#endif
virtual void int64Check(const TSourceLoc&, const char* op, bool builtIn = false);

5
glslang/MachineIndependent/preprocessor/Pp.cpp
View file

@ -724,6 +724,7 @@ int TPpContext::CPPerror(TPpToken* ppToken)
if (token == PpAtomConstInt || token == PpAtomConstUint ||
token == PpAtomConstInt64 || token == PpAtomConstUint64 ||
#ifdef AMD_EXTENSIONS
token == PpAtomConstInt16 || token == PpAtomConstUint16 ||
token == PpAtomConstFloat16 ||
#endif
token == PpAtomConstFloat || token == PpAtomConstDouble) {
@ -758,6 +759,10 @@ int TPpContext::CPPpragma(TPpToken* ppToken)
case PpAtomConstUint:
case PpAtomConstInt64:
case PpAtomConstUint64:
#ifdef AMD_EXTENSIONS
case PpAtomConstInt16:
case PpAtomConstUint16:
#endif
case PpAtomConstFloat:
case PpAtomConstDouble:
#ifdef AMD_EXTENSIONS

111
glslang/MachineIndependent/preprocessor/PpScanner.cpp
View file

@ -334,6 +334,9 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
int ii = 0;
unsigned long long ival = 0;
bool enableInt64 = pp->parseContext.version >= 450 && pp->parseContext.extensionTurnedOn(E_GL_ARB_gpu_shader_int64);
#ifdef AMD_EXTENSIONS
bool enableInt16 = pp->parseContext.version >= 450 && pp->parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_int16);
#endif
bool acceptHalf = pp->parseContext.intermediate.getSource() == EShSourceHlsl;
#ifdef AMD_EXTENSIONS
if (pp->parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float))
@ -406,6 +409,9 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
bool isUnsigned = false;
bool isInt64 = false;
#ifdef AMD_EXTENSIONS
bool isInt16 = false;
#endif
ppToken->name[len++] = (char)ch;
ch = getch();
if ((ch >= '0' && ch <= '9') ||
@ -414,7 +420,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
ival = 0;
do {
if (ival <= 0x0fffffff || (enableInt64 && ival <= 0x0fffffffffffffffull)) {
if (ival <= 0x0fffffffu || (enableInt64 && ival <= 0x0fffffffffffffffull)) {
ppToken->name[len++] = (char)ch;
if (ch >= '0' && ch <= '9') {
ii = ch - '0';
@ -453,11 +459,28 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
} else
ungetch();
}
}
else if (enableInt64 && (ch == 'l' || ch == 'L')) {
#ifdef AMD_EXTENSIONS
if (enableInt16) {
int nextCh = getch();
if ((ch == 'u' && nextCh == 's') || (ch == 'U' && nextCh == 'S')) {
if (len < MaxTokenLength)
ppToken->name[len++] = (char)nextCh;
isInt16 = true;
} else
ungetch();
}
#endif
} else if (enableInt64 && (ch == 'l' || ch == 'L')) {
if (len < MaxTokenLength)
ppToken->name[len++] = (char)ch;
isInt64 = true;
#ifdef AMD_EXTENSIONS
} else if (enableInt16 && (ch == 's' || ch == 'S')) {
if (len < MaxTokenLength)
ppToken->name[len++] = (char)ch;
isInt16 = true;
#endif
} else
ungetch();
ppToken->name[len] = '\0';
@ -465,6 +488,11 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
if (isInt64) {
ppToken->i64val = ival;
return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64;
#ifdef AMD_EXTENSIONS
} else if (isInt16) {
ppToken->ival = (int)ival;
return isUnsigned ? PpAtomConstUint16 : PpAtomConstInt16;
#endif
} else {
ppToken->ival = (int)ival;
return isUnsigned ? PpAtomConstUint : PpAtomConstInt;
@ -474,6 +502,9 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
bool isUnsigned = false;
bool isInt64 = false;
#ifdef AMD_EXTENSIONS
bool isInt16 = false;
#endif
bool octalOverflow = false;
bool nonOctal = false;
ival = 0;
@ -486,7 +517,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
pp->parseContext.ppError(ppToken->loc, "numeric literal too long", "", "");
AlreadyComplained = 1;
}
if (ival <= 0x1fffffff || (enableInt64 && ival <= 0x1fffffffffffffffull)) {
if (ival <= 0x1fffffffu || (enableInt64 && ival <= 0x1fffffffffffffffull)) {
ii = ch - '0';
ival = (ival << 3) | ii;
} else
@ -528,11 +559,28 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
} else
ungetch();
}
}
else if (enableInt64 && (ch == 'l' || ch == 'L')) {
#ifdef AMD_EXTENSIONS
if (enableInt16) {
int nextCh = getch();
if ((ch == 'u' && nextCh == 's') || (ch == 'U' && nextCh == 'S')) {
if (len < MaxTokenLength)
ppToken->name[len++] = (char)nextCh;
isInt16 = true;
} else
ungetch();
}
#endif
} else if (enableInt64 && (ch == 'l' || ch == 'L')) {
if (len < MaxTokenLength)
ppToken->name[len++] = (char)ch;
isInt64 = true;
#ifdef AMD_EXTENSIONS
} else if (enableInt16 && (ch == 's' || ch == 'S')) {
if (len < MaxTokenLength)
ppToken->name[len++] = (char)ch;
isInt16 = true;
#endif
} else
ungetch();
ppToken->name[len] = '\0';
@ -543,6 +591,11 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
if (isInt64) {
ppToken->i64val = ival;
return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64;
#ifdef AMD_EXTENSIONS
} else if (isInt16) {
ppToken->ival = (int)ival;
return isUnsigned ? PpAtomConstUint16 : PpAtomConstInt16;
#endif
} else {
ppToken->ival = (int)ival;
return isUnsigned ? PpAtomConstUint : PpAtomConstInt;
@ -569,6 +622,9 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
int numericLen = len;
bool isUnsigned = false;
bool isInt64 = false;
#ifdef AMD_EXTENSIONS
bool isInt16 = false;
#endif
if (ch == 'u' || ch == 'U') {
if (len < MaxTokenLength)
ppToken->name[len++] = (char)ch;
@ -583,10 +639,28 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
} else
ungetch();
}
#ifdef AMD_EXTENSIONS
if (enableInt16) {
int nextCh = getch();
if ((ch == 'u' && nextCh == 's') || (ch == 'U' && nextCh == 'S')) {
if (len < MaxTokenLength)
ppToken->name[len++] = (char)nextCh;
isInt16 = true;
} else
ungetch();
}
#endif
} else if (enableInt64 && (ch == 'l' || ch == 'L')) {
if (len < MaxTokenLength)
ppToken->name[len++] = (char)ch;
isInt64 = true;
#ifdef AMD_EXTENSIONS
} else if (enableInt16 && (ch == 's' || ch == 'S')) {
if (len < MaxTokenLength)
ppToken->name[len++] = (char)ch;
isInt16 = true;
#endif
} else
ungetch();
@ -596,10 +670,22 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
const unsigned remainderMaxInt = 0xFFFFFFFFu - 10 * oneTenthMaxInt;
const unsigned long long oneTenthMaxInt64 = 0xFFFFFFFFFFFFFFFFull / 10;
const unsigned long long remainderMaxInt64 = 0xFFFFFFFFFFFFFFFFull - 10 * oneTenthMaxInt64;
#ifdef AMD_EXTENSIONS
const unsigned short oneTenthMaxInt16 = 0xFFFFu / 10;
const unsigned short remainderMaxInt16 = 0xFFFFu - 10 * oneTenthMaxInt16;
#endif
for (int i = 0; i < numericLen; i++) {
ch = ppToken->name[i] - '0';
if ((enableInt64 == false && ((ival > oneTenthMaxInt) || (ival == oneTenthMaxInt && (unsigned)ch > remainderMaxInt))) ||
(enableInt64 && ((ival > oneTenthMaxInt64) || (ival == oneTenthMaxInt64 && (unsigned long long)ch > remainderMaxInt64)))) {
bool overflow = false;
if (isInt64)
overflow = (ival > oneTenthMaxInt64 || (ival == oneTenthMaxInt64 && (unsigned long long)ch > remainderMaxInt64));
#ifdef AMD_EXTENSIONS
else if (isInt16)
overflow = (ival > oneTenthMaxInt16 || (ival == oneTenthMaxInt16 && (unsigned short)ch > remainderMaxInt16));
#endif
else
overflow = (ival > oneTenthMaxInt || (ival == oneTenthMaxInt && (unsigned)ch > remainderMaxInt));
if (overflow) {
pp->parseContext.ppError(ppToken->loc, "numeric literal too big", "", "");
ival = 0xFFFFFFFFFFFFFFFFull;
break;
@ -610,6 +696,11 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
if (isInt64) {
ppToken->i64val = ival;
return isUnsigned ? PpAtomConstUint64 : PpAtomConstInt64;
#ifdef AMD_EXTENSIONS
} else if (isInt16) {
ppToken->ival = (int)ival;
return isUnsigned ? PpAtomConstUint16 : PpAtomConstInt16;
#endif
} else {
ppToken->ival = (int)ival;
return isUnsigned ? PpAtomConstUint : PpAtomConstInt;
@ -859,6 +950,10 @@ int TPpContext::tokenize(TPpToken& ppToken)
case PpAtomConstFloat:
case PpAtomConstInt64:
case PpAtomConstUint64:
#ifdef AMD_EXTENSIONS
case PpAtomConstInt16:
case PpAtomConstUint16:
#endif
case PpAtomConstDouble:
#ifdef AMD_EXTENSIONS
case PpAtomConstFloat16:

14
glslang/MachineIndependent/preprocessor/PpTokens.cpp
View file

@ -141,6 +141,10 @@ void TPpContext::TokenStream::putToken(int token, TPpToken* ppToken)
case PpAtomConstUint:
case PpAtomConstInt64:
case PpAtomConstUint64:
#ifdef AMD_EXTENSIONS
case PpAtomConstInt16:
case PpAtomConstUint16:
#endif
case PpAtomConstFloat:
case PpAtomConstDouble:
#ifdef AMD_EXTENSIONS
@ -190,6 +194,10 @@ int TPpContext::TokenStream::getToken(TParseContextBase& parseContext, TPpToken
case PpAtomConstUint:
case PpAtomConstInt64:
case PpAtomConstUint64:
#ifdef AMD_EXTENSIONS
case PpAtomConstInt16:
case PpAtomConstUint16:
#endif
len = 0;
ch = getSubtoken();
while (ch != 0 && ch != EndOfInput) {
@ -217,6 +225,9 @@ int TPpContext::TokenStream::getToken(TParseContextBase& parseContext, TPpToken
ppToken->dval = atof(ppToken->name);
break;
case PpAtomConstInt:
#ifdef AMD_EXTENSIONS
case PpAtomConstInt16:
#endif
if (len > 0 && ppToken->name[0] == '0') {
if (len > 1 && (ppToken->name[1] == 'x' || ppToken->name[1] == 'X'))
ppToken->ival = (int)strtol(ppToken->name, 0, 16);
@ -226,6 +237,9 @@ int TPpContext::TokenStream::getToken(TParseContextBase& parseContext, TPpToken
ppToken->ival = atoi(ppToken->name);
break;
case PpAtomConstUint:
#ifdef AMD_EXTENSIONS
case PpAtomConstUint16:
#endif
if (len > 0 && ppToken->name[0] == '0') {
if (len > 1 && (ppToken->name[1] == 'x' || ppToken->name[1] == 'X'))
ppToken->ival = (int)strtoul(ppToken->name, 0, 16);

4
glslang/MachineIndependent/preprocessor/PpTokens.h
View file

@ -127,6 +127,10 @@ enum EFixedAtoms {
PpAtomConstUint,
PpAtomConstInt64,
PpAtomConstUint64,
#ifdef AMD_EXTENSIONS
PpAtomConstInt16,
PpAtomConstUint16,
#endif
PpAtomConstFloat,
PpAtomConstDouble,
PpAtomConstFloat16,