//

// Copyright (C) 2002-2005  3Dlabs Inc. Ltd.

// Copyright (C) 2012-2015 LunarG, Inc.

// Copyright (C) 2015-2020 Google, Inc.

// Copyright (C) 2017 ARM Limited.

//

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions

// are met:

//

//    Redistributions of source code must retain the above copyright

//    notice, this list of conditions and the following disclaimer.

//

//    Redistributions in binary form must reproduce the above

//    copyright notice, this list of conditions and the following

//    disclaimer in the documentation and/or other materials provided

//    with the distribution.

//

//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its

//    contributors may be used to endorse or promote products derived

//    from this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

// POSSIBILITY OF SUCH DAMAGE.

//

//

// Build the intermediate representation.

//

#include "localintermediate.h"

#include "RemoveTree.h"

#include "SymbolTable.h"

#include "propagateNoContraction.h"

#include <cfloat>

#include <limits>

#include <utility>

#include <tuple>

namespace glslang {

////////////////////////////////////////////////////////////////////////////

//

// First set of functions are to help build the intermediate representation.

// These functions are not member functions of the nodes.

// They are called from parser productions.

//

/////////////////////////////////////////////////////////////////////////////

//

// Add a terminal node for an identifier in an expression.

//

// Returns the added node.

//

TIntermSymbol* TIntermediate::addSymbol(long long id, const TString& name, const TString& mangledName, const TType& type, const TConstUnionArray& constArray,

                                        TIntermTyped* constSubtree, const TSourceLoc& loc)

{

    TIntermSymbol* node = new TIntermSymbol(id, name, getStage(), type, &mangledName);

    node->setLoc(loc);

    node->setConstArray(constArray);

    node->setConstSubtree(constSubtree);

    return node;

}

TIntermSymbol* TIntermediate::addSymbol(const TIntermSymbol& intermSymbol)

{

    return addSymbol(intermSymbol.getId(),

                     intermSymbol.getName(),

                     intermSymbol.getMangledName(),

                     intermSymbol.getType(),

                     intermSymbol.getConstArray(),

                     intermSymbol.getConstSubtree(),

                     intermSymbol.getLoc());

}

TIntermSymbol* TIntermediate::addSymbol(const TVariable& variable)

{

    glslang::TSourceLoc loc; // just a null location

    loc.init();

    return addSymbol(variable, loc);

}

TIntermSymbol* TIntermediate::addSymbol(const TVariable& variable, const TSourceLoc& loc)

{

    return addSymbol(variable.getUniqueId(), variable.getName(), variable.getMangledName(), variable.getType(), variable.getConstArray(), variable.getConstSubtree(), loc);

}

TIntermSymbol* TIntermediate::addSymbol(const TType& type, const TSourceLoc& loc)

{

    TConstUnionArray unionArray;  // just a null constant

    return addSymbol(0, "", "", type, unionArray, nullptr, loc);

}

//

// Connect two nodes with a new parent that does a binary operation on the nodes.

//

// Returns the added node.

//

// Returns nullptr if the working conversions and promotions could not be found.

//

TIntermTyped* TIntermediate::addBinaryMath(TOperator op, TIntermTyped* left, TIntermTyped* right, const TSourceLoc& loc)

{

    // No operations work on blocks

    if (left->getType().getBasicType() == EbtBlock || right->getType().getBasicType() == EbtBlock ||

        left->getType().getBasicType() == EbtString || right->getType().getBasicType() == EbtString)

        return nullptr;

    // Convert "reference +/- int" and "reference - reference" to integer math

    if (op == EOpAdd || op == EOpSub) {

        // No addressing math on struct with unsized array.

        if ((left->isReference() && left->getType().getReferentType()->containsUnsizedArray()) ||

            (right->isReference() && right->getType().getReferentType()->containsUnsizedArray())) {

            return nullptr;

        }

        if (left->isReference() && isTypeInt(right->getBasicType())) {

            const TType& referenceType = left->getType();

            TIntermConstantUnion* size = addConstantUnion((unsigned long long)computeBufferReferenceTypeSize(left->getType()), loc, true);

            left  = addBuiltInFunctionCall(loc, EOpConvPtrToUint64, true, left, TType(EbtUint64));

            right = createConversion(EbtInt64, right);

            right = addBinaryMath(EOpMul, right, size, loc);

            TIntermTyped *node = addBinaryMath(op, left, right, loc);

            node = addBuiltInFunctionCall(loc, EOpConvUint64ToPtr, true, node, referenceType);

            return node;

        }

    }

    if (op == EOpAdd && right->isReference() && isTypeInt(left->getBasicType())) {

        const TType& referenceType = right->getType();

        TIntermConstantUnion* size =

            addConstantUnion((unsigned long long)computeBufferReferenceTypeSize(right->getType()), loc, true);

        right = addBuiltInFunctionCall(loc, EOpConvPtrToUint64, true, right, TType(EbtUint64));

        left  = createConversion(EbtInt64, left);

        left  = addBinaryMath(EOpMul, left, size, loc);

        TIntermTyped *node = addBinaryMath(op, left, right, loc);

        node = addBuiltInFunctionCall(loc, EOpConvUint64ToPtr, true, node, referenceType);

        return node;

    }

    if (op == EOpSub && left->isReference() && right->isReference()) {

        TIntermConstantUnion* size =

            addConstantUnion((long long)computeBufferReferenceTypeSize(left->getType()), loc, true);

        left = addBuiltInFunctionCall(loc, EOpConvPtrToUint64, true, left, TType(EbtUint64));

        right = addBuiltInFunctionCall(loc, EOpConvPtrToUint64, true, right, TType(EbtUint64));

        left = addBuiltInFunctionCall(loc, EOpConvNumeric, true, left, TType(EbtInt64));

        right = addBuiltInFunctionCall(loc, EOpConvNumeric, true, right, TType(EbtInt64));

        left = addBinaryMath(EOpSub, left, right, loc);

        TIntermTyped *node = addBinaryMath(EOpDiv, left, size, loc);

        return node;

    }

    // No other math operators supported on references

    if (left->isReference() || right->isReference())

        return nullptr;

    // Try converting the children's base types to compatible types.

    auto children = addPairConversion(op, left, right);

    left = std::get<0>(children);

    right = std::get<1>(children);

    if (left == nullptr || right == nullptr)

        return nullptr;

    // Convert the children's type shape to be compatible.

    addBiShapeConversion(op, left, right);

    if (left == nullptr || right == nullptr)

        return nullptr;

    //

    // Need a new node holding things together.  Make

    // one and promote it to the right type.

    //

    TIntermBinary* node = addBinaryNode(op, left, right, loc);

    if (! promote(node))

        return nullptr;

    node->updatePrecision();

    //

    // If they are both (non-specialization) constants, they must be folded.

    // (Unless it's the sequence (comma) operator, but that's handled in addComma().)

    //

    TIntermConstantUnion *leftTempConstant = node->getLeft()->getAsConstantUnion();

    TIntermConstantUnion *rightTempConstant = node->getRight()->getAsConstantUnion();

    if (leftTempConstant && rightTempConstant) {

        TIntermTyped* folded = leftTempConstant->fold(node->getOp(), rightTempConstant);

        if (folded)

            return folded;

    }

    // If can propagate spec-constantness and if the operation is an allowed

    // specialization-constant operation, make a spec-constant.

    if (specConstantPropagates(*node->getLeft(), *node->getRight()) && isSpecializationOperation(*node))

        node->getWritableType().getQualifier().makeSpecConstant();

    // If must propagate nonuniform, make a nonuniform.

    if ((node->getLeft()->getQualifier().isNonUniform() || node->getRight()->getQualifier().isNonUniform()) &&

            isNonuniformPropagating(node->getOp()))

        node->getWritableType().getQualifier().nonUniform = true;

    return node;

}

//

// Low level: add binary node (no promotions or other argument modifications)

//

TIntermBinary* TIntermediate::addBinaryNode(TOperator op, TIntermTyped* left, TIntermTyped* right,

    const TSourceLoc& loc) const

{

    // build the node

    TIntermBinary* node = new TIntermBinary(op);

    node->setLoc(loc.line != 0 ? loc : left->getLoc());

    node->setLeft(left);

    node->setRight(right);

    return node;

}

//

// like non-type form, but sets node's type.

//

TIntermBinary* TIntermediate::addBinaryNode(TOperator op, TIntermTyped* left, TIntermTyped* right,

    const TSourceLoc& loc, const TType& type) const

{

    TIntermBinary* node = addBinaryNode(op, left, right, loc);

    node->setType(type);

    return node;

}

//

// Low level: add unary node (no promotions or other argument modifications)

//

TIntermUnary* TIntermediate::addUnaryNode(TOperator op, TIntermTyped* child, const TSourceLoc& loc) const

{

    TIntermUnary* node = new TIntermUnary(op);

    node->setLoc(loc.line != 0 ? loc : child->getLoc());

    node->setOperand(child);

    return node;

}

//

// like non-type form, but sets node's type.

//

TIntermUnary* TIntermediate::addUnaryNode(TOperator op, TIntermTyped* child, const TSourceLoc& loc, const TType& type)

