//

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

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

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

// Copyright (C) 2017, 2022-2024 Arm Limited.

// Modifications Copyright (C) 2020-2021 Advanced Micro Devices, Inc. All rights reserved.

//

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

//

//

// Create strings that declare built-in definitions, add built-ins programmatically

// that cannot be expressed in the strings, and establish mappings between

// built-in functions and operators.

//

// Where to put a built-in:

//   TBuiltIns::initialize(version,profile)       context-independent textual built-ins; add them to the right string

//   TBuiltIns::initialize(resources,...)         context-dependent textual built-ins; add them to the right string

//   TBuiltIns::identifyBuiltIns(...,symbolTable) context-independent programmatic additions/mappings to the symbol table,

//                                                including identifying what extensions are needed if a version does not allow a symbol

//   TBuiltIns::identifyBuiltIns(...,symbolTable, resources) context-dependent programmatic additions/mappings to the symbol table,

//                                                including identifying what extensions are needed if a version does not allow a symbol

//

#include <array>

#include <sstream>

#include "Initialize.h"

#include "span.h"

namespace glslang {

// TODO: ARB_Compatability: do full extension support

const bool ARBCompatibility = true;

const bool ForwardCompatibility = false;

namespace {

//

// A set of definitions for tabling of the built-in functions.

//

// Order matters here, as does correlation with the subsequent

// "const int ..." declarations and the ArgType enumerants.

const char* TypeString[] = {

   "bool",  "bvec2", "bvec3", "bvec4",

   "float",  "vec2",  "vec3",  "vec4",

   "int",   "ivec2", "ivec3", "ivec4",

   "uint",  "uvec2", "uvec3", "uvec4",

};

const int TypeStringCount = sizeof(TypeString) / sizeof(char*); // number of entries in 'TypeString'

const int TypeStringRowShift = 2;                               // shift amount to go downe one row in 'TypeString'

const int TypeStringColumnMask = (1 << TypeStringRowShift) - 1; // reduce type to its column number in 'TypeString'

const int TypeStringScalarMask = ~TypeStringColumnMask;         // take type to its scalar column in 'TypeString'

enum ArgType {

    // numbers hardcoded to correspond to 'TypeString'; order and value matter

    TypeB    = 1 << 0,  // Boolean

    TypeF    = 1 << 1,  // float 32

    TypeI    = 1 << 2,  // int 32

    TypeU    = 1 << 3,  // uint 32

    TypeF16  = 1 << 4,  // float 16

    TypeF64  = 1 << 5,  // float 64

    TypeI8   = 1 << 6,  // int 8

    TypeI16  = 1 << 7,  // int 16

    TypeI64  = 1 << 8,  // int 64

    TypeU8   = 1 << 9,  // uint 8

    TypeU16  = 1 << 10, // uint 16

    TypeU64  = 1 << 11, // uint 64

};

// Mixtures of the above, to help the function tables

const ArgType TypeFI  = static_cast<ArgType>(TypeF | TypeI);

const ArgType TypeFIB = static_cast<ArgType>(TypeF | TypeI | TypeB);

const ArgType TypeIU  = static_cast<ArgType>(TypeI | TypeU);

// The relationships between arguments and return type, whether anything is

// output, or other unusual situations.

enum ArgClass {

    ClassRegular     = 0,  // nothing special, just all vector widths with matching return type; traditional arithmetic

    ClassLS     = 1 << 0,  // the last argument is also held fixed as a (type-matched) scalar while the others cycle

    ClassXLS    = 1 << 1,  // the last argument is exclusively a (type-matched) scalar while the others cycle

    ClassLS2    = 1 << 2,  // the last two arguments are held fixed as a (type-matched) scalar while the others cycle

    ClassFS     = 1 << 3,  // the first argument is held fixed as a (type-matched) scalar while the others cycle

    ClassFS2    = 1 << 4,  // the first two arguments are held fixed as a (type-matched) scalar while the others cycle

    ClassLO     = 1 << 5,  // the last argument is an output

    ClassB      = 1 << 6,  // return type cycles through only bool/bvec, matching vector width of args

    ClassLB     = 1 << 7,  // last argument cycles through only bool/bvec, matching vector width of args

    ClassV1     = 1 << 8,  // scalar only

    ClassFIO    = 1 << 9,  // first argument is inout

    ClassRS     = 1 << 10, // the return is held scalar as the arguments cycle

    ClassNS     = 1 << 11, // no scalar prototype

    ClassCVN    = 1 << 12, // first argument is 'coherent volatile nontemporal'

    ClassFO     = 1 << 13, // first argument is output

    ClassV3     = 1 << 14, // vec3 only

};

// Mixtures of the above, to help the function tables

const ArgClass ClassV1FIOCVN = (ArgClass)(ClassV1 | ClassFIO | ClassCVN);

const ArgClass ClassBNS     = (ArgClass)(ClassB  | ClassNS);

const ArgClass ClassRSNS    = (ArgClass)(ClassRS | ClassNS);

// A descriptor, for a single profile, of when something is available.

// If the current profile does not match 'profile' mask below, the other fields

// do not apply (nor validate).

// profiles == EBadProfile is the end of an array of these

struct Versioning {

    EProfile profiles;       // the profile(s) (mask) that the following fields are valid for

    int minExtendedVersion;  // earliest version when extensions are enabled; ignored if numExtensions is 0

    int minCoreVersion;      // earliest version function is in core; 0 means never

    int numExtensions;       // how many extensions are in the 'extensions' list

    const char** extensions; // list of extension names enabling the function

};

EProfile EDesktopProfile = static_cast<EProfile>(ENoProfile | ECoreProfile | ECompatibilityProfile);

// Declare pointers to put into the table for versioning.

    const std::array Es300Desktop130Version = { Versioning{ EEsProfile,      0, 300, 0, nullptr },

                                                Versioning{ EDesktopProfile, 0, 130, 0, nullptr },

                                              };

    const std::array Es310Desktop400Version = { Versioning{ EEsProfile,      0, 310, 0, nullptr },

                                                Versioning{ EDesktopProfile, 0, 400, 0, nullptr },

                                              };

