kc3-lang/angle/src/compiler/fuzz/translator_fuzzer.cpp

• Show log

  Commit

• Hash : 1d9b8d80
  Author :
  Date : 2023-01-24T16:50:32
  

  Reland "Add support for glShaderBinary"
  
  This is a reland of commit 228973e73135924ddf6116e0b63eff5a1ccbf232
  with the following fixes -
  
  1. Apply patch from Yuly to fix chromium build errors
  2. Fix ShaderBinaryTest instantiation call
  3. Add ShaderBinaryTest to expectations file for IOS
  
  Original change's description:
  > Add support for glShaderBinary
  >
  > This patch adds the following -
  > 1. ANGLE_shader_binary extension and GL_SHADER_BINARY_ANGLE token.
  > 2. Compiler support to generate shader binaries.
  > 3. Update compiler to use SH_SPIRV_VULKAN_OUTPUT as output type for
  > Vulkan translator.
  > 4. Support to load GL_SHADER_BINARY_ANGLE binaries.
  > 5. end2end tests for glShaderBinary.
  >
  > Tests: ShaderBinaryTest*
  > Bug: angleproject:7833
  > Change-Id: I191d5ba7c4d5304696f5e743c851dc945fa57858
  > Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4137306
  > Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  > Commit-Queue: mohan maiya <m.maiya@samsung.com>
  > Reviewed-by: Charlie Lao <cclao@google.com>
  
  Bug: angleproject:7833
  Change-Id: I21135c52e2bae955342a99aff5631ba0e687eff1
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4195852
  Reviewed-by: Yuly Novikov <ynovikov@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/compiler/fuzz/translator_fuzzer.cpp