    const

{

    TIntermUnary* node = addUnaryNode(op, child, loc);

    node->setType(type);

    return node;

}

//

// Connect two nodes through an assignment.

//

// Returns the added node.

//

// Returns nullptr if the 'right' type could not be converted to match the 'left' type,

// or the resulting operation cannot be properly promoted.

//

TIntermTyped* TIntermediate::addAssign(TOperator op, TIntermTyped* left, TIntermTyped* right,

    const TSourceLoc& loc)

{

    // No block assignment

    if (left->getType().getBasicType() == EbtBlock || right->getType().getBasicType() == EbtBlock)

        return nullptr;

    // Convert "reference += int" to "reference = reference + int". We need this because the

    // "reference + int" calculation involves a cast back to the original type, which makes it

    // not an lvalue.

    if ((op == EOpAddAssign || op == EOpSubAssign) && left->isReference()) {

        if (!(right->getType().isScalar() && right->getType().isIntegerDomain()))

            return nullptr;

        TIntermTyped* node = addBinaryMath(op == EOpAddAssign ? EOpAdd : EOpSub, left, right, loc);

        if (!node)

            return nullptr;

        TIntermSymbol* symbol = left->getAsSymbolNode();

        left = addSymbol(*symbol);

        node = addAssign(EOpAssign, left, node, loc);

        return node;

    }

    //

    // Like adding binary math, except the conversion can only go

    // from right to left.

    //

    // convert base types, nullptr return means not possible

    right = addConversion(op, left->getType(), right);

    if (right == nullptr)

        return nullptr;

    // convert shape

    right = addUniShapeConversion(op, left->getType(), right);

    // build the node

    TIntermBinary* node = addBinaryNode(op, left, right, loc);

    if (! promote(node))

        return nullptr;

    node->updatePrecision();

    return node;

}

//

// Connect two nodes through an index operator, where the left node is the base

// of an array or struct, and the right node is a direct or indirect offset.

//

// Returns the added node.

// The caller should set the type of the returned node.

//

TIntermTyped* TIntermediate::addIndex(TOperator op, TIntermTyped* base, TIntermTyped* index,

    const TSourceLoc& loc)

{

    // caller should set the type

    return addBinaryNode(op, base, index, loc);

}

//

// Add one node as the parent of another that it operates on.

//

// Returns the added node.

//

TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermTyped* child,

