From d2b161ee86735f34052cef3a3ba86731f50735bb Mon Sep 17 00:00:00 2001 From: libretroadmin Date: Thu, 23 May 2024 03:58:54 +0200 Subject: [PATCH] (glslang) Get rid of all asserts --- deps/glslang/glslang/SPIRV/GlslangToSpv.cpp | 69 +-------- .../glslang/glslang/SPIRV/InReadableOrder.cpp | 2 - deps/glslang/glslang/SPIRV/SPVRemapper.cpp | 11 +- deps/glslang/glslang/SPIRV/SpvBuilder.cpp | 55 +------ deps/glslang/glslang/SPIRV/SpvBuilder.h | 7 - deps/glslang/glslang/SPIRV/bitutils.h | 33 ----- deps/glslang/glslang/SPIRV/disassemble.cpp | 3 - deps/glslang/glslang/SPIRV/hex_float.h | 22 +-- deps/glslang/glslang/SPIRV/spvIR.h | 3 - .../glslang/glslang/Include/BaseTypes.h | 5 +- deps/glslang/glslang/glslang/Include/Common.h | 3 - .../glslang/glslang/Include/ConstantUnion.h | 134 +++++++----------- deps/glslang/glslang/glslang/Include/Types.h | 16 +-- deps/glslang/glslang/glslang/Include/arrays.h | 13 -- .../glslang/MachineIndependent/Constant.cpp | 10 +- .../glslang/MachineIndependent/Initialize.cpp | 4 +- .../MachineIndependent/Intermediate.cpp | 29 ++-- .../MachineIndependent/ParseContextBase.cpp | 2 - .../MachineIndependent/ParseHelper.cpp | 16 --- .../glslang/MachineIndependent/ShaderLang.cpp | 14 -- .../MachineIndependent/SymbolTable.cpp | 3 - .../glslang/MachineIndependent/SymbolTable.h | 23 ++- .../glslang/MachineIndependent/intermOut.cpp | 1 - .../MachineIndependent/linkValidate.cpp | 7 - .../MachineIndependent/localintermediate.h | 2 - .../MachineIndependent/preprocessor/Pp.cpp | 2 - .../preprocessor/PpAtom.cpp | 1 - .../preprocessor/PpContext.cpp | 2 - .../preprocessor/PpScanner.cpp | 5 +- .../preprocessor/PpTokens.cpp | 2 - .../propagateNoContraction.cpp | 40 ++---- .../glslang/MachineIndependent/reflection.cpp | 2 - .../glslang/OSDependent/Windows/ossource.cpp | 2 - 33 files changed, 100 insertions(+), 443 deletions(-) diff --git a/deps/glslang/glslang/SPIRV/GlslangToSpv.cpp b/deps/glslang/glslang/SPIRV/GlslangToSpv.cpp index ecdee4a6b2..0b058c3010 100755 --- a/deps/glslang/glslang/SPIRV/GlslangToSpv.cpp +++ b/deps/glslang/glslang/SPIRV/GlslangToSpv.cpp @@ -369,7 +369,6 @@ spv::Decoration TranslateLayoutDecoration(const glslang::TType& type, glslang::T switch (type.getBasicType()) { default: return spv::DecorationMax; - break; case glslang::EbtBlock: switch (type.getQualifier().storage) { case glslang::EvqUniform: @@ -382,8 +381,6 @@ spv::Decoration TranslateLayoutDecoration(const glslang::TType& type, glslang::T } case glslang::EvqVaryingIn: case glslang::EvqVaryingOut: - assert(type.getQualifier().layoutPacking == glslang::ElpNone); - return spv::DecorationMax; default: return spv::DecorationMax; } @@ -737,8 +734,6 @@ spv::BuiltIn TGlslangToSpvTraverser::TranslateBuiltInDecoration(glslang::TBuiltI // Translate glslang image layout format to SPIR-V image format. spv::ImageFormat TGlslangToSpvTraverser::TranslateImageFormat(const glslang::TType& type) { - assert(type.getBasicType() == glslang::EbtSampler); - // Check for capabilities switch (type.getQualifier().layoutFormat) { case glslang::ElfRg32f: @@ -1319,9 +1314,6 @@ bool TGlslangToSpvTraverser::visitBinary(glslang::TVisit /* visit */, glslang::T rValue = createBinaryOperation(node->getOp(), decorations, convertGlslangToSpvType(node->getType()), leftRValue, rValue, node->getType().getBasicType()); - - // these all need their counterparts in createBinaryOperation() - assert(rValue != spv::NoResult); } // store the result @@ -1358,7 +1350,6 @@ bool TGlslangToSpvTraverser::visitBinary(glslang::TVisit /* visit */, glslang::T // This may be, e.g., an anonymous block-member selection, which generally need // index remapping due to hidden members in anonymous blocks. std::vector& remapper = memberRemapper[node->getLeft()->getType().getStruct()]; - assert(remapper.size() > 0); spvIndex = remapper[glslangIndex]; } @@ -1588,7 +1579,6 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI spv::Id result = createBinaryOperation(op, decorations, convertGlslangToSpvType(node->getType()), operand, one, node->getType().getBasicType()); - assert(result != spv::NoResult); // The result of operation is always stored, but conditionally the // consumed result. The consumed result is always an r-value. @@ -1648,8 +1638,6 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt bool noReturnValue = false; bool atomic = false; - assert(node->getOp()); - spv::Decoration precision = TranslatePrecisionDecoration(node->getOperationPrecision()); switch (node->getOp()) { @@ -1725,7 +1713,6 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt builder.setLine(node->getLoc().line); if (node->isUserDefined()) result = handleUserFunctionCall(node); - // assert(result); // this can happen for bad shaders because the call graph completeness checking is not yet done if (result) { builder.clearAccessChain(); builder.setAccessChainRValue(result); @@ -1962,7 +1949,6 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt if (binOp != glslang::EOpNull) { glslang::TIntermTyped* left = node->getSequence()[0]->getAsTyped(); glslang::TIntermTyped* right = node->getSequence()[1]->getAsTyped(); - assert(left && right); builder.clearAccessChain(); left->traverse(this); @@ -1981,7 +1967,6 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt left->getType().getBasicType(), reduceComparison); // code above should only make binOp that exists in createBinaryOperation - assert(result != spv::NoResult); builder.clearAccessChain(); builder.setAccessChainRValue(result); @@ -2139,9 +2124,6 @@ bool TGlslangToSpvTraverser::visitSelection(glslang::TVisit /* visit */, glslang node->getBasicType() == glslang::EbtVoid) return false; - assert(node->getType() == node->getTrueBlock() ->getAsTyped()->getType() && - node->getType() == node->getFalseBlock()->getAsTyped()->getType()); - // return true if a single operand to ? : is okay for OpSelect const auto operandOkay = [](glslang::TIntermTyped* node) { return node->getAsSymbolNode() || node->getType().getQualifier().isConstant(); @@ -2553,7 +2535,6 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty switch (type.getBasicType()) { case glslang::EbtVoid: spvType = builder.makeVoidType(); - assert (! type.isArray()); break; case glslang::EbtFloat: spvType = builder.makeFloatType(32); @@ -2933,7 +2914,6 @@ spv::Id TGlslangToSpvTraverser::makeArraySizeId(const glslang::TArraySizes& arra // Otherwise, need a compile-time (front end) size, get it: int size = arraySizes.getDimSize(dim); - assert(size > 0); return builder.makeUintConstant(size); } @@ -3054,8 +3034,6 @@ void TGlslangToSpvTraverser::multiTypeStore(const glslang::TType& type, spv::Id multiTypeStore(glslangElementType, elementRValue); } } else { - assert(type.isStruct()); - // loop over structure members const glslang::TTypeList& members = *type.getStruct(); for (int m = 0; m < (int)members.size(); ++m) { @@ -3223,10 +3201,6 @@ bool TGlslangToSpvTraverser::isShaderEntryPoint(const glslang::TIntermAggregate* // qualifiers such that we should have only in/out/inout/constreadonly here. bool TGlslangToSpvTraverser::writableParam(glslang::TStorageQualifier qualifier) const { - assert(qualifier == glslang::EvqIn || - qualifier == glslang::EvqOut || - qualifier == glslang::EvqInOut || - qualifier == glslang::EvqConstReadOnly); return qualifier != glslang::EvqConstReadOnly; } @@ -3704,8 +3678,6 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO #ifdef AMD_EXTENSIONS // Check for fragment mask functions other than queries if (cracked.fragMask) { - assert(sampler.ms); - auto opIt = arguments.begin(); std::vector operands; @@ -4055,7 +4027,6 @@ spv::Id TGlslangToSpvTraverser::createBinaryOperation(glslang::TOperator op, OpD if (isFloat && (builder.isVector(left) || builder.isVector(right))) { if (builder.isVector(right)) std::swap(left, right); - assert(builder.isScalar(right)); needMatchingVectors = false; binOp = spv::OpVectorTimesScalar; } else @@ -4151,7 +4122,6 @@ spv::Id TGlslangToSpvTraverser::createBinaryOperation(glslang::TOperator op, OpD // handle mapped binary operations (should be non-comparison) if (binOp != spv::OpNop) { - assert(comparison == false); if (builder.isMatrix(left) || builder.isMatrix(right)) return createBinaryMatrixOperation(binOp, decorations, typeId, left, right); @@ -4275,19 +4245,10 @@ spv::Id TGlslangToSpvTraverser::createBinaryMatrixOperation(spv::Op op, OpDecora case spv::OpMatrixTimesScalar: if (builder.isMatrix(right)) std::swap(left, right); - assert(builder.isScalar(right)); break; case spv::OpVectorTimesMatrix: - assert(builder.isVector(left)); - assert(builder.isMatrix(right)); - break; case spv::OpMatrixTimesVector: - assert(builder.isMatrix(left)); - assert(builder.isVector(right)); - break; case spv::OpMatrixTimesMatrix: - assert(builder.isMatrix(left)); - assert(builder.isMatrix(right)); break; default: firstClass = false; @@ -4836,7 +4797,6 @@ spv::Id TGlslangToSpvTraverser::createIntWidthConversion(glslang::TOperator op, break; default: - assert(false && "Default missing"); break; } @@ -5182,7 +5142,6 @@ spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, OpDecora zero = builder.makeUint64Constant(0); break; default: - assert(false && "Default missing"); break; } zero = makeSmearedConstant(zero, vectorSize); @@ -5531,28 +5490,12 @@ spv::Id TGlslangToSpvTraverser::createInvocationsOperation(glslang::TOperator op return spv::NoResult; } - assert(opCode != spv::OpNop); return builder.createOp(opCode, typeId, spvGroupOperands); } // Create group invocation operations on a vector spv::Id TGlslangToSpvTraverser::CreateInvocationsVectorOperation(spv::Op op, spv::GroupOperation groupOperation, spv::Id typeId, std::vector& operands) { -#ifdef AMD_EXTENSIONS - assert(op == spv::OpGroupFMin || op == spv::OpGroupUMin || op == spv::OpGroupSMin || - op == spv::OpGroupFMax || op == spv::OpGroupUMax || op == spv::OpGroupSMax || - op == spv::OpGroupFAdd || op == spv::OpGroupIAdd || op == spv::OpGroupBroadcast || - op == spv::OpSubgroupReadInvocationKHR || - op == spv::OpGroupFMinNonUniformAMD || op == spv::OpGroupUMinNonUniformAMD || op == spv::OpGroupSMinNonUniformAMD || - op == spv::OpGroupFMaxNonUniformAMD || op == spv::OpGroupUMaxNonUniformAMD || op == spv::OpGroupSMaxNonUniformAMD || - op == spv::OpGroupFAddNonUniformAMD || op == spv::OpGroupIAddNonUniformAMD); -#else - assert(op == spv::OpGroupFMin || op == spv::OpGroupUMin || op == spv::OpGroupSMin || - op == spv::OpGroupFMax || op == spv::OpGroupUMax || op == spv::OpGroupSMax || - op == spv::OpGroupFAdd || op == spv::OpGroupIAdd || op == spv::OpGroupBroadcast || - op == spv::OpSubgroupReadInvocationKHR); -#endif - // Handle group invocation operations scalar by scalar. // The result type is the same type as the original type. // The algorithm is to: @@ -5994,10 +5937,10 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv:: builder.promoteScalar(precision, operands.front(), operands[2]); break; case glslang::EOpMix: - if (! builder.isBoolType(builder.getScalarTypeId(builder.getTypeId(operands.back())))) { - assert(isFloat); + if (! builder.isBoolType(builder.getScalarTypeId(builder.getTypeId(operands.back())))) libCall = spv::GLSLstd450FMix; - } else { + else + { opCode = spv::OpSelect; std::swap(operands.front(), operands.back()); } @@ -6080,7 +6023,6 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv:: case glslang::EOpFrexp: { libCall = spv::GLSLstd450FrexpStruct; - assert(builder.isPointerType(typeId1)); typeId1 = builder.getContainedTypeId(typeId1); int width = builder.getScalarTypeWidth(typeId1); #ifdef AMD_EXTENSIONS @@ -6221,7 +6163,6 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv:: break; default: // anything 3 or over doesn't have l-value operands, so all should be consumed - assert(consumedOperands == operands.size()); id = builder.createOp(opCode, typeId, operands); break; } @@ -6241,7 +6182,6 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv:: break; case glslang::EOpFrexp: { - assert(operands.size() == 2); if (builder.isFloatType(builder.getScalarTypeId(typeId1))) { // "exp" is floating-point type (from HLSL intrinsic) spv::Id member1 = builder.createCompositeExtract(id, frexpIntType, 1); @@ -6501,12 +6441,9 @@ spv::Id TGlslangToSpvTraverser::getSymbolId(const glslang::TIntermSymbol* symbol // - when running into a non-spec-constant, switch to createSpvConstant() spv::Id TGlslangToSpvTraverser::createSpvConstant(const glslang::TIntermTyped& node) { - assert(node.getQualifier().isConstant()); - // Handle front-end constants first (non-specialization constants). if (! node.getQualifier().specConstant) { // hand off to the non-spec-constant path - assert(node.getAsConstantUnion() != nullptr || node.getAsSymbolNode() != nullptr); int nextConst = 0; return createSpvConstantFromConstUnionArray(node.getType(), node.getAsConstantUnion() ? node.getAsConstantUnion()->getConstArray() : node.getAsSymbolNode()->getConstArray(), nextConst, false); diff --git a/deps/glslang/glslang/SPIRV/InReadableOrder.cpp b/deps/glslang/glslang/SPIRV/InReadableOrder.cpp index 52b29613a4..b207dbf0ec 100644 --- a/deps/glslang/glslang/SPIRV/InReadableOrder.cpp +++ b/deps/glslang/glslang/SPIRV/InReadableOrder.cpp @@ -50,7 +50,6 @@ #include "spvIR.h" -#include #include using spv::Block; @@ -68,7 +67,6 @@ public: // the branches have been completed. void visit(Block* block) { - assert(block); if (visited_.count(block) || delayed_.count(block)) return; callback_(block); diff --git a/deps/glslang/glslang/SPIRV/SPVRemapper.cpp b/deps/glslang/glslang/SPIRV/SPVRemapper.cpp index de86e9fda3..df12a5fb4f 100644 --- a/deps/glslang/glslang/SPIRV/SPVRemapper.cpp +++ b/deps/glslang/glslang/SPIRV/SPVRemapper.cpp @@ -41,7 +41,6 @@ #else // defined (use_cpp11) #include -#include #include "../glslang/Include/Common.h" namespace spv { @@ -317,8 +316,6 @@ namespace spv { if (errorLatch) return; - - assert(id != unused && id != unmapped); } ); } @@ -459,7 +456,6 @@ namespace spv { fnStart = start; fnRes = asId(start + 2); } else if (opCode == spv::Op::OpFunctionEnd) { - assert(fnRes != spv::NoResult); if (fnStart == 0) { error("function end without function start"); return false; @@ -471,12 +467,9 @@ namespace spv { if (errorLatch) return false; - assert(asId(start + 2) != spv::NoResult); typeConstPos.insert(start); - } else if (isTypeOp(opCode)) { - assert(asId(start + 1) != spv::NoResult); + } else if (isTypeOp(opCode)) typeConstPos.insert(start); - } return false; }, @@ -1230,8 +1223,6 @@ namespace spv { gdata.begin() + range.first); }; - assert(isTypeOp(opCode) || isConstOp(opCode)); - switch (opCode) { case spv::OpTypeOpaque: // TODO: disable until we compare the literal strings. case spv::OpTypeQueue: return false; diff --git a/deps/glslang/glslang/SPIRV/SpvBuilder.cpp b/deps/glslang/glslang/SPIRV/SpvBuilder.cpp index bb2761324b..fcee599af1 100755 --- a/deps/glslang/glslang/SPIRV/SpvBuilder.cpp +++ b/deps/glslang/glslang/SPIRV/SpvBuilder.cpp @@ -38,7 +38,6 @@ // SpvBuilder.h. // -#include #include #include @@ -309,8 +308,6 @@ Id Builder::makeVectorType(Id component, int size) Id Builder::makeMatrixType(Id component, int cols, int rows) { - assert(cols <= maxMatrixSize && rows <= maxMatrixSize); - Id column = makeVectorType(component, rows); // try to find it @@ -404,8 +401,6 @@ Id Builder::makeFunctionType(Id returnType, const std::vector& paramTypes) Id Builder::makeImageType(Id sampledType, Dim dim, bool depth, bool arrayed, bool ms, unsigned sampled, ImageFormat format) { - assert(sampled == 1 || sampled == 2); - // try to find it Instruction* type; for (int t = 0; t < (int)groupedTypes[OpTypeImage].size(); ++t) { @@ -507,8 +502,6 @@ Id Builder::makeSampledImageType(Id imageType) Id Builder::getDerefTypeId(Id resultId) const { Id typeId = getTypeId(resultId); - assert(isPointerType(typeId)); - return module.getInstruction(typeId)->getImmediateOperand(1); } @@ -849,8 +842,6 @@ Id Builder::makeFloat16Constant(float f16, bool specConstant) Id Builder::makeFpConstant(Id type, double d, bool specConstant) { - assert(isFloatType(type)); - switch (getScalarTypeWidth(type)) { case 16: return makeFloat16Constant((float)d, specConstant); @@ -921,7 +912,6 @@ Id Builder::findStructConstant(Id typeId, const std::vector& comps) Id Builder::makeCompositeConstant(Id typeId, const std::vector& members, bool specConstant) { Op opcode = specConstant ? OpSpecConstantComposite : OpConstantComposite; - assert(typeId); Op typeClass = getTypeClass(typeId); switch (typeClass) { @@ -1077,8 +1067,6 @@ void Builder::addMemberDecoration(Id id, unsigned int member, Decoration decorat // Comments in header Function* Builder::makeEntryPoint(const char* entryPoint) { - assert(! entryPointFunction); - Block* entry; std::vector params; std::vector> decorations; @@ -1138,7 +1126,6 @@ void Builder::leaveFunction() { Block* block = buildPoint; Function& function = buildPoint->getParent(); - assert(block); // If our function did not contain a return, add a return void now. if (! block->isTerminated()) { @@ -1214,13 +1201,11 @@ Id Builder::createAccessChain(StorageClass storageClass, Id base, const std::vec { // Figure out the final resulting type. spv::Id typeId = getTypeId(base); - assert(isPointerType(typeId) && offsets.size() > 0); typeId = getContainedTypeId(typeId); for (int i = 0; i < (int)offsets.size(); ++i) { - if (isStructType(typeId)) { - assert(isConstantScalar(offsets[i])); + if (isStructType(typeId)) typeId = getContainedTypeId(typeId, getConstantScalar(offsets[i])); - } else + else typeId = getContainedTypeId(typeId, offsets[i]); } typeId = makePointer(storageClass, typeId); @@ -1462,7 +1447,6 @@ Id Builder::createRvalueSwizzle(Decoration precision, Id typeId, Id source, cons return setPrecision(createSpecConstantOp(OpVectorShuffle, typeId, operands, channels), precision); } Instruction* swizzle = new Instruction(getUniqueId(), typeId, OpVectorShuffle); - assert(isVector(source)); swizzle->addIdOperand(source); swizzle->addIdOperand(source); for (int i = 0; i < (int)channels.size(); ++i) @@ -1480,11 +1464,8 @@ Id Builder::createLvalueSwizzle(Id typeId, Id target, Id source, const std::vect Instruction* swizzle = new Instruction(getUniqueId(), typeId, OpVectorShuffle); - assert(isVector(target)); swizzle->addIdOperand(target); - assert(getNumComponents(source) == (int)channels.size()); - assert(isVector(source)); swizzle->addIdOperand(source); // Set up an identity shuffle from the base value to the result value @@ -1521,9 +1502,6 @@ void Builder::promoteScalar(Decoration precision, Id& left, Id& right) // Comments in header Id Builder::smearScalar(Decoration precision, Id scalar, Id vectorType) { - assert(getNumComponents(scalar) == 1); - assert(getTypeId(scalar) == getScalarTypeId(vectorType)); - int numComponents = getNumTypeComponents(vectorType); if (numComponents == 1) return scalar; @@ -1850,7 +1828,6 @@ Id Builder::createCompositeCompare(Decoration precision, Id value1, Id value2, b // Scalars and Vectors if (isScalarType(valueType) || isVectorType(valueType)) { - assert(valueType == getTypeId(value2)); // These just need a single comparison, just have // to figure out what it is. Op op; @@ -1882,10 +1859,6 @@ Id Builder::createCompositeCompare(Decoration precision, Id value1, Id value2, b return setPrecision(resultId, precision); } - // Only structs, arrays, and matrices should be left. - // They share in common the reduction operation across their constituents. - assert(isAggregateType(valueType) || isMatrixType(valueType)); - // Compare each pair of constituents for (int constituent = 0; constituent < numConstituents; ++constituent) { std::vector indexes(1, constituent); @@ -1908,8 +1881,6 @@ Id Builder::createCompositeCompare(Decoration precision, Id value1, Id value2, b // OpCompositeConstruct Id Builder::createCompositeConstruct(Id typeId, const std::vector& constituents) { - assert(isAggregateType(typeId) || (getNumTypeConstituents(typeId) > 1 && getNumTypeConstituents(typeId) == (int)constituents.size())); - if (generatingOpCodeForSpecConst) { // Sometime, even in spec-constant-op mode, the constant composite to be // constructed may not be a specialization constant. @@ -2293,7 +2264,6 @@ void Builder::accessChainPushSwizzle(std::vector& swizzle, Id preSwizz std::vector oldSwizzle = accessChain.swizzle; accessChain.swizzle.resize(0); for (unsigned int i = 0; i < swizzle.size(); ++i) { - assert(swizzle[i] < oldSwizzle.size()); accessChain.swizzle.push_back(oldSwizzle[swizzle[i]]); } } else @@ -2306,15 +2276,10 @@ void Builder::accessChainPushSwizzle(std::vector& swizzle, Id preSwizz // Comments in header void Builder::accessChainStore(Id rvalue) { - assert(accessChain.isRValue == false); - transferAccessChainSwizzle(true); Id base = collapseAccessChain(); Id source = rvalue; - // dynamic component should be gone - assert(accessChain.component == NoResult); - // If swizzle still exists, it is out-of-order or not full, we must load the target vector, // extract and insert elements to perform writeMask and/or swizzle. if (accessChain.swizzle.size() > 0) { @@ -2399,18 +2364,8 @@ Id Builder::accessChainLoad(Decoration precision, Decoration nonUniform, Id resu Id Builder::accessChainGetLValue() { - assert(accessChain.isRValue == false); - transferAccessChainSwizzle(true); - Id lvalue = collapseAccessChain(); - - // If swizzle exists, it is out-of-order or not full, we must load the target vector, - // extract and insert elements to perform writeMask and/or swizzle. This does not - // go with getting a direct l-value pointer. - assert(accessChain.swizzle.size() == 0); - assert(accessChain.component == NoResult); - - return lvalue; + return collapseAccessChain(); } // comment in header @@ -2546,8 +2501,6 @@ void Builder::dump(std::vector& out) const // Can generate code. Id Builder::collapseAccessChain() { - assert(accessChain.isRValue == false); - // did we already emit an access chain for this? if (accessChain.instr != NoResult) return accessChain.instr; @@ -2641,13 +2594,11 @@ void Builder::transferAccessChainSwizzle(bool dynamic) // single component, either in the swizzle and/or dynamic component if (accessChain.swizzle.size() == 1) { - assert(accessChain.component == NoResult); // handle static component selection accessChain.indexChain.push_back(makeUintConstant(accessChain.swizzle.front())); accessChain.swizzle.clear(); accessChain.preSwizzleBaseType = NoType; } else if (dynamic && accessChain.component != NoResult) { - assert(accessChain.swizzle.size() == 0); // handle dynamic component accessChain.indexChain.push_back(accessChain.component); accessChain.preSwizzleBaseType = NoType; diff --git a/deps/glslang/glslang/SPIRV/SpvBuilder.h b/deps/glslang/glslang/SPIRV/SpvBuilder.h index 099b1d957f..af3b0c5941 100755 --- a/deps/glslang/glslang/SPIRV/SpvBuilder.h +++ b/deps/glslang/glslang/SPIRV/SpvBuilder.h @@ -179,37 +179,31 @@ public: int getScalarTypeWidth(Id typeId) const { Id scalarTypeId = getScalarTypeId(typeId); - assert(getTypeClass(scalarTypeId) == OpTypeInt || getTypeClass(scalarTypeId) == OpTypeFloat); return module.getInstruction(scalarTypeId)->getImmediateOperand(0); } int getTypeNumColumns(Id typeId) const { - assert(isMatrixType(typeId)); return getNumTypeConstituents(typeId); } int getNumColumns(Id resultId) const { return getTypeNumColumns(getTypeId(resultId)); } int getTypeNumRows(Id typeId) const { - assert(isMatrixType(typeId)); return getNumTypeComponents(getContainedTypeId(typeId)); } int getNumRows(Id resultId) const { return getTypeNumRows(getTypeId(resultId)); } Dim getTypeDimensionality(Id typeId) const { - assert(isImageType(typeId)); return (Dim)module.getInstruction(typeId)->getImmediateOperand(1); } Id getImageType(Id resultId) const { Id typeId = getTypeId(resultId); - assert(isImageType(typeId) || isSampledImageType(typeId)); return isSampledImageType(typeId) ? module.getInstruction(typeId)->getIdOperand(0) : typeId; } bool isArrayedImageType(Id typeId) const { - assert(isImageType(typeId)); return module.getInstruction(typeId)->getImmediateOperand(3) != 0; } @@ -519,7 +513,6 @@ public: // set new base as an l-value base void setAccessChainLValue(Id lValue) { - assert(isPointer(lValue)); accessChain.base = lValue; } diff --git a/deps/glslang/glslang/SPIRV/bitutils.h b/deps/glslang/glslang/SPIRV/bitutils.h index d5e61badd8..687a35e23e 100644 --- a/deps/glslang/glslang/SPIRV/bitutils.h +++ b/deps/glslang/glslang/SPIRV/bitutils.h @@ -24,8 +24,6 @@ namespace spvutils { template Dest BitwiseCast(Src source) { Dest dest; - static_assert(sizeof(source) == sizeof(dest), - "BitwiseCast: Source and destination must have the same size"); std::memcpy(static_cast(&dest), static_cast(&source), sizeof(dest)); return dest; } @@ -37,8 +35,6 @@ Dest BitwiseCast(Src source) { // a bit that will not fit in the underlying type is set. template struct SetBits { - static_assert(First < sizeof(T) * 8, - "Tried to set a bit that is shifted too far."); const static T get = (T(1) << First) | SetBits::get; }; @@ -47,35 +43,6 @@ struct SetBits { const static T get = T(0); }; -// This is all compile-time so we can put our tests right here. -static_assert(SetBits::get == uint32_t(0x00000000), - "SetBits failed"); -static_assert(SetBits::get == uint32_t(0x00000001), - "SetBits failed"); -static_assert(SetBits::get == uint32_t(0x80000000), - "SetBits failed"); -static_assert(SetBits::get == uint32_t(0x00000006), - "SetBits failed"); -static_assert(SetBits::get == uint32_t(0xc0000000), - "SetBits failed"); -static_assert(SetBits::get == uint32_t(0x7FFFFFFF), - "SetBits failed"); -static_assert(SetBits::get == uint32_t(0xFFFFFFFF), - "SetBits failed"); -static_assert(SetBits::get == uint32_t(0xFFFF0000), - "SetBits failed"); - -static_assert(SetBits::get == uint64_t(0x0000000000000001LL), - "SetBits failed"); -static_assert(SetBits::get == uint64_t(0x8000000000000000LL), - "SetBits failed"); -static_assert(SetBits::get == uint64_t(0xc000000000000000LL), - "SetBits failed"); -static_assert(SetBits::get == uint64_t(0x0000000080000000LL), - "SetBits failed"); -static_assert(SetBits::get == uint64_t(0x00000000FFFF0000LL), - "SetBits failed"); - } // namespace spvutils #endif // LIBSPIRV_UTIL_BITUTILS_H_ diff --git a/deps/glslang/glslang/SPIRV/disassemble.cpp b/deps/glslang/glslang/SPIRV/disassemble.cpp index 5e7f8f65f0..8f702fc860 100644 --- a/deps/glslang/glslang/SPIRV/disassemble.cpp +++ b/deps/glslang/glslang/SPIRV/disassemble.cpp @@ -38,7 +38,6 @@ #include #include -#include #include #include #include @@ -535,8 +534,6 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode, numOperands -= disassembleString(); break; default: - assert(operandClass >= OperandSource && operandClass < OperandOpcode); - if (OperandClassParams[operandClass].bitmask) outputMask(operandClass, stream[word++]); else diff --git a/deps/glslang/glslang/SPIRV/hex_float.h b/deps/glslang/glslang/SPIRV/hex_float.h index 905b21a45a..5cd686f50a 100644 --- a/deps/glslang/glslang/SPIRV/hex_float.h +++ b/deps/glslang/glslang/SPIRV/hex_float.h @@ -15,7 +15,6 @@ #ifndef LIBSPIRV_UTIL_HEX_FLOAT_H_ #define LIBSPIRV_UTIL_HEX_FLOAT_H_ -#include #include #include #include @@ -421,7 +420,6 @@ class HexFloat { new_value = static_cast(new_value | sign_mask); } exponent = static_cast(exponent + exponent_bias); - assert(exponent >= 0); // put it all together exponent = static_cast((exponent << exponent_left_shift) & @@ -638,11 +636,6 @@ class HexFloat { private: T value_; - - static_assert(num_used_bits == - Traits::num_exponent_bits + Traits::num_fraction_bits + 1, - "The number of bits do not fit"); - static_assert(sizeof(T) == sizeof(uint_type), "The type sizes do not match"); }; // Returns 4 bits represented by the hex character. @@ -651,15 +644,13 @@ inline uint8_t get_nibble_from_character(int character) { const char* lower = "abcdef"; const char* upper = "ABCDEF"; const char* p = nullptr; - if ((p = strchr(dec, character))) { + if ((p = strchr(dec, character))) return static_cast(p - dec); - } else if ((p = strchr(lower, character))) { + else if ((p = strchr(lower, character))) return static_cast(p - lower + 0xa); - } else if ((p = strchr(upper, character))) { + else if ((p = strchr(upper, character))) return static_cast(p - upper + 0xa); - } - assert(false && "This was called with a non-hex character"); return 0; } @@ -670,13 +661,6 @@ std::ostream& operator<<(std::ostream& os, const HexFloat& value) { typedef typename HF::uint_type uint_type; typedef typename HF::int_type int_type; - static_assert(HF::num_used_bits != 0, - "num_used_bits must be non-zero for a valid float"); - static_assert(HF::num_exponent_bits != 0, - "num_exponent_bits must be non-zero for a valid float"); - static_assert(HF::num_fraction_bits != 0, - "num_fractin_bits must be non-zero for a valid float"); - const uint_type bits = spvutils::BitwiseCast(value.value()); const char* const sign = (bits & HF::sign_mask) ? "-" : ""; const uint_type exponent = static_cast( diff --git a/deps/glslang/glslang/SPIRV/spvIR.h b/deps/glslang/glslang/SPIRV/spvIR.h index 8b6c6447f4..ad363da06c 100755 --- a/deps/glslang/glslang/SPIRV/spvIR.h +++ b/deps/glslang/glslang/SPIRV/spvIR.h @@ -49,7 +49,6 @@ #include "spirv.hpp" #include -#include #include #include #include @@ -265,7 +264,6 @@ public: void removeBlock(Block* block) { auto found = find(blocks.begin(), blocks.end(), block); - assert(found != blocks.end()); blocks.erase(found); delete block; } @@ -334,7 +332,6 @@ public: spv::Id getTypeId(Id resultId) const { return idToInstruction[resultId]->getTypeId(); } StorageClass getStorageClass(Id typeId) const { - assert(idToInstruction[typeId]->getOpCode() == spv::OpTypePointer); return (StorageClass)idToInstruction[typeId]->getImmediateOperand(0); } diff --git a/deps/glslang/glslang/glslang/Include/BaseTypes.h b/deps/glslang/glslang/glslang/Include/BaseTypes.h index 46fe159b49..523a1fe5a0 100644 --- a/deps/glslang/glslang/glslang/Include/BaseTypes.h +++ b/deps/glslang/glslang/glslang/Include/BaseTypes.h @@ -227,7 +227,7 @@ enum TBuiltInVariable { EbvPositionPerViewNV, EbvViewportMaskPerViewNV, EbvFragFullyCoveredNV, -#endif +#endif // HLSL built-ins that live only temporarily, until they get remapped // to one of the above. @@ -365,7 +365,7 @@ __inline const char* GetBuiltInVariableString(TBuiltInVariable v) case EbvPositionPerViewNV: return "PositionPerViewNV"; case EbvViewportMaskPerViewNV: return "ViewportMaskPerViewNV"; case EbvFragFullyCoveredNV: return "FragFullyCoveredNV"; -#endif +#endif default: return "unknown built-in variable"; } } @@ -453,7 +453,6 @@ __inline int getTypeRank(TBasicType type) { res = 3; break; default: - assert(false); break; } return res; diff --git a/deps/glslang/glslang/glslang/Include/Common.h b/deps/glslang/glslang/glslang/Include/Common.h index cdea6185ca..41b9253408 100644 --- a/deps/glslang/glslang/glslang/Include/Common.h +++ b/deps/glslang/glslang/glslang/Include/Common.h @@ -102,7 +102,6 @@ std::string to_string(const T& val) { #include #include #include -#include #include "PoolAlloc.h" @@ -257,13 +256,11 @@ template bool IsPow2(T powerOf2) // a power, just a number that must be a power of 2. template void RoundToPow2(T& number, int powerOf2) { - assert(IsPow2(powerOf2)); number = (number + powerOf2 - 1) & ~(powerOf2 - 1); } template bool IsMultipleOfPow2(T number, int powerOf2) { - assert(IsPow2(powerOf2)); return ! (number & (powerOf2 - 1)); } diff --git a/deps/glslang/glslang/glslang/Include/ConstantUnion.h b/deps/glslang/glslang/glslang/Include/ConstantUnion.h index 3e93340151..1860e37565 100644 --- a/deps/glslang/glslang/glslang/Include/ConstantUnion.h +++ b/deps/glslang/glslang/glslang/Include/ConstantUnion.h @@ -264,7 +264,7 @@ public: break; default: - assert(false && "Default missing"); + break; } return false; @@ -327,118 +327,97 @@ public: bool operator>(const TConstUnion& constant) const { - assert(type == constant.type); switch (type) { case EbtInt8: if (i8Const > constant.i8Const) return true; - - return false; + break; case EbtUint8: if (u8Const > constant.u8Const) return true; - - return false; + break; case EbtInt16: if (i16Const > constant.i16Const) return true; - - return false; + break; case EbtUint16: if (u16Const > constant.u16Const) return true; - - return false; + break; case EbtInt: if (iConst > constant.iConst) return true; - - return false; + break; case EbtUint: if (uConst > constant.uConst) return true; - - return false; + break; case EbtInt64: if (i64Const > constant.i64Const) return true; - - return false; + break; case EbtUint64: if (u64Const > constant.u64Const) return true; - - return false; + break; case EbtDouble: if (dConst > constant.dConst) return true; - - return false; + break; default: - assert(false && "Default missing"); - return false; + break; } + return false; } bool operator<(const TConstUnion& constant) const { - assert(type == constant.type); switch (type) { case EbtInt8: if (i8Const < constant.i8Const) return true; - - return false; + break; case EbtUint8: if (u8Const < constant.u8Const) return true; - - return false; + break; case EbtInt16: if (i16Const < constant.i16Const) return true; - - return false; + break; case EbtUint16: if (u16Const < constant.u16Const) return true; - - return false; + break; case EbtInt: if (iConst < constant.iConst) return true; - - return false; + break; case EbtUint: if (uConst < constant.uConst) return true; - - return false; + break; case EbtInt64: if (i64Const < constant.i64Const) return true; - - return false; + break; case EbtUint64: if (u64Const < constant.u64Const) return true; - - return false; + break; case EbtDouble: if (dConst < constant.dConst) return true; - - return false; + break; default: - assert(false && "Default missing"); - return false; + break; } + return false; } TConstUnion operator+(const TConstUnion& constant) const { TConstUnion returnValue; - assert(type == constant.type); switch (type) { case EbtInt8: returnValue.setI8Const(i8Const + constant.i8Const); break; case EbtInt16: returnValue.setI16Const(i16Const + constant.i16Const); break; @@ -449,7 +428,7 @@ public: case EbtUint: returnValue.setUConst(uConst + constant.uConst); break; case EbtUint64: returnValue.setU64Const(u64Const + constant.u64Const); break; case EbtDouble: returnValue.setDConst(dConst + constant.dConst); break; - default: assert(false && "Default missing"); + default: break; } return returnValue; @@ -458,7 +437,6 @@ public: TConstUnion operator-(const TConstUnion& constant) const { TConstUnion returnValue; - assert(type == constant.type); switch (type) { case EbtInt8: returnValue.setI8Const(i8Const - constant.i8Const); break; case EbtInt16: returnValue.setI16Const(i16Const - constant.i16Const); break; @@ -469,7 +447,7 @@ public: case EbtUint: returnValue.setUConst(uConst - constant.uConst); break; case EbtUint64: returnValue.setU64Const(u64Const - constant.u64Const); break; case EbtDouble: returnValue.setDConst(dConst - constant.dConst); break; - default: assert(false && "Default missing"); + default: break; } return returnValue; @@ -478,7 +456,6 @@ public: TConstUnion operator*(const TConstUnion& constant) const { TConstUnion returnValue; - assert(type == constant.type); switch (type) { case EbtInt8: returnValue.setI8Const(i8Const * constant.i8Const); break; case EbtInt16: returnValue.setI16Const(i16Const * constant.i16Const); break; @@ -489,7 +466,7 @@ public: case EbtUint: returnValue.setUConst(uConst * constant.uConst); break; case EbtUint64: returnValue.setU64Const(u64Const * constant.u64Const); break; case EbtDouble: returnValue.setDConst(dConst * constant.dConst); break; - default: assert(false && "Default missing"); + default: break; } return returnValue; @@ -498,7 +475,6 @@ public: TConstUnion operator%(const TConstUnion& constant) const { TConstUnion returnValue; - assert(type == constant.type); switch (type) { case EbtInt8: returnValue.setI8Const(i8Const % constant.i8Const); break; case EbtInt16: returnValue.setI8Const(i8Const % constant.i16Const); break; @@ -508,7 +484,7 @@ public: case EbtUint16: returnValue.setU16Const(u16Const % constant.u16Const); break; case EbtUint: returnValue.setUConst(uConst % constant.uConst); break; case EbtUint64: returnValue.setU64Const(u64Const % constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } return returnValue; @@ -528,7 +504,7 @@ public: case EbtUint: returnValue.setI8Const(i8Const >> constant.uConst); break; case EbtInt64: returnValue.setI8Const(i8Const >> constant.i64Const); break; case EbtUint64: returnValue.setI8Const(i8Const >> constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } break; case EbtUint8: @@ -541,7 +517,7 @@ public: case EbtUint: returnValue.setU8Const(u8Const >> constant.uConst); break; case EbtInt64: returnValue.setU8Const(u8Const >> constant.i64Const); break; case EbtUint64: returnValue.setU8Const(u8Const >> constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } break; case EbtInt16: @@ -554,7 +530,7 @@ public: case EbtUint: returnValue.setI16Const(i16Const >> constant.uConst); break; case EbtInt64: returnValue.setI16Const(i16Const >> constant.i64Const); break; case EbtUint64: returnValue.setI16Const(i16Const >> constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } break; case EbtUint16: @@ -567,7 +543,7 @@ public: case EbtUint: returnValue.setU16Const(u16Const >> constant.uConst); break; case EbtInt64: returnValue.setU16Const(u16Const >> constant.i64Const); break; case EbtUint64: returnValue.setU16Const(u16Const >> constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } break; case EbtInt: @@ -580,7 +556,7 @@ public: case EbtUint: returnValue.setIConst(iConst >> constant.uConst); break; case EbtInt64: returnValue.setIConst(iConst >> constant.i64Const); break; case EbtUint64: returnValue.setIConst(iConst >> constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } break; case EbtUint: @@ -593,7 +569,7 @@ public: case EbtUint: returnValue.setUConst(uConst >> constant.uConst); break; case EbtInt64: returnValue.setUConst(uConst >> constant.i64Const); break; case EbtUint64: returnValue.setUConst(uConst >> constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } break; case EbtInt64: @@ -606,7 +582,7 @@ public: case EbtUint: returnValue.setI64Const(i64Const >> constant.uConst); break; case EbtInt64: returnValue.setI64Const(i64Const >> constant.i64Const); break; case EbtUint64: returnValue.setI64Const(i64Const >> constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } break; case EbtUint64: @@ -619,10 +595,10 @@ public: case EbtUint: returnValue.setU64Const(u64Const >> constant.uConst); break; case EbtInt64: returnValue.setU64Const(u64Const >> constant.i64Const); break; case EbtUint64: returnValue.setU64Const(u64Const >> constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } break; - default: assert(false && "Default missing"); + default: break; } return returnValue; @@ -642,7 +618,7 @@ public: case EbtUint: returnValue.setI8Const(i8Const << constant.uConst); break; case EbtInt64: returnValue.setI8Const(i8Const << constant.i64Const); break; case EbtUint64: returnValue.setI8Const(i8Const << constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } break; case EbtUint8: @@ -655,7 +631,7 @@ public: case EbtUint: returnValue.setU8Const(u8Const << constant.uConst); break; case EbtInt64: returnValue.setU8Const(u8Const << constant.i64Const); break; case EbtUint64: returnValue.setU8Const(u8Const << constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } break; case EbtInt16: @@ -668,7 +644,7 @@ public: case EbtUint: returnValue.setI16Const(i16Const << constant.uConst); break; case EbtInt64: returnValue.setI16Const(i16Const << constant.i64Const); break; case EbtUint64: returnValue.setI16Const(i16Const << constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } break; case EbtUint16: @@ -681,7 +657,7 @@ public: case EbtUint: returnValue.setU16Const(u16Const << constant.uConst); break; case EbtInt64: returnValue.setU16Const(u16Const << constant.i64Const); break; case EbtUint64: returnValue.setU16Const(u16Const << constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } break; case EbtInt: @@ -694,7 +670,7 @@ public: case EbtUint: returnValue.setIConst(iConst << constant.uConst); break; case EbtInt64: returnValue.setIConst(iConst << constant.i64Const); break; case EbtUint64: returnValue.setIConst(iConst << constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } break; case EbtUint: @@ -707,7 +683,7 @@ public: case EbtUint: returnValue.setUConst(uConst << constant.uConst); break; case EbtInt64: returnValue.setUConst(uConst << constant.i64Const); break; case EbtUint64: returnValue.setUConst(uConst << constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } break; case EbtInt64: @@ -720,7 +696,7 @@ public: case EbtUint: returnValue.setI64Const(i64Const << constant.uConst); break; case EbtInt64: returnValue.setI64Const(i64Const << constant.i64Const); break; case EbtUint64: returnValue.setI64Const(i64Const << constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } break; case EbtUint64: @@ -733,10 +709,10 @@ public: case EbtUint: returnValue.setU64Const(u64Const << constant.uConst); break; case EbtInt64: returnValue.setU64Const(u64Const << constant.i64Const); break; case EbtUint64: returnValue.setU64Const(u64Const << constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } break; - default: assert(false && "Default missing"); + default: break; } return returnValue; @@ -745,7 +721,6 @@ public: TConstUnion operator&(const TConstUnion& constant) const { TConstUnion returnValue; - assert(type == constant.type); switch (type) { case EbtInt8: returnValue.setI8Const(i8Const & constant.i8Const); break; case EbtUint8: returnValue.setU8Const(u8Const & constant.u8Const); break; @@ -755,7 +730,7 @@ public: case EbtUint: returnValue.setUConst(uConst & constant.uConst); break; case EbtInt64: returnValue.setI64Const(i64Const & constant.i64Const); break; case EbtUint64: returnValue.setU64Const(u64Const & constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } return returnValue; @@ -764,7 +739,6 @@ public: TConstUnion operator|(const TConstUnion& constant) const { TConstUnion returnValue; - assert(type == constant.type); switch (type) { case EbtInt8: returnValue.setI8Const(i8Const | constant.i8Const); break; case EbtUint8: returnValue.setU8Const(u8Const | constant.u8Const); break; @@ -774,7 +748,7 @@ public: case EbtUint: returnValue.setUConst(uConst | constant.uConst); break; case EbtInt64: returnValue.setI64Const(i64Const | constant.i64Const); break; case EbtUint64: returnValue.setU64Const(u64Const | constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } return returnValue; @@ -783,7 +757,6 @@ public: TConstUnion operator^(const TConstUnion& constant) const { TConstUnion returnValue; - assert(type == constant.type); switch (type) { case EbtInt8: returnValue.setI8Const(i8Const ^ constant.i8Const); break; case EbtUint8: returnValue.setU8Const(u8Const ^ constant.u8Const); break; @@ -793,7 +766,7 @@ public: case EbtUint: returnValue.setUConst(uConst ^ constant.uConst); break; case EbtInt64: returnValue.setI64Const(i64Const ^ constant.i64Const); break; case EbtUint64: returnValue.setU64Const(u64Const ^ constant.u64Const); break; - default: assert(false && "Default missing"); + default: break; } return returnValue; @@ -811,7 +784,7 @@ public: case EbtUint: returnValue.setUConst(~uConst); break; case EbtInt64: returnValue.setI64Const(~i64Const); break; case EbtUint64: returnValue.setU64Const(~u64Const); break; - default: assert(false && "Default missing"); + default: break; } return returnValue; @@ -820,10 +793,9 @@ public: TConstUnion operator&&(const TConstUnion& constant) const { TConstUnion returnValue; - assert(type == constant.type); switch (type) { case EbtBool: returnValue.setBConst(bConst && constant.bConst); break; - default: assert(false && "Default missing"); + default: break; } return returnValue; @@ -832,10 +804,9 @@ public: TConstUnion operator||(const TConstUnion& constant) const { TConstUnion returnValue; - assert(type == constant.type); switch (type) { case EbtBool: returnValue.setBConst(bConst || constant.bConst); break; - default: assert(false && "Default missing"); + default: break; } return returnValue; @@ -917,12 +888,9 @@ public: double dot(const TConstUnionArray& rhs) { - assert(rhs.unionArray->size() == unionArray->size()); double sum = 0.0; - for (size_t comp = 0; comp < unionArray->size(); ++comp) sum += (*this)[comp].getDConst() * rhs[comp].getDConst(); - return sum; } diff --git a/deps/glslang/glslang/glslang/Include/Types.h b/deps/glslang/glslang/glslang/Include/Types.h index 39d6737cfc..5874b3e58c 100644 --- a/deps/glslang/glslang/glslang/Include/Types.h +++ b/deps/glslang/glslang/glslang/Include/Types.h @@ -187,7 +187,7 @@ struct TSampler { // misnomer now; includes images, textures without sampler, sampler == right.sampler && external == right.external && vectorSize == right.vectorSize && - structReturnIndex == right.structReturnIndex; + structReturnIndex == right.structReturnIndex; } bool operator!=(const TSampler& right) const @@ -1179,7 +1179,6 @@ public: sampler.clear(); qualifier.clear(); qualifier.storage = q; - assert(!(isMatrix() && vectorSize != 0)); // prevent vectorSize != 0 on matrices } // for explicit precision qualifier TType(TBasicType t, TStorageQualifier q, TPrecisionQualifier p, int vs = 1, int mc = 0, int mr = 0, @@ -1191,8 +1190,6 @@ public: qualifier.clear(); qualifier.storage = q; qualifier.precision = p; - assert(p >= EpqNone && p <= EpqHigh); - assert(!(isMatrix() && vectorSize != 0)); // prevent vectorSize != 0 on matrices } // for turning a TPublicType into a TType, using a shallow copy explicit TType(const TPublicType& p) : @@ -1328,13 +1325,11 @@ public: virtual void setFieldName(const TString& n) { fieldName = NewPoolTString(n.c_str()); } virtual const TString& getTypeName() const { - assert(typeName); return *typeName; } virtual const TString& getFieldName() const { - assert(fieldName); return *fieldName; } @@ -1363,9 +1358,9 @@ public: virtual bool isArray() const { return arraySizes != nullptr; } virtual bool isSizedArray() const { return isArray() && arraySizes->isSized(); } virtual bool isUnsizedArray() const { return isArray() && !arraySizes->isSized(); } - virtual bool isArrayVariablyIndexed() const { assert(isArray()); return arraySizes->isVariablyIndexed(); } - virtual void setArrayVariablyIndexed() { assert(isArray()); arraySizes->setVariablyIndexed(); } - virtual void updateImplicitArraySize(int size) { assert(isArray()); arraySizes->updateImplicitSize(size); } + virtual bool isArrayVariablyIndexed() const { return arraySizes->isVariablyIndexed(); } + virtual void setArrayVariablyIndexed() { arraySizes->setVariablyIndexed(); } + virtual void updateImplicitArraySize(int size) { arraySizes->updateImplicitSize(size); } virtual bool isStruct() const { return structure != nullptr; } virtual bool isFloatingDomain() const { return basicType == EbtFloat || basicType == EbtDouble || basicType == EbtFloat16; } virtual bool isIntegerDomain() const @@ -1487,8 +1482,6 @@ public: { // For when we may already be sharing existing array descriptors, // keeping the pointers the same, just updating the contents. - assert(arraySizes != nullptr); - assert(type.arraySizes != nullptr); *arraySizes = *type.arraySizes; } void copyArraySizes(const TArraySizes& s) @@ -1855,7 +1848,6 @@ public: // See if two type's arrayness match in everything except their outer dimension bool sameInnerArrayness(const TType& right) const { - assert(arraySizes != nullptr && right.arraySizes != nullptr); return arraySizes->sameInnerArrayness(*right.arraySizes); } diff --git a/deps/glslang/glslang/glslang/Include/arrays.h b/deps/glslang/glslang/glslang/Include/arrays.h index af8f560b3b..ab0e5761e6 100644 --- a/deps/glslang/glslang/glslang/Include/arrays.h +++ b/deps/glslang/glslang/glslang/Include/arrays.h @@ -107,21 +107,16 @@ struct TSmallArrayVector { unsigned int frontSize() const { - assert(sizes != nullptr && sizes->size() > 0); return sizes->front().size; } TIntermTyped* frontNode() const { - assert(sizes != nullptr && sizes->size() > 0); return sizes->front().node; } void changeFront(unsigned int s) { - assert(sizes != nullptr); - // this should only happen for implicitly sized arrays, not specialization constants - assert(sizes->front().node == nullptr); sizes->front().size = s; } @@ -140,7 +135,6 @@ struct TSmallArrayVector { void pop_front() { - assert(sizes != nullptr && sizes->size() > 0); if (sizes->size() == 1) dealloc(); else @@ -153,7 +147,6 @@ struct TSmallArrayVector { // one dimension.) void copyNonFront(const TSmallArrayVector& rhs) { - assert(sizes == nullptr); if (rhs.size() > 1) { alloc(); sizes->insert(sizes->begin(), rhs.sizes->begin() + 1, rhs.sizes->end()); @@ -162,20 +155,16 @@ struct TSmallArrayVector { unsigned int getDimSize(int i) const { - assert(sizes != nullptr && (int)sizes->size() > i); return (*sizes)[i].size; } void setDimSize(int i, unsigned int size) const { - assert(sizes != nullptr && (int)sizes->size() > i); - assert((*sizes)[i].node == nullptr); (*sizes)[i].size = size; } TIntermTyped* getDimNode(int i) const { - assert(sizes != nullptr && (int)sizes->size() > i); return (*sizes)[i].node; } @@ -246,7 +235,6 @@ struct TArraySizes { int size = 1; for (int d = 0; d < sizes.size(); ++d) { // this only makes sense in paths that have a known array size - assert(sizes.getDimSize(d) != UnsizedArraySize); size *= sizes.getDimSize(d); } return size; @@ -296,7 +284,6 @@ struct TArraySizes { void dereference() { sizes.pop_front(); } void copyDereferenced(const TArraySizes& rhs) { - assert(sizes.size() == 0); if (rhs.sizes.size() > 1) sizes.copyNonFront(rhs.sizes); } diff --git a/deps/glslang/glslang/glslang/MachineIndependent/Constant.cpp b/deps/glslang/glslang/glslang/MachineIndependent/Constant.cpp index 142492dc33..20eb2caf79 100644 --- a/deps/glslang/glslang/glslang/MachineIndependent/Constant.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/Constant.cpp @@ -342,7 +342,7 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TIntermTyped* right for (int i = 0; i < newComps; i++) { switch (getType().getBasicType()) { case EbtBool: newConstArray[i].setBConst((leftUnionArray[i] == rightUnionArray[i]) ? false : true); break; - default: assert(false && "Default missing"); + default: break; } } break; @@ -505,7 +505,6 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType) return 0; default: - assert(componentWise); break; } @@ -817,7 +816,7 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode) case EbtUint64: newConstArray[comp].setU64Const(std::min(childConstUnions[0][arg0comp].getU64Const(), childConstUnions[1][arg1comp].getU64Const())); break; - default: assert(false && "Default missing"); + default: break; } break; case EOpMax: @@ -851,7 +850,7 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode) case EbtUint64: newConstArray[comp].setU64Const(std::max(childConstUnions[0][arg0comp].getU64Const(), childConstUnions[1][arg1comp].getU64Const())); break; - default: assert(false && "Default missing"); + default: break; } break; case EOpClamp: @@ -894,7 +893,7 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode) newConstArray[comp].setU64Const(std::min(std::max(childConstUnions[0][arg0comp].getU64Const(), childConstUnions[1][arg1comp].getU64Const()), childConstUnions[2][arg2comp].getU64Const())); break; - default: assert(false && "Default missing"); + default: break; } break; case EOpLessThan: @@ -1077,7 +1076,6 @@ TIntermTyped* TIntermediate::foldDereference(TIntermTyped* node, int index, cons start = size * index; else { // it is a structure - assert(node->isStruct()); start = 0; for (int i = 0; i < index; ++i) start += (*node->getType().getStruct())[i].type->computeNumComponents(); diff --git a/deps/glslang/glslang/glslang/MachineIndependent/Initialize.cpp b/deps/glslang/glslang/glslang/MachineIndependent/Initialize.cpp index 43ec88a9f8..f04febe1d7 100755 --- a/deps/glslang/glslang/glslang/MachineIndependent/Initialize.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/Initialize.cpp @@ -6255,7 +6255,6 @@ void TBuiltIns::addSamplingFunctions(TSampler sampler, const TString& typeName, compare = true; totalDims = 4; } - assert(totalDims <= 4); if (extraProj && ! proj) continue; @@ -8059,7 +8058,6 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion break; default: - assert(false && "Language not supported"); break; } @@ -8568,7 +8566,7 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion break; default: - assert(false && "Language not supported"); + break; } } diff --git a/deps/glslang/glslang/glslang/MachineIndependent/Intermediate.cpp b/deps/glslang/glslang/glslang/MachineIndependent/Intermediate.cpp index 6dbc40bd03..50d3da3a0b 100644 --- a/deps/glslang/glslang/glslang/MachineIndependent/Intermediate.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/Intermediate.cpp @@ -1582,10 +1582,8 @@ static bool canSignedIntTypeRepresentAllUnsignedValues(TBasicType sintType, TBas case EbtUint16: case EbtUint: case EbtUint64: - return false; default: - assert(false); - return false; + break; } break; case EbtInt16: @@ -1595,10 +1593,8 @@ static bool canSignedIntTypeRepresentAllUnsignedValues(TBasicType sintType, TBas case EbtUint16: case EbtUint: case EbtUint64: - return false; default: - assert(false); - return false; + break; } break; case EbtInt: @@ -1607,10 +1603,8 @@ static bool canSignedIntTypeRepresentAllUnsignedValues(TBasicType sintType, TBas case EbtUint16: return true; case EbtUint: - return false; default: - assert(false); - return false; + break; } break; case EbtInt64: @@ -1620,16 +1614,14 @@ static bool canSignedIntTypeRepresentAllUnsignedValues(TBasicType sintType, TBas case EbtUint: return true; case EbtUint64: - return false; default: - assert(false); - return false; + break; } break; default: - assert(false); - return false; + break; } + return false; } @@ -1644,9 +1636,9 @@ static TBasicType getCorrespondingUnsignedType(TBasicType type) { case EbtInt64: return EbtUint64; default: - assert(false); - return EbtNumTypes; + break; } + return EbtNumTypes; } // Implements the following rules @@ -2363,8 +2355,6 @@ TIntermConstantUnion* TIntermediate::addConstantUnion(bool b, const TSourceLoc& TIntermConstantUnion* TIntermediate::addConstantUnion(double d, TBasicType baseType, const TSourceLoc& loc, bool literal) const { - assert(baseType == EbtFloat || baseType == EbtDouble || baseType == EbtFloat16); - TConstUnionArray unionArray(1); unionArray[0].setDConst(d); @@ -3742,7 +3732,6 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC void TIntermAggregate::setPragmaTable(const TPragmaTable& pTable) { - assert(pragmaTable == nullptr); pragmaTable = new TPragmaTable; *pragmaTable = pTable; } @@ -3768,8 +3757,6 @@ struct TextureUpgradeAndSamplerRemovalTransform : public TIntermTraverser { TQualifierList& qual = ag->getQualifierList(); // qual and seq are indexed using the same indices, so we have to modify both in lock-step - assert(seq.size() == qual.size() || qual.empty()); - size_t write = 0; for (size_t i = 0; i < seq.size(); ++i) { TIntermSymbol* symbol = seq[i]->getAsSymbolNode(); diff --git a/deps/glslang/glslang/glslang/MachineIndependent/ParseContextBase.cpp b/deps/glslang/glslang/glslang/MachineIndependent/ParseContextBase.cpp index bfa9de4dff..2e5d9343b0 100644 --- a/deps/glslang/glslang/glslang/MachineIndependent/ParseContextBase.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/ParseContextBase.cpp @@ -283,8 +283,6 @@ TVariable* TParseContextBase::getEditableVariable(const char* name) { bool builtIn; TSymbol* symbol = symbolTable.find(name, &builtIn); - - assert(symbol != nullptr); if (symbol == nullptr) return nullptr; diff --git a/deps/glslang/glslang/glslang/MachineIndependent/ParseHelper.cpp b/deps/glslang/glslang/glslang/MachineIndependent/ParseHelper.cpp index 583974f930..a33a93a9c7 100755 --- a/deps/glslang/glslang/glslang/MachineIndependent/ParseHelper.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/ParseHelper.cpp @@ -491,8 +491,6 @@ void TParseContext::fixIoArraySize(const TSourceLoc& loc, TType& type) if (! type.isArray() || type.getQualifier().patch || symbolTable.atBuiltInLevel()) return; - assert(! isIoResizeArray(type)); - if (type.getQualifier().storage != EvqVaryingIn || type.getQualifier().patch) return; @@ -526,7 +524,6 @@ void TParseContext::ioArrayCheck(const TSourceLoc& loc, const TType& type, const void TParseContext::handleIoResizeArrayAccess(const TSourceLoc& /*loc*/, TIntermTyped* base) { TIntermSymbol* symbolNode = base->getAsSymbolNode(); - assert(symbolNode); if (! symbolNode) return; @@ -1395,7 +1392,6 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan if (argp->size() > 0) arg0 = (*argp)[0]->getAsTyped(); } else { - assert(callNode.getAsUnaryNode()); unaryArg = callNode.getAsUnaryNode()->getOperand(); arg0 = unaryArg; } @@ -1727,8 +1723,6 @@ void TParseContext::nonOpBuiltInCheck(const TSourceLoc& loc, const TFunction& fn // If PureOperatorBuiltins == true, then all built-ins should be mapped // to a TOperator, and this function would then never get called. - assert(PureOperatorBuiltins == false); - // built-in texturing functions get their return value precision from the precision of the sampler if (fnCandidate.getType().getQualifier().precision == EpqNone && fnCandidate.getParamCount() > 0 && fnCandidate[0].type->getBasicType() == EbtSampler) @@ -2969,8 +2963,6 @@ int TParseContext::computeSamplerTypeIndex(TSampler& sampler) int flattened = EsdNumDims * (EbtNumTypes * (2 * (2 * (2 * (2 * arrayIndex + msIndex) + imageIndex) + shadowIndex) + externalIndex) + sampler.type) + sampler.dim; - assert(flattened < maxSamplerIndex); - return flattened; } @@ -3136,8 +3128,6 @@ void TParseContext::structArrayCheck(const TSourceLoc& /*loc*/, const TType& typ void TParseContext::arraySizesCheck(const TSourceLoc& loc, const TQualifier& qualifier, TArraySizes* arraySizes, const TIntermTyped* initializer, bool lastMember) { - assert(arraySizes); - // always allow special built-in ins/outs sized to topologies if (parsingBuiltins) return; @@ -3945,9 +3935,7 @@ void TParseContext::arrayLimitCheck(const TSourceLoc& loc, const TString& identi void TParseContext::limitCheck(const TSourceLoc& loc, int value, const char* limit, const char* feature) { TSymbol* symbol = symbolTable.find(limit); - assert(symbol->getAsVariable()); const TConstUnionArray& constArray = symbol->getAsVariable()->getConstArray(); - assert(! constArray.empty()); if (value > constArray[0].getIConst()) error(loc, "must be less than or equal to", feature, "%s (%d)", limit, constArray[0].getIConst()); } @@ -4112,8 +4100,6 @@ void TParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& publi } #endif } else { - assert(language == EShLangTessEvaluation); - // input primitive if (id == TQualifier::getGeometryString(ElgTriangles)) { publicType.shaderQualifiers.geometry = ElgTriangles; @@ -5598,7 +5584,6 @@ TIntermNode* TParseContext::executeInitializer(const TSourceLoc& loc, TIntermTyp // We either have a folded constant in getAsConstantUnion, or we have to use // the initializer's subtree in the AST to represent the computation of a // specialization constant. - assert(initializer->getAsConstantUnion() || initializer->getType().getQualifier().isSpecConstant()); if (initializer->getAsConstantUnion()) variable->setConstArray(initializer->getAsConstantUnion()->getConstArray()); else { @@ -6487,7 +6472,6 @@ void TParseContext::invariantCheck(const TSourceLoc& loc, const TQualifier& qual void TParseContext::updateStandaloneQualifierDefaults(const TSourceLoc& loc, const TPublicType& publicType) { if (publicType.shaderQualifiers.vertices != TQualifier::layoutNotSet) { - assert(language == EShLangTessControl || language == EShLangGeometry); const char* id = (language == EShLangTessControl) ? "vertices" : "max_vertices"; if (publicType.qualifier.storage != EvqVaryingOut) diff --git a/deps/glslang/glslang/glslang/MachineIndependent/ShaderLang.cpp b/deps/glslang/glslang/glslang/MachineIndependent/ShaderLang.cpp index 7c04b1820a..49327020de 100644 --- a/deps/glslang/glslang/glslang/MachineIndependent/ShaderLang.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/ShaderLang.cpp @@ -131,9 +131,6 @@ int MapVersionToIndex(int version) case 460: index = 16; break; default: break; } - - assert(index < VersionCount); - return index; } @@ -147,9 +144,6 @@ int MapSpvVersionToIndex(const SpvVersion& spvVersion) index = 1; else if (spvVersion.vulkan > 0) index = 2; - - assert(index < SpvVersionCount); - return index; } @@ -166,9 +160,6 @@ int MapProfileToIndex(EProfile profile) case EEsProfile: index = 3; break; default: break; } - - assert(index < ProfileCount); - return index; } @@ -183,9 +174,6 @@ int MapSourceToIndex(EShSource source) case EShSourceHlsl: index = 1; break; default: break; } - - assert(index < SourceCount); - return index; } @@ -866,7 +854,6 @@ bool ProcessDeferred( strings[1] = customPreamble; lengths[1] = strlen(strings[1]); names[1] = nullptr; - assert(2 == numPre); if (requireNonempty) { const int postIndex = numStrings + numPre; strings[postIndex] = "\n int;"; @@ -1253,7 +1240,6 @@ int __fastcall ShFinalize() { glslang::GetGlobalLock(); --NumberOfClients; - assert(NumberOfClients >= 0); bool finalize = NumberOfClients == 0; glslang::ReleaseGlobalLock(); if (! finalize) diff --git a/deps/glslang/glslang/glslang/MachineIndependent/SymbolTable.cpp b/deps/glslang/glslang/glslang/MachineIndependent/SymbolTable.cpp index 59552b987d..608f32fecd 100644 --- a/deps/glslang/glslang/glslang/MachineIndependent/SymbolTable.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/SymbolTable.cpp @@ -289,7 +289,6 @@ TVariable::TVariable(const TVariable& copyOf) : TSymbol(copyOf) setExtensions(copyOf.numExtensions, copyOf.extensions); if (! copyOf.constArray.empty()) { - assert(! copyOf.type.isStruct()); TConstUnionArray newArray(copyOf.constArray, 0, copyOf.constArray.size()); constArray = newArray; } @@ -368,8 +367,6 @@ TSymbolTableLevel* TSymbolTableLevel::clone() const void TSymbolTable::copyTable(const TSymbolTable& copyOf) { - assert(adoptedLevels == copyOf.adoptedLevels); - uniqueId = copyOf.uniqueId; noBuiltInRedeclarations = copyOf.noBuiltInRedeclarations; separateNameSpaces = copyOf.separateNameSpaces; diff --git a/deps/glslang/glslang/glslang/MachineIndependent/SymbolTable.h b/deps/glslang/glslang/glslang/MachineIndependent/SymbolTable.h index f928b7aedf..dc9cbc7e55 100644 --- a/deps/glslang/glslang/glslang/MachineIndependent/SymbolTable.h +++ b/deps/glslang/glslang/glslang/MachineIndependent/SymbolTable.h @@ -105,8 +105,6 @@ public: virtual int getUniqueId() const { return uniqueId; } virtual void setExtensions(int num, const char* const exts[]) { - assert(extensions == 0); - assert(num > 0); numExtensions = num; extensions = NewPoolObject(exts[0], num); for (int e = 0; e < num; ++e) @@ -161,10 +159,10 @@ public: virtual TVariable* getAsVariable() { return this; } virtual const TVariable* getAsVariable() const { return this; } virtual const TType& getType() const { return type; } - virtual TType& getWritableType() { assert(writable); return type; } + virtual TType& getWritableType() { return type; } virtual bool isUserType() const { return userType; } virtual const TConstUnionArray& getConstArray() const { return constArray; } - virtual TConstUnionArray& getWritableConstArray() { assert(writable); return constArray; } + virtual TConstUnionArray& getWritableConstArray() { return constArray; } virtual void setConstArray(const TConstUnionArray& array) { constArray = array; } virtual void setConstSubtree(TIntermTyped* subtree) { constSubtree = subtree; } virtual TIntermTyped* getConstSubtree() const { return constSubtree; } @@ -239,7 +237,6 @@ public: // mangled name. virtual void addParameter(TParameter& p) { - assert(writable); parameters.push_back(p); p.type->appendMangledName(mangledName); @@ -264,7 +261,6 @@ public: virtual void removePrefix(const TString& prefix) { - assert(mangledName.compare(0, prefix.size(), prefix) == 0); mangledName.erase(0, prefix.size()); } @@ -272,15 +268,15 @@ public: virtual const TType& getType() const override { return returnType; } virtual TBuiltInVariable getDeclaredBuiltInType() const { return declaredBuiltIn; } virtual TType& getWritableType() override { return returnType; } - virtual void relateToOperator(TOperator o) { assert(writable); op = o; } + virtual void relateToOperator(TOperator o) { op = o; } virtual TOperator getBuiltInOp() const { return op; } - virtual void setDefined() { assert(writable); defined = true; } + virtual void setDefined() { defined = true; } virtual bool isDefined() const { return defined; } - virtual void setPrototyped() { assert(writable); prototyped = true; } + virtual void setPrototyped() { prototyped = true; } virtual bool isPrototyped() const { return prototyped; } - virtual void setImplicitThis() { assert(writable); implicitThis = true; } + virtual void setImplicitThis() { implicitThis = true; } virtual bool hasImplicitThis() const { return implicitThis; } - virtual void setIllegalImplicitThis() { assert(writable); illegalImplicitThis = true; } + virtual void setIllegalImplicitThis() { illegalImplicitThis = true; } virtual bool hasIllegalImplicitThis() const { return illegalImplicitThis; } // Return total number of parameters @@ -290,7 +286,7 @@ public: // Return number of fixed parameters (without default values) virtual int getFixedParamCount() const { return getParamCount() - getDefaultParamCount(); } - virtual TParameter& operator[](int i) { assert(writable); return parameters[i]; } + virtual TParameter& operator[](int i) { return parameters[i]; } virtual const TParameter& operator[](int i) const { return parameters[i]; } virtual void dump(TInfoSink &infoSink) const override; @@ -340,7 +336,6 @@ public: virtual TType& getWritableType() { - assert(writable); const TTypeList& types = *anonContainer.getType().getStruct(); return *types[memberNumber].type; } @@ -598,7 +593,6 @@ public: // symbol finds. void pushThis(TSymbol& thisSymbol) { - assert(thisSymbol.getName().size() == 0); table.push_back(new TSymbolTableLevel); table.back()->setThisLevel(); insert(thisSymbol); @@ -670,7 +664,6 @@ public: return copy; } else { const TAnonMember* anon = shared->getAsAnonMember(); - assert(anon); TVariable* container = anon->getAnonContainer().clone(); container->changeName(NewPoolTString("")); container->setUniqueId(anon->getAnonContainer().getUniqueId()); diff --git a/deps/glslang/glslang/glslang/MachineIndependent/intermOut.cpp b/deps/glslang/glslang/glslang/MachineIndependent/intermOut.cpp index fc75964fa1..4f8d0f6fcb 100755 --- a/deps/glslang/glslang/glslang/MachineIndependent/intermOut.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/intermOut.cpp @@ -1112,7 +1112,6 @@ static void OutputDouble(TInfoSink& out, double value, TOutputTraverser::EExtraO if (fabs(value) > 0.0 && (fabs(value) < 1e-5 || fabs(value) > 1e12)) format = "%-.13e"; int len = snprintf(buf, maxSize, format, value); - assert(len < maxSize); // remove a leading zero in the 100s slot in exponent; it is not portable // pattern: XX...XXXe+0XX or XX...XXXe-0XX diff --git a/deps/glslang/glslang/glslang/MachineIndependent/linkValidate.cpp b/deps/glslang/glslang/glslang/MachineIndependent/linkValidate.cpp index 3e4b5cedb6..2457cc8b00 100644 --- a/deps/glslang/glslang/glslang/MachineIndependent/linkValidate.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/linkValidate.cpp @@ -235,7 +235,6 @@ void TIntermediate::mergeLinkerObjects(TInfoSink& infoSink, TIntermSequence& lin for (std::size_t linkObj = 0; linkObj < initialNumLinkerObjects; ++linkObj) { TIntermSymbol* symbol = linkerObjects[linkObj]->getAsSymbolNode(); TIntermSymbol* unitSymbol = unitLinkerObjects[unitLinkObj]->getAsSymbolNode(); - assert(symbol && unitSymbol); if (symbol->getName() == unitSymbol->getName()) { // filter out copy merge = false; @@ -720,10 +719,6 @@ TIntermSequence& TIntermediate::findLinkerObjects() const { // Get the top-level globals TIntermSequence& globals = treeRoot->getAsAggregate()->getSequence(); - - // Get the last member of the sequences, expected to be the linker-object lists - assert(globals.back()->getAsAggregate()->getOp() == EOpLinkerObjects); - return globals.back()->getAsAggregate()->getSequence(); } @@ -1008,7 +1003,6 @@ int TIntermediate::addXfbBufferOffset(const TType& type) { const TQualifier& qualifier = type.getQualifier(); - assert(qualifier.hasXfbOffset() && qualifier.hasXfbBuffer()); TXfbBuffer& buffer = xfbBuffers[qualifier.layoutXfbBuffer]; // compute the range @@ -1044,7 +1038,6 @@ unsigned int TIntermediate::computeTypeXfbSize(const TType& type, bool& contains if (type.isArray()) { // TODO: perf: this can be flattened by using getCumulativeArraySize(), and a deref that discards all arrayness - assert(type.isSizedArray()); TType elementType(type, 0); return type.getOuterArraySize() * computeTypeXfbSize(elementType, containsDouble); } diff --git a/deps/glslang/glslang/glslang/MachineIndependent/localintermediate.h b/deps/glslang/glslang/glslang/MachineIndependent/localintermediate.h index f3a0e413e2..5206c0c6c1 100755 --- a/deps/glslang/glslang/glslang/MachineIndependent/localintermediate.h +++ b/deps/glslang/glslang/glslang/MachineIndependent/localintermediate.h @@ -70,13 +70,11 @@ public: } void resize(int s) { - assert(s <= size_); size_ = s; } int size() const { return size_; } selectorType operator[](int i) const { - assert(i < MaxSwizzleSelectors); return components[i]; } diff --git a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/Pp.cpp b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/Pp.cpp index 6a2ab91904..e3b9dc95b3 100644 --- a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/Pp.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/Pp.cpp @@ -855,7 +855,6 @@ int TPpContext::CPPextension(TPpToken* ppToken) if (token != PpAtomIdentifier) _parseContext.ppError(ppToken->loc, "extension name expected", "#extension", ""); - assert(strlen(ppToken->name) <= MaxTokenLength); strcpy(extensionName, ppToken->name); token = scanToken(ppToken); @@ -1063,7 +1062,6 @@ int TPpContext::tMacroInput::scan(TPpToken* ppToken) if (prepaste) { // already know we should be on a ##, verify - assert(token == PpAtomPaste); prepaste = false; postpaste = true; } diff --git a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpAtom.cpp b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpAtom.cpp index 06c2333ef1..8d71dc9b8c 100644 --- a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpAtom.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpAtom.cpp @@ -80,7 +80,6 @@ NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define _CRT_SECURE_NO_WARNINGS #endif -#include #include #include diff --git a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.cpp b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.cpp index 83c9d7e8e1..7e60921937 100755 --- a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpContext.cpp @@ -107,8 +107,6 @@ TPpContext::~TPpContext() void TPpContext::setInput(TInputScanner& input, bool versionWillBeError) { - assert(inputStack.size() == 0); - pushInput(new tStringInput(this, input)); errorOnVersion = versionWillBeError; diff --git a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpScanner.cpp b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpScanner.cpp index c73d74178d..1c587f980e 100755 --- a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpScanner.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpScanner.cpp @@ -666,7 +666,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) #ifdef AMD_EXTENSIONS nextCh = getch(); - if ((nextCh == 's' || nextCh == 'S') && + if ((nextCh == 's' || nextCh == 'S') && pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { if (len < MaxTokenLength) ppToken->name[len++] = (char)nextCh; @@ -679,7 +679,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken) ppToken->name[len++] = (char)ch; isInt64 = true; #ifdef AMD_EXTENSIONS - } else if ((ch == 's' || ch == 'S') && + } else if ((ch == 's' || ch == 'S') && pp->_parseContext.intermediate.getSource() == EShSourceGlsl) { if (len < MaxTokenLength) ppToken->name[len++] = (char)ch; @@ -1118,7 +1118,6 @@ int TPpContext::tokenPaste(int token, TPpToken& ppToken) // next token has to be ## token = scanToken(&pastedPpToken); - assert(token == PpAtomPaste); // This covers end of macro expansion if (endOfReplacementList()) { diff --git a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp index 0f84773050..d20bbe70b8 100755 --- a/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp @@ -89,7 +89,6 @@ NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #endif #endif -#include #include #include #include @@ -176,7 +175,6 @@ void TPpContext::TokenStream::ungetSubtoken() void TPpContext::TokenStream::putToken(int atom, TPpToken* ppToken) { // save the atom - assert((atom & ~0xff) == 0); putSubtoken(static_cast(atom)); // save the backing name string diff --git a/deps/glslang/glslang/glslang/MachineIndependent/propagateNoContraction.cpp b/deps/glslang/glslang/glslang/MachineIndependent/propagateNoContraction.cpp index ae95688ae8..1ee780a0b1 100644 --- a/deps/glslang/glslang/glslang/MachineIndependent/propagateNoContraction.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/propagateNoContraction.cpp @@ -131,7 +131,6 @@ bool isAssignOperation(glslang::TOperator op) // Note the node should only hold a uint scalar. unsigned getStructIndexFromConstantUnion(glslang::TIntermTyped* node) { - assert(node->getAsConstantUnion() && node->getAsConstantUnion()->isScalar()); unsigned struct_dereference_index = node->getAsConstantUnion()->getConstArray()[0].getUConst(); return struct_dereference_index; } @@ -333,7 +332,6 @@ bool TSymbolDefinitionCollectingTraverser::visitUnary(glslang::TVisit /* visit * node->getOperand()->traverse(this); if (isAssignOperation(node->getOp())) { // We should always be able to get an access chain of the operand node. - assert(!current_object_.empty()); // If the operand node object is 'precise', we collect its access chain // for the initial set of 'precise' objects. @@ -365,7 +363,6 @@ bool TSymbolDefinitionCollectingTraverser::visitBinary(glslang::TVisit /* visit if (isAssignOperation(node->getOp())) { // We should always be able to get an access chain for the left node. - assert(!current_object_.empty()); // If the left node object is 'precise', it is an initial precise object // specified in the shader source. Adds it to the initial work list to @@ -485,22 +482,19 @@ public: getPrecisenessAndRemainedAccessChain(glslang::TIntermOperator* node, const ObjectAccessChain& precise_object) { - assert(isAssignOperation(node->getOp())); precise_object_ = &precise_object; ObjectAccessChain assignee_object; if (glslang::TIntermBinary* BN = node->getAsBinaryNode()) { // This is a binary assignment node, we need to check the // preciseness of the left node. - assert(accesschain_mapping_.count(BN->getLeft())); // The left node (assignee node) is an object node, traverse the // node to let the 'precise' of nesting objects being transfered to // nested objects. BN->getLeft()->traverse(this); // After traversing the left node, if the left node is 'precise', // we can conclude this assignment should propagate 'precise'. - if (isPreciseObjectNode(BN->getLeft())) { + if (isPreciseObjectNode(BN->getLeft())) return make_tuple(true, ObjectAccessChain()); - } // If the preciseness of the left node (assignee node) can not // be determined by now, we need to compare the access chain string // of the assignee object with the given precise object. @@ -510,7 +504,7 @@ public: // This is a unary assignment node, we need to check the // preciseness of the operand node. For unary assignment node, the // operand node should always be an object node. - assert(accesschain_mapping_.count(UN->getOperand())); + // Traverse the operand node to let the 'precise' being propagated // from lower nodes to upper nodes. UN->getOperand()->traverse(this); @@ -523,9 +517,6 @@ public: // be determined by now, we need to compare the access chain string // of the assignee object with the given precise object. assignee_object = accesschain_mapping_.at(UN->getOperand()); - } else { - // Not a binary or unary node, should not happen. - assert(false); } // Compare the access chain string of the assignee node with the given @@ -578,16 +569,15 @@ bool TNoContractionAssigneeCheckingTraverser::visitBinary(glslang::TVisit, // accesschain_mapping_. if (accesschain_mapping_.count(node)) { // A binary object node must be a dereference node. - assert(isDereferenceOperation(node->getOp())); + // If the left node is 'precise', this node should also be precise, // otherwise, compare with the given precise_object_. If the // access chain of this node matches with the given precise_object_, // this node should be marked as 'precise'. - if (isPreciseObjectNode(node->getLeft())) { + if (isPreciseObjectNode(node->getLeft())) node->getWritableType().getQualifier().noContraction = true; - } else if (accesschain_mapping_.at(node) == *precise_object_) { + else if (accesschain_mapping_.at(node) == *precise_object_) node->getWritableType().getQualifier().noContraction = true; - } } return false; } @@ -598,10 +588,8 @@ void TNoContractionAssigneeCheckingTraverser::visitSymbol(glslang::TIntermSymbol { // A symbol node should always be an object node, and should have been added // to the map from object nodes to their access chain strings. - assert(accesschain_mapping_.count(node)); - if (accesschain_mapping_.at(node) == *precise_object_) { + if (accesschain_mapping_.at(node) == *precise_object_) node->getWritableType().getQualifier().noContraction = true; - } } // @@ -630,17 +618,13 @@ public: { remained_accesschain_ = assignee_remained_accesschain; if (glslang::TIntermBinary* BN = defining_node->getAsBinaryNode()) { - assert(isAssignOperation(BN->getOp())); BN->getRight()->traverse(this); - if (isArithmeticOperation(BN->getOp())) { + if (isArithmeticOperation(BN->getOp())) BN->getWritableType().getQualifier().noContraction = true; - } } else if (glslang::TIntermUnary* UN = defining_node->getAsUnaryNode()) { - assert(isAssignOperation(UN->getOp())); UN->getOperand()->traverse(this); - if (isArithmeticOperation(UN->getOp())) { + if (isArithmeticOperation(UN->getOp())) UN->getWritableType().getQualifier().noContraction = true; - } } } @@ -648,7 +632,6 @@ public: void propagateNoContractionInReturnNode(glslang::TIntermBranch* return_node) { remained_accesschain_ = ""; - assert(return_node->getFlowOp() == glslang::EOpReturn && return_node->getExpression()); return_node->getExpression()->traverse(this); } @@ -675,7 +658,6 @@ protected: // Gets the node pointed by the access chain index extracted before. glslang::TIntermTyped* potential_precise_node = node->getSequence()[precise_accesschain_index]->getAsTyped(); - assert(potential_precise_node); // Pop the front access chain index from the path, and visit the nested node. { ObjectAccessChain next_level_accesschain = @@ -745,17 +727,15 @@ protected: { // Symbol nodes are object nodes and should always have an // access chain collected before matches with it. - assert(accesschain_mapping_.count(node)); ObjectAccessChain new_precise_accesschain = accesschain_mapping_.at(node); // If the unused access chain is empty, this symbol node should be // marked as 'precise'. Otherwise, the unused access chain should be // appended to the symbol ID to build a new access chain which points to // the nested 'precise' object in this symbol object. - if (remained_accesschain_.empty()) { + if (remained_accesschain_.empty()) node->getWritableType().getQualifier().noContraction = true; - } else { + else new_precise_accesschain += ObjectAccesschainDelimiter + remained_accesschain_; - } // Add the new 'precise' access chain to the work list and make sure we // don't visit it again. if (!added_precise_object_ids_.count(new_precise_accesschain)) { diff --git a/deps/glslang/glslang/glslang/MachineIndependent/reflection.cpp b/deps/glslang/glslang/glslang/MachineIndependent/reflection.cpp index dbf55a8175..cd61057088 100644 --- a/deps/glslang/glslang/glslang/MachineIndependent/reflection.cpp +++ b/deps/glslang/glslang/glslang/MachineIndependent/reflection.cpp @@ -306,8 +306,6 @@ public: if (base->getType().isArray()) { TType derefType(base->getType(), 0); - - assert(! anonymous); for (int e = 0; e < base->getType().getCumulativeArraySize(); ++e) blockIndex = addBlockName(blockName + "[" + String(e) + "]", derefType, getBlockSize(base->getType())); diff --git a/deps/glslang/glslang/glslang/OSDependent/Windows/ossource.cpp b/deps/glslang/glslang/glslang/OSDependent/Windows/ossource.cpp index 0bf25e7e57..6c30865fa0 100644 --- a/deps/glslang/glslang/glslang/OSDependent/Windows/ossource.cpp +++ b/deps/glslang/glslang/glslang/OSDependent/Windows/ossource.cpp @@ -38,7 +38,6 @@ #define STRICT #define VC_EXTRALEAN 1 #include -#include #include #include #include @@ -86,7 +85,6 @@ bool OS_SetTLSValue(OS_TLSIndex nIndex, void *lpvValue) void* OS_GetTLSValue(OS_TLSIndex nIndex) { - assert(nIndex != OS_INVALID_TLS_INDEX); return TlsGetValue(ToNativeTLSIndex(nIndex)); }