• //
  // Copyright 2016 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // translator_fuzzer.cpp: A libfuzzer fuzzer for the shader translator.
  
  #include <cstddef>
  #include <cstdint>
  #include <iostream>
  #include <memory>
  #include <unordered_map>
  
  #include "angle_gl.h"
  #include "anglebase/no_destructor.h"
  #include "compiler/translator/Compiler.h"
  #include "compiler/translator/util.h"
  
  using namespace sh;
  
  namespace
  {
  struct TranslatorCacheKey
  {
      bool operator==(const TranslatorCacheKey &other) const
      {
          return type == other.type && spec == other.spec && output == other.output;
      }
  
      uint32_t type   = 0;
      uint32_t spec   = 0;
      uint32_t output = 0;
  };
  }  // anonymous namespace
  
  namespace std
  {
  
  template <>
  struct hash<TranslatorCacheKey>
  {
      std::size_t operator()(const TranslatorCacheKey &k) const
      {
          return (hash<uint32_t>()(k.type) << 1) ^ (hash<uint32_t>()(k.spec) >> 1) ^
                 hash<uint32_t>()(k.output);
      }
  };
  }  // namespace std
  
  struct TCompilerDeleter
  {
      void operator()(TCompiler *compiler) const { DeleteCompiler(compiler); }
  };
  
  extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
  {
      ShaderDumpHeader header{};
      if (size <= sizeof(header))
      {
          return 0;
      }
  
      // Make sure the rest of data will be a valid C string so that we don't have to copy it.
      if (data[size - 1] != 0)
      {
          return 0;
      }
  
      memcpy(&header, data, sizeof(header));
      ShCompileOptions options{};
      memcpy(&options, &header.basicCompileOptions, offsetof(ShCompileOptions, metal));
      memcpy(&options.metal, &header.metalCompileOptions, sizeof(options.metal));
      memcpy(&options.pls, &header.plsCompileOptions, sizeof(options.pls));
      size -= sizeof(header);
      data += sizeof(header);
      uint32_t type = header.type;
      uint32_t spec = header.spec;
  
      if (type != GL_FRAGMENT_SHADER && type != GL_VERTEX_SHADER)
      {
          return 0;
      }
  
      if (spec != SH_GLES2_SPEC && type != SH_WEBGL_SPEC && spec != SH_GLES3_SPEC &&
          spec != SH_WEBGL2_SPEC)
      {
          return 0;
      }
  
      ShShaderOutput shaderOutput = static_cast<ShShaderOutput>(header.output);
  
      bool hasUnsupportedOptions = false;
  
      const bool hasMacGLSLOptions = options.rewriteFloatUnaryMinusOperator ||
                                     options.addAndTrueToLoopCondition ||
                                     options.rewriteDoWhileLoops || options.unfoldShortCircuit ||
                                     options.rewriteRowMajorMatrices;
  
      if (!IsOutputGLSL(shaderOutput) && !IsOutputESSL(shaderOutput))
      {
          hasUnsupportedOptions =
              hasUnsupportedOptions || options.emulateAtan2FloatFunction || options.clampFragDepth ||
              options.regenerateStructNames || options.rewriteRepeatedAssignToSwizzled ||
              options.useUnusedStandardSharedBlocks || options.selectViewInNvGLSLVertexShader;
  
          hasUnsupportedOptions = hasUnsupportedOptions || hasMacGLSLOptions;
      }
      else
      {
  #if !defined(ANGLE_PLATFORM_APPLE)
          hasUnsupportedOptions = hasUnsupportedOptions || hasMacGLSLOptions;
  #endif
      }
      if (!IsOutputVulkan(shaderOutput))
      {
          hasUnsupportedOptions =
              hasUnsupportedOptions || options.emulateSeamfulCubeMapSampling ||
              options.useSpecializationConstant || options.addVulkanXfbEmulationSupportCode ||
              options.roundOutputAfterDithering || options.addAdvancedBlendEquationsEmulation;
      }
      if (!IsOutputHLSL(shaderOutput))
      {
          hasUnsupportedOptions = hasUnsupportedOptions ||
                                  options.expandSelectHLSLIntegerPowExpressions ||
                                  options.allowTranslateUniformBlockToStructuredBuffer ||
                                  options.rewriteIntegerUnaryMinusOperator;
      }
  
      // If there are any options not supported with this output, don't attempt to run the translator.
      if (hasUnsupportedOptions)
      {
          return 0;
      }
  
      // Make sure the rest of the options are in a valid range.
      options.pls.fragmentSyncType = static_cast<ShFragmentSynchronizationType>(
          static_cast<uint32_t>(options.pls.fragmentSyncType) %
          static_cast<uint32_t>(ShFragmentSynchronizationType::InvalidEnum));
  
      std::vector<uint32_t> validOutputs;
      validOutputs.push_back(SH_ESSL_OUTPUT);
      validOutputs.push_back(SH_GLSL_COMPATIBILITY_OUTPUT);
      validOutputs.push_back(SH_GLSL_130_OUTPUT);
      validOutputs.push_back(SH_GLSL_140_OUTPUT);
      validOutputs.push_back(SH_GLSL_150_CORE_OUTPUT);
      validOutputs.push_back(SH_GLSL_330_CORE_OUTPUT);
      validOutputs.push_back(SH_GLSL_400_CORE_OUTPUT);
      validOutputs.push_back(SH_GLSL_410_CORE_OUTPUT);
      validOutputs.push_back(SH_GLSL_420_CORE_OUTPUT);
      validOutputs.push_back(SH_GLSL_430_CORE_OUTPUT);
      validOutputs.push_back(SH_GLSL_440_CORE_OUTPUT);
      validOutputs.push_back(SH_GLSL_450_CORE_OUTPUT);
      validOutputs.push_back(SH_SPIRV_VULKAN_OUTPUT);
      validOutputs.push_back(SH_HLSL_3_0_OUTPUT);
      validOutputs.push_back(SH_HLSL_4_1_OUTPUT);
      validOutputs.push_back(SH_HLSL_4_0_FL9_3_OUTPUT);
      bool found = false;
      for (auto valid : validOutputs)
      {
          found = found || (valid == shaderOutput);
      }
      if (!found)
      {
          return 0;
      }
  
      if (!sh::Initialize())
      {
          return 0;
      }
  
      TranslatorCacheKey key;
      key.type   = type;
      key.spec   = spec;
      key.output = shaderOutput;
  
      using UniqueTCompiler = std::unique_ptr<TCompiler, TCompilerDeleter>;
      static angle::base::NoDestructor<angle::HashMap<TranslatorCacheKey, UniqueTCompiler>>
          translators;
  
      if (translators->find(key) == translators->end())
      {
          UniqueTCompiler translator(
              ConstructCompiler(type, static_cast<ShShaderSpec>(spec), shaderOutput));
  
          if (translator == nullptr)
          {
              return 0;
          }
  
          ShBuiltInResources resources;
          sh::InitBuiltInResources(&resources);
  
          // Enable all the extensions to have more coverage
          resources.OES_standard_derivatives        = 1;
          resources.OES_EGL_image_external          = 1;
          resources.OES_EGL_image_external_essl3    = 1;
          resources.NV_EGL_stream_consumer_external = 1;
          resources.ARB_texture_rectangle           = 1;
          resources.EXT_blend_func_extended         = 1;
          resources.EXT_draw_buffers                = 1;
          resources.EXT_frag_depth                  = 1;
          resources.EXT_shader_texture_lod          = 1;
          resources.EXT_shader_framebuffer_fetch    = 1;
          resources.NV_shader_framebuffer_fetch     = 1;
          resources.ARM_shader_framebuffer_fetch    = 1;
          resources.EXT_YUV_target                  = 1;
          resources.APPLE_clip_distance             = 1;
          resources.MaxDualSourceDrawBuffers        = 1;
          resources.EXT_gpu_shader5                 = 1;
          resources.MaxClipDistances                = 1;
          resources.EXT_shadow_samplers             = 1;
          resources.EXT_clip_cull_distance          = 1;
          resources.ANGLE_clip_cull_distance        = 1;
          resources.EXT_primitive_bounding_box      = 1;
          resources.OES_primitive_bounding_box      = 1;
  
          if (!translator->Init(resources))
          {
              return 0;
          }
  
          (*translators)[key] = std::move(translator);
      }
  
      auto &translator = (*translators)[key];
  
      const char *shaderStrings[] = {reinterpret_cast<const char *>(data)};
      translator->compile(shaderStrings, 1, options);
  
      return 0;
  }
  

Download