    const TSourceLoc& loc)

{

    if (child == nullptr)

        return nullptr;

    if (child->getType().getBasicType() == EbtBlock)

        return nullptr;

    switch (op) {

    case EOpLogicalNot:

        if (getSource() == EShSourceHlsl) {

            break; // HLSL can promote logical not

        }

        if (child->getType().getBasicType() != EbtBool || child->getType().isMatrix() || child->getType().isArray() || child->getType().isVector()) {

            return nullptr;

        }

        break;

    case EOpPostIncrement:

    case EOpPreIncrement:

    case EOpPostDecrement:

    case EOpPreDecrement:

    case EOpNegative:

        if (child->getType().getBasicType() == EbtStruct || child->getType().isArray())

            return nullptr;

        break;

    default: break; // some compilers want this

    }

    //

    // Do we need to promote the operand?

    //

    TBasicType newType = EbtVoid;

    switch (op) {

    case EOpConstructBool:   newType = EbtBool;   break;

    case EOpConstructFloat:  newType = EbtFloat;  break;

    case EOpConstructInt:    newType = EbtInt;    break;

    case EOpConstructUint:   newType = EbtUint;   break;

    case EOpConstructInt8:   newType = EbtInt8;   break;

    case EOpConstructUint8:  newType = EbtUint8;  break;

    case EOpConstructInt16:  newType = EbtInt16;  break;

    case EOpConstructUint16: newType = EbtUint16; break;

    case EOpConstructInt64:  newType = EbtInt64;  break;

    case EOpConstructUint64: newType = EbtUint64; break;

    case EOpConstructDouble: newType = EbtDouble; break;

    case EOpConstructFloat16: newType = EbtFloat16; break;

    case EOpConstructBFloat16: newType = EbtBFloat16; break;

    case EOpConstructFloatE4M3: newType = EbtFloatE4M3; break;

    case EOpConstructFloatE5M2: newType = EbtFloatE5M2; break;

    default: break; // some compilers want this

    }

    if (newType != EbtVoid) {

        TType newTType(newType, EvqTemporary, child->getVectorSize(), child->getMatrixCols(), child->getMatrixRows(), child->isVector());

        if (child->getType().isLongVector()) {

            newTType.shallowCopy(child->getType());

            newTType.setBasicType(newType);

            newTType.makeTemporary();

            newTType.getQualifier().clear();

        }

        child = addConversion(op, newTType, child);

        if (child == nullptr)

            return nullptr;

    }

    //

    // For constructors, we are now done, it was all in the conversion.

    // TODO: but, did this bypass constant folding?

    //

    switch (op) {

        case EOpConstructInt8:

        case EOpConstructUint8:

        case EOpConstructInt16:

        case EOpConstructUint16:

        case EOpConstructInt:

        case EOpConstructUint:

        case EOpConstructInt64:

        case EOpConstructUint64:

        case EOpConstructBool:

        case EOpConstructFloat:

        case EOpConstructDouble:

        case EOpConstructFloat16:

        case EOpConstructBFloat16:

        case EOpConstructFloatE5M2:

        case EOpConstructFloatE4M3: {

            TIntermUnary* unary_node = child->getAsUnaryNode();

            if (unary_node != nullptr)

                unary_node->updatePrecision();

            return child;

        }

        default: break; // some compilers want this

    }

    //

    // Make a new node for the operator.

    //

    TIntermUnary* node = addUnaryNode(op, child, loc);

    if (! promote(node))

        return nullptr;

    node->updatePrecision();

    // If it's a (non-specialization) constant, it must be folded.

    if (node->getOperand()->getAsConstantUnion())

        return node->getOperand()->getAsConstantUnion()->fold(op, node->getType());

    // If it's a specialization constant, the result is too,

    // if the operation is allowed for specialization constants.

    if (node->getOperand()->getType().getQualifier().isSpecConstant() && isSpecializationOperation(*node))

        node->getWritableType().getQualifier().makeSpecConstant();

    // If must propagate nonuniform, make a nonuniform.

    if (node->getOperand()->getQualifier().isNonUniform() && isNonuniformPropagating(node->getOp()))

        node->getWritableType().getQualifier().nonUniform = true;

    return node;

}

