// // Recursively generate mangled names. // void TType::buildMangledName(TString& mangledName) { if (isMatrix()) mangledName += 'm'; else if (isVector()) mangledName += 'v'; switch (basicType) { case EbtFloat: mangledName += 'f'; break; case EbtDouble: mangledName += 'd'; break; case EbtInt: mangledName += 'i'; break; case EbtUint: mangledName += 'u'; break; case EbtBool: mangledName += 'b'; break; case EbtSampler: switch (sampler.type) { case EbtInt: mangledName += "i"; break; case EbtUint: mangledName += "u"; break; default: break; // some compilers want this } if (sampler.image) mangledName += "I"; else mangledName += "s"; if (sampler.arrayed) mangledName += "A"; if (sampler.shadow) mangledName += "S"; switch (sampler.dim) { case Esd1D: mangledName += "1"; break; case Esd2D: mangledName += "2"; break; case Esd3D: mangledName += "3"; break; case EsdCube: mangledName += "C"; break; case EsdRect: mangledName += "R2"; break; case EsdBuffer: mangledName += "B"; break; default: break; // some compilers want this } break; case EbtStruct: mangledName += "struct-"; if (typeName) mangledName += *typeName; for (unsigned int i = 0; i < structure->size(); ++i) { mangledName += '-'; (*structure)[i].type->buildMangledName(mangledName); } default: break; } if (getVectorSize() > 0) mangledName += static_cast<char>('0' + getVectorSize()); else { mangledName += static_cast<char>('0' + getMatrixCols()); mangledName += static_cast<char>('0' + getMatrixRows()); } if (arraySizes) { const int maxSize = 11; char buf[maxSize]; snprintf(buf, maxSize, "%d", arraySizes->sizes.front()); mangledName += '['; mangledName += buf; mangledName += ']'; } }
// // Recursively generate mangled names. // void TType::buildMangledName(TString& mangledName) const { if (isMatrix()) mangledName += 'm'; else if (isVector()) mangledName += 'v'; switch (basicType) { case EbtFloat: mangledName += 'f'; break; case EbtDouble: mangledName += 'd'; break; #ifdef AMD_EXTENSIONS case EbtFloat16: mangledName += "f16"; break; #endif case EbtInt: mangledName += 'i'; break; 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: switch (sampler.type) { case EbtInt: mangledName += "i"; break; case EbtUint: mangledName += "u"; break; default: break; // some compilers want this } if (sampler.image) mangledName += "I"; // a normal image else if (sampler.sampler) mangledName += "p"; // a "pure" sampler else if (!sampler.combined) mangledName += "t"; // a "pure" texture else mangledName += "s"; // traditional combined sampler if (sampler.arrayed) mangledName += "A"; if (sampler.shadow) mangledName += "S"; if (sampler.external) mangledName += "E"; switch (sampler.dim) { case Esd1D: mangledName += "1"; break; case Esd2D: mangledName += "2"; break; case Esd3D: mangledName += "3"; break; case EsdCube: mangledName += "C"; break; case EsdRect: mangledName += "R2"; break; case EsdBuffer: mangledName += "B"; break; case EsdSubpass: mangledName += "P"; break; default: break; // some compilers want this } switch (sampler.vectorSize) { case 1: mangledName += "1"; break; case 2: mangledName += "2"; break; case 3: mangledName += "3"; break; case 4: break; // default to prior name mangle behavior } if (sampler.ms) mangledName += "M"; break; case EbtStruct: case EbtBlock: if (basicType == EbtStruct) mangledName += "struct-"; else mangledName += "block-"; if (typeName) mangledName += *typeName; for (unsigned int i = 0; i < structure->size(); ++i) { mangledName += '-'; (*structure)[i].type->buildMangledName(mangledName); } default: break; } if (getVectorSize() > 0) mangledName += static_cast<char>('0' + getVectorSize()); else { mangledName += static_cast<char>('0' + getMatrixCols()); mangledName += static_cast<char>('0' + getMatrixRows()); } if (arraySizes) { const int maxSize = 11; char buf[maxSize]; for (int i = 0; i < arraySizes->getNumDims(); ++i) { if (arraySizes->getDimNode(i)) { if (arraySizes->getDimNode(i)->getAsSymbolNode()) snprintf(buf, maxSize, "s%d", arraySizes->getDimNode(i)->getAsSymbolNode()->getId()); else snprintf(buf, maxSize, "s%p", arraySizes->getDimNode(i)); } else snprintf(buf, maxSize, "%d", arraySizes->getDimSize(i)); mangledName += '['; mangledName += buf; mangledName += ']'; } } }
// // Do folding between a pair of nodes // TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNode) { TConstUnion *unionArray = getUnionArrayPointer(); int objectSize = getType().getObjectSize(); TConstUnion* newConstArray = 0; // For most cases, the return type matches the argument type, so set that // up and just code to exceptions below. TType returnType; returnType.shallowCopy(getType()); // // A pair of nodes is to be folded together // TIntermConstantUnion *node = constantNode->getAsConstantUnion(); TConstUnion *rightUnionArray = node->getUnionArrayPointer(); if (constantNode->getType().getObjectSize() == 1 && objectSize > 1) { // for a case like float f = vec4(2,3,4,5) + 1.2; rightUnionArray = new TConstUnion[objectSize]; for (int i = 0; i < objectSize; ++i) rightUnionArray[i] = *node->getUnionArrayPointer(); } else if (constantNode->getType().getObjectSize() > 1 && objectSize == 1) { // for a case like float f = 1.2 + vec4(2,3,4,5); rightUnionArray = node->getUnionArrayPointer(); unionArray = new TConstUnion[constantNode->getType().getObjectSize()]; for (int i = 0; i < constantNode->getType().getObjectSize(); ++i) unionArray[i] = *getUnionArrayPointer(); returnType.shallowCopy(node->getType()); objectSize = constantNode->getType().getObjectSize(); } int index = 0; bool boolNodeFlag = false; switch(op) { case EOpAdd: newConstArray = new TConstUnion[objectSize]; for (int i = 0; i < objectSize; i++) newConstArray[i] = unionArray[i] + rightUnionArray[i]; break; case EOpSub: newConstArray = new TConstUnion[objectSize]; for (int i = 0; i < objectSize; i++) newConstArray[i] = unionArray[i] - rightUnionArray[i]; break; case EOpMul: case EOpVectorTimesScalar: case EOpMatrixTimesScalar: newConstArray = new TConstUnion[objectSize]; for (int i = 0; i < objectSize; i++) newConstArray[i] = unionArray[i] * rightUnionArray[i]; break; case EOpMatrixTimesMatrix: newConstArray = new TConstUnion[getMatrixRows() * node->getMatrixCols()]; for (int row = 0; row < getMatrixRows(); row++) { for (int column = 0; column < node->getMatrixCols(); column++) { double sum = 0.0f; for (int i = 0; i < node->getMatrixRows(); i++) sum += unionArray[i * getMatrixRows() + row].getDConst() * rightUnionArray[column * node->getMatrixRows() + i].getDConst(); newConstArray[column * getMatrixRows() + row].setDConst(sum); } } returnType.shallowCopy(TType(getType().getBasicType(), EvqConst, 0, getMatrixRows(), node->getMatrixCols())); break; case EOpDiv: newConstArray = new TConstUnion[objectSize]; for (int i = 0; i < objectSize; i++) { switch (getType().getBasicType()) { case EbtDouble: case EbtFloat: newConstArray[i].setDConst(unionArray[i].getDConst() / rightUnionArray[i].getDConst()); break; case EbtInt: if (rightUnionArray[i] == 0) { newConstArray[i].setIConst(0xEFFFFFFF); } else newConstArray[i].setIConst(unionArray[i].getIConst() / rightUnionArray[i].getIConst()); break; case EbtUint: if (rightUnionArray[i] == 0) { newConstArray[i].setUConst(0xFFFFFFFF); } else newConstArray[i].setUConst(unionArray[i].getUConst() / rightUnionArray[i].getUConst()); break; default: return 0; } } break; case EOpMatrixTimesVector: newConstArray = new TConstUnion[getMatrixRows()]; for (int i = 0; i < getMatrixRows(); i++) { double sum = 0.0f; for (int j = 0; j < node->getVectorSize(); j++) { sum += unionArray[j*getMatrixRows() + i].getDConst() * rightUnionArray[j].getDConst(); } newConstArray[i].setDConst(sum); } returnType.shallowCopy(TType(getBasicType(), EvqConst, getMatrixRows())); break; case EOpVectorTimesMatrix: newConstArray = new TConstUnion[node->getMatrixCols()]; for (int i = 0; i < node->getMatrixCols(); i++) { double sum = 0.0f; for (int j = 0; j < getVectorSize(); j++) sum += unionArray[j].getDConst() * rightUnionArray[i*node->getMatrixRows() + j].getDConst(); newConstArray[i].setDConst(sum); } returnType.shallowCopy(TType(getBasicType(), EvqConst, node->getMatrixCols())); break; case EOpMod: newConstArray = new TConstUnion[objectSize]; for (int i = 0; i < objectSize; i++) newConstArray[i] = unionArray[i] % rightUnionArray[i]; break; case EOpRightShift: newConstArray = new TConstUnion[objectSize]; for (int i = 0; i < objectSize; i++) newConstArray[i] = unionArray[i] >> rightUnionArray[i]; break; case EOpLeftShift: newConstArray = new TConstUnion[objectSize]; for (int i = 0; i < objectSize; i++) newConstArray[i] = unionArray[i] << rightUnionArray[i]; break; case EOpAnd: newConstArray = new TConstUnion[objectSize]; for (int i = 0; i < objectSize; i++) newConstArray[i] = unionArray[i] & rightUnionArray[i]; break; case EOpInclusiveOr: newConstArray = new TConstUnion[objectSize]; for (int i = 0; i < objectSize; i++) newConstArray[i] = unionArray[i] | rightUnionArray[i]; break; case EOpExclusiveOr: newConstArray = new TConstUnion[objectSize]; for (int i = 0; i < objectSize; i++) newConstArray[i] = unionArray[i] ^ rightUnionArray[i]; break; case EOpLogicalAnd: // this code is written for possible future use, will not get executed currently newConstArray = new TConstUnion[objectSize]; for (int i = 0; i < objectSize; i++) newConstArray[i] = unionArray[i] && rightUnionArray[i]; break; case EOpLogicalOr: // this code is written for possible future use, will not get executed currently newConstArray = new TConstUnion[objectSize]; for (int i = 0; i < objectSize; i++) newConstArray[i] = unionArray[i] || rightUnionArray[i]; break; case EOpLogicalXor: newConstArray = new TConstUnion[objectSize]; for (int i = 0; i < objectSize; i++) { switch (getType().getBasicType()) { case EbtBool: newConstArray[i].setBConst((unionArray[i] == rightUnionArray[i]) ? false : true); break; default: assert(false && "Default missing"); } } break; case EOpLessThan: assert(objectSize == 1); newConstArray = new TConstUnion[1]; newConstArray->setBConst(*unionArray < *rightUnionArray); returnType.shallowCopy(TType(EbtBool, EvqConst)); break; case EOpGreaterThan: assert(objectSize == 1); newConstArray = new TConstUnion[1]; newConstArray->setBConst(*unionArray > *rightUnionArray); returnType.shallowCopy(TType(EbtBool, EvqConst)); break; case EOpLessThanEqual: { assert(objectSize == 1); TConstUnion constant; constant.setBConst(*unionArray > *rightUnionArray); newConstArray = new TConstUnion[1]; newConstArray->setBConst(!constant.getBConst()); returnType.shallowCopy(TType(EbtBool, EvqConst)); break; } case EOpGreaterThanEqual: { assert(objectSize == 1); TConstUnion constant; constant.setBConst(*unionArray < *rightUnionArray); newConstArray = new TConstUnion[1]; newConstArray->setBConst(!constant.getBConst()); returnType.shallowCopy(TType(EbtBool, EvqConst)); break; } case EOpEqual: if (getType().getBasicType() == EbtStruct) { if (! CompareStructure(node->getType(), node->getUnionArrayPointer(), unionArray)) boolNodeFlag = true; } else { for (int i = 0; i < objectSize; i++) { if (unionArray[i] != rightUnionArray[i]) { boolNodeFlag = true; break; // break out of for loop } } } newConstArray = new TConstUnion[1]; newConstArray->setBConst(! boolNodeFlag); returnType.shallowCopy(TType(EbtBool, EvqConst)); break; case EOpNotEqual: if (getType().getBasicType() == EbtStruct) { if (CompareStructure(node->getType(), node->getUnionArrayPointer(), unionArray)) boolNodeFlag = true; } else { for (int i = 0; i < objectSize; i++) { if (unionArray[i] == rightUnionArray[i]) { boolNodeFlag = true; break; // break out of for loop } } } newConstArray = new TConstUnion[1]; newConstArray->setBConst(! boolNodeFlag); returnType.shallowCopy(TType(EbtBool, EvqConst)); break; default: return 0; } TIntermConstantUnion *newNode = new TIntermConstantUnion(newConstArray, returnType); newNode->setLoc(getLoc()); return newNode; }