impellerc_main.cc

Go to the documentation of this file.

// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#include <filesystem>
#include <system_error>
 
#include "flutter/fml/backtrace.h"
#include "flutter/fml/command_line.h"
#include "flutter/fml/file.h"
#include "flutter/fml/mapping.h"
#include "impeller/compiler/compiler.h"
#include "impeller/compiler/runtime_stage_data.h"
#include "impeller/compiler/shader_bundle.h"
#include "impeller/compiler/source_options.h"
#include "impeller/compiler/switches.h"
#include "impeller/compiler/types.h"
#include "impeller/compiler/utilities.h"
 
namespace impeller {
namespace compiler {
 
namespace {
 
Reflector::Options CreateReflectorOptions(const SourceOptions& options,
                                          const Switches& switches) {
  Reflector::Options reflector_options;
  reflector_options.target_platform = options.target_platform;
  reflector_options.entry_point_name = options.entry_point_name;
  reflector_options.shader_name =
      InferShaderNameFromPath(switches.source_file_name);
  reflector_options.header_file_name =
      Utf8FromPath(switches.reflection_header_name.filename());
  return reflector_options;
}
 
std::shared_ptr<Compiler> CreateCompiler(
    TargetPlatform platform,
    const std::shared_ptr<const fml::Mapping>& source_file_mapping,
    const Switches& switches) {
  SourceOptions options = switches.CreateSourceOptions();
  options.target_platform = platform;
  Reflector::Options reflector_options =
      CreateReflectorOptions(options, switches);
  return std::make_shared<Compiler>(source_file_mapping, options,
                                    reflector_options);
}
 
void OutputVerboseErrorFile(const std::string& verbose_error_messages,
                            const Switches& switches) {
  auto error_mapping = std::make_shared<fml::NonOwnedMapping>(
      reinterpret_cast<const uint8_t*>(verbose_error_messages.data()),
      verbose_error_messages.size(), [](auto, auto) {});
  std::filesystem::path output_path =
      std::filesystem::path(fml::CreateTemporaryDirectory()) /
      "impellerc_verbose_error.txt";
 
  if (fml::WriteAtomically(*switches.working_directory,
                           Utf8FromPath(output_path).c_str(), *error_mapping)) {
    std::cerr << "Full \"" << InferShaderNameFromPath(switches.source_file_name)
              << "\" error output written to " << output_path << std::endl;
  } else {
    std::cerr << "Failed to write full \""
              << InferShaderNameFromPath(switches.source_file_name)
              << "\" error output to " << output_path << std::endl;
  }
}
 
bool OutputIPLR(const std::vector<std::shared_ptr<Compiler>>& compilers,
                const Switches& switches) {
  FML_DCHECK(switches.iplr);
 
  RuntimeStageData stages;
  for (const auto& compiler : compilers) {
    std::shared_ptr<RuntimeStageData::Shader> stage_data =
        compiler->GetReflector()->GetRuntimeStageShaderData();
    if (!stage_data) {
      std::cerr << "Runtime stage information was nil." << std::endl;
      return false;
    }
    stages.AddShader(stage_data);
  }
 
  auto stage_data_mapping = switches.json_format ? stages.CreateJsonMapping()
                                                 : stages.CreateMapping();
  if (!stage_data_mapping) {
    std::cerr << "Runtime stage data could not be created." << std::endl;
    return false;
  }
  if (!fml::WriteAtomically(*switches.working_directory,                  //
                            Utf8FromPath(switches.sl_file_name).c_str(),  //
                            *stage_data_mapping                           //
                            )) {
    std::cerr << "Could not write file to " << switches.sl_file_name
              << std::endl;
    return false;
  }
  // Tools that consume the runtime stage data expect the access mode to
  // be 0644.
  if (!SetPermissiveAccess(switches.sl_file_name)) {
    return false;
  }
  return true;
}
 
bool OutputSLFile(const Compiler& compiler, const Switches& switches) {
  auto sl_file_name = std::filesystem::absolute(
      std::filesystem::current_path() / switches.sl_file_name);
  if (!fml::WriteAtomically(*switches.working_directory,
                            Utf8FromPath(sl_file_name).c_str(),
                            *compiler.GetSLShaderSource())) {
    std::cerr << "Could not write file to " << switches.sl_file_name
              << std::endl;
    return false;
  }
  return true;
}
 
bool OutputSPIRV(const Compiler& compiler, const Switches& switches) {
  auto spriv_file_name = std::filesystem::absolute(
      std::filesystem::current_path() / switches.spirv_file_name);
  if (!fml::WriteAtomically(*switches.working_directory,
                            Utf8FromPath(spriv_file_name).c_str(),
                            *compiler.GetSPIRVAssembly())) {
    std::cerr << "Could not write file to " << switches.spirv_file_name
              << std::endl;
    return false;
  }
  return true;
}
 
bool ShouldOutputReflectionData(const Switches& switches) {
  return !switches.reflection_json_name.empty() ||
         !switches.reflection_header_name.empty() ||
         !switches.reflection_cc_name.empty();
}
 
bool OutputReflectionData(const Compiler& compiler, const Switches& switches) {
  if (!switches.reflection_json_name.empty()) {
    auto reflection_json_name = std::filesystem::absolute(
        std::filesystem::current_path() / switches.reflection_json_name);
    if (!fml::WriteAtomically(*switches.working_directory,
                              Utf8FromPath(reflection_json_name).c_str(),
                              *compiler.GetReflector()->GetReflectionJSON())) {
      std::cerr << "Could not write reflection json to "
                << switches.reflection_json_name << std::endl;
      return false;
    }
  }
 
  if (!switches.reflection_header_name.empty()) {
    auto reflection_header_name = std::filesystem::absolute(
        std::filesystem::current_path() / switches.reflection_header_name);
    if (!fml::WriteAtomically(
            *switches.working_directory,
            Utf8FromPath(reflection_header_name).c_str(),
            *compiler.GetReflector()->GetReflectionHeader())) {
      std::cerr << "Could not write reflection header to "
                << switches.reflection_header_name << std::endl;
      return false;
    }
  }
 
  if (!switches.reflection_cc_name.empty()) {
    auto reflection_cc_name = std::filesystem::absolute(
        std::filesystem::current_path() / switches.reflection_cc_name);
    if (!fml::WriteAtomically(*switches.working_directory,
                              Utf8FromPath(reflection_cc_name).c_str(),
                              *compiler.GetReflector()->GetReflectionCC())) {
      std::cerr << "Could not write reflection CC to "
                << switches.reflection_cc_name << std::endl;
      return false;
    }
  }
  return true;
}
 
bool OutputDepfile(const Compiler& compiler, const Switches& switches) {
  if (!switches.depfile_path.empty()) {
    std::string result_file = Utf8FromPath(switches.sl_file_name);
    auto depfile_path = std::filesystem::absolute(
        std::filesystem::current_path() / switches.depfile_path);
    if (!fml::WriteAtomically(*switches.working_directory,
                              Utf8FromPath(depfile_path).c_str(),
                              *compiler.CreateDepfileContents({result_file}))) {
      std::cerr << "Could not write depfile to " << switches.depfile_path
                << std::endl;
      return false;
    }
  }
 
  return true;
}
 
}  // namespace
 
bool Main(const fml::CommandLine& command_line) {
  fml::InstallCrashHandler();
  if (command_line.HasOption("help")) {
    Switches::PrintHelp(std::cout);
    return true;
  }
 
  Switches switches(command_line);
  if (!switches.AreValid(std::cerr)) {
    std::cerr << "Invalid flags specified." << std::endl;
    Switches::PrintHelp(std::cerr);
    return false;
  }
 
  if (!switches.shader_bundle.empty()) {
    // Invoke the compiler multiple times to build a shader bundle with the
    // given shader_bundle spec.
    return GenerateShaderBundle(switches);
  }
 
  std::shared_ptr<fml::FileMapping> source_file_mapping =
      fml::FileMapping::CreateReadOnly(Utf8FromPath(switches.source_file_name));
  if (!source_file_mapping) {
    std::cerr << "Could not open input file." << std::endl;
    return false;
  }
 
  std::vector<std::shared_ptr<Compiler>> compilers;
  compilers.reserve(switches.PlatformsToCompile().size());
  for (const auto& platform : switches.PlatformsToCompile()) {
    std::shared_ptr<Compiler> compiler =
        CreateCompiler(platform, source_file_mapping, switches);
    if (compiler->IsValid()) {
      compilers.push_back(compiler);
    } else {
      std::cerr << "Compilation failed for target: "
                << TargetPlatformToString(platform) << std::endl;
 
      std::string verbose_error_messages = compiler->GetVerboseErrorMessages();
      if (verbose_error_messages.empty()) {
        // No verbose error messages. Output the regular error messages.
        std::cerr << compiler->GetErrorMessages();
      } else {
        if (switches.verbose) {
          // Verbose messages are available and the --verbose flag was set.
          // Directly output the verbose error messages.
          std::cerr << verbose_error_messages;
        } else {
          // Verbose messages are available and the --verbose flag was not set.
          // Output the regular error messages and write the verbose error
          // messages to a file.
          std::cerr << compiler->GetErrorMessages();
          OutputVerboseErrorFile(verbose_error_messages, switches);
        }
      }
 
      return false;
    }
  }
 
  // --------------------------------------------------------------------------
  /// 1. Output the source file. When in IPLR/RuntimeStage mode, output the
  ///    serialized IPLR flatbuffer. Otherwise output the shader source in the
  ///    target shading language.
  ///
 
  if (switches.iplr) {
    if (!OutputIPLR(compilers, switches)) {
      return false;
    }
  } else {
    // Non-IPLR mode is supported only for single platform targets. There is
    // exactly 1 created compiler for this case.
    FML_DCHECK(compilers.size() == 1);
    if (!OutputSLFile(*compilers.front(), switches)) {
      return false;
    }
  }
 
  // Use the first compiler for outputting the SPIRV file, reflection data, and
  // the depfile. The SPIRV and depfile outputs do not depend on the target
  // platform, so any valid compiler can be used. Reflection data output is only
  // supported for single platform targets, so it uses the first (only) valid
  // compiler as well.
  auto first_valid_compiler = compilers.front();
 
  // --------------------------------------------------------------------------
  /// 2. Output SPIRV file.
  ///
 
  if (!OutputSPIRV(*first_valid_compiler, switches)) {
    return false;
  }
 
  // --------------------------------------------------------------------------
  /// 3. Output shader reflection data.
  ///    May include a JSON file, a C++ header, and/or a C++ TU.
  ///
 
  if (ShouldOutputReflectionData(switches)) {
    // Outputting reflection data is supported only for single platform targets.
    FML_DCHECK(compilers.size() == 1);
    if (!OutputReflectionData(*first_valid_compiler, switches)) {
      return false;
    }
  }
 
  // --------------------------------------------------------------------------
  /// 4. Output a depfile.
  ///
 
  // Dep file output does not depend on the target platform. Any valid compiler
  // can be used to output it. Arbitrarily pick the first valid compiler.
  if (!OutputDepfile(*first_valid_compiler, switches)) {
    return false;
  }
 
  return true;
}
 
}  // namespace compiler
}  // namespace impeller
 
int main(int argc, char const* argv[]) {
  return impeller::compiler::Main(
             fml::CommandLineFromPlatformOrArgcArgv(argc, argv))
             ? EXIT_SUCCESS
             : EXIT_FAILURE;
}