TIntermTyped* TIntermediate::addBuiltInFunctionCall(const TSourceLoc& loc, TOperator op, bool unary,

    TIntermNode* childNode, const TType& returnType)

{

    if (unary) {

        //

        // Treat it like a unary operator.

        // addUnaryMath() should get the type correct on its own;

        // including constness (which would differ from the prototype).

        //

        TIntermTyped* child = childNode->getAsTyped();

        if (child == nullptr)

            return nullptr;

        if (child->getAsConstantUnion()) {

            TIntermTyped* folded = child->getAsConstantUnion()->fold(op, returnType);

            if (folded)

                return folded;

        }

        return addUnaryNode(op, child, child->getLoc(), returnType);

    } else {

        // setAggregateOperater() calls fold() for constant folding

        TIntermTyped* node = setAggregateOperator(childNode, op, returnType, loc);

        return node;

    }

}

//

// This is the safe way to change the operator on an aggregate, as it

// does lots of error checking and fixing.  Especially for establishing

// a function call's operation on its set of parameters.  Sequences

// of instructions are also aggregates, but they just directly set

// their operator to EOpSequence.

//

// Returns an aggregate node, which could be the one passed in if

// it was already an aggregate.

//

TIntermTyped* TIntermediate::setAggregateOperator(TIntermNode* node, TOperator op, const TType& type,

    const TSourceLoc& loc)