    const std::array Es310Desktop450Version = { Versioning{ EEsProfile,      0, 310, 0, nullptr },

                                                Versioning{ EDesktopProfile, 0, 450, 0, nullptr },

                                              };

// The main descriptor of what a set of function prototypes can look like, and

// a pointer to extra versioning information, when needed.

struct BuiltInFunction {

    TOperator op;                 // operator to map the name to

    const char* name;             // function name

    int numArguments;             // number of arguments (overloads with varying arguments need different entries)

    ArgType types;                // ArgType mask

    ArgClass classes;             // the ways this particular function entry manifests

    const span<const Versioning> versioning; // An empty span means always a valid version

};

// The tables can have the same built-in function name more than one time,

// but the exact same prototype must be indicated at most once.

// The prototypes that get declared are the union of all those indicated.

// This is important when different releases add new prototypes for the same name.

// It also also congnitively simpler tiling of the prototype space.

// In practice, most names can be fully represented with one entry.

//

// Table is terminated by an OpNull TOperator.

const std::array BaseFunctions = {

//    TOperator,           name,       arg-count,   ArgType,   ArgClass,     versioning

//    ---------            ----        ---------    -------    --------      ----------

    BuiltInFunction{ EOpRadians,          "radians",          1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpDegrees,          "degrees",          1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpSin,              "sin",              1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpCos,              "cos",              1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpTan,              "tan",              1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpAsin,             "asin",             1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpAcos,             "acos",             1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpAtan,             "atan",             2,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpAtan,             "atan",             1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpPow,              "pow",              2,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpExp,              "exp",              1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpLog,              "log",              1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpExp2,             "exp2",             1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpLog2,             "log2",             1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpSqrt,             "sqrt",             1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpInverseSqrt,      "inversesqrt",      1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpAbs,              "abs",              1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpSign,             "sign",             1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpFloor,            "floor",            1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpCeil,             "ceil",             1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpFract,            "fract",            1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpMod,              "mod",              2,   TypeF,     ClassLS,      {} },

    BuiltInFunction{ EOpMin,              "min",              2,   TypeF,     ClassLS,      {} },

    BuiltInFunction{ EOpMax,              "max",              2,   TypeF,     ClassLS,      {} },

    BuiltInFunction{ EOpClamp,            "clamp",            3,   TypeF,     ClassLS2,     {} },

    BuiltInFunction{ EOpMix,              "mix",              3,   TypeF,     ClassLS,      {} },

    BuiltInFunction{ EOpStep,             "step",             2,   TypeF,     ClassFS,      {} },

    BuiltInFunction{ EOpSmoothStep,       "smoothstep",       3,   TypeF,     ClassFS2,     {} },

    BuiltInFunction{ EOpNormalize,        "normalize",        1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpFaceForward,      "faceforward",      3,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpReflect,          "reflect",          2,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpRefract,          "refract",          3,   TypeF,     ClassXLS,     {} },

    BuiltInFunction{ EOpLength,           "length",           1,   TypeF,     ClassRS,      {} },

    BuiltInFunction{ EOpDistance,         "distance",         2,   TypeF,     ClassRS,      {} },

    BuiltInFunction{ EOpDot,              "dot",              2,   TypeF,     ClassRS,      {} },

    BuiltInFunction{ EOpCross,            "cross",            2,   TypeF,     ClassV3,      {} },

    BuiltInFunction{ EOpLessThan,         "lessThan",         2,   TypeFI,    ClassBNS,     {} },

    BuiltInFunction{ EOpLessThanEqual,    "lessThanEqual",    2,   TypeFI,    ClassBNS,     {} },

    BuiltInFunction{ EOpGreaterThan,      "greaterThan",      2,   TypeFI,    ClassBNS,     {} },

    BuiltInFunction{ EOpGreaterThanEqual, "greaterThanEqual", 2,   TypeFI,    ClassBNS,     {} },

    BuiltInFunction{ EOpVectorEqual,      "equal",            2,   TypeFIB,   ClassBNS,     {} },

    BuiltInFunction{ EOpVectorNotEqual,   "notEqual",         2,   TypeFIB,   ClassBNS,     {} },

    BuiltInFunction{ EOpAny,              "any",              1,   TypeB,     ClassRSNS,    {} },

    BuiltInFunction{ EOpAll,              "all",              1,   TypeB,     ClassRSNS,    {} },

    BuiltInFunction{ EOpVectorLogicalNot, "not",              1,   TypeB,     ClassNS,      {} },

    BuiltInFunction{ EOpSinh,             "sinh",             1,   TypeF,     ClassRegular, {Es300Desktop130Version} },

    BuiltInFunction{ EOpCosh,             "cosh",             1,   TypeF,     ClassRegular, {Es300Desktop130Version} },

    BuiltInFunction{ EOpTanh,             "tanh",             1,   TypeF,     ClassRegular, {Es300Desktop130Version} },

    BuiltInFunction{ EOpAsinh,            "asinh",            1,   TypeF,     ClassRegular, {Es300Desktop130Version} },

    BuiltInFunction{ EOpAcosh,            "acosh",            1,   TypeF,     ClassRegular, {Es300Desktop130Version} },

    BuiltInFunction{ EOpAtanh,            "atanh",            1,   TypeF,     ClassRegular, {Es300Desktop130Version} },

    BuiltInFunction{ EOpAbs,              "abs",              1,   TypeI,     ClassRegular, {Es300Desktop130Version} },

    BuiltInFunction{ EOpSign,             "sign",             1,   TypeI,     ClassRegular, {Es300Desktop130Version} },

    BuiltInFunction{ EOpTrunc,            "trunc",            1,   TypeF,     ClassRegular, {Es300Desktop130Version} },

    BuiltInFunction{ EOpRound,            "round",            1,   TypeF,     ClassRegular, {Es300Desktop130Version} },

    BuiltInFunction{ EOpRoundEven,        "roundEven",        1,   TypeF,     ClassRegular, {Es300Desktop130Version} },

    BuiltInFunction{ EOpModf,             "modf",             2,   TypeF,     ClassLO,      {Es300Desktop130Version} },

    BuiltInFunction{ EOpMin,              "min",              2,   TypeIU,    ClassLS,      {Es300Desktop130Version} },

    BuiltInFunction{ EOpMax,              "max",              2,   TypeIU,    ClassLS,      {Es300Desktop130Version} },

    BuiltInFunction{ EOpClamp,            "clamp",            3,   TypeIU,    ClassLS2,     {Es300Desktop130Version} },

    BuiltInFunction{ EOpMix,              "mix",              3,   TypeF,     ClassLB,      {Es300Desktop130Version} },

    BuiltInFunction{ EOpIsInf,            "isinf",            1,   TypeF,     ClassB,       {Es300Desktop130Version} },

    BuiltInFunction{ EOpIsNan,            "isnan",            1,   TypeF,     ClassB,       {Es300Desktop130Version} },

    BuiltInFunction{ EOpLessThan,         "lessThan",         2,   TypeU,     ClassBNS,     {Es300Desktop130Version} },

    BuiltInFunction{ EOpLessThanEqual,    "lessThanEqual",    2,   TypeU,     ClassBNS,     {Es300Desktop130Version} },

    BuiltInFunction{ EOpGreaterThan,      "greaterThan",      2,   TypeU,     ClassBNS,     {Es300Desktop130Version} },

    BuiltInFunction{ EOpGreaterThanEqual, "greaterThanEqual", 2,   TypeU,     ClassBNS,     {Es300Desktop130Version} },

    BuiltInFunction{ EOpVectorEqual,      "equal",            2,   TypeU,     ClassBNS,     {Es300Desktop130Version} },

    BuiltInFunction{ EOpVectorNotEqual,   "notEqual",         2,   TypeU,     ClassBNS,     {Es300Desktop130Version} },

    BuiltInFunction{ EOpAtomicAdd,        "atomicAdd",        2,   TypeIU,    ClassV1FIOCVN, {Es310Desktop400Version} },

    BuiltInFunction{ EOpAtomicMin,        "atomicMin",        2,   TypeIU,    ClassV1FIOCVN, {Es310Desktop400Version} },

    BuiltInFunction{ EOpAtomicMax,        "atomicMax",        2,   TypeIU,    ClassV1FIOCVN, {Es310Desktop400Version} },

    BuiltInFunction{ EOpAtomicAnd,        "atomicAnd",        2,   TypeIU,    ClassV1FIOCVN, {Es310Desktop400Version} },

    BuiltInFunction{ EOpAtomicOr,         "atomicOr",         2,   TypeIU,    ClassV1FIOCVN, {Es310Desktop400Version} },

    BuiltInFunction{ EOpAtomicXor,        "atomicXor",        2,   TypeIU,    ClassV1FIOCVN, {Es310Desktop400Version} },

    BuiltInFunction{ EOpAtomicExchange,   "atomicExchange",   2,   TypeIU,    ClassV1FIOCVN, {Es310Desktop400Version} },

    BuiltInFunction{ EOpAtomicCompSwap,   "atomicCompSwap",   3,   TypeIU,    ClassV1FIOCVN, {Es310Desktop400Version} },

    BuiltInFunction{ EOpMix,              "mix",              3,   TypeB,     ClassRegular, {Es310Desktop450Version} },

    BuiltInFunction{ EOpMix,              "mix",              3,   TypeIU,    ClassLB,      {Es310Desktop450Version} },

};

const std::array DerivativeFunctions = {

    BuiltInFunction{ EOpDPdx,             "dFdx",             1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpDPdy,             "dFdy",             1,   TypeF,     ClassRegular, {} },

    BuiltInFunction{ EOpFwidth,           "fwidth",           1,   TypeF,     ClassRegular, {} },

};

// For functions declared some other way, but still use the table to relate to operator.

struct CustomFunction {

