SPIRV/SpvTools.cpp

   1 //
   2 // Copyright (C) 2014-2016 LunarG, Inc.
   3 // Copyright (C) 2018-2020 Google, Inc.
   4 //
   5 // All rights reserved.
   6 //
   7 // Redistribution and use in source and binary forms, with or without
   8 // modification, are permitted provided that the following conditions
   9 // are met:
  10 //
  11 //    Redistributions of source code must retain the above copyright
  12 //    notice, this list of conditions and the following disclaimer.
  13 //
  14 //    Redistributions in binary form must reproduce the above
  15 //    copyright notice, this list of conditions and the following
  16 //    disclaimer in the documentation and/or other materials provided
  17 //    with the distribution.
  18 //
  19 //    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
  20 //    contributors may be used to endorse or promote products derived
  21 //    from this software without specific prior written permission.
  22 //
  23 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  26 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  27 // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  28 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  29 // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  30 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  31 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  33 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  34 // POSSIBILITY OF SUCH DAMAGE.
  35
  36 //
  37 // Call into SPIRV-Tools to disassemble, validate, and optimize.
  38 //
  39
  40 #if ENABLE_OPT
  41
  42 #include <cstdio>
  43 #include <iostream>
  44
  45 #include "SpvTools.h"
  46 #include "spirv-tools/optimizer.hpp"
  47
  48 namespace glslang {
  49
  50 // Translate glslang's view of target versioning to what SPIRV-Tools uses.
  51 spv_target_env MapToSpirvToolsEnv(const SpvVersion& spvVersion, spv::SpvBuildLogger* logger)
  52 {
  53     switch (spvVersion.vulkan) {
  54     case glslang::EShTargetVulkan_1_0:
  55         return spv_target_env::SPV_ENV_VULKAN_1_0;
  56     case glslang::EShTargetVulkan_1_1:
  57         switch (spvVersion.spv) {
  58         case EShTargetSpv_1_0:
  59         case EShTargetSpv_1_1:
  60         case EShTargetSpv_1_2:
  61         case EShTargetSpv_1_3:
  62             return spv_target_env::SPV_ENV_VULKAN_1_1;
  63         case EShTargetSpv_1_4:
  64             return spv_target_env::SPV_ENV_VULKAN_1_1_SPIRV_1_4;
  65         default:
  66             logger->missingFunctionality("Target version for SPIRV-Tools validator");
  67             return spv_target_env::SPV_ENV_VULKAN_1_1;
  68         }
  69     case glslang::EShTargetVulkan_1_2:
  70         return spv_target_env::SPV_ENV_VULKAN_1_2;
  71     case glslang::EShTargetUniversal:
  72         switch (spvVersion.spv) {
  73         case EShTargetSpv_1_0:
  74             return spv_target_env::SPV_ENV_UNIVERSAL_1_0;
  75         case EShTargetSpv_1_1:
  76             return spv_target_env::SPV_ENV_UNIVERSAL_1_1;
  77         case EShTargetSpv_1_2:
  78             return spv_target_env::SPV_ENV_UNIVERSAL_1_2;
  79         case EShTargetSpv_1_3:
  80             return spv_target_env::SPV_ENV_UNIVERSAL_1_3;
  81         case EShTargetSpv_1_4:
  82             return spv_target_env::SPV_ENV_UNIVERSAL_1_4;
  83         case EShTargetSpv_1_5:
  84             return spv_target_env::SPV_ENV_UNIVERSAL_1_5;
  85         case EShTargetSpv_1_6:
  86             return spv_target_env::SPV_ENV_UNIVERSAL_1_6;
  87         default:
  88             logger->missingFunctionality("Target version for SPIRV-Tools validator");
  89             return spv_target_env::SPV_ENV_UNIVERSAL_1_6;
  90         }
  91     default:
  92         break;
  93     }
  94
  95     if (spvVersion.openGl > 0)
  96         return spv_target_env::SPV_ENV_OPENGL_4_5;
  97
  98     logger->missingFunctionality("Target version for SPIRV-Tools validator");
  99     return spv_target_env::SPV_ENV_UNIVERSAL_1_0;
 100 }
 101
 102 // Callback passed to spvtools::Optimizer::SetMessageConsumer
 103 void OptimizerMesssageConsumer(spv_message_level_t level, const char *source,
 104         const spv_position_t &position, const char *message)
 105 {
 106     auto &out = std::cerr;
 107     switch (level)
 108     {
 109     case SPV_MSG_FATAL:
 110     case SPV_MSG_INTERNAL_ERROR:
 111     case SPV_MSG_ERROR:
 112         out << "error: ";
 113         break;
 114     case SPV_MSG_WARNING:
 115         out << "warning: ";
 116         break;
 117     case SPV_MSG_INFO:
 118     case SPV_MSG_DEBUG:
 119         out << "info: ";
 120         break;
 121     default:
 122         break;
 123     }
 124     if (source)
 125     {
 126         out << source << ":";
 127     }
 128     out << position.line << ":" << position.column << ":" << position.index << ":";
 129     if (message)
 130     {
 131         out << " " << message;
 132     }
 133     out << std::endl;
 134 }
 135
 136 // Use the SPIRV-Tools disassembler to print SPIR-V using a SPV_ENV_UNIVERSAL_1_3 environment.
 137 void SpirvToolsDisassemble(std::ostream& out, const std::vector<unsigned int>& spirv)
 138 {
 139     SpirvToolsDisassemble(out, spirv, spv_target_env::SPV_ENV_UNIVERSAL_1_3);
 140 }
 141
 142 // Use the SPIRV-Tools disassembler to print SPIR-V with a provided SPIR-V environment.
 143 void SpirvToolsDisassemble(std::ostream& out, const std::vector<unsigned int>& spirv,
 144                            spv_target_env requested_context)
 145 {
 146     // disassemble
 147     spv_context context = spvContextCreate(requested_context);
 148     spv_text text;
 149     spv_diagnostic diagnostic = nullptr;
 150     spvBinaryToText(context, spirv.data(), spirv.size(),
 151         SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES | SPV_BINARY_TO_TEXT_OPTION_INDENT,
 152         &text, &diagnostic);
 153
 154     // dump
 155     if (diagnostic == nullptr)
 156         out << text->str;
 157     else
 158         spvDiagnosticPrint(diagnostic);
 159
 160     // teardown
 161     spvDiagnosticDestroy(diagnostic);
 162     spvContextDestroy(context);
 163 }
 164
 165 // Apply the SPIRV-Tools validator to generated SPIR-V.
 166 void SpirvToolsValidate(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
 167                         spv::SpvBuildLogger* logger, bool prelegalization)
 168 {
 169     // validate
 170     spv_context context = spvContextCreate(MapToSpirvToolsEnv(intermediate.getSpv(), logger));
 171     spv_const_binary_t binary = { spirv.data(), spirv.size() };
 172     spv_diagnostic diagnostic = nullptr;
 173     spv_validator_options options = spvValidatorOptionsCreate();
 174     spvValidatorOptionsSetRelaxBlockLayout(options, intermediate.usingHlslOffsets());
 175     spvValidatorOptionsSetBeforeHlslLegalization(options, prelegalization);
 176     spvValidatorOptionsSetScalarBlockLayout(options, intermediate.usingScalarBlockLayout());
 177     spvValidatorOptionsSetWorkgroupScalarBlockLayout(options, intermediate.usingScalarBlockLayout());
 178     spvValidateWithOptions(context, options, &binary, &diagnostic);
 179
 180     // report
 181     if (diagnostic != nullptr) {
 182         logger->error("SPIRV-Tools Validation Errors");
 183         logger->error(diagnostic->error);
 184     }
 185
 186     // tear down
 187     spvValidatorOptionsDestroy(options);
 188     spvDiagnosticDestroy(diagnostic);
 189     spvContextDestroy(context);
 190 }
 191
 192 // Apply the SPIRV-Tools optimizer to generated SPIR-V.  HLSL SPIR-V is legalized in the process.
 193 void SpirvToolsTransform(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
 194                          spv::SpvBuildLogger* logger, const SpvOptions* options)
 195 {
 196     spv_target_env target_env = MapToSpirvToolsEnv(intermediate.getSpv(), logger);
 197
 198     spvtools::Optimizer optimizer(target_env);
 199     optimizer.SetMessageConsumer(OptimizerMesssageConsumer);
 200
 201     // If debug (specifically source line info) is being generated, propagate
 202     // line information into all SPIR-V instructions. This avoids loss of
 203     // information when instructions are deleted or moved. Later, remove
 204     // redundant information to minimize final SPRIR-V size.
 205     if (options->stripDebugInfo) {
 206         optimizer.RegisterPass(spvtools::CreateStripDebugInfoPass());
 207     }
 208     optimizer.RegisterPass(spvtools::CreateWrapOpKillPass());
 209     optimizer.RegisterPass(spvtools::CreateDeadBranchElimPass());
 210     optimizer.RegisterPass(spvtools::CreateMergeReturnPass());
 211     optimizer.RegisterPass(spvtools::CreateInlineExhaustivePass());
 212     optimizer.RegisterPass(spvtools::CreateEliminateDeadFunctionsPass());
 213     optimizer.RegisterPass(spvtools::CreateScalarReplacementPass());
 214     optimizer.RegisterPass(spvtools::CreateLocalAccessChainConvertPass());
 215     optimizer.RegisterPass(spvtools::CreateLocalSingleBlockLoadStoreElimPass());
 216     optimizer.RegisterPass(spvtools::CreateLocalSingleStoreElimPass());
 217     optimizer.RegisterPass(spvtools::CreateSimplificationPass());
 218     optimizer.RegisterPass(spvtools::CreateAggressiveDCEPass());
 219     optimizer.RegisterPass(spvtools::CreateVectorDCEPass());
 220     optimizer.RegisterPass(spvtools::CreateDeadInsertElimPass());
 221     optimizer.RegisterPass(spvtools::CreateAggressiveDCEPass());
 222     optimizer.RegisterPass(spvtools::CreateDeadBranchElimPass());
 223     optimizer.RegisterPass(spvtools::CreateBlockMergePass());
 224     optimizer.RegisterPass(spvtools::CreateLocalMultiStoreElimPass());
 225     optimizer.RegisterPass(spvtools::CreateIfConversionPass());
 226     optimizer.RegisterPass(spvtools::CreateSimplificationPass());
 227     optimizer.RegisterPass(spvtools::CreateAggressiveDCEPass());
 228     optimizer.RegisterPass(spvtools::CreateVectorDCEPass());
 229     optimizer.RegisterPass(spvtools::CreateDeadInsertElimPass());
 230     optimizer.RegisterPass(spvtools::CreateInterpolateFixupPass());
 231     if (options->optimizeSize) {
 232         optimizer.RegisterPass(spvtools::CreateRedundancyEliminationPass());
 233     }
 234     optimizer.RegisterPass(spvtools::CreateAggressiveDCEPass());
 235     optimizer.RegisterPass(spvtools::CreateCFGCleanupPass());
 236
 237     spvtools::OptimizerOptions spvOptOptions;
 238     optimizer.SetTargetEnv(MapToSpirvToolsEnv(intermediate.getSpv(), logger));
 239     spvOptOptions.set_run_validator(false); // The validator may run as a separate step later on
 240     optimizer.Run(spirv.data(), spirv.size(), &spirv, spvOptOptions);
 241 }
 242
 243 // Apply the SPIRV-Tools optimizer to strip debug info from SPIR-V.  This is implicitly done by
 244 // SpirvToolsTransform if spvOptions->stripDebugInfo is set, but can be called separately if
 245 // optimization is disabled.
 246 void SpirvToolsStripDebugInfo(const glslang::TIntermediate& intermediate,
 247         std::vector<unsigned int>& spirv, spv::SpvBuildLogger* logger)
 248 {
 249     spv_target_env target_env = MapToSpirvToolsEnv(intermediate.getSpv(), logger);
 250
 251     spvtools::Optimizer optimizer(target_env);
 252     optimizer.SetMessageConsumer(OptimizerMesssageConsumer);
 253
 254     optimizer.RegisterPass(spvtools::CreateStripDebugInfoPass());
 255
 256     spvtools::OptimizerOptions spvOptOptions;
 257     optimizer.SetTargetEnv(MapToSpirvToolsEnv(intermediate.getSpv(), logger));
 258     spvOptOptions.set_run_validator(false); // The validator may run as a separate step later on
 259     optimizer.Run(spirv.data(), spirv.size(), &spirv, spvOptOptions);
 260 }
 261
 262 }; // end namespace glslang
 263
 264 #endif