{

    TIntermAggregate* aggNode;

    //

    // Make sure we have an aggregate.  If not turn it into one.

    //

    if (node != nullptr) {

        aggNode = node->getAsAggregate();

        if (aggNode == nullptr || aggNode->getOp() != EOpNull) {

            //

            // Make an aggregate containing this node.

            //

            aggNode = new TIntermAggregate();

            aggNode->getSequence().push_back(node);

        }

    } else

        aggNode = new TIntermAggregate();

    //

    // Set the operator.

    //

    aggNode->setOperator(op);

    if (loc.line != 0 || node != nullptr)

        aggNode->setLoc(loc.line != 0 ? loc : node->getLoc());

    aggNode->setType(type);

    return fold(aggNode);

}

bool TIntermediate::isConversionAllowed(TOperator op, TIntermTyped* node) const

{

    //

    // Does the base type even allow the operation?

    //

    switch (node->getBasicType()) {

    case EbtVoid:

        return false;

    case EbtAtomicUint:

    case EbtSampler:

    case EbtAccStruct:

        // opaque types can be passed to functions

        if (op == EOpFunction)

            break;

        // HLSL can assign samplers directly (no constructor)

        if (getSource() == EShSourceHlsl && node->getBasicType() == EbtSampler)

            break;

        // samplers can get assigned via a sampler constructor

        // (well, not yet, but code in the rest of this function is ready for it)

        if (node->getBasicType() == EbtSampler && op == EOpAssign &&

            node->getAsOperator() != nullptr && node->getAsOperator()->getOp() == EOpConstructTextureSampler)

            break;

        // otherwise, opaque types can't even be operated on, let alone converted

        return false;

    default:

        break;

    }

    return true;

}

bool TIntermediate::buildConvertOp(TBasicType dst, TBasicType src, TOperator& newOp) const

{

    // (bfloat16_t,fp8) <-> bool not supported

    if (((src == EbtBFloat16 || src == EbtFloatE5M2 || src == EbtFloatE4M3) && dst == EbtBool) ||

        ((dst == EbtBFloat16 || dst == EbtFloatE5M2 || dst == EbtFloatE4M3) && src == EbtBool)) {

        return false;

    }

    if ((isTypeInt(dst) || isTypeFloat(dst) || dst == EbtBool) &&

        (isTypeInt(src) || isTypeFloat(src) || src == EbtBool)) {

        newOp = EOpConvNumeric;

        return true;

    }

    return false;

}

// This is 'mechanism' here, it does any conversion told.

// It is about basic type, not about shape.

// The policy comes from the shader or the calling code.

TIntermTyped* TIntermediate::createConversion(TBasicType convertTo, TIntermTyped* node) const