    TOperator op;                 // operator to map the name to

    const char* name;             // function name

    const span<const Versioning> versioning; // An empty span means always a valid version

};

const CustomFunction CustomFunctions[] = {

    { EOpBarrier,             "barrier",             {} },

    { EOpMemoryBarrierShared, "memoryBarrierShared", {} },

    { EOpGroupMemoryBarrier,  "groupMemoryBarrier",  {} },

    { EOpMemoryBarrier,       "memoryBarrier",       {} },

    { EOpMemoryBarrierBuffer, "memoryBarrierBuffer", {} },

    { EOpPackSnorm2x16,       "packSnorm2x16",       {} },

    { EOpUnpackSnorm2x16,     "unpackSnorm2x16",     {} },

    { EOpPackUnorm2x16,       "packUnorm2x16",       {} },

    { EOpUnpackUnorm2x16,     "unpackUnorm2x16",     {} },

    { EOpPackHalf2x16,        "packHalf2x16",        {} },

    { EOpUnpackHalf2x16,      "unpackHalf2x16",      {} },

    { EOpMul,                 "matrixCompMult",      {} },

    { EOpOuterProduct,        "outerProduct",        {} },

    { EOpTranspose,           "transpose",           {} },

    { EOpDeterminant,         "determinant",         {} },

    { EOpMatrixInverse,       "inverse",             {} },

    { EOpFloatBitsToInt,      "floatBitsToInt",      {} },

    { EOpFloatBitsToUint,     "floatBitsToUint",     {} },

    { EOpIntBitsToFloat,      "intBitsToFloat",      {} },

    { EOpUintBitsToFloat,     "uintBitsToFloat",     {} },

    { EOpTextureQuerySize,      "textureSize",           {} },

    { EOpTextureQueryLod,       "textureQueryLod",       {} },

    { EOpTextureQueryLod,       "textureQueryLOD",       {} }, // extension GL_ARB_texture_query_lod

    { EOpTextureQueryLevels,    "textureQueryLevels",    {} },

    { EOpTextureQuerySamples,   "textureSamples",        {} },

    { EOpTexture,               "texture",               {} },

    { EOpTextureProj,           "textureProj",           {} },

    { EOpTextureLod,            "textureLod",            {} },

    { EOpTextureOffset,         "textureOffset",         {} },

    { EOpTextureFetch,          "texelFetch",            {} },

    { EOpTextureFetchOffset,    "texelFetchOffset",      {} },

    { EOpTextureProjOffset,     "textureProjOffset",     {} },

    { EOpTextureLodOffset,      "textureLodOffset",      {} },

    { EOpTextureProjLod,        "textureProjLod",        {} },

    { EOpTextureProjLodOffset,  "textureProjLodOffset",  {} },

    { EOpTextureGrad,           "textureGrad",           {} },

    { EOpTextureGradOffset,     "textureGradOffset",     {} },

    { EOpTextureProjGrad,       "textureProjGrad",       {} },

    { EOpTextureProjGradOffset, "textureProjGradOffset", {} },

};

// For the given table of functions, add all the indicated prototypes for each

// one, to be returned in the passed in decls.

void AddTabledBuiltin(TString& decls, const BuiltInFunction& function)

{

    const auto isScalarType = [](int type) { return (type & TypeStringColumnMask) == 0; };

    // loop across these two:

    //  0: the varying arg set, and

    //  1: the fixed scalar args

    const ArgClass ClassFixed = (ArgClass)(ClassLS | ClassXLS | ClassLS2 | ClassFS | ClassFS2);

    for (int fixed = 0; fixed < ((function.classes & ClassFixed) > 0 ? 2 : 1); ++fixed) {

        if (fixed == 0 && (function.classes & ClassXLS))

            continue;

        // walk the type strings in TypeString[]

        for (int type = 0; type < TypeStringCount; ++type) {

            // skip types not selected: go from type to row number to type bit

            if ((function.types & (1 << (type >> TypeStringRowShift))) == 0)

                continue;

            // if we aren't on a scalar, and should be, skip

            if ((function.classes & ClassV1) && !isScalarType(type))

                continue;

            // if we aren't on a 3-vector, and should be, skip

            if ((function.classes & ClassV3) && (type & TypeStringColumnMask) != 2)

                continue;

            // skip replication of all arg scalars between the varying arg set and the fixed args

            if (fixed == 1 && type == (type & TypeStringScalarMask) && (function.classes & ClassXLS) == 0)

                continue;

            // skip scalars when we are told to

            if ((function.classes & ClassNS) && isScalarType(type))

                continue;

            // return type

            if (function.classes & ClassB)

                decls.append(TypeString[type & TypeStringColumnMask]);

            else if (function.classes & ClassRS)

                decls.append(TypeString[type & TypeStringScalarMask]);

            else

                decls.append(TypeString[type]);

            decls.append(" ");

            decls.append(function.name);

            decls.append("(");

            // arguments

            for (int arg = 0; arg < function.numArguments; ++arg) {

                if (arg == function.numArguments - 1 && (function.classes & ClassLO))

                    decls.append("out ");

                if (arg == 0) {

                    if (function.classes & ClassCVN)

                        decls.append("coherent volatile nontemporal ");

                    if (function.classes & ClassFIO)

                        decls.append("inout ");

                    if (function.classes & ClassFO)

                        decls.append("out ");

                }

                if ((function.classes & ClassLB) && arg == function.numArguments - 1)

                    decls.append(TypeString[type & TypeStringColumnMask]);

                else if (fixed && ((arg == function.numArguments - 1 && (function.classes & (ClassLS | ClassXLS |

                                                                                                       ClassLS2))) ||

                                   (arg == function.numArguments - 2 && (function.classes & ClassLS2))             ||

                                   (arg == 0                         && (function.classes & (ClassFS | ClassFS2))) ||

                                   (arg == 1                         && (function.classes & ClassFS2))))

                    decls.append(TypeString[type & TypeStringScalarMask]);

                else

                    decls.append(TypeString[type]);

                if (arg < function.numArguments - 1)

                    decls.append(",");

            }

            decls.append(");\n");

        }

    }

}

// Add long vector prototype for the builtin function. This is similar to

// AddTabledBuiltin, but only generates builtins where one type is an

// arbitrary vector. See comments on "enum ArgClass" for more details.

void AddLongVectorBuiltin(TString& decls, const BuiltInFunction& function)

{

    const auto isScalarType = [](int type) { return (type & TypeStringColumnMask) == 0; };

    // loop across these two:

    //  0: the varying arg set, and

    //  1: the fixed scalar args

    const ArgClass ClassFixed = (ArgClass)(ClassLS | ClassXLS | ClassLS2 | ClassFS | ClassFS2);

    for (int fixed = 0; fixed < ((function.classes & ClassFixed) > 0 ? 2 : 1); ++fixed) {

        if (fixed == 0 && (function.classes & ClassXLS))

            continue;

        // Iterate over the different scalar types (needed for ClassRS)

        for (int type = 0; type < TypeStringCount; ++type) {

            if (!isScalarType(type))

                continue;

            // skip types not selected: go from type to row number to type bit

            if ((function.types & (1 << (type >> TypeStringRowShift))) == 0)

                continue;

            // skip scalar-only

            if (function.classes & ClassV1)

                continue;

            // skip 3-vector

            if (function.classes & ClassV3)

                continue;

            TString decl;

            // return type

            if (function.classes & ClassB)

                decl.append("vector");

            else if (function.classes & ClassRS)

                decl.append(TypeString[type & TypeStringScalarMask]);

            else

                decl.append("vector");

            decl.append(" ");

            decl.append(function.name);

            decl.append("(");

            // arguments

            for (int arg = 0; arg < function.numArguments; ++arg) {

                if (arg == function.numArguments - 1 && (function.classes & ClassLO))

                    decl.append("out ");

                if (arg == 0) {

                    if (function.classes & ClassCVN)

                        decl.append("coherent volatile nontemporal ");

                    if (function.classes & ClassFIO)

                        decl.append("inout ");

                    if (function.classes & ClassFO)

                        decl.append("out ");

                }

                if ((function.classes & ClassLB) && arg == function.numArguments - 1)

                    decl.append("vector");

                else if (fixed && ((arg == function.numArguments - 1 && (function.classes & (ClassLS | ClassXLS |

                                                                                                       ClassLS2))) ||

                                   (arg == function.numArguments - 2 && (function.classes & ClassLS2))             ||

                                   (arg == 0                         && (function.classes & (ClassFS | ClassFS2))) ||

                                   (arg == 1                         && (function.classes & ClassFS2))))

                    decl.append(TypeString[type & TypeStringScalarMask]);

                else

                    decl.append("vector");

                if (arg < function.numArguments - 1)

                    decl.append(",");

            }

            decl.append(");\n");

            decls.append(decl);

        }

    }

}

// See if the tabled versioning information allows the current version.

bool ValidVersion(const BuiltInFunction& function, int version, EProfile profile, const SpvVersion& /* spVersion */)

{

    // nullptr means always valid

    if (function.versioning.empty())

        return true;

    // check for what is said about our current profile

    for (const auto& v : function.versioning) {

        if ((v.profiles & profile) != 0) {

            if (v.minCoreVersion <= version || (v.numExtensions > 0 && v.minExtendedVersion <= version))

                return true;

        }

    }

    return false;

}

// Relate a single table of built-ins to their AST operator.

// This can get called redundantly (especially for the common built-ins, when

// called once per stage). This is a performance issue only, not a correctness

// concern.  It is done for quality arising from simplicity, as there are subtleties

// to get correct if instead trying to do it surgically.

template<class FunctionContainer>

void RelateTabledBuiltins(const FunctionContainer& functions, TSymbolTable& symbolTable)

{

    for (const auto& fn : functions) {

        symbolTable.relateToOperator(fn.name, fn.op);

    }

}

Initialize.cpp:void glslang::(anonymous namespace)::RelateTabledBuiltins<std::__1::array<glslang::(anonymous namespace)::BuiltInFunction, 79ul> >(std::__1::array<glslang::(anonymous namespace)::BuiltInFunction, 79ul> const&, glslang::TSymbolTable&)

Line

Count

Source

499

23.4k

{

500

1.84M

    for (const auto& fn : functions) {

501

1.84M

        symbolTable.relateToOperator(fn.name, fn.op);

502

1.84M

    }

503

23.4k

}

Initialize.cpp:void glslang::(anonymous namespace)::RelateTabledBuiltins<std::__1::array<glslang::(anonymous namespace)::BuiltInFunction, 3ul> >(std::__1::array<glslang::(anonymous namespace)::BuiltInFunction, 3ul> const&, glslang::TSymbolTable&)

Line

Count

Source

499

23.4k

{

500

70.2k

    for (const auto& fn : functions) {

501

70.2k

        symbolTable.relateToOperator(fn.name, fn.op);

502

70.2k

    }

503

23.4k

}

Initialize.cpp:void glslang::(anonymous namespace)::RelateTabledBuiltins<glslang::(anonymous namespace)::CustomFunction [39]>(glslang::(anonymous namespace)::CustomFunction const (&) [39], glslang::TSymbolTable&)

Line

Count

Source

499

23.4k

{

500

913k

    for (const auto& fn : functions) {

501

913k

        symbolTable.relateToOperator(fn.name, fn.op);

502

913k

    }

503

23.4k

}

} // end anonymous namespace

// Add declarations for all tables of built-in functions.

void TBuiltIns::addTabledBuiltins(int version, EProfile profile, const SpvVersion& spvVersion)

{

    const auto forEachFunction = [&](TString& decls, const span<const BuiltInFunction>& functions) {

        for (const auto& fn : functions) {

            if (ValidVersion(fn, version, profile, spvVersion)) {

                AddTabledBuiltin(decls, fn);

                if (profile != EEsProfile) {

                    AddLongVectorBuiltin(decls, fn);

                }

            }

        }

    };

    forEachFunction(commonBuiltins, BaseFunctions);

    forEachFunction(stageBuiltins[EShLangFragment], DerivativeFunctions);

    if ((profile == EEsProfile && version >= 320) || (profile != EEsProfile && version >= 450))

        forEachFunction(stageBuiltins[EShLangCompute], DerivativeFunctions);

}

// Relate all tables of built-ins to the AST operators.

void TBuiltIns::relateTabledBuiltins(int /* version */, EProfile /* profile */, const SpvVersion& /* spvVersion */, EShLanguage /* stage */, TSymbolTable& symbolTable)

{

    RelateTabledBuiltins(BaseFunctions, symbolTable);

    RelateTabledBuiltins(DerivativeFunctions, symbolTable);

    RelateTabledBuiltins(CustomFunctions, symbolTable);

}

inline bool IncludeLegacy(int version, EProfile profile, const SpvVersion& spvVersion)

{

    return profile != EEsProfile && (version <= 130 || (spvVersion.spv == 0 && version == 140 && ARBCompatibility) ||

           profile == ECompatibilityProfile);

}

// Construct TBuiltInParseables base class.  This can be used for language-common constructs.

TBuiltInParseables::TBuiltInParseables()

{

}

// Destroy TBuiltInParseables.

TBuiltInParseables::~TBuiltInParseables()

{

}

TBuiltIns::TBuiltIns()

{

    // Set up textual representations for making all the permutations

    // of texturing/imaging functions.

    prefixes[EbtFloat] =  "";

    prefixes[EbtInt]   = "i";

    prefixes[EbtUint]  = "u";

    prefixes[EbtFloat16] = "f16";

    prefixes[EbtInt8]  = "i8";

    prefixes[EbtUint8] = "u8";

    prefixes[EbtInt16]  = "i16";

    prefixes[EbtUint16] = "u16";

    prefixes[EbtInt64]  = "i64";

    prefixes[EbtUint64] = "u64";

    postfixes[2] = "2";

    postfixes[3] = "3";

    postfixes[4] = "4";

    // Map from symbolic class of texturing dimension to numeric dimensions.

    dimMap[Esd2D] = 2;

    dimMap[Esd3D] = 3;

    dimMap[EsdCube] = 3;

    dimMap[Esd1D] = 1;

    dimMap[EsdRect] = 2;

    dimMap[EsdBuffer] = 1;

    dimMap[EsdSubpass] = 2;  // potentially unused for now

    dimMap[EsdAttachmentEXT] = 2;  // potentially unused for now

}

TBuiltIns::~TBuiltIns()

{

}

//

// Add all context-independent built-in functions and variables that are present

// for the given version and profile.  Share common ones across stages, otherwise

// make stage-specific entries.

//

// Most built-ins variables can be added as simple text strings.  Some need to

// be added programmatically, which is done later in IdentifyBuiltIns() below.

//

void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvVersion)

