impeller::compiler::Compiler Class Reference

#include <compiler.h>

Public Member Functions
	Compiler (const std::shared_ptr< const fml::Mapping > &source_mapping, const SourceOptions &options, Reflector::Options reflector_options)
	~Compiler ()
bool	IsValid () const
std::shared_ptr< fml::Mapping >	GetSPIRVAssembly () const
std::shared_ptr< fml::Mapping >	GetSLShaderSource () const
std::string	GetErrorMessages () const
std::string	GetVerboseErrorMessages () const
const std::vector< std::string > &	GetIncludedFileNames () const
std::unique_ptr< fml::Mapping >	CreateDepfileContents (std::initializer_list< std::string > targets) const
const Reflector *	GetReflector () const

Detailed Description

Definition at line 25 of file compiler.h.

Constructor & Destructor Documentation

Compiler()

impeller::compiler::Compiler::Compiler	(	const std::shared_ptr< const fml::Mapping > &	source_mapping,
		const SourceOptions &	options,
		Reflector::Options	reflector_options
	)

Definition at line 330 of file compiler.cc.

    : options_(source_options) {
  if (!source_mapping || source_mapping->GetMapping() == nullptr) {
    COMPILER_ERROR(error_stream_)
        << "Could not read shader source or shader source was empty.";
    return;
  }
 
  if (source_options.target_platform == TargetPlatform::kUnknown) {
    COMPILER_ERROR(error_stream_) << "Target platform not specified.";
    return;
  }
 
  SPIRVCompilerOptions spirv_options;
 
  // Make sure reflection is as effective as possible. The generated shaders
  // will be processed later by backend specific compilers.
  spirv_options.generate_debug_info = true;
 
  switch (options_.source_language) {
    case SourceLanguage::kGLSL:
      // Expects GLSL 4.60 (Core Profile).
      // https://www.khronos.org/registry/OpenGL/specs/gl/GLSLangSpec.4.60.pdf
      spirv_options.source_langauge =
          shaderc_source_language::shaderc_source_language_glsl;
      spirv_options.source_profile = SPIRVCompilerSourceProfile{
          shaderc_profile::shaderc_profile_core,  //
          460,                                    //
      };
      break;
    case SourceLanguage::kHLSL:
      spirv_options.source_langauge =
          shaderc_source_language::shaderc_source_language_hlsl;
      break;
    case SourceLanguage::kUnknown:
      COMPILER_ERROR(error_stream_) << "Source language invalid.";
      return;
  }
 
  switch (source_options.target_platform) {
    case TargetPlatform::kMetalDesktop:
    case TargetPlatform::kMetalIOS: {
      SPIRVCompilerTargetEnv target;
 
      if (source_options.use_half_textures) {
        target.env = shaderc_target_env::shaderc_target_env_opengl;
        target.version = shaderc_env_version::shaderc_env_version_opengl_4_5;
        target.spirv_version = shaderc_spirv_version::shaderc_spirv_version_1_0;
      } else {
        target.env = shaderc_target_env::shaderc_target_env_vulkan;
        target.version = shaderc_env_version::shaderc_env_version_vulkan_1_1;
        target.spirv_version = shaderc_spirv_version::shaderc_spirv_version_1_3;
      }
 
      spirv_options.target = target;
    } break;
    case TargetPlatform::kOpenGLES:
    case TargetPlatform::kOpenGLDesktop:
    case TargetPlatform::kVulkan:
    case TargetPlatform::kRuntimeStageVulkan: {
      SPIRVCompilerTargetEnv target;
 
      target.env = shaderc_target_env::shaderc_target_env_vulkan;
      target.version = shaderc_env_version::shaderc_env_version_vulkan_1_1;
      target.spirv_version = shaderc_spirv_version::shaderc_spirv_version_1_3;
 
      if (source_options.target_platform ==
          TargetPlatform::kRuntimeStageVulkan) {
        spirv_options.macro_definitions.push_back("IMPELLER_GRAPHICS_BACKEND");
        spirv_options.relaxed_vulkan_rules = true;
      }
      spirv_options.target = target;
    } break;
    case TargetPlatform::kRuntimeStageMetal:
    case TargetPlatform::kRuntimeStageGLES:
    case TargetPlatform::kRuntimeStageGLES3: {
      SPIRVCompilerTargetEnv target;
 
      target.env = shaderc_target_env::shaderc_target_env_opengl;
      target.version = shaderc_env_version::shaderc_env_version_opengl_4_5;
      target.spirv_version = shaderc_spirv_version::shaderc_spirv_version_1_0;
 
      spirv_options.target = target;
      spirv_options.macro_definitions.push_back("IMPELLER_GRAPHICS_BACKEND");
      if (source_options.target_platform == TargetPlatform::kRuntimeStageGLES ||
          source_options.target_platform ==
              TargetPlatform::kRuntimeStageGLES3) {
        spirv_options.macro_definitions.push_back("IMPELLER_TARGET_OPENGLES");
      }
    } break;
    case TargetPlatform::kSkSL: {
      SPIRVCompilerTargetEnv target;
 
      target.env = shaderc_target_env::shaderc_target_env_opengl;
      target.version = shaderc_env_version::shaderc_env_version_opengl_4_5;
      target.spirv_version = shaderc_spirv_version::shaderc_spirv_version_1_0;
 
      // When any optimization level above 'zero' is enabled, the phi merges at
      // loop continue blocks are rendered using syntax that is supported in
      // GLSL, but not in SkSL.
      // https://bugs.chromium.org/p/skia/issues/detail?id=13518.
      spirv_options.optimization_level =
          shaderc_optimization_level::shaderc_optimization_level_zero;
      spirv_options.target = target;
      spirv_options.macro_definitions.push_back("SKIA_GRAPHICS_BACKEND");
    } break;
    case TargetPlatform::kUnknown:
      COMPILER_ERROR(error_stream_) << "Target platform invalid.";
      return;
  }
 
  // Implicit definition that indicates that this compilation is for the device
  // (instead of the host).
  spirv_options.macro_definitions.push_back("IMPELLER_DEVICE");
  for (const auto& define : source_options.defines) {
    spirv_options.macro_definitions.push_back(define);
  }
 
  std::vector<std::string> included_file_names;
  spirv_options.includer = std::make_shared<Includer>(
      options_.working_directory, options_.include_dirs,
      [&included_file_names](auto included_name) {
        included_file_names.emplace_back(std::move(included_name));
      });
 
  // SPIRV Generation.
  SPIRVCompiler spv_compiler(source_options, source_mapping);
 
  spirv_assembly_ = spv_compiler.CompileToSPV(
      error_stream_, spirv_options.BuildShadercOptions());
 
  if (!spirv_assembly_) {
    return;
  } else {
    included_file_names_ = std::move(included_file_names);
  }
 
  // SL Generation.
  spirv_cross::Parser parser(
      reinterpret_cast<const uint32_t*>(spirv_assembly_->GetMapping()),
      spirv_assembly_->GetSize() / sizeof(uint32_t));
  // The parser and compiler must be run separately because the parser contains
  // meta information (like type member names) that are useful for reflection.
  parser.parse();
 
  const auto parsed_ir =
      std::make_shared<spirv_cross::ParsedIR>(parser.get_parsed_ir());
 
  auto sl_compiler = CreateCompiler(*parsed_ir, options_);
 
  if (!sl_compiler) {
    COMPILER_ERROR(error_stream_)
        << "Could not create compiler for target platform.";
    return;
  }
 
  CanonicalizeUniformBlockInstanceNamesForGL(source_options.target_platform,
                                             sl_compiler.GetCompiler());
 
  uint32_t ubo_size = CalculateUBOSize(sl_compiler.GetCompiler());
  if (ubo_size > kMaxUniformBufferSize) {
    COMPILER_ERROR(error_stream_) << "Uniform buffer size exceeds max ("
                                  << kMaxUniformBufferSize << "): " << ubo_size;
    return;
  }
 
  // We need to invoke the compiler even if we don't use the SL mapping later
  // for Vulkan. The reflector needs information that is only valid after a
  // successful compilation call.
  auto sl_compilation_result_str = sl_compiler.GetCompiler()->compile();
  auto sl_compilation_result =
      CreateMappingWithString(sl_compilation_result_str);
 
  // If the target is Vulkan, our shading language is SPIRV which we already
  // have. We just need to strip it of debug information. If it isn't, we need
  // to invoke the appropriate compiler to compile the SPIRV to the target SL.
  if (source_options.target_platform == TargetPlatform::kVulkan ||
      source_options.target_platform == TargetPlatform::kRuntimeStageVulkan) {
    auto stripped_spirv_options = spirv_options;
    stripped_spirv_options.generate_debug_info = false;
    sl_mapping_ = spv_compiler.CompileToSPV(
        error_stream_, stripped_spirv_options.BuildShadercOptions());
  } else {
    sl_mapping_ = sl_compilation_result;
  }
 
  if (!sl_mapping_) {
    COMPILER_ERROR(error_stream_) << "Could not generate SL from SPIRV";
    return;
  }
 
  if (sl_compiler.GetType() == CompilerBackend::Type::kSkSL &&
      !ValidateSkSLResult(sl_compilation_result_str).ok()) {
    return;
  }
 
  reflector_ = std::make_unique<Reflector>(std::move(reflector_options),  //
                                           parsed_ir,                     //
                                           GetSLShaderSource(),           //
                                           sl_compiler                    //
  );
 
  if (!reflector_->IsValid()) {
    COMPILER_ERROR(error_stream_)
        << "Could not complete reflection on generated shader.";
    return;
  }
 
  is_valid_ = true;
}