{

    //

    // Add a new newNode for the conversion.

    //

    bool convertToIntTypes = (convertTo == EbtInt8  || convertTo == EbtUint8  ||

                              convertTo == EbtInt16 || convertTo == EbtUint16 ||

                              convertTo == EbtInt   || convertTo == EbtUint   ||

                              convertTo == EbtInt64 || convertTo == EbtUint64);

    bool convertFromIntTypes = (node->getBasicType() == EbtInt8  || node->getBasicType() == EbtUint8  ||

                                node->getBasicType() == EbtInt16 || node->getBasicType() == EbtUint16 ||

                                node->getBasicType() == EbtInt   || node->getBasicType() == EbtUint   ||

                                node->getBasicType() == EbtInt64 || node->getBasicType() == EbtUint64);

    bool convertToFloatTypes = (convertTo == EbtFloat16 || convertTo == EbtBFloat16 || convertTo == EbtFloat || convertTo == EbtDouble ||

                                convertTo == EbtFloatE5M2 || convertTo == EbtFloatE4M3);

    bool convertFromFloatTypes = (node->getBasicType() == EbtFloat16 ||

                                  node->getBasicType() == EbtBFloat16 ||

                                  node->getBasicType() == EbtFloat ||

                                  node->getBasicType() == EbtDouble ||

                                  node->getBasicType() == EbtFloatE5M2 ||

                                  node->getBasicType() == EbtFloatE4M3);

    if (((convertTo == EbtInt8 || convertTo == EbtUint8) && ! convertFromIntTypes) ||

        ((node->getBasicType() == EbtInt8 || node->getBasicType() == EbtUint8) && ! convertToIntTypes)) {

        if (! getArithemeticInt8Enabled()) {

            return nullptr;

        }

    }

    if (((convertTo == EbtInt16 || convertTo == EbtUint16) && ! convertFromIntTypes) ||

        ((node->getBasicType() == EbtInt16 || node->getBasicType() == EbtUint16) && ! convertToIntTypes)) {

        if (! getArithemeticInt16Enabled()) {

            return nullptr;

        }

    }

    if ((convertTo == EbtFloat16 && ! convertFromFloatTypes) ||

        (node->getBasicType() == EbtFloat16 && ! convertToFloatTypes)) {

        if (! getArithemeticFloat16Enabled()) {

            return nullptr;

        }

    }

    TIntermUnary* newNode = nullptr;

    TOperator newOp = EOpNull;

    if (!buildConvertOp(convertTo, node->getBasicType(), newOp)) {

        return nullptr;

    }

    TType newType(convertTo, EvqTemporary, node->getVectorSize(), node->getMatrixCols(), node->getMatrixRows());

    if (node->getType().isLongVector()) {

        newType.shallowCopy(node->getType());

        newType.setBasicType(convertTo);

        newType.makeTemporary();

        newType.getQualifier().clear();

    }

    newNode = addUnaryNode(newOp, node, node->getLoc(), newType);

    if (node->getAsConstantUnion()) {

        // 8/16-bit storage extensions don't support 8/16-bit constants, so don't fold conversions

        // to those types

        if ((getArithemeticInt8Enabled() || !(convertTo == EbtInt8 || convertTo == EbtUint8)) &&

            (getArithemeticInt16Enabled() || !(convertTo == EbtInt16 || convertTo == EbtUint16)) &&

            (getArithemeticFloat16Enabled() || !(convertTo == EbtFloat16)))

        {

            TIntermTyped* folded = node->getAsConstantUnion()->fold(newOp, newType);

            if (folded)

                return folded;

        }

    }

    // Propagate specialization-constant-ness, if allowed

    if (node->getType().getQualifier().isSpecConstant() && isSpecializationOperation(*newNode))

        newNode->getWritableType().getQualifier().makeSpecConstant();

    return newNode;

}

TIntermTyped* TIntermediate::addConversion(TBasicType convertTo, TIntermTyped* node) const

{

    return createConversion(convertTo, node);

}

// For converting a pair of operands to a binary operation to compatible

// types with each other, relative to the operation in 'op'.

// This does not cover assignment operations, which is asymmetric in that the

// left type is not changeable.

// See addConversion(op, type, node) for assignments and unary operation

// conversions.

//

// Generally, this is focused on basic type conversion, not shape conversion.

// See addShapeConversion() for shape conversions.

//

// Returns the converted pair of nodes.

// Returns <nullptr, nullptr> when there is no conversion.

std::tuple<TIntermTyped*, TIntermTyped*>

TIntermediate::addPairConversion(TOperator op, TIntermTyped* node0, TIntermTyped* node1)

