/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "WebGLShaderValidator.h"

#include "gfxPrefs.h"

#include "GLContext.h"

#include "mozilla/gfx/Logging.h"

#include "mozilla/Preferences.h"

#include "MurmurHash3.h"

#include "nsPrintfCString.h"

#include <string>

#include <vector>

#include "WebGLContext.h"

namespace mozilla {

namespace webgl {

uint64_t

IdentifierHashFunc(const char* name, size_t len)

{

    // NB: we use the x86 function everywhere, even though it's suboptimal perf

    // on x64.  They return different results; not sure if that's a requirement.

    uint64_t hash[2];

    MurmurHash3_x86_128(name, len, 0, hash);

    return hash[0];

}

static ShCompileOptions

ChooseValidatorCompileOptions(const ShBuiltInResources& resources,

                              const mozilla::gl::GLContext* gl)

{

    ShCompileOptions options = SH_VARIABLES |

                               SH_ENFORCE_PACKING_RESTRICTIONS |

                               SH_OBJECT_CODE |

                               SH_INIT_GL_POSITION |

                               SH_INITIALIZE_UNINITIALIZED_LOCALS |

                               SH_INIT_OUTPUT_VARIABLES;

#ifndef XP_MACOSX

    // We want to do this everywhere, but to do this on Mac, we need

    // to do it only on Mac OSX > 10.6 as this causes the shader

    // compiler in 10.6 to crash

    options |= SH_CLAMP_INDIRECT_ARRAY_BOUNDS;

#endif

    if (gl->WorkAroundDriverBugs()) {

#ifdef XP_MACOSX

        // Work around https://bugs.webkit.org/show_bug.cgi?id=124684,

        // https://chromium.googlesource.com/angle/angle/+/5e70cf9d0b1bb

        options |= SH_UNFOLD_SHORT_CIRCUIT;

        // Work around that Mac drivers handle struct scopes incorrectly.

        options |= SH_REGENERATE_STRUCT_NAMES;

        options |= SH_INIT_OUTPUT_VARIABLES;

        // Work around that Intel drivers on Mac OSX handle for-loop incorrectly.

        if (gl->Vendor() == gl::GLVendor::Intel) {

            options |= SH_ADD_AND_TRUE_TO_LOOP_CONDITION;

        }

#endif

        if (!gl->IsANGLE() && gl->Vendor() == gl::GLVendor::Intel) {

            // Failures on at least Windows+Intel+OGL on:

            // conformance/glsl/constructors/glsl-construct-mat2.html

            options |= SH_SCALARIZE_VEC_AND_MAT_CONSTRUCTOR_ARGS;

        }

    }

    if (gfxPrefs::WebGLAllANGLEOptions()) {

        options = -1;

        options ^= SH_INTERMEDIATE_TREE;

        options ^= SH_LINE_DIRECTIVES;

        options ^= SH_SOURCE_PATH;

        options ^= SH_LIMIT_EXPRESSION_COMPLEXITY;

        options ^= SH_LIMIT_CALL_STACK_DEPTH;

        options ^= SH_EXPAND_SELECT_HLSL_INTEGER_POW_EXPRESSIONS;

        options ^= SH_HLSL_GET_DIMENSIONS_IGNORES_BASE_LEVEL;

        options ^= SH_DONT_REMOVE_INVARIANT_FOR_FRAGMENT_INPUT;

        options ^= SH_REMOVE_INVARIANT_AND_CENTROID_FOR_ESSL3;

    }

    if (resources.MaxExpressionComplexity > 0) {

        options |= SH_LIMIT_EXPRESSION_COMPLEXITY;

    }

    if (resources.MaxCallStackDepth > 0) {

        options |= SH_LIMIT_CALL_STACK_DEPTH;

    }

    return options;

}

} // namespace webgl

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

static ShShaderOutput

ShaderOutput(gl::GLContext* gl)

{

    if (gl->IsGLES()) {

        return SH_ESSL_OUTPUT;

    } else {

        uint32_t version = gl->ShadingLanguageVersion();

        switch (version) {

        case 100: return SH_GLSL_COMPATIBILITY_OUTPUT;

        case 120: return SH_GLSL_COMPATIBILITY_OUTPUT;

        case 130: return SH_GLSL_130_OUTPUT;

        case 140: return SH_GLSL_140_OUTPUT;

        case 150: return SH_GLSL_150_CORE_OUTPUT;

        case 330: return SH_GLSL_330_CORE_OUTPUT;

        case 400: return SH_GLSL_400_CORE_OUTPUT;

        case 410: return SH_GLSL_410_CORE_OUTPUT;

        case 420: return SH_GLSL_420_CORE_OUTPUT;

        case 430: return SH_GLSL_430_CORE_OUTPUT;

        case 440: return SH_GLSL_440_CORE_OUTPUT;

        default:

            if (version >= 450) {

                // "OpenGL 4.6 is also guaranteed to support all previous versions of the

                //  OpenGL Shading Language back to version 1.10."

                return SH_GLSL_450_CORE_OUTPUT;

            }

            gfxCriticalNote << "Unexpected GLSL version: " << version;

        }

    }

    return SH_GLSL_COMPATIBILITY_OUTPUT;

}

webgl::ShaderValidator*

WebGLContext::CreateShaderValidator(GLenum shaderType) const

{

    if (mBypassShaderValidation)

        return nullptr;

    const auto spec = (IsWebGL2() ? SH_WEBGL2_SPEC : SH_WEBGL_SPEC);

    const auto outputLanguage = ShaderOutput(gl);

    ShBuiltInResources resources;

    memset(&resources, 0, sizeof(resources));

    sh::InitBuiltInResources(&resources);

    resources.HashFunction = webgl::IdentifierHashFunc;

    resources.MaxVertexAttribs = mGLMaxVertexAttribs;

    resources.MaxVertexUniformVectors = mGLMaxVertexUniformVectors;

    resources.MaxVaryingVectors = mGLMaxVaryingVectors;

    resources.MaxVertexTextureImageUnits = mGLMaxVertexTextureImageUnits;

    resources.MaxCombinedTextureImageUnits = mGLMaxCombinedTextureImageUnits;

    resources.MaxTextureImageUnits = mGLMaxFragmentTextureImageUnits;

    resources.MaxFragmentUniformVectors = mGLMaxFragmentUniformVectors;

    const bool hasMRTs = (IsWebGL2() ||

                          IsExtensionEnabled(WebGLExtensionID::WEBGL_draw_buffers));

    resources.MaxDrawBuffers = (hasMRTs ? mGLMaxDrawBuffers : 1);

    if (IsExtensionEnabled(WebGLExtensionID::EXT_frag_depth))

        resources.EXT_frag_depth = 1;

    if (IsExtensionEnabled(WebGLExtensionID::OES_standard_derivatives))

        resources.OES_standard_derivatives = 1;

    if (IsExtensionEnabled(WebGLExtensionID::WEBGL_draw_buffers))

        resources.EXT_draw_buffers = 1;

    if (IsExtensionEnabled(WebGLExtensionID::EXT_shader_texture_lod))

        resources.EXT_shader_texture_lod = 1;

    // Tell ANGLE to allow highp in frag shaders. (unless disabled)

    // If underlying GLES doesn't have highp in frag shaders, it should complain anyways.

    resources.FragmentPrecisionHigh = mDisableFragHighP ? 0 : 1;

    if (gl->WorkAroundDriverBugs()) {

#ifdef XP_MACOSX

        if (gl->Vendor() == gl::GLVendor::NVIDIA) {

            // Work around bug 890432

            resources.MaxExpressionComplexity = 1000;

        }

#endif

    }

    const auto compileOptions = webgl::ChooseValidatorCompileOptions(resources, gl);

    return webgl::ShaderValidator::Create(shaderType, spec, outputLanguage, resources,

                                          compileOptions);

}

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

namespace webgl {

/*static*/ ShaderValidator*

ShaderValidator::Create(GLenum shaderType, ShShaderSpec spec,

                        ShShaderOutput outputLanguage,

                        const ShBuiltInResources& resources,

                        ShCompileOptions compileOptions)

{

    ShHandle handle = sh::ConstructCompiler(shaderType, spec, outputLanguage, &resources);

    if (!handle)

        return nullptr;

    return new ShaderValidator(handle, compileOptions, resources.MaxVaryingVectors);

}

ShaderValidator::~ShaderValidator()

{

    sh::Destruct(mHandle);

}

bool

ShaderValidator::ValidateAndTranslate(const char* source)

{

    MOZ_ASSERT(!mHasRun);

    mHasRun = true;

    const char* const parts[] = {

        source

    };

    return sh::Compile(mHandle, parts, ArrayLength(parts), mCompileOptions);

}

void

ShaderValidator::GetInfoLog(nsACString* out) const

{

    MOZ_ASSERT(mHasRun);

    const std::string &log = sh::GetInfoLog(mHandle);

    out->Assign(log.data(), log.length());

}

void

ShaderValidator::GetOutput(nsACString* out) const

{

    MOZ_ASSERT(mHasRun);

    const std::string &output = sh::GetObjectCode(mHandle);

    out->Assign(output.data(), output.length());

}

template<size_t N>

static bool

StartsWith(const std::string& haystack, const char (&needle)[N])

{

    return haystack.compare(0, N - 1, needle) == 0;

}

bool

ShaderValidator::CanLinkTo(const ShaderValidator* prev, nsCString* const out_log) const

{

    if (!prev) {

        nsPrintfCString error("Passed in NULL prev ShaderValidator.");

        *out_log = error;

        return false;

    }

    const auto shaderVersion = sh::GetShaderVersion(mHandle);

    if (sh::GetShaderVersion(prev->mHandle) != shaderVersion) {

        nsPrintfCString error("Vertex shader version %d does not match"

                              " fragment shader version %d.",

                              sh::GetShaderVersion(prev->mHandle),

                              sh::GetShaderVersion(mHandle));

        *out_log = error;

        return false;

    }

    {

        const std::vector<sh::Uniform>* vertPtr = sh::GetUniforms(prev->mHandle);

        const std::vector<sh::Uniform>* fragPtr = sh::GetUniforms(mHandle);

        if (!vertPtr || !fragPtr) {

            nsPrintfCString error("Could not create uniform list.");

            *out_log = error;

            return false;

        }

        for (auto itrFrag = fragPtr->begin(); itrFrag != fragPtr->end(); ++itrFrag) {

            for (auto itrVert = vertPtr->begin(); itrVert != vertPtr->end(); ++itrVert) {

                if (itrVert->name != itrFrag->name)

                    continue;

                if (!itrVert->isSameUniformAtLinkTime(*itrFrag)) {

                    nsPrintfCString error("Uniform `%s` is not linkable between"

                                          " attached shaders.",

                                          itrFrag->name.c_str());

                    *out_log = error;

                    return false;

                }

                break;

            }

        }

    }

    {

        const auto vertVars = sh::GetInterfaceBlocks(prev->mHandle);

        const auto fragVars = sh::GetInterfaceBlocks(mHandle);

        if (!vertVars || !fragVars) {

            nsPrintfCString error("Could not create uniform block list.");

            *out_log = error;

            return false;

        }

        for (const auto& fragVar : *fragVars) {

            for (const auto& vertVar : *vertVars) {

                if (vertVar.name != fragVar.name)

                    continue;

                if (!vertVar.isSameInterfaceBlockAtLinkTime(fragVar)) {

                    nsPrintfCString error("Interface block `%s` is not linkable between"

                                          " attached shaders.",

                                          fragVar.name.c_str());

                    *out_log = error;

                    return false;

                }

                break;

            }

        }

    }

    const auto& vertVaryings = sh::GetVaryings(prev->mHandle);

    const auto& fragVaryings = sh::GetVaryings(mHandle);

    if (!vertVaryings || !fragVaryings) {

        nsPrintfCString error("Could not create varying list.");

        *out_log = error;

        return false;

    }

    {

        std::vector<sh::ShaderVariable> staticUseVaryingList;

        for (const auto& fragVarying : *fragVaryings) {

            static const char prefix[] = "gl_";

            if (StartsWith(fragVarying.name, prefix)) {

                if (fragVarying.staticUse) {

                    staticUseVaryingList.push_back(fragVarying);

                }

                continue;

            }

            bool definedInVertShader = false;

            bool staticVertUse = false;

            for (const auto& vertVarying : *vertVaryings) {

                if (vertVarying.name != fragVarying.name)

                    continue;

                if (!vertVarying.isSameVaryingAtLinkTime(fragVarying, shaderVersion)) {

                    nsPrintfCString error("Varying `%s`is not linkable between"

                                          " attached shaders.",

                                          fragVarying.name.c_str());

                    *out_log = error;

                    return false;

                }

                definedInVertShader = true;

                staticVertUse = vertVarying.staticUse;

                break;

            }

            if (!definedInVertShader && fragVarying.staticUse) {

                nsPrintfCString error("Varying `%s` has static-use in the frag"

                                      " shader, but is undeclared in the vert"

                                      " shader.", fragVarying.name.c_str());

                *out_log = error;

                return false;

            }

            if (staticVertUse && fragVarying.staticUse) {

                staticUseVaryingList.push_back(fragVarying);

            }

        }

        if (!sh::CheckVariablesWithinPackingLimits(mMaxVaryingVectors,

                                                 staticUseVaryingList))

        {

            *out_log = "Statically used varyings do not fit within packing limits. (see"

                       " GLSL ES Specification 1.0.17, p111)";

            return false;

        }

    }

    if (shaderVersion == 100) {

        // Enforce ESSL1 invariant linking rules.

        bool isInvariant_Position = false;

        bool isInvariant_PointSize = false;

        bool isInvariant_FragCoord = false;

        bool isInvariant_PointCoord = false;

        for (const auto& varying : *vertVaryings) {

            if (varying.name == "gl_Position") {

                isInvariant_Position = varying.isInvariant;

            } else if (varying.name == "gl_PointSize") {

                isInvariant_PointSize = varying.isInvariant;

            }

        }

        for (const auto& varying : *fragVaryings) {

            if (varying.name == "gl_FragCoord") {

                isInvariant_FragCoord = varying.isInvariant;

            } else if (varying.name == "gl_PointCoord") {

                isInvariant_PointCoord = varying.isInvariant;

            }

        }

        ////

        const auto fnCanBuiltInsLink = [](bool vertIsInvariant, bool fragIsInvariant) {

            if (vertIsInvariant)

                return true;

            return !fragIsInvariant;

        };

        if (!fnCanBuiltInsLink(isInvariant_Position, isInvariant_FragCoord)) {

            *out_log = "gl_Position must be invariant if gl_FragCoord is. (see GLSL ES"

                       " Specification 1.0.17, p39)";

            return false;

        }

        if (!fnCanBuiltInsLink(isInvariant_PointSize, isInvariant_PointCoord)) {

            *out_log = "gl_PointSize must be invariant if gl_PointCoord is. (see GLSL ES"

                       " Specification 1.0.17, p39)";

            return false;

        }

    }

    return true;

}

size_t

ShaderValidator::CalcNumSamplerUniforms() const

{

    size_t accum = 0;

    const std::vector<sh::Uniform>& uniforms = *sh::GetUniforms(mHandle);

    for (auto itr = uniforms.begin(); itr != uniforms.end(); ++itr) {

        GLenum type = itr->type;

        if (type == LOCAL_GL_SAMPLER_2D ||

            type == LOCAL_GL_SAMPLER_CUBE)

        {

            accum += itr->getArraySizeProduct();

        }

    }

    return accum;

}

size_t

ShaderValidator::NumAttributes() const

{

  return sh::GetAttributes(mHandle)->size();

}

// Attribs cannot be structs or arrays, and neither can vertex inputs in ES3.

// Therefore, attrib names are always simple.

bool

ShaderValidator::FindAttribUserNameByMappedName(const std::string& mappedName,

                                                const std::string** const out_userName) const

{

    const std::vector<sh::Attribute>& attribs = *sh::GetAttributes(mHandle);

    for (auto itr = attribs.begin(); itr != attribs.end(); ++itr) {

        if (itr->mappedName == mappedName) {

            *out_userName = &(itr->name);

            return true;

        }

    }

    return false;

}

bool

ShaderValidator::FindAttribMappedNameByUserName(const std::string& userName,

                                                const std::string** const out_mappedName) const

{

    const std::vector<sh::Attribute>& attribs = *sh::GetAttributes(mHandle);

    for (auto itr = attribs.begin(); itr != attribs.end(); ++itr) {

        if (itr->name == userName) {

            *out_mappedName = &(itr->mappedName);

            return true;

        }

    }

    return false;

}

bool

ShaderValidator::FindVaryingByMappedName(const std::string& mappedName,

                                         std::string* const out_userName,

                                         bool* const out_isArray) const

{

    const std::vector<sh::Varying>& varyings = *sh::GetVaryings(mHandle);

    for (auto itr = varyings.begin(); itr != varyings.end(); ++itr) {

        const sh::ShaderVariable* found;

        if (!itr->findInfoByMappedName(mappedName, &found, out_userName))

            continue;

        *out_isArray = found->isArray();

        return true;

    }

    return false;

}

bool

ShaderValidator::FindVaryingMappedNameByUserName(const std::string& userName,

                                                 const std::string** const out_mappedName) const

{

    const std::vector<sh::Varying>& attribs = *sh::GetVaryings(mHandle);

    for (auto itr = attribs.begin(); itr != attribs.end(); ++itr) {

        if (itr->name == userName) {

            *out_mappedName = &(itr->mappedName);

            return true;

        }

    }

    return false;

}

// This must handle names like "foo.bar[0]".

bool

ShaderValidator::FindUniformByMappedName(const std::string& mappedName,

                                         std::string* const out_userName,

                                         bool* const out_isArray) const

{

    const std::vector<sh::Uniform>& uniforms = *sh::GetUniforms(mHandle);

    for (auto itr = uniforms.begin(); itr != uniforms.end(); ++itr) {

        const sh::ShaderVariable* found;

        if (!itr->findInfoByMappedName(mappedName, &found, out_userName))

            continue;

        *out_isArray = found->isArray();

        return true;

    }

    const size_t dotPos = mappedName.find(".");

    const std::vector<sh::InterfaceBlock>& interfaces = *sh::GetInterfaceBlocks(mHandle);

    for (const auto& interface : interfaces) {

        std::string mappedFieldName;

        const bool hasInstanceName = !interface.instanceName.empty();

        // If the InterfaceBlock has an instanceName, all variables defined

        // within the block are qualified with the block name, as opposed

        // to being placed in the global scope.

        if (hasInstanceName) {

            // If mappedName has no block name prefix, skip

            if (std::string::npos == dotPos)

                continue;

            // If mappedName has a block name prefix that doesn't match, skip

            const std::string mappedInterfaceBlockName = mappedName.substr(0, dotPos);

            if (interface.mappedName != mappedInterfaceBlockName)

                continue;

            mappedFieldName = mappedName.substr(dotPos + 1);

        } else {

            mappedFieldName = mappedName;

        }

        for (const auto& field : interface.fields) {

            const sh::ShaderVariable* found;

            if (!field.findInfoByMappedName(mappedFieldName, &found, out_userName))

                continue;

            if (hasInstanceName) {

                // Prepend the user name of the interface that matched

                *out_userName = interface.name + "." + *out_userName;

            }

            *out_isArray = found->isArray();

            return true;

        }

    }

    return false;

}

bool

ShaderValidator::UnmapUniformBlockName(const nsACString& baseMappedName,

                                       nsCString* const out_baseUserName) const

{

    const std::vector<sh::InterfaceBlock>& interfaces = *sh::GetInterfaceBlocks(mHandle);

    for (const auto& interface : interfaces) {

        const nsDependentCString interfaceMappedName(interface.mappedName.data(),

                                                     interface.mappedName.size());

        if (baseMappedName == interfaceMappedName) {

            *out_baseUserName = interface.name.data();

            return true;

        }

    }

    return false;

}

void

ShaderValidator::EnumerateFragOutputs(std::map<nsCString, const nsCString> &out_FragOutputs) const

{

    const auto* fragOutputs = sh::GetOutputVariables(mHandle);

    if (fragOutputs) {

        for (const auto& fragOutput : *fragOutputs) {

            out_FragOutputs.insert({nsCString(fragOutput.name.c_str()),

                                    nsCString(fragOutput.mappedName.c_str())});

        }

    }

}

} // namespace webgl

} // namespace mozilla