References impeller::compiler::SPIRVCompilerOptions::BuildShadercOptions(), COMPILER_ERROR, impeller::compiler::SPIRVCompiler::CompileToSPV(), impeller::compiler::CreateCompiler(), impeller::CreateMappingWithString(), impeller::compiler::SourceOptions::defines, impeller::compiler::SPIRVCompilerTargetEnv::env, impeller::compiler::SPIRVCompilerOptions::generate_debug_info, GetSLShaderSource(), impeller::compiler::SourceOptions::include_dirs, impeller::compiler::SPIRVCompilerOptions::includer, impeller::compiler::kGLSL, impeller::compiler::kHLSL, impeller::compiler::kMaxUniformBufferSize, impeller::compiler::kMetalDesktop, impeller::compiler::kMetalIOS, impeller::compiler::kOpenGLDesktop, impeller::compiler::kOpenGLES, impeller::compiler::kRuntimeStageGLES, impeller::compiler::kRuntimeStageGLES3, impeller::compiler::kRuntimeStageMetal, impeller::compiler::kRuntimeStageVulkan, impeller::compiler::CompilerBackend::kSkSL, impeller::compiler::kSkSL, impeller::compiler::kUnknown, impeller::compiler::kVulkan, impeller::compiler::SPIRVCompilerOptions::macro_definitions, impeller::compiler::SPIRVCompilerOptions::optimization_level, impeller::compiler::SPIRVCompilerOptions::relaxed_vulkan_rules, impeller::compiler::SPIRVCompilerOptions::source_langauge, impeller::compiler::SourceOptions::source_language, impeller::compiler::SPIRVCompilerOptions::source_profile, impeller::compiler::SPIRVCompilerOptions::target, target, impeller::compiler::SourceOptions::target_platform, impeller::compiler::SourceOptions::use_half_textures, and impeller::compiler::SourceOptions::working_directory.

