Flutter Impeller
impellerc_main.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include <filesystem>
6 #include <system_error>
7 
8 #include "flutter/fml/backtrace.h"
9 #include "flutter/fml/command_line.h"
10 #include "flutter/fml/file.h"
11 #include "flutter/fml/mapping.h"
19 
20 namespace impeller {
21 namespace compiler {
22 
24  const Switches& switches) {
25  Reflector::Options reflector_options;
26  reflector_options.target_platform = options.target_platform;
27  reflector_options.entry_point_name = options.entry_point_name;
28  reflector_options.shader_name =
30  reflector_options.header_file_name = Utf8FromPath(
31  std::filesystem::path{switches.reflection_header_name}.filename());
32  return reflector_options;
33 }
34 
35 /// Run the shader compiler to geneate SkSL reflection data.
36 /// If there is an error, prints error text and returns `nullptr`.
37 static std::shared_ptr<RuntimeStageData::Shader> CompileSkSL(
38  std::shared_ptr<fml::Mapping> source_file_mapping,
39  const Switches& switches) {
40  auto options = switches.CreateSourceOptions(TargetPlatform::kSkSL);
41 
42  Reflector::Options sksl_reflector_options =
43  CreateReflectorOptions(options, switches);
44  sksl_reflector_options.target_platform = TargetPlatform::kSkSL;
45 
46  Compiler sksl_compiler =
47  Compiler(std::move(source_file_mapping), options, sksl_reflector_options);
48  if (!sksl_compiler.IsValid()) {
49  std::cerr << "Compilation to SkSL failed." << std::endl;
50  std::cerr << sksl_compiler.GetErrorMessages() << std::endl;
51  return nullptr;
52  }
53  return sksl_compiler.GetReflector()->GetRuntimeStageShaderData();
54 }
55 
56 static bool OutputIPLR(
57  const Switches& switches,
58  const std::shared_ptr<fml::Mapping>& source_file_mapping) {
59  FML_DCHECK(switches.iplr);
60 
61  RuntimeStageData stages;
62  std::shared_ptr<RuntimeStageData::Shader> sksl_shader;
64  sksl_shader = CompileSkSL(source_file_mapping, switches);
65  if (!sksl_shader) {
66  return false;
67  }
68  stages.AddShader(sksl_shader);
69  }
70 
71  for (const auto& platform : switches.PlatformsToCompile()) {
72  if (platform == TargetPlatform::kSkSL) {
73  // Already handled above.
74  continue;
75  }
76  SourceOptions options = switches.CreateSourceOptions(platform);
77 
78  // Invoke the compiler and generate reflection data for a single shader.
79 
80  Reflector::Options reflector_options =
81  CreateReflectorOptions(options, switches);
82  Compiler compiler(source_file_mapping, options, reflector_options);
83  if (!compiler.IsValid()) {
84  std::cerr << "Compilation failed." << std::endl;
85  std::cerr << compiler.GetErrorMessages() << std::endl;
86  return false;
87  }
88 
89  auto reflector = compiler.GetReflector();
90  if (reflector == nullptr) {
91  std::cerr << "Could not create reflector." << std::endl;
92  return false;
93  }
94 
95  auto stage_data = reflector->GetRuntimeStageShaderData();
96  if (!stage_data) {
97  std::cerr << "Runtime stage information was nil." << std::endl;
98  return false;
99  }
100 
101  stages.AddShader(stage_data);
102  }
103 
104  auto stage_data_mapping = switches.json_format ? stages.CreateJsonMapping()
105  : stages.CreateMapping();
106  if (!stage_data_mapping) {
107  std::cerr << "Runtime stage data could not be created." << std::endl;
108  return false;
109  }
110  if (!fml::WriteAtomically(*switches.working_directory, //
111  Utf8FromPath(switches.sl_file_name).c_str(), //
112  *stage_data_mapping //
113  )) {
114  std::cerr << "Could not write file to " << switches.sl_file_name
115  << std::endl;
116  return false;
117  }
118  // Tools that consume the runtime stage data expect the access mode to
119  // be 0644.
120  if (!SetPermissiveAccess(switches.sl_file_name)) {
121  return false;
122  }
123  return true;
124 }
125 
126 static bool OutputSLFile(const Compiler& compiler, const Switches& switches) {
127  // --------------------------------------------------------------------------
128  /// 2. Output the source file. When in IPLR/RuntimeStage mode, output the
129  /// serialized IPLR flatbuffer.
130  ///
131 
132  auto sl_file_name = std::filesystem::absolute(
133  std::filesystem::current_path() / switches.sl_file_name);
134  if (!fml::WriteAtomically(*switches.working_directory,
135  Utf8FromPath(sl_file_name).c_str(),
136  *compiler.GetSLShaderSource())) {
137  std::cerr << "Could not write file to " << switches.sl_file_name
138  << std::endl;
139  return false;
140  }
141  return true;
142 }
143 
144 static bool OutputReflectionData(const Compiler& compiler,
145  const Switches& switches,
146  const SourceOptions& options) {
147  // --------------------------------------------------------------------------
148  /// 3. Output shader reflection data.
149  /// May include a JSON file, a C++ header, and/or a C++ TU.
150  ///
151 
153  if (!switches.reflection_json_name.empty()) {
154  auto reflection_json_name = std::filesystem::absolute(
155  std::filesystem::current_path() / switches.reflection_json_name);
156  if (!fml::WriteAtomically(
157  *switches.working_directory,
158  Utf8FromPath(reflection_json_name).c_str(),
159  *compiler.GetReflector()->GetReflectionJSON())) {
160  std::cerr << "Could not write reflection json to "
161  << switches.reflection_json_name << std::endl;
162  return false;
163  }
164  }
165 
166  if (!switches.reflection_header_name.empty()) {
167  auto reflection_header_name =
168  std::filesystem::absolute(std::filesystem::current_path() /
169  switches.reflection_header_name.c_str());
170  if (!fml::WriteAtomically(
171  *switches.working_directory,
172  Utf8FromPath(reflection_header_name).c_str(),
173  *compiler.GetReflector()->GetReflectionHeader())) {
174  std::cerr << "Could not write reflection header to "
175  << switches.reflection_header_name << std::endl;
176  return false;
177  }
178  }
179 
180  if (!switches.reflection_cc_name.empty()) {
181  auto reflection_cc_name =
182  std::filesystem::absolute(std::filesystem::current_path() /
183  switches.reflection_cc_name.c_str());
184  if (!fml::WriteAtomically(*switches.working_directory,
185  Utf8FromPath(reflection_cc_name).c_str(),
186  *compiler.GetReflector()->GetReflectionCC())) {
187  std::cerr << "Could not write reflection CC to "
188  << switches.reflection_cc_name << std::endl;
189  return false;
190  }
191  }
192  }
193  return true;
194 }
195 
196 static bool OutputDepfile(const Compiler& compiler, const Switches& switches) {
197  // --------------------------------------------------------------------------
198  /// 4. Output a depfile.
199  ///
200 
201  if (!switches.depfile_path.empty()) {
202  std::string result_file;
203  switch (switches.SelectDefaultTargetPlatform()) {
213  result_file = switches.sl_file_name;
214  break;
216  result_file = switches.spirv_file_name;
217  break;
218  }
219  auto depfile_path = std::filesystem::absolute(
220  std::filesystem::current_path() / switches.depfile_path.c_str());
221  if (!fml::WriteAtomically(*switches.working_directory,
222  Utf8FromPath(depfile_path).c_str(),
223  *compiler.CreateDepfileContents({result_file}))) {
224  std::cerr << "Could not write depfile to " << switches.depfile_path
225  << std::endl;
226  return false;
227  }
228  }
229 
230  return true;
231 }
232 
233 bool Main(const fml::CommandLine& command_line) {
234  fml::InstallCrashHandler();
235  if (command_line.HasOption("help")) {
236  Switches::PrintHelp(std::cout);
237  return true;
238  }
239 
240  Switches switches(command_line);
241  if (!switches.AreValid(std::cerr)) {
242  std::cerr << "Invalid flags specified." << std::endl;
243  Switches::PrintHelp(std::cerr);
244  return false;
245  }
246 
247  if (!switches.shader_bundle.empty()) {
248  // Invoke the compiler multiple times to build a shader bundle with the
249  // given shader_bundle spec.
250  return GenerateShaderBundle(switches);
251  }
252 
253  std::shared_ptr<fml::FileMapping> source_file_mapping =
254  fml::FileMapping::CreateReadOnly(switches.source_file_name);
255  if (!source_file_mapping) {
256  std::cerr << "Could not open input file." << std::endl;
257  return false;
258  }
259 
260  if (switches.iplr && !OutputIPLR(switches, source_file_mapping)) {
261  return false;
262  }
263 
264  // Create at least one compiler to output the SL file, reflection data, and a
265  // depfile.
266  // TODO(dnfield): This seems off. We should more explicitly handle how we
267  // generate reflection and depfile data for the runtime stage case.
268  // https://github.com/flutter/flutter/issues/140841
269 
270  SourceOptions options = switches.CreateSourceOptions();
271 
272  // Invoke the compiler and generate reflection data for a single shader.
273 
274  Reflector::Options reflector_options =
275  CreateReflectorOptions(options, switches);
276 
277  Compiler compiler(source_file_mapping, options, reflector_options);
278  if (!compiler.IsValid()) {
279  std::cerr << "Compilation failed." << std::endl;
280  std::cerr << compiler.GetErrorMessages() << std::endl;
281  return false;
282  }
283 
284  auto spriv_file_name = std::filesystem::absolute(
285  std::filesystem::current_path() / switches.spirv_file_name);
286  if (!fml::WriteAtomically(*switches.working_directory,
287  Utf8FromPath(spriv_file_name).c_str(),
288  *compiler.GetSPIRVAssembly())) {
289  std::cerr << "Could not write file to " << switches.spirv_file_name
290  << std::endl;
291  return false;
292  }
293 
294  if (!switches.iplr && !OutputSLFile(compiler, switches)) {
295  return false;
296  }
297 
298  if (!OutputReflectionData(compiler, switches, options)) {
299  return false;
300  }
301 
302  if (!OutputDepfile(compiler, switches)) {
303  return false;
304  }
305 
306  return true;
307 }
308 
309 } // namespace compiler
310 } // namespace impeller
311 
312 int main(int argc, char const* argv[]) {
314  fml::CommandLineFromPlatformOrArgcArgv(argc, argv))
315  ? EXIT_SUCCESS
316  : EXIT_FAILURE;
317 }
impeller::compiler::Switches::reflection_cc_name
std::string reflection_cc_name
Definition: switches.h:36
impeller::compiler::Compiler
Definition: compiler.h:25
runtime_stage_data.h
impeller::compiler::Switches::reflection_header_name
std::string reflection_header_name
Definition: switches.h:35
impeller::compiler::RuntimeStageData::CreateJsonMapping
std::shared_ptr< fml::Mapping > CreateJsonMapping() const
Definition: runtime_stage_data.cc:210
shader_bundle.h
impeller::compiler::Compiler::CreateDepfileContents
std::unique_ptr< fml::Mapping > CreateDepfileContents(std::initializer_list< std::string > targets) const
Definition: compiler.cc:483
impeller::compiler::Switches::PrintHelp
static void PrintHelp(std::ostream &stream)
Definition: switches.cc:41
impeller::compiler::RuntimeStageData
Definition: runtime_stage_data.h:21
impeller::compiler::TargetPlatform::kMetalDesktop
@ kMetalDesktop
impeller::compiler::Switches::SelectDefaultTargetPlatform
TargetPlatform SelectDefaultTargetPlatform() const
Definition: switches.cc:299
impeller::compiler::OutputDepfile
static bool OutputDepfile(const Compiler &compiler, const Switches &switches)
Definition: impellerc_main.cc:196
impeller::compiler::SourceOptions
Definition: source_options.h:20
impeller::compiler::TargetPlatformNeedsReflection
bool TargetPlatformNeedsReflection(TargetPlatform platform)
Definition: types.cc:141
impeller::compiler::RuntimeStageData::AddShader
void AddShader(const std::shared_ptr< Shader > &data)
Definition: runtime_stage_data.cc:27
impeller::compiler::InferShaderNameFromPath
std::string InferShaderNameFromPath(std::string_view path)
Definition: utilities.cc:34
impeller::compiler::TargetPlatform::kMetalIOS
@ kMetalIOS
impeller::compiler::Reflector::GetReflectionCC
std::shared_ptr< fml::Mapping > GetReflectionCC() const
Definition: reflector.cc:125
switches.h
impeller::compiler::Reflector::Options::header_file_name
std::string header_file_name
Definition: reflector.h:152
impeller::compiler::Switches::spirv_file_name
std::string spirv_file_name
Definition: switches.h:33
impeller::compiler::Reflector::GetReflectionHeader
std::shared_ptr< fml::Mapping > GetReflectionHeader() const
Definition: reflector.cc:121
impeller::compiler::Reflector::Options::target_platform
TargetPlatform target_platform
Definition: reflector.h:149
impeller::compiler::RuntimeStageData::CreateMapping
std::shared_ptr< fml::Mapping > CreateMapping() const
Definition: runtime_stage_data.cc:392
impeller::compiler::Main
bool Main(const fml::CommandLine &command_line)
Definition: impellerc_main.cc:233
impeller::compiler::Switches::json_format
bool json_format
Definition: switches.h:39
impeller::compiler::Reflector::GetRuntimeStageShaderData
std::shared_ptr< RuntimeStageData::Shader > GetRuntimeStageShaderData() const
Definition: reflector.cc:129
impeller::compiler::Switches::reflection_json_name
std::string reflection_json_name
Definition: switches.h:34
impeller::compiler::TargetPlatform::kVulkan
@ kVulkan
impeller::compiler::Reflector::Options::shader_name
std::string shader_name
Definition: reflector.h:151
impeller::compiler::SourceOptions::entry_point_name
std::string entry_point_name
Definition: source_options.h:27
impeller::compiler::Compiler::GetErrorMessages
std::string GetErrorMessages() const
Definition: compiler.cc:455
impeller::compiler::TargetPlatform::kRuntimeStageVulkan
@ kRuntimeStageVulkan
impeller::compiler::Compiler::GetSPIRVAssembly
std::shared_ptr< fml::Mapping > GetSPIRVAssembly() const
Definition: compiler.cc:437
source_options.h
impeller::compiler::OutputReflectionData
static bool OutputReflectionData(const Compiler &compiler, const Switches &switches, const SourceOptions &options)
Definition: impellerc_main.cc:144
impeller::compiler::Compiler::GetReflector
const Reflector * GetReflector() const
Definition: compiler.cc:498
impeller::compiler::OutputIPLR
static bool OutputIPLR(const Switches &switches, const std::shared_ptr< fml::Mapping > &source_file_mapping)
Definition: impellerc_main.cc:56
impeller::compiler::Reflector::Options
Definition: reflector.h:148
compiler.h
impeller::compiler::OutputSLFile
static bool OutputSLFile(const Compiler &compiler, const Switches &switches)
Definition: impellerc_main.cc:126
utilities.h
impeller::compiler::Switches::sl_file_name
std::string sl_file_name
Definition: switches.h:30
impeller::compiler::CompileSkSL
static std::shared_ptr< RuntimeStageData::Shader > CompileSkSL(std::shared_ptr< fml::Mapping > source_file_mapping, const Switches &switches)
Definition: impellerc_main.cc:37
impeller::compiler::Switches::PlatformsToCompile
std::vector< TargetPlatform > PlatformsToCompile() const
A vector containing at least one valid platform.
Definition: switches.cc:292
impeller::compiler::Switches::iplr
bool iplr
Definition: switches.h:31
impeller::compiler::SourceOptions::target_platform
TargetPlatform target_platform
Definition: source_options.h:22
impeller::compiler::Compiler::IsValid
bool IsValid() const
Definition: compiler.cc:445
impeller::compiler::TargetPlatform::kOpenGLDesktop
@ kOpenGLDesktop
impeller::compiler::TargetPlatform::kUnknown
@ kUnknown
impeller::compiler::TargetPlatform::kOpenGLES
@ kOpenGLES
impeller::compiler::Switches::CreateSourceOptions
SourceOptions CreateSourceOptions(std::optional< TargetPlatform > target_platform=std::nullopt) const
Definition: switches.cc:307
impeller::compiler::Compiler::GetSLShaderSource
std::shared_ptr< fml::Mapping > GetSLShaderSource() const
Definition: compiler.cc:441
main
int main(int argc, char const *argv[])
Definition: impellerc_main.cc:312
impeller::compiler::SetPermissiveAccess
bool SetPermissiveAccess(const std::filesystem::path &p)
Sets the file access mode of the file at path 'p' to 0644.
Definition: utilities.cc:16
impeller::compiler::Utf8FromPath
std::string Utf8FromPath(const std::filesystem::path &path)
Converts a native format path to a utf8 string.
Definition: utilities.cc:30
impeller::compiler::TargetPlatform::kRuntimeStageMetal
@ kRuntimeStageMetal
impeller::compiler::Reflector::GetReflectionJSON
std::shared_ptr< fml::Mapping > GetReflectionJSON() const
Definition: reflector.cc:108
impeller::compiler::Switches
Definition: switches.h:21
impeller::compiler::Reflector::Options::entry_point_name
std::string entry_point_name
Definition: reflector.h:150
impeller::compiler::Switches::depfile_path
std::string depfile_path
Definition: switches.h:37
impeller::compiler::TargetPlatformBundlesSkSL
bool TargetPlatformBundlesSkSL(TargetPlatform platform)
Definition: types.cc:320
impeller
Definition: aiks_blur_unittests.cc:20
impeller::compiler::GenerateShaderBundle
bool GenerateShaderBundle(Switches &switches)
Parses the JSON shader bundle configuration and invokes the compiler multiple times to produce a shad...
Definition: shader_bundle.cc:210
impeller::compiler::Switches::source_file_name
std::string source_file_name
Definition: switches.h:25
impeller::compiler::Switches::working_directory
std::shared_ptr< fml::UniqueFD > working_directory
Definition: switches.h:23
types.h
impeller::compiler::TargetPlatform::kSkSL
@ kSkSL
impeller::compiler::TargetPlatform::kRuntimeStageGLES
@ kRuntimeStageGLES
impeller::compiler::Switches::shader_bundle
std::string shader_bundle
Definition: switches.h:32
impeller::compiler::CreateReflectorOptions
static Reflector::Options CreateReflectorOptions(const SourceOptions &options, const Switches &switches)
Definition: impellerc_main.cc:23
impeller::compiler::Switches::AreValid
bool AreValid(std::ostream &explain) const
Definition: switches.cc:239