//

// Copyright(C) 2021 Advanced Micro Devices, Inc.

//

// 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.

//

//

// GL_EXT_spirv_intrinsics

//

#include "../Include/intermediate.h"

#include "../Include/SpirvIntrinsics.h"

#include "../Include/Types.h"

#include "ParseHelper.h"

namespace glslang {

bool TSpirvTypeParameter::operator==(const TSpirvTypeParameter& rhs) const

{

    if (getAsConstant() != nullptr)

        return getAsConstant()->getConstArray() == rhs.getAsConstant()->getConstArray();

    assert(getAsType() != nullptr);

    return *getAsType() == *rhs.getAsType();

}

//

// Handle SPIR-V requirements

//

TSpirvRequirement* TParseContext::makeSpirvRequirement(const TSourceLoc& loc, const TString& name,

                                                       const TIntermAggregate* extensions,

                                                       const TIntermAggregate* capabilities)

{

    TSpirvRequirement* spirvReq = new TSpirvRequirement;

    if (name == "extensions") {

        assert(extensions);

        for (auto extension : extensions->getSequence()) {

            assert(extension->getAsConstantUnion());

            spirvReq->extensions.insert(*extension->getAsConstantUnion()->getConstArray()[0].getSConst());

        }

    } else if (name == "capabilities") {

        assert(capabilities);

        for (auto capability : capabilities->getSequence()) {

            assert(capability->getAsConstantUnion());

            spirvReq->capabilities.insert(capability->getAsConstantUnion()->getConstArray()[0].getIConst());

        }

    } else

        error(loc, "unknown SPIR-V requirement", name.c_str(), "");

    return spirvReq;

}

TSpirvRequirement* TParseContext::mergeSpirvRequirements(const TSourceLoc& loc, TSpirvRequirement* spirvReq1,

                                                         TSpirvRequirement* spirvReq2)

{

    // Merge the second SPIR-V requirement to the first one

    if (!spirvReq2->extensions.empty()) {

        if (spirvReq1->extensions.empty())

            spirvReq1->extensions = spirvReq2->extensions;

        else

            error(loc, "too many SPIR-V requirements", "extensions", "");

    }

    if (!spirvReq2->capabilities.empty()) {

        if (spirvReq1->capabilities.empty())

            spirvReq1->capabilities = spirvReq2->capabilities;

        else

            error(loc, "too many SPIR-V requirements", "capabilities", "");

    }

    return spirvReq1;

}

void TIntermediate::insertSpirvRequirement(const TSpirvRequirement* spirvReq)

{

    if (!spirvRequirement)

        spirvRequirement = new TSpirvRequirement;

    for (auto extension : spirvReq->extensions)

        spirvRequirement->extensions.insert(extension);

    for (auto capability : spirvReq->capabilities)

        spirvRequirement->capabilities.insert(capability);

}

//

// Handle SPIR-V execution modes

//

void TIntermediate::insertSpirvExecutionMode(int executionMode, const TIntermAggregate* args)

{

    if (!spirvExecutionMode)

        spirvExecutionMode = new TSpirvExecutionMode;

    TVector<const TIntermConstantUnion*> extraOperands;

    if (args) {

        for (auto arg : args->getSequence()) {

            auto extraOperand = arg->getAsConstantUnion();

            assert(extraOperand != nullptr);

            extraOperands.push_back(extraOperand);

        }

    }

    spirvExecutionMode->modes[executionMode] = extraOperands;

}

void TIntermediate::insertSpirvExecutionModeId(int executionMode, const TIntermAggregate* args)

{

    if (!spirvExecutionMode)

        spirvExecutionMode = new TSpirvExecutionMode;

    assert(args);

    TVector<const TIntermTyped*> extraOperands;

    for (auto arg : args->getSequence()) {

        auto extraOperand = arg->getAsTyped();

        assert(extraOperand != nullptr && extraOperand->getQualifier().isConstant());

        extraOperands.push_back(extraOperand);

    }

    spirvExecutionMode->modeIds[executionMode] = extraOperands;

}

//

// Handle SPIR-V decorate qualifiers

//

void TQualifier::setSpirvDecorate(int decoration, const TIntermAggregate* args)

{

    if (!spirvDecorate)

        spirvDecorate = new TSpirvDecorate;

    TVector<const TIntermConstantUnion*> extraOperands;

    if (args) {

        for (auto arg : args->getSequence()) {

            auto extraOperand = arg->getAsConstantUnion();

            assert(extraOperand != nullptr);

            extraOperands.push_back(extraOperand);

        }

    }

    spirvDecorate->decorates[decoration] = extraOperands;

}

void TQualifier::setSpirvDecorateId(int decoration, const TIntermAggregate* args)

{

    if (!spirvDecorate)

        spirvDecorate = new TSpirvDecorate;

    assert(args);

    TVector<const TIntermTyped*> extraOperands;

    for (auto arg : args->getSequence()) {

        auto extraOperand = arg->getAsTyped();

        assert(extraOperand != nullptr);

        extraOperands.push_back(extraOperand);

    }

    spirvDecorate->decorateIds[decoration] = extraOperands;

}

void TQualifier::setSpirvDecorateString(int decoration, const TIntermAggregate* args)

{

    if (!spirvDecorate)

        spirvDecorate = new TSpirvDecorate;

    assert(args);

    TVector<const TIntermConstantUnion*> extraOperands;

    for (auto arg : args->getSequence()) {

        auto extraOperand = arg->getAsConstantUnion();

        assert(extraOperand != nullptr);

        extraOperands.push_back(extraOperand);

    }

    spirvDecorate->decorateStrings[decoration] = extraOperands;

}

TString TQualifier::getSpirvDecorateQualifierString() const

{

    assert(spirvDecorate);

    TString qualifierString;

    const auto appendFloat = [&](float f) { qualifierString.append(std::to_string(f).c_str()); };

    const auto appendInt = [&](int i) { qualifierString.append(std::to_string(i).c_str()); };

    const auto appendUint = [&](unsigned int u) { qualifierString.append(std::to_string(u).c_str()); };

    const auto appendBool = [&](bool b) { qualifierString.append(std::to_string(b).c_str()); };

    const auto appendStr = [&](const char* s) { qualifierString.append(s); };

    const auto appendDecorate = [&](const TIntermTyped* constant) {

        if (constant->getAsConstantUnion()) {

            auto& constArray = constant->getAsConstantUnion()->getConstArray();

            if (constant->getBasicType() == EbtFloat) {

                float value = static_cast<float>(constArray[0].getDConst());

                appendFloat(value);

            } else if (constant->getBasicType() == EbtInt) {

                int value = constArray[0].getIConst();

                appendInt(value);

            } else if (constant->getBasicType() == EbtUint) {

                unsigned value = constArray[0].getUConst();

                appendUint(value);

            } else if (constant->getBasicType() == EbtBool) {

                bool value = constArray[0].getBConst();

                appendBool(value);

            } else if (constant->getBasicType() == EbtString) {

                const TString* value = constArray[0].getSConst();

                appendStr(value->c_str());

            } else

                assert(0);

        } else {

            assert(constant->getAsSymbolNode());

            appendStr(constant->getAsSymbolNode()->getName().c_str());

        }

    };

    for (auto& decorate : spirvDecorate->decorates) {

        appendStr("spirv_decorate(");

        appendInt(decorate.first);

        for (auto extraOperand : decorate.second) {

            appendStr(", ");

            appendDecorate(extraOperand);

        }

        appendStr(") ");

    }

    for (auto& decorateId : spirvDecorate->decorateIds) {

        appendStr("spirv_decorate_id(");

        appendInt(decorateId.first);

        for (auto extraOperand : decorateId.second) {

            appendStr(", ");

            appendDecorate(extraOperand);

        }

        appendStr(") ");

    }

    for (auto& decorateString : spirvDecorate->decorateStrings) {

        appendStr("spirv_decorate_string(");

        appendInt(decorateString.first);

        for (auto extraOperand : decorateString.second) {

            appendStr(", ");

            appendDecorate(extraOperand);

        }

        appendStr(") ");

    }

    return qualifierString;

}

//

// Handle SPIR-V type specifiers

//

void TPublicType::setSpirvType(const TSpirvInstruction& spirvInst, const TSpirvTypeParameters* typeParams)

{

    if (!spirvType)

        spirvType = new TSpirvType;

    basicType = EbtSpirvType;

    spirvType->spirvInst = spirvInst;

    if (typeParams)

        spirvType->typeParams = *typeParams;

}

TSpirvTypeParameters* TParseContext::makeSpirvTypeParameters(const TSourceLoc& loc, const TIntermConstantUnion* constant)

{

    TSpirvTypeParameters* spirvTypeParams = new TSpirvTypeParameters;

    if (constant->getBasicType() != EbtFloat &&

        constant->getBasicType() != EbtInt &&

        constant->getBasicType() != EbtUint &&

        constant->getBasicType() != EbtBool &&

        constant->getBasicType() != EbtString)

        error(loc, "this type not allowed", constant->getType().getBasicString(), "");

    else

        spirvTypeParams->push_back(TSpirvTypeParameter(constant));

    return spirvTypeParams;

}

TSpirvTypeParameters* TParseContext::makeSpirvTypeParameters(const TSourceLoc& /* loc */,

                                                             const TPublicType& type)

{

    TSpirvTypeParameters* spirvTypeParams = new TSpirvTypeParameters;

    spirvTypeParams->push_back(TSpirvTypeParameter(new TType(type)));

    return spirvTypeParams;

}

TSpirvTypeParameters* TParseContext::mergeSpirvTypeParameters(TSpirvTypeParameters* spirvTypeParams1, TSpirvTypeParameters* spirvTypeParams2)

{

    // Merge SPIR-V type parameters of the second one to the first one

    for (const auto& spirvTypeParam : *spirvTypeParams2)

        spirvTypeParams1->push_back(spirvTypeParam);

    return spirvTypeParams1;

}

//

// Handle SPIR-V instruction qualifiers

//

TSpirvInstruction* TParseContext::makeSpirvInstruction(const TSourceLoc& loc, const TString& name, const TString& value)

{

    TSpirvInstruction* spirvInst = new TSpirvInstruction;

    if (name == "set")

        spirvInst->set = value;

    else

        error(loc, "unknown SPIR-V instruction qualifier", name.c_str(), "");

    return spirvInst;

}

TSpirvInstruction* TParseContext::makeSpirvInstruction(const TSourceLoc& loc, const TString& name, int value)

{

    TSpirvInstruction* spirvInstuction = new TSpirvInstruction;

    if (name == "id")

        spirvInstuction->id = value;

    else

        error(loc, "unknown SPIR-V instruction qualifier", name.c_str(), "");

    return spirvInstuction;

}

TSpirvInstruction* TParseContext::mergeSpirvInstruction(const TSourceLoc& loc, TSpirvInstruction* spirvInst1, TSpirvInstruction* spirvInst2)

{

    // Merge qualifiers of the second SPIR-V instruction to those of the first one

    if (!spirvInst2->set.empty()) {

        if (spirvInst1->set.empty())

            spirvInst1->set = spirvInst2->set;

        else

            error(loc, "too many SPIR-V instruction qualifiers", "spirv_instruction", "(set)");

    }

    if (spirvInst2->id != -1) {

        if (spirvInst1->id == -1)

            spirvInst1->id = spirvInst2->id;

        else

            error(loc, "too many SPIR-V instruction qualifiers", "spirv_instruction", "(id)");

    }

    return spirvInst1;

}

} // end namespace glslang