~Compiler()

impeller::compiler::Compiler::~Compiler ( )

default

Member Function Documentation

CreateDepfileContents()

std::unique_ptr< fml::Mapping > impeller::compiler::Compiler::CreateDepfileContents

(

std::initializer_list< std::string >

targets

)

const

Definition at line 648 of file compiler.cc.

                                                        {
  // https://github.com/ninja-build/ninja/blob/master/src/depfile_parser.cc#L28
  const auto targets = JoinStrings(targets_names, " ");
  const auto dependencies = GetDependencyNames(" ");
 
  std::stringstream stream;
  stream << targets << ": " << dependencies << "\n";
 
  auto contents = std::make_shared<std::string>(stream.str());
  return std::make_unique<fml::NonOwnedMapping>(
      reinterpret_cast<const uint8_t*>(contents->data()), contents->size(),
      [contents](auto, auto) {});
}

References impeller::compiler::JoinStrings().

GetErrorMessages()

std::string impeller::compiler::Compiler::GetErrorMessages

(

)

const

Definition at line 616 of file compiler.cc.

                                           {
  return error_stream_.str();
}

Referenced by impeller::compiler::GenerateShaderBackendFB(), and impeller::compiler::testing::TEST_P().

GetIncludedFileNames()

const std::vector< std::string > & impeller::compiler::Compiler::GetIncludedFileNames

(

)

const

Definition at line 624 of file compiler.cc.

                                                                 {
  return included_file_names_;
}

Referenced by impeller::compiler::GenerateShaderBackendFB().

GetReflector()

const Reflector * impeller::compiler::Compiler::GetReflector

(

)

const

Definition at line 663 of file compiler.cc.

                                              {
  return reflector_.get();
}

Referenced by impeller::compiler::GenerateShaderBackendFB().

GetSLShaderSource()

std::shared_ptr< fml::Mapping > impeller::compiler::Compiler::GetSLShaderSource

(

)

const

Definition at line 602 of file compiler.cc.

                                                            {
  return sl_mapping_;
}

Referenced by Compiler().

GetSPIRVAssembly()

std::shared_ptr< fml::Mapping > impeller::compiler::Compiler::GetSPIRVAssembly

(

)

const

Definition at line 598 of file compiler.cc.

                                                           {
  return spirv_assembly_;
}

Referenced by impeller::compiler::testing::TEST().

GetVerboseErrorMessages()

std::string impeller::compiler::Compiler::GetVerboseErrorMessages

(

)

const

Gets verbose error messages if available.

This is only populated when GetErrorMessages() returns a truncated error message. If GetErrorMessages() did not have to be truncated, this will return an empty string.

Definition at line 620 of file compiler.cc.

                                                  {
  return verbose_error_stream_.str();
}

Referenced by impeller::compiler::testing::TEST_P().

IsValid()

bool impeller::compiler::Compiler::IsValid

(

)

const

Definition at line 606 of file compiler.cc.

                             {
  return is_valid_;
}

Referenced by impeller::compiler::GenerateShaderBackendFB().

---

The documentation for this class was generated from the following files:

• impeller/compiler/compiler.h
• impeller/compiler/compiler.cc