{

    if (!isConversionAllowed(op, node0) || !isConversionAllowed(op, node1))

        return std::make_tuple(nullptr, nullptr);

    if (node0->getType() != node1->getType()) {

        // If differing structure, then no conversions.

        if (node0->isStruct() || node1->isStruct())

            return std::make_tuple(nullptr, nullptr);

        // If differing arrays, then no conversions.

        if (node0->getType().isArray() || node1->getType().isArray())

            return std::make_tuple(nullptr, nullptr);

        // No implicit conversions for operations involving cooperative matrices

        if (node0->getType().isCoopMat() || node1->getType().isCoopMat())

            return std::make_tuple(node0, node1);

    }

    auto promoteTo = std::make_tuple(EbtNumTypes, EbtNumTypes);

    switch (op) {

    //

    // List all the binary ops that can implicitly convert one operand to the other's type;

    // This implements the 'policy' for implicit type conversion.

    //

    case EOpLessThan:

    case EOpGreaterThan:

    case EOpLessThanEqual:

    case EOpGreaterThanEqual:

    case EOpEqual:

    case EOpNotEqual:

    case EOpAdd:

    case EOpSub:

    case EOpMul:

    case EOpDiv:

    case EOpMod:

    case EOpVectorTimesScalar:

    case EOpVectorTimesMatrix:

    case EOpMatrixTimesVector:

    case EOpMatrixTimesScalar:

    case EOpAnd:

    case EOpInclusiveOr:

    case EOpExclusiveOr:

    case EOpSequence:          // used by ?:

        if (node0->getBasicType() == node1->getBasicType())

            return std::make_tuple(node0, node1);

        promoteTo = getConversionDestinationType(node0->getBasicType(), node1->getBasicType(), op);

        if (std::get<0>(promoteTo) == EbtNumTypes || std::get<1>(promoteTo) == EbtNumTypes)

            return std::make_tuple(nullptr, nullptr);

        break;

    case EOpLogicalAnd:

    case EOpLogicalOr:

    case EOpLogicalXor:

        if (getSource() == EShSourceHlsl)

            promoteTo = std::make_tuple(EbtBool, EbtBool);

        else

            return std::make_tuple(node0, node1);

        break;

    // There are no conversions needed for GLSL; the shift amount just needs to be an

    // integer type, as does the base.

    // HLSL can promote bools to ints to make this work.

    case EOpLeftShift:

    case EOpRightShift:

        if (getSource() == EShSourceHlsl) {

            TBasicType node0BasicType = node0->getBasicType();

            if (node0BasicType == EbtBool)

                node0BasicType = EbtInt;

            if (node1->getBasicType() == EbtBool)

                promoteTo = std::make_tuple(node0BasicType, EbtInt);

            else

                promoteTo = std::make_tuple(node0BasicType, node1->getBasicType());

        } else {

            if (isTypeInt(node0->getBasicType()) && isTypeInt(node1->getBasicType()))

                return std::make_tuple(node0, node1);

            else

                return std::make_tuple(nullptr, nullptr);

        }

        break;

    default:

        if (node0->getType() == node1->getType())

            return std::make_tuple(node0, node1);

        return std::make_tuple(nullptr, nullptr);

    }

    TIntermTyped* newNode0;

    TIntermTyped* newNode1;

    if (std::get<0>(promoteTo) != node0->getType().getBasicType()) {

        if (node0->getAsConstantUnion())

            newNode0 = promoteConstantUnion(std::get<0>(promoteTo), node0->getAsConstantUnion());

        else

            newNode0 = createConversion(std::get<0>(promoteTo), node0);

    } else

        newNode0 = node0;

    if (std::get<1>(promoteTo) != node1->getType().getBasicType()) {

        if (node1->getAsConstantUnion())

            newNode1 = promoteConstantUnion(std::get<1>(promoteTo), node1->getAsConstantUnion());

        else

            newNode1 = createConversion(std::get<1>(promoteTo), node1);

    } else

        newNode1 = node1;

    return std::make_tuple(newNode0, newNode1);

}

//

// Convert the node's type to the given type, as allowed by the operation involved: 'op'.

// For implicit conversions, 'op' is not the requested conversion, it is the explicit

// operation requiring the implicit conversion.

//

// Binary operation conversions should be handled by addConversion(op, node, node), not here.

//

// Returns a node representing the conversion, which could be the same

// node passed in if no conversion was needed.

//

// Generally, this is focused on basic type conversion, not shape conversion.

// See addShapeConversion() for shape conversions.

//

// Return nullptr if a conversion can't be done.

//

TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TIntermTyped* node)