{

    addTabledBuiltins(version, profile, spvVersion);

    //============================================================================

    //

    // Prototypes for built-in functions used repeatly by different shaders

    //

    //============================================================================

    //

    // Derivatives Functions.

    //

    TString derivativeControls (

        "float dFdxFine(float p);"

        "vec2  dFdxFine(vec2  p);"

        "vec3  dFdxFine(vec3  p);"

        "vec4  dFdxFine(vec4  p);"

        "float dFdyFine(float p);"

        "vec2  dFdyFine(vec2  p);"

        "vec3  dFdyFine(vec3  p);"

        "vec4  dFdyFine(vec4  p);"

        "float fwidthFine(float p);"

        "vec2  fwidthFine(vec2  p);"

        "vec3  fwidthFine(vec3  p);"

        "vec4  fwidthFine(vec4  p);"

        "float dFdxCoarse(float p);"

        "vec2  dFdxCoarse(vec2  p);"

        "vec3  dFdxCoarse(vec3  p);"

        "vec4  dFdxCoarse(vec4  p);"

        "float dFdyCoarse(float p);"

        "vec2  dFdyCoarse(vec2  p);"

        "vec3  dFdyCoarse(vec3  p);"

        "vec4  dFdyCoarse(vec4  p);"

        "float fwidthCoarse(float p);"

        "vec2  fwidthCoarse(vec2  p);"

        "vec3  fwidthCoarse(vec3  p);"

        "vec4  fwidthCoarse(vec4  p);"

    );

    TString derivativesAndControl16bits (

        "float16_t dFdx(float16_t);"

        "f16vec2   dFdx(f16vec2);"

        "f16vec3   dFdx(f16vec3);"

        "f16vec4   dFdx(f16vec4);"

        "float16_t dFdy(float16_t);"

        "f16vec2   dFdy(f16vec2);"

        "f16vec3   dFdy(f16vec3);"

        "f16vec4   dFdy(f16vec4);"

        "float16_t dFdxFine(float16_t);"

        "f16vec2   dFdxFine(f16vec2);"

        "f16vec3   dFdxFine(f16vec3);"

        "f16vec4   dFdxFine(f16vec4);"

        "float16_t dFdyFine(float16_t);"

        "f16vec2   dFdyFine(f16vec2);"

        "f16vec3   dFdyFine(f16vec3);"

        "f16vec4   dFdyFine(f16vec4);"

        "float16_t dFdxCoarse(float16_t);"

        "f16vec2   dFdxCoarse(f16vec2);"

        "f16vec3   dFdxCoarse(f16vec3);"

        "f16vec4   dFdxCoarse(f16vec4);"

        "float16_t dFdyCoarse(float16_t);"

        "f16vec2   dFdyCoarse(f16vec2);"

        "f16vec3   dFdyCoarse(f16vec3);"

        "f16vec4   dFdyCoarse(f16vec4);"

        "float16_t fwidth(float16_t);"

        "f16vec2   fwidth(f16vec2);"

        "f16vec3   fwidth(f16vec3);"

        "f16vec4   fwidth(f16vec4);"

        "float16_t fwidthFine(float16_t);"

        "f16vec2   fwidthFine(f16vec2);"

        "f16vec3   fwidthFine(f16vec3);"

        "f16vec4   fwidthFine(f16vec4);"

        "float16_t fwidthCoarse(float16_t);"

        "f16vec2   fwidthCoarse(f16vec2);"

        "f16vec3   fwidthCoarse(f16vec3);"

        "f16vec4   fwidthCoarse(f16vec4);"

    );

    TString derivativesAndControl64bits (

        "float64_t dFdx(float64_t);"

        "f64vec2   dFdx(f64vec2);"

        "f64vec3   dFdx(f64vec3);"

        "f64vec4   dFdx(f64vec4);"

        "float64_t dFdy(float64_t);"

        "f64vec2   dFdy(f64vec2);"

        "f64vec3   dFdy(f64vec3);"

        "f64vec4   dFdy(f64vec4);"

        "float64_t dFdxFine(float64_t);"

        "f64vec2   dFdxFine(f64vec2);"

        "f64vec3   dFdxFine(f64vec3);"

        "f64vec4   dFdxFine(f64vec4);"

        "float64_t dFdyFine(float64_t);"

        "f64vec2   dFdyFine(f64vec2);"

        "f64vec3   dFdyFine(f64vec3);"

        "f64vec4   dFdyFine(f64vec4);"

        "float64_t dFdxCoarse(float64_t);"

        "f64vec2   dFdxCoarse(f64vec2);"

        "f64vec3   dFdxCoarse(f64vec3);"

        "f64vec4   dFdxCoarse(f64vec4);"

        "float64_t dFdyCoarse(float64_t);"

        "f64vec2   dFdyCoarse(f64vec2);"

        "f64vec3   dFdyCoarse(f64vec3);"

        "f64vec4   dFdyCoarse(f64vec4);"

        "float64_t fwidth(float64_t);"

        "f64vec2   fwidth(f64vec2);"

        "f64vec3   fwidth(f64vec3);"

        "f64vec4   fwidth(f64vec4);"

        "float64_t fwidthFine(float64_t);"

        "f64vec2   fwidthFine(f64vec2);"

        "f64vec3   fwidthFine(f64vec3);"

        "f64vec4   fwidthFine(f64vec4);"

        "float64_t fwidthCoarse(float64_t);"

        "f64vec2   fwidthCoarse(f64vec2);"

        "f64vec3   fwidthCoarse(f64vec3);"

        "f64vec4   fwidthCoarse(f64vec4);"

    );

    //============================================================================

    //

    // Prototypes for built-in functions seen by both vertex and fragment shaders.

    //

    //============================================================================

    //

    // double functions added to desktop 4.00, but not fma, frexp, ldexp, or pack/unpack

    //

    if (profile != EEsProfile && version >= 150) {  // ARB_gpu_shader_fp64

        commonBuiltins.append(

            "double sqrt(double);"

            "dvec2  sqrt(dvec2);"

            "dvec3  sqrt(dvec3);"

            "dvec4  sqrt(dvec4);"

            "double inversesqrt(double);"

            "dvec2  inversesqrt(dvec2);"

            "dvec3  inversesqrt(dvec3);"

            "dvec4  inversesqrt(dvec4);"

            "double abs(double);"

            "dvec2  abs(dvec2);"

            "dvec3  abs(dvec3);"

            "dvec4  abs(dvec4);"

            "double sign(double);"

            "dvec2  sign(dvec2);"

            "dvec3  sign(dvec3);"

            "dvec4  sign(dvec4);"

            "double floor(double);"

            "dvec2  floor(dvec2);"

            "dvec3  floor(dvec3);"

            "dvec4  floor(dvec4);"

            "double trunc(double);"

            "dvec2  trunc(dvec2);"

            "dvec3  trunc(dvec3);"

            "dvec4  trunc(dvec4);"

            "double round(double);"

            "dvec2  round(dvec2);"

            "dvec3  round(dvec3);"

            "dvec4  round(dvec4);"

            "double roundEven(double);"

            "dvec2  roundEven(dvec2);"

            "dvec3  roundEven(dvec3);"

            "dvec4  roundEven(dvec4);"

            "double ceil(double);"

            "dvec2  ceil(dvec2);"

            "dvec3  ceil(dvec3);"

            "dvec4  ceil(dvec4);"

            "double fract(double);"

            "dvec2  fract(dvec2);"

            "dvec3  fract(dvec3);"

            "dvec4  fract(dvec4);"

            "double mod(double, double);"

            "dvec2  mod(dvec2 , double);"

            "dvec3  mod(dvec3 , double);"

            "dvec4  mod(dvec4 , double);"

            "dvec2  mod(dvec2 , dvec2);"

            "dvec3  mod(dvec3 , dvec3);"

            "dvec4  mod(dvec4 , dvec4);"

            "double modf(double, out double);"

            "dvec2  modf(dvec2,  out dvec2);"

            "dvec3  modf(dvec3,  out dvec3);"

            "dvec4  modf(dvec4,  out dvec4);"

            "double min(double, double);"

            "dvec2  min(dvec2,  double);"

            "dvec3  min(dvec3,  double);"

            "dvec4  min(dvec4,  double);"

            "dvec2  min(dvec2,  dvec2);"

            "dvec3  min(dvec3,  dvec3);"

            "dvec4  min(dvec4,  dvec4);"

            "double max(double, double);"

            "dvec2  max(dvec2 , double);"

            "dvec3  max(dvec3 , double);"

            "dvec4  max(dvec4 , double);"

            "dvec2  max(dvec2 , dvec2);"

            "dvec3  max(dvec3 , dvec3);"

            "dvec4  max(dvec4 , dvec4);"

            "double clamp(double, double, double);"

            "dvec2  clamp(dvec2 , double, double);"

            "dvec3  clamp(dvec3 , double, double);"

            "dvec4  clamp(dvec4 , double, double);"

            "dvec2  clamp(dvec2 , dvec2 , dvec2);"

            "dvec3  clamp(dvec3 , dvec3 , dvec3);"

            "dvec4  clamp(dvec4 , dvec4 , dvec4);"

            "double mix(double, double, double);"

            "dvec2  mix(dvec2,  dvec2,  double);"

            "dvec3  mix(dvec3,  dvec3,  double);"

            "dvec4  mix(dvec4,  dvec4,  double);"

            "dvec2  mix(dvec2,  dvec2,  dvec2);"

            "dvec3  mix(dvec3,  dvec3,  dvec3);"

            "dvec4  mix(dvec4,  dvec4,  dvec4);"

            "double mix(double, double, bool);"

            "dvec2  mix(dvec2,  dvec2,  bvec2);"

            "dvec3  mix(dvec3,  dvec3,  bvec3);"

            "dvec4  mix(dvec4,  dvec4,  bvec4);"

            "double step(double, double);"

            "dvec2  step(dvec2 , dvec2);"

            "dvec3  step(dvec3 , dvec3);"

            "dvec4  step(dvec4 , dvec4);"

            "dvec2  step(double, dvec2);"

            "dvec3  step(double, dvec3);"

            "dvec4  step(double, dvec4);"

            "double smoothstep(double, double, double);"

            "dvec2  smoothstep(dvec2 , dvec2 , dvec2);"

            "dvec3  smoothstep(dvec3 , dvec3 , dvec3);"

            "dvec4  smoothstep(dvec4 , dvec4 , dvec4);"

            "dvec2  smoothstep(double, double, dvec2);"

            "dvec3  smoothstep(double, double, dvec3);"

            "dvec4  smoothstep(double, double, dvec4);"

            "bool  isnan(double);"

            "bvec2 isnan(dvec2);"

            "bvec3 isnan(dvec3);"

            "bvec4 isnan(dvec4);"

            "bool  isinf(double);"

            "bvec2 isinf(dvec2);"

            "bvec3 isinf(dvec3);"

            "bvec4 isinf(dvec4);"

            "double length(double);"

            "double length(dvec2);"

            "double length(dvec3);"

            "double length(dvec4);"

            "double distance(double, double);"

            "double distance(dvec2 , dvec2);"

            "double distance(dvec3 , dvec3);"

            "double distance(dvec4 , dvec4);"

            "double dot(double, double);"

            "double dot(dvec2 , dvec2);"

            "double dot(dvec3 , dvec3);"

            "double dot(dvec4 , dvec4);"

            "dvec3 cross(dvec3, dvec3);"

            "double normalize(double);"

            "dvec2  normalize(dvec2);"

            "dvec3  normalize(dvec3);"

            "dvec4  normalize(dvec4);"

            "double faceforward(double, double, double);"

            "dvec2  faceforward(dvec2,  dvec2,  dvec2);"

            "dvec3  faceforward(dvec3,  dvec3,  dvec3);"

            "dvec4  faceforward(dvec4,  dvec4,  dvec4);"

            "double reflect(double, double);"

            "dvec2  reflect(dvec2 , dvec2 );"

            "dvec3  reflect(dvec3 , dvec3 );"

            "dvec4  reflect(dvec4 , dvec4 );"

            "double refract(double, double, double);"

            "dvec2  refract(dvec2 , dvec2 , double);"

            "dvec3  refract(dvec3 , dvec3 , double);"

            "dvec4  refract(dvec4 , dvec4 , double);"

            "dmat2 matrixCompMult(dmat2, dmat2);"

            "dmat3 matrixCompMult(dmat3, dmat3);"

            "dmat4 matrixCompMult(dmat4, dmat4);"

            "dmat2x3 matrixCompMult(dmat2x3, dmat2x3);"

            "dmat2x4 matrixCompMult(dmat2x4, dmat2x4);"

            "dmat3x2 matrixCompMult(dmat3x2, dmat3x2);"

            "dmat3x4 matrixCompMult(dmat3x4, dmat3x4);"

            "dmat4x2 matrixCompMult(dmat4x2, dmat4x2);"

            "dmat4x3 matrixCompMult(dmat4x3, dmat4x3);"

            "dmat2   outerProduct(dvec2, dvec2);"

            "dmat3   outerProduct(dvec3, dvec3);"

            "dmat4   outerProduct(dvec4, dvec4);"

            "dmat2x3 outerProduct(dvec3, dvec2);"

            "dmat3x2 outerProduct(dvec2, dvec3);"

            "dmat2x4 outerProduct(dvec4, dvec2);"

            "dmat4x2 outerProduct(dvec2, dvec4);"

            "dmat3x4 outerProduct(dvec4, dvec3);"

            "dmat4x3 outerProduct(dvec3, dvec4);"

            "dmat2   transpose(dmat2);"

            "dmat3   transpose(dmat3);"

            "dmat4   transpose(dmat4);"

            "dmat2x3 transpose(dmat3x2);"

            "dmat3x2 transpose(dmat2x3);"

            "dmat2x4 transpose(dmat4x2);"

            "dmat4x2 transpose(dmat2x4);"

            "dmat3x4 transpose(dmat4x3);"

            "dmat4x3 transpose(dmat3x4);"

            "double determinant(dmat2);"

            "double determinant(dmat3);"

            "double determinant(dmat4);"

            "dmat2 inverse(dmat2);"

            "dmat3 inverse(dmat3);"

            "dmat4 inverse(dmat4);"

            "bvec2 lessThan(dvec2, dvec2);"

            "bvec3 lessThan(dvec3, dvec3);"

            "bvec4 lessThan(dvec4, dvec4);"

            "bvec2 lessThanEqual(dvec2, dvec2);"

            "bvec3 lessThanEqual(dvec3, dvec3);"

            "bvec4 lessThanEqual(dvec4, dvec4);"

            "bvec2 greaterThan(dvec2, dvec2);"

            "bvec3 greaterThan(dvec3, dvec3);"

            "bvec4 greaterThan(dvec4, dvec4);"

            "bvec2 greaterThanEqual(dvec2, dvec2);"

            "bvec3 greaterThanEqual(dvec3, dvec3);"

            "bvec4 greaterThanEqual(dvec4, dvec4);"

            "bvec2 equal(dvec2, dvec2);"

            "bvec3 equal(dvec3, dvec3);"

            "bvec4 equal(dvec4, dvec4);"

            "bvec2 notEqual(dvec2, dvec2);"

            "bvec3 notEqual(dvec3, dvec3);"

            "bvec4 notEqual(dvec4, dvec4);"

            "\n");

    }

    if (profile == EEsProfile && version >= 310) {  // Explicit Types

      commonBuiltins.append(

        "float64_t sqrt(float64_t);"

        "f64vec2  sqrt(f64vec2);"

        "f64vec3  sqrt(f64vec3);"

        "f64vec4  sqrt(f64vec4);"

        "float64_t inversesqrt(float64_t);"

        "f64vec2  inversesqrt(f64vec2);"

        "f64vec3  inversesqrt(f64vec3);"

        "f64vec4  inversesqrt(f64vec4);"

        "float64_t abs(float64_t);"

        "f64vec2  abs(f64vec2);"

        "f64vec3  abs(f64vec3);"

        "f64vec4  abs(f64vec4);"

        "float64_t sign(float64_t);"

        "f64vec2  sign(f64vec2);"

        "f64vec3  sign(f64vec3);"

        "f64vec4  sign(f64vec4);"

        "float64_t floor(float64_t);"

        "f64vec2  floor(f64vec2);"

        "f64vec3  floor(f64vec3);"

        "f64vec4  floor(f64vec4);"

        "float64_t trunc(float64_t);"

        "f64vec2  trunc(f64vec2);"

        "f64vec3  trunc(f64vec3);"

        "f64vec4  trunc(f64vec4);"

        "float64_t round(float64_t);"

        "f64vec2  round(f64vec2);"

        "f64vec3  round(f64vec3);"

        "f64vec4  round(f64vec4);"

        "float64_t roundEven(float64_t);"

        "f64vec2  roundEven(f64vec2);"

        "f64vec3  roundEven(f64vec3);"

        "f64vec4  roundEven(f64vec4);"

        "float64_t ceil(float64_t);"

        "f64vec2  ceil(f64vec2);"

        "f64vec3  ceil(f64vec3);"

        "f64vec4  ceil(f64vec4);"

        "float64_t fract(float64_t);"

        "f64vec2  fract(f64vec2);"

        "f64vec3  fract(f64vec3);"

        "f64vec4  fract(f64vec4);"

        "float64_t mod(float64_t, float64_t);"

        "f64vec2  mod(f64vec2 , float64_t);"

        "f64vec3  mod(f64vec3 , float64_t);"

        "f64vec4  mod(f64vec4 , float64_t);"

        "f64vec2  mod(f64vec2 , f64vec2);"

        "f64vec3  mod(f64vec3 , f64vec3);"

        "f64vec4  mod(f64vec4 , f64vec4);"

        "float64_t modf(float64_t, out float64_t);"

        "f64vec2  modf(f64vec2,  out f64vec2);"

        "f64vec3  modf(f64vec3,  out f64vec3);"

        "f64vec4  modf(f64vec4,  out f64vec4);"

        "float64_t min(float64_t, float64_t);"

        "f64vec2  min(f64vec2,  float64_t);"

        "f64vec3  min(f64vec3,  float64_t);"