| // Copyright 2020 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 <cstdio> |
| #include <fstream> |
| #include <iostream> |
| #include <memory> |
| #include <sstream> |
| #include <string> |
| #include <vector> |
| |
| #if TINT_BUILD_GLSL_WRITER |
| #include "StandAlone/ResourceLimits.h" |
| #include "glslang/Public/ShaderLang.h" |
| #endif |
| |
| #if TINT_BUILD_SPV_READER |
| #include "spirv-tools/libspirv.hpp" |
| #endif // TINT_BUILD_SPV_READER |
| |
| #include "src/utils/io/command.h" |
| #include "src/utils/string.h" |
| #include "src/val/val.h" |
| #include "tint/tint.h" |
| |
| namespace { |
| |
| [[noreturn]] void TintInternalCompilerErrorReporter( |
| const tint::diag::List& diagnostics) { |
| auto printer = tint::diag::Printer::create(stderr, true); |
| tint::diag::Formatter{}.format(diagnostics, printer.get()); |
| tint::diag::Style bold_red{tint::diag::Color::kRed, true}; |
| constexpr const char* please_file_bug = R"( |
| ******************************************************************** |
| * The tint shader compiler has encountered an unexpected error. * |
| * * |
| * Please help us fix this issue by submitting a bug report at * |
| * crbug.com/tint with the source program that triggered the bug. * |
| ******************************************************************** |
| )"; |
| printer->write(please_file_bug, bold_red); |
| exit(1); |
| } |
| |
| enum class Format { |
| kNone = -1, |
| kSpirv, |
| kSpvAsm, |
| kWgsl, |
| kMsl, |
| kHlsl, |
| kGlsl, |
| }; |
| |
| struct Options { |
| bool show_help = false; |
| |
| std::string input_filename; |
| std::string output_file = "-"; // Default to stdout |
| |
| bool parse_only = false; |
| bool disable_workgroup_init = false; |
| bool validate = false; |
| bool demangle = false; |
| bool dump_inspector_bindings = false; |
| |
| Format format = Format::kNone; |
| |
| bool emit_single_entry_point = false; |
| std::string ep_name; |
| |
| std::vector<std::string> transforms; |
| |
| bool use_fxc = false; |
| std::string dxc_path; |
| std::string xcrun_path; |
| }; |
| |
| const char kUsage[] = R"(Usage: tint [options] <input-file> |
| |
| options: |
| --format <spirv|spvasm|wgsl|msl|hlsl> -- Output format. |
| If not provided, will be inferred from output |
| filename extension: |
| .spvasm -> spvasm |
| .spv -> spirv |
| .wgsl -> wgsl |
| .metal -> msl |
| .hlsl -> hlsl |
| If none matches, then default to SPIR-V assembly. |
| -ep <name> -- Output single entry point |
| --output-file <name> -- Output file name. Use "-" for standard output |
| -o <name> -- Output file name. Use "-" for standard output |
| --transform <name list> -- Runs transforms, name list is comma separated |
| Available transforms: |
| ${transforms} |
| --parse-only -- Stop after parsing the input |
| --disable-workgroup-init -- Disable workgroup memory zero initialization. |
| --demangle -- Preserve original source names. Demangle them. |
| Affects AST dumping, and text-based output languages. |
| --dump-inspector-bindings -- Dump reflection data about bindins to stdout. |
| -h -- This help text |
| --validate -- Validates the generated shader |
| --fxc -- Ask to validate HLSL output using FXC instead of DXC. |
| When specified, automatically enables --validate |
| --dxc -- Path to DXC executable, used to validate HLSL output. |
| When specified, automatically enables --validate |
| --xcrun -- Path to xcrun executable, used to validate MSL output. |
| When specified, automatically enables --validate)"; |
| |
| Format parse_format(const std::string& fmt) { |
| (void)fmt; |
| |
| #if TINT_BUILD_SPV_WRITER |
| if (fmt == "spirv") |
| return Format::kSpirv; |
| if (fmt == "spvasm") |
| return Format::kSpvAsm; |
| #endif // TINT_BUILD_SPV_WRITER |
| |
| #if TINT_BUILD_WGSL_WRITER |
| if (fmt == "wgsl") |
| return Format::kWgsl; |
| #endif // TINT_BUILD_WGSL_WRITER |
| |
| #if TINT_BUILD_MSL_WRITER |
| if (fmt == "msl") |
| return Format::kMsl; |
| #endif // TINT_BUILD_MSL_WRITER |
| |
| #if TINT_BUILD_HLSL_WRITER |
| if (fmt == "hlsl") |
| return Format::kHlsl; |
| #endif // TINT_BUILD_HLSL_WRITER |
| |
| #if TINT_BUILD_GLSL_WRITER |
| if (fmt == "glsl") |
| return Format::kGlsl; |
| #endif // TINT_BUILD_GLSL_WRITER |
| |
| return Format::kNone; |
| } |
| |
| #if TINT_BUILD_SPV_WRITER || TINT_BUILD_WGSL_WRITER || \ |
| TINT_BUILD_MSL_WRITER || TINT_BUILD_HLSL_WRITER |
| /// @param input input string |
| /// @param suffix potential suffix string |
| /// @returns true if input ends with the given suffix. |
| bool ends_with(const std::string& input, const std::string& suffix) { |
| const auto input_len = input.size(); |
| const auto suffix_len = suffix.size(); |
| // Avoid integer overflow. |
| return (input_len >= suffix_len) && |
| (input_len - suffix_len == input.rfind(suffix)); |
| } |
| #endif |
| |
| /// @param filename the filename to inspect |
| /// @returns the inferred format for the filename suffix |
| Format infer_format(const std::string& filename) { |
| (void)filename; |
| |
| #if TINT_BUILD_SPV_WRITER |
| if (ends_with(filename, ".spv")) { |
| return Format::kSpirv; |
| } |
| if (ends_with(filename, ".spvasm")) { |
| return Format::kSpvAsm; |
| } |
| #endif // TINT_BUILD_SPV_WRITER |
| |
| #if TINT_BUILD_WGSL_WRITER |
| if (ends_with(filename, ".wgsl")) { |
| return Format::kWgsl; |
| } |
| #endif // TINT_BUILD_WGSL_WRITER |
| |
| #if TINT_BUILD_MSL_WRITER |
| if (ends_with(filename, ".metal")) { |
| return Format::kMsl; |
| } |
| #endif // TINT_BUILD_MSL_WRITER |
| |
| #if TINT_BUILD_HLSL_WRITER |
| if (ends_with(filename, ".hlsl")) { |
| return Format::kHlsl; |
| } |
| #endif // TINT_BUILD_HLSL_WRITER |
| |
| return Format::kNone; |
| } |
| |
| std::vector<std::string> split_transform_names(std::string list) { |
| std::vector<std::string> res; |
| |
| std::stringstream str(list); |
| while (str.good()) { |
| std::string substr; |
| getline(str, substr, ','); |
| res.push_back(substr); |
| } |
| return res; |
| } |
| |
| std::string TextureDimensionToString( |
| tint::inspector::ResourceBinding::TextureDimension dim) { |
| switch (dim) { |
| case tint::inspector::ResourceBinding::TextureDimension::kNone: |
| return "None"; |
| case tint::inspector::ResourceBinding::TextureDimension::k1d: |
| return "1d"; |
| case tint::inspector::ResourceBinding::TextureDimension::k2d: |
| return "2d"; |
| case tint::inspector::ResourceBinding::TextureDimension::k2dArray: |
| return "2dArray"; |
| case tint::inspector::ResourceBinding::TextureDimension::k3d: |
| return "3d"; |
| case tint::inspector::ResourceBinding::TextureDimension::kCube: |
| return "Cube"; |
| case tint::inspector::ResourceBinding::TextureDimension::kCubeArray: |
| return "CubeArray"; |
| } |
| |
| return "Unknown"; |
| } |
| |
| std::string SampledKindToString( |
| tint::inspector::ResourceBinding::SampledKind kind) { |
| switch (kind) { |
| case tint::inspector::ResourceBinding::SampledKind::kFloat: |
| return "Float"; |
| case tint::inspector::ResourceBinding::SampledKind::kUInt: |
| return "UInt"; |
| case tint::inspector::ResourceBinding::SampledKind::kSInt: |
| return "SInt"; |
| case tint::inspector::ResourceBinding::SampledKind::kUnknown: |
| break; |
| } |
| |
| return "Unknown"; |
| } |
| |
| std::string TexelFormatToString( |
| tint::inspector::ResourceBinding::TexelFormat format) { |
| switch (format) { |
| case tint::inspector::ResourceBinding::TexelFormat::kR32Uint: |
| return "R32Uint"; |
| case tint::inspector::ResourceBinding::TexelFormat::kR32Sint: |
| return "R32Sint"; |
| case tint::inspector::ResourceBinding::TexelFormat::kR32Float: |
| return "R32Float"; |
| case tint::inspector::ResourceBinding::TexelFormat::kRgba8Unorm: |
| return "Rgba8Unorm"; |
| case tint::inspector::ResourceBinding::TexelFormat::kRgba8Snorm: |
| return "Rgba8Snorm"; |
| case tint::inspector::ResourceBinding::TexelFormat::kRgba8Uint: |
| return "Rgba8Uint"; |
| case tint::inspector::ResourceBinding::TexelFormat::kRgba8Sint: |
| return "Rgba8Sint"; |
| case tint::inspector::ResourceBinding::TexelFormat::kRg32Uint: |
| return "Rg32Uint"; |
| case tint::inspector::ResourceBinding::TexelFormat::kRg32Sint: |
| return "Rg32Sint"; |
| case tint::inspector::ResourceBinding::TexelFormat::kRg32Float: |
| return "Rg32Float"; |
| case tint::inspector::ResourceBinding::TexelFormat::kRgba16Uint: |
| return "Rgba16Uint"; |
| case tint::inspector::ResourceBinding::TexelFormat::kRgba16Sint: |
| return "Rgba16Sint"; |
| case tint::inspector::ResourceBinding::TexelFormat::kRgba16Float: |
| return "Rgba16Float"; |
| case tint::inspector::ResourceBinding::TexelFormat::kRgba32Uint: |
| return "Rgba32Uint"; |
| case tint::inspector::ResourceBinding::TexelFormat::kRgba32Sint: |
| return "Rgba32Sint"; |
| case tint::inspector::ResourceBinding::TexelFormat::kRgba32Float: |
| return "Rgba32Float"; |
| case tint::inspector::ResourceBinding::TexelFormat::kNone: |
| return "None"; |
| } |
| return "Unknown"; |
| } |
| |
| std::string ResourceTypeToString( |
| tint::inspector::ResourceBinding::ResourceType type) { |
| switch (type) { |
| case tint::inspector::ResourceBinding::ResourceType::kUniformBuffer: |
| return "UniformBuffer"; |
| case tint::inspector::ResourceBinding::ResourceType::kStorageBuffer: |
| return "StorageBuffer"; |
| case tint::inspector::ResourceBinding::ResourceType::kReadOnlyStorageBuffer: |
| return "ReadOnlyStorageBuffer"; |
| case tint::inspector::ResourceBinding::ResourceType::kSampler: |
| return "Sampler"; |
| case tint::inspector::ResourceBinding::ResourceType::kComparisonSampler: |
| return "ComparisonSampler"; |
| case tint::inspector::ResourceBinding::ResourceType::kSampledTexture: |
| return "SampledTexture"; |
| case tint::inspector::ResourceBinding::ResourceType::kMultisampledTexture: |
| return "MultisampledTexture"; |
| case tint::inspector::ResourceBinding::ResourceType:: |
| kWriteOnlyStorageTexture: |
| return "WriteOnlyStorageTexture"; |
| case tint::inspector::ResourceBinding::ResourceType::kDepthTexture: |
| return "DepthTexture"; |
| case tint::inspector::ResourceBinding::ResourceType:: |
| kDepthMultisampledTexture: |
| return "DepthMultisampledTexture"; |
| case tint::inspector::ResourceBinding::ResourceType::kExternalTexture: |
| return "ExternalTexture"; |
| } |
| |
| return "Unknown"; |
| } |
| |
| bool ParseArgs(const std::vector<std::string>& args, Options* opts) { |
| for (size_t i = 1; i < args.size(); ++i) { |
| const std::string& arg = args[i]; |
| if (arg == "--format") { |
| ++i; |
| if (i >= args.size()) { |
| std::cerr << "Missing value for --format argument." << std::endl; |
| return false; |
| } |
| opts->format = parse_format(args[i]); |
| |
| if (opts->format == Format::kNone) { |
| std::cerr << "Unknown output format: " << args[i] << std::endl; |
| return false; |
| } |
| } else if (arg == "-ep") { |
| if (i + 1 >= args.size()) { |
| std::cerr << "Missing value for -ep" << std::endl; |
| return false; |
| } |
| i++; |
| opts->ep_name = args[i]; |
| opts->emit_single_entry_point = true; |
| |
| } else if (arg == "-o" || arg == "--output-name") { |
| ++i; |
| if (i >= args.size()) { |
| std::cerr << "Missing value for " << arg << std::endl; |
| return false; |
| } |
| opts->output_file = args[i]; |
| |
| } else if (arg == "-h" || arg == "--help") { |
| opts->show_help = true; |
| } else if (arg == "--transform") { |
| ++i; |
| if (i >= args.size()) { |
| std::cerr << "Missing value for " << arg << std::endl; |
| return false; |
| } |
| opts->transforms = split_transform_names(args[i]); |
| } else if (arg == "--parse-only") { |
| opts->parse_only = true; |
| } else if (arg == "--disable-workgroup-init") { |
| opts->disable_workgroup_init = true; |
| } else if (arg == "--demangle") { |
| opts->demangle = true; |
| } else if (arg == "--dump-inspector-bindings") { |
| opts->dump_inspector_bindings = true; |
| } else if (arg == "--validate") { |
| opts->validate = true; |
| } else if (arg == "--fxc") { |
| opts->validate = true; |
| opts->use_fxc = true; |
| } else if (arg == "--dxc") { |
| ++i; |
| if (i >= args.size()) { |
| std::cerr << "Missing value for " << arg << std::endl; |
| return false; |
| } |
| opts->dxc_path = args[i]; |
| opts->validate = true; |
| } else if (arg == "--xcrun") { |
| ++i; |
| if (i >= args.size()) { |
| std::cerr << "Missing value for " << arg << std::endl; |
| return false; |
| } |
| opts->xcrun_path = args[i]; |
| opts->validate = true; |
| } else if (!arg.empty()) { |
| if (arg[0] == '-') { |
| std::cerr << "Unrecognized option: " << arg << std::endl; |
| return false; |
| } |
| if (!opts->input_filename.empty()) { |
| std::cerr << "More than one input file specified: '" |
| << opts->input_filename << "' and '" << arg << "'" |
| << std::endl; |
| return false; |
| } |
| opts->input_filename = arg; |
| } |
| } |
| return true; |
| } |
| |
| /// Copies the content from the file named `input_file` to `buffer`, |
| /// assuming each element in the file is of type `T`. If any error occurs, |
| /// writes error messages to the standard error stream and returns false. |
| /// Assumes the size of a `T` object is divisible by its required alignment. |
| /// @returns true if we successfully read the file. |
| template <typename T> |
| bool ReadFile(const std::string& input_file, std::vector<T>* buffer) { |
| if (!buffer) { |
| std::cerr << "The buffer pointer was null" << std::endl; |
| return false; |
| } |
| |
| FILE* file = nullptr; |
| #if defined(_MSC_VER) |
| fopen_s(&file, input_file.c_str(), "rb"); |
| #else |
| file = fopen(input_file.c_str(), "rb"); |
| #endif |
| if (!file) { |
| std::cerr << "Failed to open " << input_file << std::endl; |
| return false; |
| } |
| |
| fseek(file, 0, SEEK_END); |
| const auto file_size = static_cast<size_t>(ftell(file)); |
| if (0 != (file_size % sizeof(T))) { |
| std::cerr << "File " << input_file |
| << " does not contain an integral number of objects: " |
| << file_size << " bytes in the file, require " << sizeof(T) |
| << " bytes per object" << std::endl; |
| fclose(file); |
| return false; |
| } |
| fseek(file, 0, SEEK_SET); |
| |
| buffer->clear(); |
| buffer->resize(file_size / sizeof(T)); |
| |
| size_t bytes_read = fread(buffer->data(), 1, file_size, file); |
| fclose(file); |
| if (bytes_read != file_size) { |
| std::cerr << "Failed to read " << input_file << std::endl; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /// Writes the given `buffer` into the file named as `output_file` using the |
| /// given `mode`. If `output_file` is empty or "-", writes to standard |
| /// output. If any error occurs, returns false and outputs error message to |
| /// standard error. The ContainerT type must have data() and size() methods, |
| /// like `std::string` and `std::vector` do. |
| /// @returns true on success |
| template <typename ContainerT> |
| bool WriteFile(const std::string& output_file, |
| const std::string mode, |
| const ContainerT& buffer) { |
| const bool use_stdout = output_file.empty() || output_file == "-"; |
| FILE* file = stdout; |
| |
| if (!use_stdout) { |
| #if defined(_MSC_VER) |
| fopen_s(&file, output_file.c_str(), mode.c_str()); |
| #else |
| file = fopen(output_file.c_str(), mode.c_str()); |
| #endif |
| if (!file) { |
| std::cerr << "Could not open file " << output_file << " for writing" |
| << std::endl; |
| return false; |
| } |
| } |
| |
| size_t written = |
| fwrite(buffer.data(), sizeof(typename ContainerT::value_type), |
| buffer.size(), file); |
| if (buffer.size() != written) { |
| if (use_stdout) { |
| std::cerr << "Could not write all output to standard output" << std::endl; |
| } else { |
| std::cerr << "Could not write to file " << output_file << std::endl; |
| fclose(file); |
| } |
| return false; |
| } |
| if (!use_stdout) { |
| fclose(file); |
| } |
| |
| return true; |
| } |
| |
| #if TINT_BUILD_SPV_WRITER |
| std::string Disassemble(const std::vector<uint32_t>& data) { |
| std::string spv_errors; |
| spv_target_env target_env = SPV_ENV_UNIVERSAL_1_0; |
| |
| auto msg_consumer = [&spv_errors](spv_message_level_t level, const char*, |
| const spv_position_t& position, |
| const char* message) { |
| switch (level) { |
| case SPV_MSG_FATAL: |
| case SPV_MSG_INTERNAL_ERROR: |
| case SPV_MSG_ERROR: |
| spv_errors += "error: line " + std::to_string(position.index) + ": " + |
| message + "\n"; |
| break; |
| case SPV_MSG_WARNING: |
| spv_errors += "warning: line " + std::to_string(position.index) + ": " + |
| message + "\n"; |
| break; |
| case SPV_MSG_INFO: |
| spv_errors += "info: line " + std::to_string(position.index) + ": " + |
| message + "\n"; |
| break; |
| case SPV_MSG_DEBUG: |
| break; |
| } |
| }; |
| |
| spvtools::SpirvTools tools(target_env); |
| tools.SetMessageConsumer(msg_consumer); |
| |
| std::string result; |
| if (!tools.Disassemble(data, &result, |
| SPV_BINARY_TO_TEXT_OPTION_INDENT | |
| SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES)) { |
| std::cerr << spv_errors << std::endl; |
| } |
| return result; |
| } |
| #endif // TINT_BUILD_SPV_WRITER |
| |
| /// PrintWGSL writes the WGSL of the program to the provided ostream, if the |
| /// WGSL writer is enabled, otherwise it does nothing. |
| /// @param out the output stream to write the WGSL to |
| /// @param program the program |
| void PrintWGSL(std::ostream& out, const tint::Program& program) { |
| #if TINT_BUILD_WGSL_WRITER |
| tint::writer::wgsl::Options options; |
| auto result = tint::writer::wgsl::Generate(&program, options); |
| out << std::endl << result.wgsl << std::endl; |
| #else |
| (void)out; |
| (void)program; |
| #endif |
| } |
| |
| /// Generate SPIR-V code for a program. |
| /// @param program the program to generate |
| /// @param options the options that Tint was invoked with |
| /// @returns true on success |
| bool GenerateSpirv(const tint::Program* program, const Options& options) { |
| #if TINT_BUILD_SPV_WRITER |
| // TODO(jrprice): Provide a way for the user to set non-default options. |
| tint::writer::spirv::Options gen_options; |
| gen_options.disable_workgroup_init = options.disable_workgroup_init; |
| auto result = tint::writer::spirv::Generate(program, gen_options); |
| if (!result.success) { |
| PrintWGSL(std::cerr, *program); |
| std::cerr << "Failed to generate: " << result.error << std::endl; |
| return false; |
| } |
| |
| if (options.format == Format::kSpvAsm) { |
| if (!WriteFile(options.output_file, "w", Disassemble(result.spirv))) { |
| return false; |
| } |
| } else { |
| if (!WriteFile(options.output_file, "wb", result.spirv)) { |
| return false; |
| } |
| } |
| |
| if (options.validate) { |
| // Use Vulkan 1.1, since this is what Tint, internally, uses. |
| spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_1); |
| tools.SetMessageConsumer([](spv_message_level_t, const char*, |
| const spv_position_t& pos, const char* msg) { |
| std::cerr << (pos.line + 1) << ":" << (pos.column + 1) << ": " << msg |
| << std::endl; |
| }); |
| if (!tools.Validate(result.spirv.data(), result.spirv.size(), |
| spvtools::ValidatorOptions())) { |
| return false; |
| } |
| } |
| |
| return true; |
| #else |
| (void)program; |
| (void)options; |
| std::cerr << "SPIR-V writer not enabled in tint build" << std::endl; |
| return false; |
| #endif // TINT_BUILD_SPV_WRITER |
| } |
| |
| /// Generate WGSL code for a program. |
| /// @param program the program to generate |
| /// @param options the options that Tint was invoked with |
| /// @returns true on success |
| bool GenerateWgsl(const tint::Program* program, const Options& options) { |
| #if TINT_BUILD_WGSL_WRITER |
| // TODO(jrprice): Provide a way for the user to set non-default options. |
| tint::writer::wgsl::Options gen_options; |
| auto result = tint::writer::wgsl::Generate(program, gen_options); |
| if (!result.success) { |
| std::cerr << "Failed to generate: " << result.error << std::endl; |
| return false; |
| } |
| |
| return WriteFile(options.output_file, "w", result.wgsl); |
| #else |
| (void)program; |
| (void)options; |
| std::cerr << "WGSL writer not enabled in tint build" << std::endl; |
| return false; |
| #endif // TINT_BUILD_WGSL_WRITER |
| } |
| |
| /// Generate MSL code for a program. |
| /// @param program the program to generate |
| /// @param options the options that Tint was invoked with |
| /// @returns true on success |
| bool GenerateMsl(const tint::Program* program, const Options& options) { |
| #if TINT_BUILD_MSL_WRITER |
| const tint::Program* input_program = program; |
| |
| // Remap resource numbers to a flat namespace. |
| // TODO(crbug.com/tint/1101): Make this more robust for multiple entry points. |
| using BindingPoint = tint::transform::BindingPoint; |
| tint::transform::BindingRemapper::BindingPoints binding_points; |
| uint32_t next_buffer_idx = 0; |
| uint32_t next_sampler_idx = 0; |
| uint32_t next_texture_idx = 0; |
| |
| tint::inspector::Inspector inspector(program); |
| auto entry_points = inspector.GetEntryPoints(); |
| for (auto& entry_point : entry_points) { |
| auto bindings = inspector.GetResourceBindings(entry_point.name); |
| for (auto& binding : bindings) { |
| BindingPoint src = {binding.bind_group, binding.binding}; |
| if (binding_points.count(src)) { |
| continue; |
| } |
| switch (binding.resource_type) { |
| case tint::inspector::ResourceBinding::ResourceType::kUniformBuffer: |
| case tint::inspector::ResourceBinding::ResourceType::kStorageBuffer: |
| case tint::inspector::ResourceBinding::ResourceType:: |
| kReadOnlyStorageBuffer: |
| binding_points.emplace(src, BindingPoint{0, next_buffer_idx++}); |
| break; |
| case tint::inspector::ResourceBinding::ResourceType::kSampler: |
| case tint::inspector::ResourceBinding::ResourceType::kComparisonSampler: |
| binding_points.emplace(src, BindingPoint{0, next_sampler_idx++}); |
| break; |
| case tint::inspector::ResourceBinding::ResourceType::kSampledTexture: |
| case tint::inspector::ResourceBinding::ResourceType:: |
| kMultisampledTexture: |
| case tint::inspector::ResourceBinding::ResourceType:: |
| kWriteOnlyStorageTexture: |
| case tint::inspector::ResourceBinding::ResourceType::kDepthTexture: |
| case tint::inspector::ResourceBinding::ResourceType:: |
| kDepthMultisampledTexture: |
| case tint::inspector::ResourceBinding::ResourceType::kExternalTexture: |
| binding_points.emplace(src, BindingPoint{0, next_texture_idx++}); |
| break; |
| } |
| } |
| } |
| |
| // Run the binding remapper transform. |
| tint::transform::Output transform_output; |
| if (!binding_points.empty()) { |
| tint::transform::Manager manager; |
| tint::transform::DataMap inputs; |
| inputs.Add<tint::transform::BindingRemapper::Remappings>( |
| std::move(binding_points), |
| tint::transform::BindingRemapper::AccessControls{}, |
| /* mayCollide */ true); |
| manager.Add<tint::transform::BindingRemapper>(); |
| transform_output = manager.Run(program, inputs); |
| input_program = &transform_output.program; |
| } |
| |
| // TODO(jrprice): Provide a way for the user to set non-default options. |
| tint::writer::msl::Options gen_options; |
| gen_options.disable_workgroup_init = options.disable_workgroup_init; |
| auto result = tint::writer::msl::Generate(input_program, gen_options); |
| if (!result.success) { |
| PrintWGSL(std::cerr, *program); |
| std::cerr << "Failed to generate: " << result.error << std::endl; |
| return false; |
| } |
| |
| if (!WriteFile(options.output_file, "w", result.msl)) { |
| return false; |
| } |
| |
| if (options.validate) { |
| tint::val::Result res; |
| #ifdef TINT_ENABLE_MSL_VALIDATION_USING_METAL_API |
| res = tint::val::MslUsingMetalAPI(result.msl); |
| #else |
| #ifdef _WIN32 |
| const char* default_xcrun_exe = "metal.exe"; |
| #else |
| const char* default_xcrun_exe = "xcrun"; |
| #endif |
| auto xcrun = tint::utils::Command::LookPath( |
| options.xcrun_path.empty() ? default_xcrun_exe : options.xcrun_path); |
| if (xcrun.Found()) { |
| res = tint::val::Msl(xcrun.Path(), result.msl); |
| } else { |
| res.output = "xcrun executable not found. Cannot validate."; |
| res.failed = true; |
| } |
| #endif // TINT_ENABLE_MSL_VALIDATION_USING_METAL_API |
| if (res.failed) { |
| std::cerr << res.output << std::endl; |
| return false; |
| } |
| } |
| |
| return true; |
| #else |
| (void)program; |
| (void)options; |
| std::cerr << "MSL writer not enabled in tint build" << std::endl; |
| return false; |
| #endif // TINT_BUILD_MSL_WRITER |
| } |
| |
| /// Generate HLSL code for a program. |
| /// @param program the program to generate |
| /// @param options the options that Tint was invoked with |
| /// @returns true on success |
| bool GenerateHlsl(const tint::Program* program, const Options& options) { |
| #if TINT_BUILD_HLSL_WRITER |
| // TODO(jrprice): Provide a way for the user to set non-default options. |
| tint::writer::hlsl::Options gen_options; |
| gen_options.disable_workgroup_init = options.disable_workgroup_init; |
| auto result = tint::writer::hlsl::Generate(program, gen_options); |
| if (!result.success) { |
| PrintWGSL(std::cerr, *program); |
| std::cerr << "Failed to generate: " << result.error << std::endl; |
| return false; |
| } |
| |
| if (!WriteFile(options.output_file, "w", result.hlsl)) { |
| return false; |
| } |
| |
| if (options.validate) { |
| tint::val::Result res; |
| if (options.use_fxc) { |
| #ifdef _WIN32 |
| res = tint::val::HlslUsingFXC(result.hlsl, result.entry_points); |
| #else |
| res.failed = true; |
| res.output = "FXC can only be used on Windows. Sorry :X"; |
| #endif // _WIN32 |
| } else { |
| auto dxc = tint::utils::Command::LookPath( |
| options.dxc_path.empty() ? "dxc" : options.dxc_path); |
| if (dxc.Found()) { |
| res = tint::val::HlslUsingDXC(dxc.Path(), result.hlsl, |
| result.entry_points); |
| } else { |
| res.failed = true; |
| res.output = "DXC executable not found. Cannot validate"; |
| } |
| } |
| if (res.failed) { |
| std::cerr << res.output << std::endl; |
| return false; |
| } |
| } |
| |
| return true; |
| #else |
| (void)program; |
| (void)options; |
| std::cerr << "HLSL writer not enabled in tint build" << std::endl; |
| return false; |
| #endif // TINT_BUILD_HLSL_WRITER |
| } |
| |
| #if TINT_BUILD_GLSL_WRITER |
| EShLanguage pipeline_stage_to_esh_language(tint::ast::PipelineStage stage) { |
| switch (stage) { |
| case tint::ast::PipelineStage::kFragment: |
| return EShLangFragment; |
| case tint::ast::PipelineStage::kVertex: |
| return EShLangVertex; |
| case tint::ast::PipelineStage::kCompute: |
| return EShLangCompute; |
| default: |
| TINT_ASSERT(AST, false); |
| return EShLangVertex; |
| } |
| } |
| #endif |
| |
| /// Generate GLSL code for a program. |
| /// @param program the program to generate |
| /// @param options the options that Tint was invoked with |
| /// @returns true on success |
| bool GenerateGlsl(const tint::Program* program, const Options& options) { |
| #if TINT_BUILD_GLSL_WRITER |
| if (options.validate) { |
| glslang::InitializeProcess(); |
| } |
| |
| auto generate = [&](const tint::Program* prg, |
| const std::string entry_point_name) -> bool { |
| tint::writer::glsl::Options gen_options; |
| auto result = |
| tint::writer::glsl::Generate(prg, gen_options, entry_point_name); |
| if (!result.success) { |
| PrintWGSL(std::cerr, *prg); |
| std::cerr << "Failed to generate: " << result.error << std::endl; |
| return false; |
| } |
| |
| if (!WriteFile(options.output_file, "w", result.glsl)) { |
| return false; |
| } |
| |
| if (options.validate) { |
| for (auto entry_pt : result.entry_points) { |
| EShLanguage lang = pipeline_stage_to_esh_language(entry_pt.second); |
| glslang::TShader shader(lang); |
| const char* strings[1] = {result.glsl.c_str()}; |
| int lengths[1] = {static_cast<int>(result.glsl.length())}; |
| shader.setStringsWithLengths(strings, lengths, 1); |
| shader.setEntryPoint("main"); |
| bool glslang_result = |
| shader.parse(&glslang::DefaultTBuiltInResource, 310, EEsProfile, |
| false, false, EShMsgDefault); |
| if (!glslang_result) { |
| std::cerr << "Error parsing GLSL shader:\n" |
| << shader.getInfoLog() << "\n" |
| << shader.getInfoDebugLog() << "\n"; |
| return false; |
| } |
| } |
| } |
| return true; |
| }; |
| |
| tint::inspector::Inspector inspector(program); |
| |
| if (inspector.GetEntryPoints().empty()) { |
| // Pass empty string here so that the GLSL generator will generate |
| // code for all functions, reachable or not. |
| return generate(program, ""); |
| } |
| |
| bool success = true; |
| for (auto& entry_point : inspector.GetEntryPoints()) { |
| success &= generate(program, entry_point.name); |
| } |
| return success; |
| #else |
| (void)program; |
| (void)options; |
| std::cerr << "GLSL writer not enabled in tint build" << std::endl; |
| return false; |
| #endif // TINT_BUILD_GLSL_WRITER |
| } |
| |
| } // namespace |
| |
| int main(int argc, const char** argv) { |
| std::vector<std::string> args(argv, argv + argc); |
| Options options; |
| |
| tint::SetInternalCompilerErrorReporter(&TintInternalCompilerErrorReporter); |
| |
| #if TINT_BUILD_WGSL_WRITER |
| tint::Program::printer = [](const tint::Program* program) { |
| auto result = tint::writer::wgsl::Generate(program, {}); |
| if (!result.error.empty()) { |
| return "error: " + result.error; |
| } |
| return result.wgsl; |
| }; |
| #endif // TINT_BUILD_WGSL_WRITER |
| |
| if (!ParseArgs(args, &options)) { |
| std::cerr << "Failed to parse arguments." << std::endl; |
| return 1; |
| } |
| |
| struct TransformFactory { |
| const char* name; |
| std::function<void(tint::transform::Manager& manager, |
| tint::transform::DataMap& inputs)> |
| make; |
| }; |
| std::vector<TransformFactory> transforms = { |
| {"first_index_offset", |
| [](tint::transform::Manager& m, tint::transform::DataMap& i) { |
| i.Add<tint::transform::FirstIndexOffset::BindingPoint>(0, 0); |
| m.Add<tint::transform::FirstIndexOffset>(); |
| }}, |
| {"fold_trivial_single_use_lets", |
| [](tint::transform::Manager& m, tint::transform::DataMap&) { |
| m.Add<tint::transform::FoldTrivialSingleUseLets>(); |
| }}, |
| {"renamer", |
| [](tint::transform::Manager& m, tint::transform::DataMap&) { |
| m.Add<tint::transform::Renamer>(); |
| }}, |
| {"robustness", |
| [](tint::transform::Manager& m, tint::transform::DataMap&) { |
| m.Add<tint::transform::Robustness>(); |
| }}, |
| }; |
| auto transform_names = [&] { |
| std::stringstream names; |
| for (auto& t : transforms) { |
| names << " " << t.name << std::endl; |
| } |
| return names.str(); |
| }; |
| |
| if (options.show_help) { |
| std::string usage = |
| tint::utils::ReplaceAll(kUsage, "${transforms}", transform_names()); |
| std::cout << usage << std::endl; |
| return 0; |
| } |
| |
| // Implement output format defaults. |
| if (options.format == Format::kNone) { |
| // Try inferring from filename. |
| options.format = infer_format(options.output_file); |
| } |
| if (options.format == Format::kNone) { |
| // Ultimately, default to SPIR-V assembly. That's nice for interactive use. |
| options.format = Format::kSpvAsm; |
| } |
| |
| auto diag_printer = tint::diag::Printer::create(stderr, true); |
| tint::diag::Formatter diag_formatter; |
| |
| std::unique_ptr<tint::Program> program; |
| std::unique_ptr<tint::Source::File> source_file; |
| |
| enum class InputFormat { |
| kUnknown, |
| kWgsl, |
| kSpirvBin, |
| kSpirvAsm, |
| }; |
| auto input_format = InputFormat::kUnknown; |
| |
| if (options.input_filename.size() > 5 && |
| options.input_filename.substr(options.input_filename.size() - 5) == |
| ".wgsl") { |
| input_format = InputFormat::kWgsl; |
| } else if (options.input_filename.size() > 4 && |
| options.input_filename.substr(options.input_filename.size() - 4) == |
| ".spv") { |
| input_format = InputFormat::kSpirvBin; |
| } else if (options.input_filename.size() > 7 && |
| options.input_filename.substr(options.input_filename.size() - 7) == |
| ".spvasm") { |
| input_format = InputFormat::kSpirvAsm; |
| } |
| |
| switch (input_format) { |
| case InputFormat::kUnknown: { |
| std::cerr << "Unknown input format" << std::endl; |
| return 1; |
| } |
| case InputFormat::kWgsl: { |
| #if TINT_BUILD_WGSL_READER |
| std::vector<uint8_t> data; |
| if (!ReadFile<uint8_t>(options.input_filename, &data)) { |
| return 1; |
| } |
| source_file = std::make_unique<tint::Source::File>( |
| options.input_filename, std::string(data.begin(), data.end())); |
| program = std::make_unique<tint::Program>( |
| tint::reader::wgsl::Parse(source_file.get())); |
| break; |
| #else |
| std::cerr << "Tint not built with the WGSL reader enabled" << std::endl; |
| return 1; |
| #endif // TINT_BUILD_WGSL_READER |
| } |
| case InputFormat::kSpirvBin: { |
| #if TINT_BUILD_SPV_READER |
| std::vector<uint32_t> data; |
| if (!ReadFile<uint32_t>(options.input_filename, &data)) { |
| return 1; |
| } |
| program = |
| std::make_unique<tint::Program>(tint::reader::spirv::Parse(data)); |
| break; |
| #else |
| std::cerr << "Tint not built with the SPIR-V reader enabled" << std::endl; |
| return 1; |
| #endif // TINT_BUILD_SPV_READER |
| } |
| case InputFormat::kSpirvAsm: { |
| #if TINT_BUILD_SPV_READER |
| std::vector<char> text; |
| if (!ReadFile<char>(options.input_filename, &text)) { |
| return 1; |
| } |
| // Use Vulkan 1.1, since this is what Tint, internally, is expecting. |
| spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_1); |
| tools.SetMessageConsumer([](spv_message_level_t, const char*, |
| const spv_position_t& pos, const char* msg) { |
| std::cerr << (pos.line + 1) << ":" << (pos.column + 1) << ": " << msg |
| << std::endl; |
| }); |
| std::vector<uint32_t> data; |
| if (!tools.Assemble(text.data(), text.size(), &data, |
| SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS)) { |
| return 1; |
| } |
| program = |
| std::make_unique<tint::Program>(tint::reader::spirv::Parse(data)); |
| break; |
| #else |
| std::cerr << "Tint not built with the SPIR-V reader enabled" << std::endl; |
| return 1; |
| #endif // TINT_BUILD_SPV_READER |
| } |
| } |
| |
| if (!program) { |
| std::cerr << "Failed to parse input file: " << options.input_filename |
| << std::endl; |
| return 1; |
| } |
| if (program->Diagnostics().count() > 0) { |
| if (!program->IsValid() && input_format != InputFormat::kWgsl) { |
| // Invalid program from a non-wgsl source. Print the WGSL, to help |
| // understand the diagnostics. |
| PrintWGSL(std::cout, *program); |
| } |
| diag_formatter.format(program->Diagnostics(), diag_printer.get()); |
| } |
| |
| if (!program->IsValid()) { |
| return 1; |
| } |
| if (options.parse_only) { |
| return 1; |
| } |
| |
| tint::transform::Manager transform_manager; |
| tint::transform::DataMap transform_inputs; |
| for (const auto& name : options.transforms) { |
| // TODO(dsinclair): The vertex pulling transform requires setup code to |
| // be run that needs user input. Should we find a way to support that here |
| // maybe through a provided file? |
| |
| bool found = false; |
| for (auto& t : transforms) { |
| if (t.name == name) { |
| t.make(transform_manager, transform_inputs); |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| std::cerr << "Unknown transform: " << name << std::endl; |
| std::cerr << "Available transforms: " << std::endl << transform_names(); |
| return 1; |
| } |
| } |
| |
| if (options.emit_single_entry_point) { |
| transform_manager.append( |
| std::make_unique<tint::transform::SingleEntryPoint>()); |
| transform_inputs.Add<tint::transform::SingleEntryPoint::Config>( |
| options.ep_name); |
| } |
| |
| switch (options.format) { |
| case Format::kMsl: { |
| #if TINT_BUILD_MSL_WRITER |
| transform_inputs.Add<tint::transform::Renamer::Config>( |
| tint::transform::Renamer::Target::kMslKeywords); |
| transform_manager.Add<tint::transform::Renamer>(); |
| #endif // TINT_BUILD_MSL_WRITER |
| break; |
| } |
| #if TINT_BUILD_GLSL_WRITER |
| case Format::kGlsl: { |
| break; |
| } |
| #endif // TINT_BUILD_GLSL_WRITER |
| case Format::kHlsl: { |
| #if TINT_BUILD_HLSL_WRITER |
| transform_inputs.Add<tint::transform::Renamer::Config>( |
| tint::transform::Renamer::Target::kHlslKeywords); |
| transform_manager.Add<tint::transform::Renamer>(); |
| #endif // TINT_BUILD_HLSL_WRITER |
| break; |
| } |
| default: |
| break; |
| } |
| |
| auto out = transform_manager.Run(program.get(), std::move(transform_inputs)); |
| if (!out.program.IsValid()) { |
| PrintWGSL(std::cerr, out.program); |
| diag_formatter.format(out.program.Diagnostics(), diag_printer.get()); |
| return 1; |
| } |
| |
| *program = std::move(out.program); |
| |
| if (options.dump_inspector_bindings) { |
| std::cout << std::string(80, '-') << std::endl; |
| tint::inspector::Inspector inspector(program.get()); |
| auto entry_points = inspector.GetEntryPoints(); |
| if (!inspector.error().empty()) { |
| std::cerr << "Failed to get entry points from Inspector: " |
| << inspector.error() << std::endl; |
| return 1; |
| } |
| |
| for (auto& entry_point : entry_points) { |
| auto bindings = inspector.GetResourceBindings(entry_point.name); |
| if (!inspector.error().empty()) { |
| std::cerr << "Failed to get bindings from Inspector: " |
| << inspector.error() << std::endl; |
| return 1; |
| } |
| std::cout << "Entry Point = " << entry_point.name << std::endl; |
| for (auto& binding : bindings) { |
| std::cout << "\t[" << binding.bind_group << "][" << binding.binding |
| << "]:" << std::endl; |
| std::cout << "\t\t resource_type = " |
| << ResourceTypeToString(binding.resource_type) << std::endl; |
| std::cout << "\t\t dim = " << TextureDimensionToString(binding.dim) |
| << std::endl; |
| std::cout << "\t\t sampled_kind = " |
| << SampledKindToString(binding.sampled_kind) << std::endl; |
| std::cout << "\t\t image_format = " |
| << TexelFormatToString(binding.image_format) << std::endl; |
| } |
| } |
| std::cout << std::string(80, '-') << std::endl; |
| } |
| |
| bool success = false; |
| switch (options.format) { |
| case Format::kSpirv: |
| case Format::kSpvAsm: |
| success = GenerateSpirv(program.get(), options); |
| break; |
| case Format::kWgsl: |
| success = GenerateWgsl(program.get(), options); |
| break; |
| case Format::kMsl: |
| success = GenerateMsl(program.get(), options); |
| break; |
| case Format::kHlsl: |
| success = GenerateHlsl(program.get(), options); |
| break; |
| case Format::kGlsl: |
| success = GenerateGlsl(program.get(), options); |
| break; |
| default: |
| std::cerr << "Unknown output format specified" << std::endl; |
| return 1; |
| } |
| if (!success) { |
| return 1; |
| } |
| |
| return 0; |
| } |