{

    if (!isConversionAllowed(op, node))

        return nullptr;

    // Otherwise, if types are identical, no problem

    if (type == node->getType())

        return node;

    // If one's a structure, then no conversions.

    if (type.isStruct() || node->isStruct())

        return nullptr;

    // If one's an array, then no conversions.

    if (type.isArray() || node->getType().isArray())

        return nullptr;

    // Reject implicit conversions to cooperative matrix types

    if (node->getType().isCoopMat() &&

        op != EOpConstructCooperativeMatrixNV &&

        op != EOpConstructCooperativeMatrixKHR &&

        op != glslang::EOpCompositeConstructCoopMatQCOM)

        return nullptr;

    if (node->getType().isTensorLayoutNV() ||

        node->getType().isTensorViewNV())

        return nullptr;

    // Reject implicit conversions to cooperative vector types

    if (node->getType().isCoopVecNV() &&

        op != EOpConstructCooperativeVectorNV)

        return nullptr;

    // Note: callers are responsible for other aspects of shape,

    // like vector and matrix sizes.

    switch (op) {

    //

    // Explicit conversions (unary operations)

    //

    case EOpConstructBool:

    case EOpConstructFloat:

    case EOpConstructInt:

    case EOpConstructUint:

    case EOpConstructDouble:

    case EOpConstructFloat16:

    case EOpConstructBFloat16:

    case EOpConstructFloatE5M2:

    case EOpConstructFloatE4M3:

    case EOpConstructInt8:

    case EOpConstructUint8:

    case EOpConstructInt16:

    case EOpConstructUint16:

    case EOpConstructInt64:

    case EOpConstructUint64:

    case EOpConstructSaturated:

        break;

    //

    // Implicit conversions

    //

    case EOpLogicalNot:

    case EOpFunctionCall:

    case EOpReturn:

    case EOpAssign:

    case EOpAddAssign:

    case EOpSubAssign:

    case EOpMulAssign:

    case EOpVectorTimesScalarAssign:

    case EOpMatrixTimesScalarAssign:

    case EOpDivAssign:

    case EOpModAssign:

    case EOpAndAssign:

    case EOpInclusiveOrAssign:

    case EOpExclusiveOrAssign:

    case EOpAtan:

    case EOpClamp:

    case EOpCross:

    case EOpDistance:

    case EOpDot:

    case EOpDst:

    case EOpFaceForward:

    case EOpFma:

    case EOpFrexp:

    case EOpLdexp:

    case EOpMix:

    case EOpLit:

    case EOpMax:

    case EOpMin:

    case EOpMod:

    case EOpModf:

    case EOpPow:

    case EOpReflect:

    case EOpRefract:

    case EOpSmoothStep:

    case EOpStep:

    case EOpSequence:

    case EOpConstructStruct:

    case EOpConstructCooperativeMatrixNV:

    case EOpConstructCooperativeMatrixKHR:

    case EOpConstructCooperativeVectorNV:

        if (type.isReference() || node->getType().isReference()) {

            // types must match to assign a reference

            if (type == node->getType())

                return node;

            else

                return nullptr;

        }

        if (type.getBasicType() == node->getType().getBasicType())

            return node;

        if (! canImplicitlyPromote(node->getBasicType(), type.getBasicType(), op))

            return nullptr;

        break;

    // For GLSL, there are no conversions needed; the shift amount just needs to be an

    // integer type, as do the base/result.

    // HLSL can convert the shift from a bool to an int.

    case EOpLeftShiftAssign:

    case EOpRightShiftAssign:

    {

        if (!(getSource() == EShSourceHlsl && node->getType().getBasicType() == EbtBool)) {

            if (isTypeInt(type.getBasicType()) && isTypeInt(node->getBasicType()))

                return node;

            else

                return nullptr;

        }

        break;

    }

    default:

        // default is to require a match; all exceptions should have case statements above

        if (type.getBasicType() == node->getType().getBasicType())

            return node;

        else

            return nullptr;

    }

    bool canPromoteConstant = true;

    // GL_EXT_shader_16bit_storage can't do OpConstantComposite with

    // 16-bit types, so disable promotion for those types.

    // Many issues with this, from JohnK:

    //  - this isn't really right to discuss SPIR-V here

    //  - this could easily be entirely about scalars, so is overstepping

    //  - we should be looking at what the shader asked for, and saying whether or