Implement GLSL writer backend.

This is a modified version of the HLSL writer. Basic types, arrays, entry points, reserved keywords, uniforms, builtin uniforms, structs, some builtin functions, zero initialization are implemented. Textures, SSBOs and storage textures in particular are unimplemented. All the unit tests "pass", but the output is not correct in many cases. triangle.wgsl outputs correct vertex and fragment shaders that pass GLSL validation via glslang. compute_boids.wgsl outputs a valid but not correct compute shader. Change-Id: I96c7aaf60cf2d4237e45d732e5f51b345aea0552 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/57780 Kokoro: Kokoro <noreply+kokoro@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org> Reviewed-by: Ben Clayton <bclayton@google.com>
2025-12-16 00:17:03 +00:00 · 2021-10-06 18:55:10 +00:00
parent 08146e2300
commit a9f8c7db81
46 changed files with 10570 additions and 0 deletions
--- a/src/transform/glsl.cc
+++ b/src/transform/glsl.cc
@@ -0,0 +1,102 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/transform/glsl.h"
+
+#include <utility>
+
+#include "src/program_builder.h"
+#include "src/transform/calculate_array_length.h"
+#include "src/transform/canonicalize_entry_point_io.h"
+#include "src/transform/decompose_memory_access.h"
+#include "src/transform/external_texture_transform.h"
+#include "src/transform/fold_trivial_single_use_lets.h"
+#include "src/transform/inline_pointer_lets.h"
+#include "src/transform/loop_to_for_loop.h"
+#include "src/transform/manager.h"
+#include "src/transform/pad_array_elements.h"
+#include "src/transform/promote_initializers_to_const_var.h"
+#include "src/transform/simplify.h"
+#include "src/transform/zero_init_workgroup_memory.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::transform::Glsl);
+TINT_INSTANTIATE_TYPEINFO(tint::transform::Glsl::Config);
+
+namespace tint {
+namespace transform {
+
+Glsl::Glsl() = default;
+Glsl::~Glsl() = default;
+
+Output Glsl::Run(const Program* in, const DataMap& inputs) {
+  Manager manager;
+  DataMap data;
+
+  auto* cfg = inputs.Get<Config>();
+
+  // Attempt to convert `loop`s into for-loops. This is to try and massage the
+  // output into something that will not cause FXC to choke or misbehave.
+  manager.Add<FoldTrivialSingleUseLets>();
+  manager.Add<LoopToForLoop>();
+
+  if (!cfg || !cfg->disable_workgroup_init) {
+    // ZeroInitWorkgroupMemory must come before CanonicalizeEntryPointIO as
+    // ZeroInitWorkgroupMemory may inject new builtin parameters.
+    manager.Add<ZeroInitWorkgroupMemory>();
+  }
+  manager.Add<CanonicalizeEntryPointIO>();
+  manager.Add<InlinePointerLets>();
+  // Simplify cleans up messy `*(&(expr))` expressions from InlinePointerLets.
+  manager.Add<Simplify>();
+  manager.Add<CalculateArrayLength>();
+  manager.Add<ExternalTextureTransform>();
+  manager.Add<PromoteInitializersToConstVar>();
+  manager.Add<PadArrayElements>();
+
+  // For now, canonicalize to structs for all IO, as in HLSL.
+  // TODO(senorblanco): we could skip this by accessing global entry point
+  // variables directly.
+  data.Add<CanonicalizeEntryPointIO::Config>(
+      CanonicalizeEntryPointIO::ShaderStyle::kHlsl);
+  auto out = manager.Run(in, data);
+  if (!out.program.IsValid()) {
+    return out;
+  }
+
+  ProgramBuilder builder;
+  CloneContext ctx(&builder, &out.program);
+  AddEmptyEntryPoint(ctx);
+  ctx.Clone();
+  builder.SetTransformApplied(this);
+  return Output{Program(std::move(builder))};
+}
+
+void Glsl::AddEmptyEntryPoint(CloneContext& ctx) const {
+  for (auto* func : ctx.src->AST().Functions()) {
+    if (func->IsEntryPoint()) {
+      return;
+    }
+  }
+  ctx.dst->Func(ctx.dst->Symbols().New("unused_entry_point"), {},
+                ctx.dst->ty.void_(), {},
+                {ctx.dst->Stage(ast::PipelineStage::kCompute),
+                 ctx.dst->WorkgroupSize(1)});
+}
+
+Glsl::Config::Config(bool disable_wi) : disable_workgroup_init(disable_wi) {}
+Glsl::Config::Config(const Config&) = default;
+Glsl::Config::~Config() = default;
+
+}  // namespace transform
+}  // namespace tint
--- a/src/transform/glsl.h
+++ b/src/transform/glsl.h
@@ -0,0 +1,67 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_TRANSFORM_GLSL_H_
+#define SRC_TRANSFORM_GLSL_H_
+
+#include "src/transform/transform.h"
+
+namespace tint {
+
+// Forward declarations
+class CloneContext;
+
+namespace transform {
+
+/// Glsl is a transform used to sanitize a Program for use with the Glsl writer.
+/// Passing a non-sanitized Program to the Glsl writer will result in undefined
+/// behavior.
+class Glsl : public Castable<Glsl, Transform> {
+ public:
+  /// Configuration options for the Glsl sanitizer transform.
+  struct Config : public Castable<Data, transform::Data> {
+    /// Constructor
+    /// @param disable_workgroup_init `true` to disable workgroup memory zero
+    ///        initialization
+    explicit Config(bool disable_workgroup_init = false);
+
+    /// Copy constructor
+    Config(const Config&);
+
+    /// Destructor
+    ~Config() override;
+
+    /// Set to `true` to disable workgroup memory zero initialization
+    bool disable_workgroup_init = false;
+  };
+
+  /// Constructor
+  Glsl();
+  ~Glsl() override;
+
+  /// Runs the transform on `program`, returning the transformation result.
+  /// @param program the source program to transform
+  /// @param data optional extra transform-specific data
+  /// @returns the transformation result
+  Output Run(const Program* program, const DataMap& data = {}) override;
+
+ private:
+  /// Add an empty shader entry point if none exist in the module.
+  void AddEmptyEntryPoint(CloneContext& ctx) const;
+};
+
+}  // namespace transform
+}  // namespace tint
+
+#endif  // SRC_TRANSFORM_GLSL_H_
--- a/src/transform/glsl_test.cc
+++ b/src/transform/glsl_test.cc
@@ -0,0 +1,41 @@
+// Copyright 2021 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/transform/glsl.h"
+
+#include "src/transform/test_helper.h"
+
+namespace tint {
+namespace transform {
+namespace {
+
+using GlslTest = TransformTest;
+
+TEST_F(GlslTest, AddEmptyEntryPoint) {
+  auto* src = R"()";
+
+  auto* expect = R"(
+[[stage(compute), workgroup_size(1)]]
+fn unused_entry_point() {
+}
+)";
+
+  auto got = Run<Glsl>(src);
+
+  EXPECT_EQ(expect, str(got));
+}
+
+}  // namespace
+}  // namespace transform
+}  // namespace tint
--- a/src/transform/renamer.cc
+++ b/src/transform/renamer.cc
@@ -31,6 +31,211 @@ namespace transform {

 namespace {

+// This list is used for a binary search and must be kept in sorted order.
+const char* kReservedKeywordsGLSL[] = {
+    "active",
+    "asm",
+    "atomic_uint",
+    "attribute",
+    "bool",
+    "break",
+    "buffer",
+    "bvec2",
+    "bvec3",
+    "bvec4",
+    "case",
+    "cast",
+    "centroid",
+    "class",
+    "coherent",
+    "common",
+    "const",
+    "continue",
+    "default",
+    "discard",
+    "dmat2",
+    "dmat2x2",
+    "dmat2x3",
+    "dmat2x4",
+    "dmat3",
+    "dmat3x2",
+    "dmat3x3",
+    "dmat3x4",
+    "dmat4",
+    "dmat4x2",
+    "dmat4x3",
+    "dmat4x4",
+    "do",
+    "double",
+    "dvec2",
+    "dvec3",
+    "dvec4",
+    "else",
+    "enum",
+    "extern",
+    "external",
+    "false",
+    "filter",
+    "fixed",
+    "flat",
+    "float",
+    "for",
+    "fvec2",
+    "fvec3",
+    "fvec4",
+    "goto",
+    "half",
+    "highp",
+    "hvec2",
+    "hvec3",
+    "hvec4",
+    "if",
+    "iimage1D",
+    "iimage1DArray",
+    "iimage2D",
+    "iimage2DArray",
+    "iimage2DMS",
+    "iimage2DMSArray",
+    "iimage2DRect",
+    "iimage3D",
+    "iimageBuffer",
+    "iimageCube",
+    "iimageCubeArray",
+    "image1D",
+    "image1DArray",
+    "image2D",
+    "image2DArray",
+    "image2DMS",
+    "image2DMSArray",
+    "image2DRect",
+    "image3D",
+    "imageBuffer",
+    "imageCube",
+    "imageCubeArray",
+    "in",
+    "inline",
+    "inout",
+    "input",
+    "int",
+    "interface",
+    "invariant",
+    "isampler1D",
+    "isampler1DArray",
+    "isampler2D",
+    "isampler2DArray",
+    "isampler2DMS",
+    "isampler2DMSArray",
+    "isampler2DRect",
+    "isampler3D",
+    "isamplerBuffer",
+    "isamplerCube",
+    "isamplerCubeArray",
+    "ivec2",
+    "ivec3",
+    "ivec4",
+    "layout",
+    "long",
+    "lowp",
+    "mat2",
+    "mat2x2",
+    "mat2x3",
+    "mat2x4",
+    "mat3",
+    "mat3x2",
+    "mat3x3",
+    "mat3x4",
+    "mat4",
+    "mat4x2",
+    "mat4x3",
+    "mat4x4",
+    "mediump",
+    "namespace",
+    "noinline",
+    "noperspective",
+    "out",
+    "output",
+    "partition",
+    "patch",
+    "precise",
+    "precision",
+    "public",
+    "readonly",
+    "resource",
+    "restrict",
+    "return",
+    "sample",
+    "sampler1D",
+    "sampler1DArray",
+    "sampler1DArrayShadow",
+    "sampler1DShadow",
+    "sampler2D",
+    "sampler2DArray",
+    "sampler2DArrayShadow",
+    "sampler2DMS",
+    "sampler2DMSArray",
+    "sampler2DRect",
+    "sampler2DRectShadow",
+    "sampler2DShadow",
+    "sampler3D",
+    "sampler3DRect",
+    "samplerBuffer",
+    "samplerCube",
+    "samplerCubeArray",
+    "samplerCubeArrayShadow",
+    "samplerCubeShadow",
+    "shared",
+    "short",
+    "sizeof",
+    "smooth",
+    "static",
+    "struct",
+    "subroutine",
+    "superp",
+    "switch",
+    "template",
+    "this",
+    "true",
+    "typedef",
+    "uimage1D",
+    "uimage1DArray",
+    "uimage2D",
+    "uimage2DArray",
+    "uimage2DMS",
+    "uimage2DMSArray",
+    "uimage2DRect",
+    "uimage3D",
+    "uimageBuffer",
+    "uimageCube",
+    "uimageCubeArray",
+    "uint",
+    "uniform",
+    "union",
+    "unsigned",
+    "usampler1D",
+    "usampler1DArray",
+    "usampler2D",
+    "usampler2DArray",
+    "usampler2DMS",
+    "usampler2DMSArray",
+    "usampler2DRect",
+    "usampler3D",
+    "usamplerBuffer",
+    "usamplerCube",
+    "usamplerCubeArray",
+    "using",
+    "uvec2",
+    "uvec3",
+    "uvec4",
+    "varying",
+    "vec2",
+    "vec3",
+    "vec4",
+    "void",
+    "volatile",
+    "while",
+    "writeonly",
+};
+
 // This list is used for a binary search and must be kept in sorted order.
 const char* kReservedKeywordsHLSL[] = {
    "AddressU",
@@ -944,6 +1149,16 @@ Output Renamer::Run(const Program* in, const DataMap& inputs) {
      case Target::kAll:
        // Always rename.
        break;
+      case Target::kGlslKeywords:
+        if (!std::binary_search(
+                kReservedKeywordsGLSL,
+                kReservedKeywordsGLSL +
+                    sizeof(kReservedKeywordsGLSL) / sizeof(const char*),
+                name_in)) {
+          // No match, just reuse the original name.
+          return ctx.dst->Symbols().New(name_in);
+        }
+        break;
      case Target::kHlslKeywords:
        if (!std::binary_search(
                kReservedKeywordsHLSL,
--- a/src/transform/renamer.h
+++ b/src/transform/renamer.h
@@ -50,6 +50,8 @@ class Renamer : public Castable<Renamer, Transform> {
  enum class Target {
    /// Rename every symbol.
    kAll,
+    /// Only rename symbols that are reserved keywords in GLSL.
+    kGlslKeywords,
    /// Only rename symbols that are reserved keywords in HLSL.
    kHlslKeywords,
    /// Only rename symbols that are reserved keywords in MSL.