C, C++ APIs are sensitive to entry_point_name
Before, the C API ignored the entry point name.
Before, the C++ API didn't have entry points that accepted
an entry point name.
diff --git a/libshaderc/CMakeLists.txt b/libshaderc/CMakeLists.txt
index 59ff932..888c858 100644
--- a/libshaderc/CMakeLists.txt
+++ b/libshaderc/CMakeLists.txt
@@ -23,7 +23,7 @@
shaderc_add_tests(
TEST_PREFIX shaderc
LINK_LIBS shaderc
- INCLUDE_DIRS include ${glslang_SOURCE_DIR}
+ INCLUDE_DIRS include ${glslang_SOURCE_DIR} ${spirv-tools_SOURCE_DIR}/include
TEST_NAMES
shaderc
shaderc_cpp)
@@ -34,7 +34,7 @@
shaderc_add_tests(
TEST_PREFIX shaderc_combined
LINK_LIBS shaderc_combined ${CMAKE_THREAD_LIBS_INIT}
- INCLUDE_DIRS include ${glslang_SOURCE_DIR}
+ INCLUDE_DIRS include ${glslang_SOURCE_DIR} ${spirv-tools_SOURCE_DIR}/include
TEST_NAMES
shaderc
shaderc_cpp)
diff --git a/libshaderc/include/shaderc/shaderc.hpp b/libshaderc/include/shaderc/shaderc.hpp
index 1dc2631..a3facfc 100644
--- a/libshaderc/include/shaderc/shaderc.hpp
+++ b/libshaderc/include/shaderc/shaderc.hpp
@@ -279,6 +279,9 @@
// The input_file_name is a null-termintated string. It is used as a tag to
// identify the source string in cases like emitting error messages. It
// doesn't have to be a 'file name'.
+ // The entry_point_name parameter is a null-terminated string specifying
+ // the entry point name for HLSL compilation. For GLSL compilation, the
+ // entry point name is assumed to be "main".
// The compilation is passed any options specified in the CompileOptions
// parameter.
// It is valid for the returned CompilationResult object to outlive this
@@ -290,16 +293,30 @@
size_t source_text_size,
shaderc_shader_kind shader_kind,
const char* input_file_name,
+ const char* entry_point_name,
const CompileOptions& options) const {
shaderc_compilation_result_t compilation_result = shaderc_compile_into_spv(
compiler_, source_text, source_text_size, shader_kind, input_file_name,
- "main", options.options_);
+ entry_point_name, options.options_);
return SpvCompilationResult(compilation_result);
}
+ // Compiles the given source shader and returns a SPIR-V binary module
+ // compilation result.
+ // Like the first CompileGlslToSpv method but assumes the entry point name
+ // is "main".
+ SpvCompilationResult CompileGlslToSpv(const char* source_text,
+ size_t source_text_size,
+ shaderc_shader_kind shader_kind,
+ const char* input_file_name,
+ const CompileOptions& options) const {
+ return CompileGlslToSpv(source_text, source_text_size, shader_kind,
+ input_file_name, "main", options);
+ }
+
// Compiles the given source GLSL and returns a SPIR-V binary module
// compilation result.
- // Like the first CompileGlslToSpv method but uses default options.
+ // Like the previous CompileGlslToSpv method but uses default options.
SpvCompilationResult CompileGlslToSpv(const char* source_text,
size_t source_text_size,
shaderc_shader_kind shader_kind,
@@ -310,10 +327,10 @@
return SpvCompilationResult(compilation_result);
}
- // Compiles the given source GLSL and returns a SPIR-V binary module
+ // Compiles the given source shader and returns a SPIR-V binary module
// compilation result.
// Like the first CompileGlslToSpv method but the source is provided as
- // a std::string.
+ // a std::string, and we assume the entry point is "main".
SpvCompilationResult CompileGlslToSpv(const std::string& source_text,
shaderc_shader_kind shader_kind,
const char* input_file_name,
@@ -322,10 +339,23 @@
input_file_name, options);
}
- // Compiles the given source GLSL and returns a SPIR-V binary module
+ // Compiles the given source shader and returns a SPIR-V binary module
// compilation result.
// Like the first CompileGlslToSpv method but the source is provided as
- // a std::string and also uses default compiler options.
+ // a std::string.
+ SpvCompilationResult CompileGlslToSpv(const std::string& source_text,
+ shaderc_shader_kind shader_kind,
+ const char* input_file_name,
+ const char* entry_point_name,
+ const CompileOptions& options) const {
+ return CompileGlslToSpv(source_text.data(), source_text.size(), shader_kind,
+ input_file_name, entry_point_name, options);
+ }
+
+ // Compiles the given source GLSL and returns a SPIR-V binary module
+ // compilation result.
+ // Like the previous CompileGlslToSpv method but assumes the entry point
+ // name is "main".
SpvCompilationResult CompileGlslToSpv(const std::string& source_text,
shaderc_shader_kind shader_kind,
const char* input_file_name) const {
@@ -383,23 +413,46 @@
AssemblyCompilationResult CompileGlslToSpvAssembly(
const char* source_text, size_t source_text_size,
shaderc_shader_kind shader_kind, const char* input_file_name,
- const CompileOptions& options) const {
+ const char* entry_point_name, const CompileOptions& options) const {
shaderc_compilation_result_t compilation_result =
shaderc_compile_into_spv_assembly(
compiler_, source_text, source_text_size, shader_kind,
- input_file_name, "main", options.options_);
+ input_file_name, entry_point_name, options.options_);
return AssemblyCompilationResult(compilation_result);
}
// Compiles the given source GLSL and returns the SPIR-V assembly text
+ // compilation result.
+ // Similare to the previous method, but assumes entry point name is "main".
+ AssemblyCompilationResult CompileGlslToSpvAssembly(
+ const char* source_text, size_t source_text_size,
+ shaderc_shader_kind shader_kind, const char* input_file_name,
+ const CompileOptions& options) const {
+ return CompileGlslToSpvAssembly(source_text, source_text_size, shader_kind,
+ input_file_name, "main", options);
+ }
+
+ // Compiles the given source GLSL and returns the SPIR-V assembly text
// result. Like the first CompileGlslToSpvAssembly method but the source
// is provided as a std::string. Options are otherwise similar to
// the first CompileToSpv method.
AssemblyCompilationResult CompileGlslToSpvAssembly(
const std::string& source_text, shaderc_shader_kind shader_kind,
- const char* input_file_name, const CompileOptions& options) const {
+ const char* input_file_name, const char* entry_point_name,
+ const CompileOptions& options) const {
return CompileGlslToSpvAssembly(source_text.data(), source_text.size(),
- shader_kind, input_file_name, options);
+ shader_kind, input_file_name,
+ entry_point_name, options);
+ }
+
+ // Compiles the given source GLSL and returns the SPIR-V assembly text
+ // result. Like the previous CompileGlslToSpvAssembly method but assumes
+ // the entry point name is "main".
+ AssemblyCompilationResult CompileGlslToSpvAssembly(
+ const std::string& source_text, shaderc_shader_kind shader_kind,
+ const char* input_file_name, const CompileOptions& options) const {
+ return CompileGlslToSpvAssembly(source_text, shader_kind, input_file_name,
+ "main", options);
}
// Preprocesses the given source GLSL and returns the preprocessed
diff --git a/libshaderc/src/shaderc.cc b/libshaderc/src/shaderc.cc
index 845320b..15d16d2 100644
--- a/libshaderc/src/shaderc.cc
+++ b/libshaderc/src/shaderc.cc
@@ -394,7 +394,7 @@
std::tie(compilation_succeeded, compilation_output_data,
compilation_output_data_size_in_bytes) =
additional_options->compiler.Compile(
- source_string, forced_stage, input_file_name_str,
+ source_string, forced_stage, input_file_name_str, entry_point_name,
// stage_deducer has a flag: error_, which we need to check later.
// We need to make this a reference wrapper, so that std::function
// won't make a copy for this callable object.
@@ -406,7 +406,7 @@
std::tie(compilation_succeeded, compilation_output_data,
compilation_output_data_size_in_bytes) =
shaderc_util::Compiler().Compile(
- source_string, forced_stage, input_file_name_str,
+ source_string, forced_stage, input_file_name_str, entry_point_name,
std::ref(stage_deducer), includer, output_type, &errors,
&total_warnings, &total_errors, compiler->initializer);
}
diff --git a/libshaderc/src/shaderc_cpp_test.cc b/libshaderc/src/shaderc_cpp_test.cc
index 2762197..6917e59 100644
--- a/libshaderc/src/shaderc_cpp_test.cc
+++ b/libshaderc/src/shaderc_cpp_test.cc
@@ -19,6 +19,7 @@
#include <unordered_map>
#include "SPIRV/spirv.hpp"
+#include "spirv-tools/libspirv.hpp"
#include "common_shaders_for_test.h"
#include "shaderc/shaderc.hpp"
@@ -1017,30 +1018,86 @@
TEST_F(CppInterface, SourceLangGlslMinimalGlslVertexShaderSucceeds) {
options_.SetSourceLanguage(shaderc_source_language_glsl);
- EXPECT_TRUE(CompilationSuccess(kVertexOnlyShader,
- shaderc_glsl_vertex_shader,
+ EXPECT_TRUE(CompilationSuccess(kVertexOnlyShader, shaderc_glsl_vertex_shader,
options_));
}
TEST_F(CppInterface, SourceLangGlslMinimalHlslVertexShaderFails) {
options_.SetSourceLanguage(shaderc_source_language_glsl);
EXPECT_FALSE(CompilationSuccess(kMinimalHlslShader,
- shaderc_glsl_vertex_shader,
- options_));
+ shaderc_glsl_vertex_shader, options_));
}
TEST_F(CppInterface, SourceLangHlslMinimalGlslVertexShaderFails) {
options_.SetSourceLanguage(shaderc_source_language_hlsl);
- EXPECT_FALSE(CompilationSuccess(kVertexOnlyShader,
- shaderc_glsl_vertex_shader,
+ EXPECT_FALSE(CompilationSuccess(kVertexOnlyShader, shaderc_glsl_vertex_shader,
options_));
}
TEST_F(CppInterface, SourceLangHlslMinimalHlslVertexShaderSucceeds) {
options_.SetSourceLanguage(shaderc_source_language_hlsl);
- EXPECT_TRUE(CompilationSuccess(kMinimalHlslShader,
- shaderc_glsl_vertex_shader,
+ EXPECT_TRUE(CompilationSuccess(kMinimalHlslShader, shaderc_glsl_vertex_shader,
options_));
}
+TEST(
+ EntryPointTest,
+ SourceLangHlslMinimalHlslVertexShaderAsConstCharPtrSucceedsWithEntryPointName) {
+ shaderc::Compiler compiler;
+ CompileOptions options;
+ options.SetSourceLanguage(shaderc_source_language_hlsl);
+ auto result = compiler.CompileGlslToSpv(
+ kMinimalHlslShader, strlen(kMinimalHlslShader),
+ shaderc_glsl_vertex_shader, "shader", "EntryPoint", options);
+ std::vector<uint32_t> binary(result.begin(), result.end());
+ std::string assembly;
+ spvtools::SpirvTools(SPV_ENV_UNIVERSAL_1_0).Disassemble(binary, &assembly);
+ EXPECT_THAT(assembly,
+ HasSubstr("OpEntryPoint Vertex %EntryPoint \"EntryPoint\""))
+ << assembly;
+}
+
+TEST(
+ EntryPointTest,
+ SourceLangHlslMinimalHlslVertexShaderAsStdStringSucceedsWithEntryPointName) {
+ shaderc::Compiler compiler;
+ CompileOptions options;
+ options.SetSourceLanguage(shaderc_source_language_hlsl);
+ std::string shader(kMinimalHlslShader);
+ auto result = compiler.CompileGlslToSpv(shader, shaderc_glsl_vertex_shader,
+ "shader", "EntryPoint", options);
+ std::vector<uint32_t> binary(result.begin(), result.end());
+ std::string assembly;
+ spvtools::SpirvTools(SPV_ENV_UNIVERSAL_1_0).Disassemble(binary, &assembly);
+ EXPECT_THAT(assembly,
+ HasSubstr("OpEntryPoint Vertex %EntryPoint \"EntryPoint\""))
+ << assembly;
+}
+
+TEST(
+ EntryPointTest,
+ SourceLangHlslMinimalHlslVertexShaderAsConstCharPtrSucceedsToAssemblyWithEntryPointName) {
+ shaderc::Compiler compiler;
+ CompileOptions options;
+ options.SetSourceLanguage(shaderc_source_language_hlsl);
+ auto assembly = compiler.CompileGlslToSpvAssembly(
+ kMinimalHlslShader, strlen(kMinimalHlslShader),
+ shaderc_glsl_vertex_shader, "shader", "EntryPoint", options);
+ EXPECT_THAT(std::string(assembly.begin(), assembly.end()),
+ HasSubstr("OpEntryPoint Vertex %EntryPoint \"EntryPoint\""));
+}
+
+TEST(
+ EntryPointTest,
+ SourceLangHlslMinimalHlslVertexShaderAsStdStringSucceedsToAssemblyWithEntryPointName) {
+ shaderc::Compiler compiler;
+ CompileOptions options;
+ options.SetSourceLanguage(shaderc_source_language_hlsl);
+ std::string shader(kMinimalHlslShader);
+ auto assembly = compiler.CompileGlslToSpvAssembly(
+ shader, shaderc_glsl_vertex_shader, "shader", "EntryPoint", options);
+ EXPECT_THAT(std::string(assembly.begin(), assembly.end()),
+ HasSubstr("OpEntryPoint Vertex %EntryPoint \"EntryPoint\""));
+}
+
} // anonymous namespace
diff --git a/libshaderc/src/shaderc_test.cc b/libshaderc/src/shaderc_test.cc
index 280a5d1..bde5cf0 100644
--- a/libshaderc/src/shaderc_test.cc
+++ b/libshaderc/src/shaderc_test.cc
@@ -72,43 +72,49 @@
};
// Generate a compilation result object with the given compile,
-// shader source, shader kind, input file name, options, and for the
-// specified output type.
+// shader source, shader kind, input file name, entry point name, options,
+// and for the specified output type. The entry point name is only significant
+// for HLSL compilation.
shaderc_compilation_result_t MakeCompilationResult(
const shaderc_compiler_t compiler, const std::string& shader,
shaderc_shader_kind kind, const char* input_file_name,
- const shaderc_compile_options_t options, OutputType output_type) {
+ const char* entry_point_name, const shaderc_compile_options_t options,
+ OutputType output_type) {
switch (output_type) {
case OutputType::SpirvBinary:
return shaderc_compile_into_spv(compiler, shader.c_str(), shader.size(),
- kind, input_file_name, "", options);
+ kind, input_file_name, entry_point_name,
+ options);
break;
case OutputType::SpirvAssemblyText:
- return shaderc_compile_into_spv_assembly(compiler, shader.c_str(),
- shader.size(), kind,
- input_file_name, "", options);
+ return shaderc_compile_into_spv_assembly(
+ compiler, shader.c_str(), shader.size(), kind, input_file_name,
+ entry_point_name, options);
break;
case OutputType::PreprocessedText:
return shaderc_compile_into_preprocessed_text(
- compiler, shader.c_str(), shader.size(), kind, input_file_name, "",
- options);
+ compiler, shader.c_str(), shader.size(), kind, input_file_name,
+ entry_point_name, options);
break;
}
// We shouldn't reach here. But some compilers might not know that.
// Be a little defensive and produce something.
return shaderc_compile_into_spv(compiler, shader.c_str(), shader.size(), kind,
- input_file_name, "", options);
+ input_file_name, entry_point_name, options);
}
+
// RAII class for shaderc_compilation_result. Used for shader compilation.
class Compilation {
public:
// Compiles shader and keeps the result.
Compilation(const shaderc_compiler_t compiler, const std::string& shader,
shaderc_shader_kind kind, const char* input_file_name,
+ const char* entry_point_name,
const shaderc_compile_options_t options = nullptr,
OutputType output_type = OutputType::SpirvBinary)
- : compiled_result_(MakeCompilationResult(
- compiler, shader, kind, input_file_name, options, output_type)) {}
+ : compiled_result_(
+ MakeCompilationResult(compiler, shader, kind, input_file_name,
+ entry_point_name, options, output_type)) {}
~Compilation() { shaderc_result_release(compiled_result_); }
@@ -155,6 +161,17 @@
shaderc_compiler_t compiler;
};
+// RAII class for shader_compiler_options_t
+class Options {
+ public:
+ Options() : options_(shaderc_compile_options_initialize()) {}
+ ~Options() { shaderc_compile_options_release(options_); }
+ shaderc_compile_options_t get() { return options_; }
+
+ private:
+ shaderc_compile_options_t options_;
+};
+
// Helper function to check if the compilation result indicates a successful
// compilation.
bool CompilationResultIsSuccess(const shaderc_compilation_result_t result) {
@@ -178,7 +195,7 @@
shaderc_shader_kind kind,
const shaderc_compile_options_t options = nullptr) {
const Compilation comp(compiler.get_compiler_handle(), shader, kind, "shader",
- options, OutputType::SpirvBinary);
+ "main", options, OutputType::SpirvBinary);
return ResultContainsValidSpv(comp.result());
}
@@ -195,7 +212,7 @@
OutputType output_type = OutputType::SpirvBinary) {
return CompilationResultIsSuccess(
Compilation(compiler_.get_compiler_handle(), shader, kind, "shader",
- options, output_type)
+ "main", options, output_type)
.result());
}
@@ -206,7 +223,7 @@
const shaderc_compile_options_t options = nullptr,
OutputType output_type = OutputType::SpirvBinary) {
const Compilation comp(compiler_.get_compiler_handle(), shader, kind,
- "shader", options, output_type);
+ "shader", "main", options, output_type);
EXPECT_TRUE(CompilationResultIsSuccess(comp.result())) << kind << '\n'
<< shader;
return shaderc_result_get_error_message(comp.result());
@@ -219,7 +236,7 @@
OutputType output_type = OutputType::SpirvBinary,
const char* source_name = "shader") {
const Compilation comp(compiler_.get_compiler_handle(), shader, kind,
- source_name, options, output_type);
+ source_name, "main", options, output_type);
EXPECT_FALSE(CompilationResultIsSuccess(comp.result())) << kind << '\n'
<< shader;
EXPECT_EQ(0u, shaderc_result_get_length(comp.result()));
@@ -232,7 +249,7 @@
const shaderc_compile_options_t options = nullptr,
OutputType output_type = OutputType::SpirvBinary) {
const Compilation comp(compiler_.get_compiler_handle(), shader, kind,
- "shader", options, output_type);
+ "shader", "main", options, output_type);
return shaderc_result_get_error_message(comp.result());
};
@@ -243,7 +260,7 @@
const shaderc_compile_options_t options = nullptr,
OutputType output_type = OutputType::SpirvBinary) {
const Compilation comp(compiler_.get_compiler_handle(), shader, kind,
- "shader", options, output_type);
+ "shader", "main", options, output_type);
EXPECT_TRUE(CompilationResultIsSuccess(comp.result())) << kind << '\n'
<< shader;
// Use string(const char* s, size_t n) constructor instead of
@@ -362,7 +379,7 @@
TEST_F(CompileStringTest, GetNumErrors) {
Compilation comp(compiler_.get_compiler_handle(), kTwoErrorsShader,
- shaderc_glsl_vertex_shader, "shader");
+ shaderc_glsl_vertex_shader, "shader", "main");
// Expects compilation failure and two errors.
EXPECT_FALSE(CompilationResultIsSuccess(comp.result()));
EXPECT_EQ(2u, shaderc_result_get_num_errors(comp.result()));
@@ -372,7 +389,7 @@
TEST_F(CompileStringTest, GetNumWarnings) {
Compilation comp(compiler_.get_compiler_handle(), kTwoWarningsShader,
- shaderc_glsl_vertex_shader, "shader");
+ shaderc_glsl_vertex_shader, "shader", "main");
// Expects compilation success with two warnings.
EXPECT_TRUE(CompilationResultIsSuccess(comp.result()));
EXPECT_EQ(2u, shaderc_result_get_num_warnings(comp.result()));
@@ -382,7 +399,7 @@
TEST_F(CompileStringTest, ZeroErrorsZeroWarnings) {
Compilation comp(compiler_.get_compiler_handle(), kMinimalShader,
- shaderc_glsl_vertex_shader, "shader");
+ shaderc_glsl_vertex_shader, "shader", "main");
// Expects compilation success with zero warnings.
EXPECT_TRUE(CompilationResultIsSuccess(comp.result()));
EXPECT_EQ(0u, shaderc_result_get_num_warnings(comp.result()));
@@ -394,7 +411,7 @@
// The shader kind/stage can not be determined, the error type field should
// indicate the error type is shaderc_shader_kind_error.
Compilation comp(compiler_.get_compiler_handle(), kMinimalShader,
- shaderc_glsl_infer_from_source, "shader");
+ shaderc_glsl_infer_from_source, "shader", "main");
EXPECT_EQ(shaderc_compilation_status_invalid_stage,
shaderc_result_get_compilation_status(comp.result()));
}
@@ -402,7 +419,7 @@
// The shader kind is valid, the result object's error type field should
// indicate this compilaion fails due to compilation errors.
Compilation comp(compiler_.get_compiler_handle(), kTwoErrorsShader,
- shaderc_glsl_vertex_shader, "shader");
+ shaderc_glsl_vertex_shader, "shader", "main");
EXPECT_EQ(shaderc_compilation_status_compilation_error,
shaderc_result_get_compilation_status(comp.result()));
}
@@ -869,8 +886,8 @@
TestIncluder::ReleaseIncluderResponseWrapper, &includer);
const Compilation comp(compiler.get_compiler_handle(), shader,
- shaderc_glsl_vertex_shader, "shader", options.get(),
- OutputType::PreprocessedText);
+ shaderc_glsl_vertex_shader, "shader", "main",
+ options.get(), OutputType::PreprocessedText);
// Checks the existence of the expected string.
EXPECT_THAT(shaderc_result_get_bytes(comp.result()),
HasSubstr(test_case.expected_substring()));
@@ -892,7 +909,7 @@
shaderc_compile_options_clone(options.get()));
const Compilation comp(compiler.get_compiler_handle(), shader,
- shaderc_glsl_vertex_shader, "shader",
+ shaderc_glsl_vertex_shader, "shader", "main",
cloned_options.get(), OutputType::PreprocessedText);
// Checks the existence of the expected string.
EXPECT_THAT(shaderc_result_get_bytes(comp.result()),
@@ -998,13 +1015,13 @@
// Warnings on particular lines should be inhibited.
Compilation comp_line(compiler_.get_compiler_handle(),
kDeprecatedAttributeShader, shaderc_glsl_vertex_shader,
- "shader", options_.get());
+ "shader", "main", options_.get());
EXPECT_EQ(0u, shaderc_result_get_num_warnings(comp_line.result()));
// Global warnings should be inhibited.
- Compilation comp_global(compiler_.get_compiler_handle(),
- kMinimalUnknownVersionShader,
- shaderc_glsl_vertex_shader, "shader", options_.get());
+ Compilation comp_global(
+ compiler_.get_compiler_handle(), kMinimalUnknownVersionShader,
+ shaderc_glsl_vertex_shader, "shader", "main", options_.get());
EXPECT_EQ(0u, shaderc_result_get_num_warnings(comp_global.result()));
}
@@ -1019,13 +1036,13 @@
// Warnings on particular lines should be inhibited.
Compilation comp_line(compiler_.get_compiler_handle(),
kDeprecatedAttributeShader, shaderc_glsl_vertex_shader,
- "shader", options_.get());
+ "shader", "main", options_.get());
EXPECT_EQ(0u, shaderc_result_get_num_warnings(comp_line.result()));
// Global warnings should be inhibited.
- Compilation comp_global(compiler_.get_compiler_handle(),
- kMinimalUnknownVersionShader,
- shaderc_glsl_vertex_shader, "shader", options_.get());
+ Compilation comp_global(
+ compiler_.get_compiler_handle(), kMinimalUnknownVersionShader,
+ shaderc_glsl_vertex_shader, "shader", "main", options_.get());
EXPECT_EQ(0u, shaderc_result_get_num_warnings(comp_global.result()));
}
@@ -1327,4 +1344,33 @@
options_.get()));
}
+TEST(EntryPointTest,
+ LangGlslOnHlslVertexSucceedsButAssumesEntryPointNameIsMain) {
+ Compiler compiler;
+ Options options;
+ auto compilation =
+ Compilation(compiler.get_compiler_handle(), kGlslVertexShader,
+ shaderc_glsl_vertex_shader, "shader", "blah blah blah",
+ options.get(), OutputType::SpirvAssemblyText);
+
+ EXPECT_THAT(shaderc_result_get_bytes(compilation.result()),
+ HasSubstr("OpEntryPoint Vertex %main \"main\""))
+ << std::string(shaderc_result_get_bytes(compilation.result()));
+}
+
+TEST(EntryPointTest, LangHlslOnHlslVertexSucceedsWithGivenEntryPointName) {
+ Compiler compiler;
+ Options options;
+ shaderc_compile_options_set_source_language(options.get(),
+ shaderc_source_language_hlsl);
+ auto compilation =
+ Compilation(compiler.get_compiler_handle(), kHlslVertexShader,
+ shaderc_glsl_vertex_shader, "shader", "EntryPoint",
+ options.get(), OutputType::SpirvAssemblyText);
+
+ EXPECT_THAT(shaderc_result_get_bytes(compilation.result()),
+ HasSubstr("OpEntryPoint Vertex %EntryPoint \"EntryPoint\""))
+ << std::string(shaderc_result_get_bytes(compilation.result()));
+}
+
} // anonymous namespace
diff --git a/libshaderc_util/include/libshaderc_util/compiler.h b/libshaderc_util/include/libshaderc_util/compiler.h
index d396ca1..fc47766 100644
--- a/libshaderc_util/include/libshaderc_util/compiler.h
+++ b/libshaderc_util/include/libshaderc_util/compiler.h
@@ -94,7 +94,7 @@
public:
// Source language
enum class SourceLanguage {
- GLSL, // The default
+ GLSL, // The default
HLSL,
};
@@ -168,6 +168,11 @@
// If the forced_shader stage parameter is not EShLangCount then
// the shader is assumed to be of the given stage.
//
+ // For HLSL compilation, entry_point_name is the null-terminated string for
+ // the
+ // entry point. For GLSL compilation, entry_point_name is ignored, and
+ // compilation assumes the entry point is named "main".
+ //
// The stage_callback function will be called if a shader_stage has
// not been forced and the stage can not be determined
// from the shader text. Any #include directives are parsed with the given
@@ -194,7 +199,7 @@
// If the output is a text string, the size equals the length of that string.
std::tuple<bool, std::vector<uint32_t>, size_t> Compile(
const string_piece& input_source_string, EShLanguage forced_shader_stage,
- const std::string& error_tag,
+ const std::string& error_tag, const char* entry_point_name,
const std::function<EShLanguage(std::ostream* error_stream,
const string_piece& error_tag)>&
stage_callback,
diff --git a/libshaderc_util/src/compiler.cc b/libshaderc_util/src/compiler.cc
index 52eb81f..a170a4c 100644
--- a/libshaderc_util/src/compiler.cc
+++ b/libshaderc_util/src/compiler.cc
@@ -81,7 +81,8 @@
result = static_cast<EShMessages>(result | EShMsgSpvRules);
break;
case Compiler::TargetEnv::Vulkan:
- result = static_cast<EShMessages>(result | EShMsgSpvRules | EShMsgVulkanRules);
+ result =
+ static_cast<EShMessages>(result | EShMsgSpvRules | EShMsgVulkanRules);
break;
}
return result;
@@ -92,7 +93,7 @@
namespace shaderc_util {
std::tuple<bool, std::vector<uint32_t>, size_t> Compiler::Compile(
const string_piece& input_source_string, EShLanguage forced_shader_stage,
- const std::string& error_tag,
+ const std::string& error_tag, const char* entry_point_name,
const std::function<EShLanguage(std::ostream* error_stream,
const string_piece& error_tag)>&
stage_callback,
@@ -179,13 +180,13 @@
shader.setStringsWithLengthsAndNames(&shader_strings, &shader_lengths,
&string_names, 1);
shader.setPreamble(preamble.c_str());
+ shader.setEntryPoint(entry_point_name);
// TODO(dneto): Generate source-level debug info if requested.
- bool success = shader.parse(&shaderc_util::kDefaultTBuiltInResource,
- default_version_, default_profile_,
- force_version_profile_, kNotForwardCompatible,
- GetMessageRules(target_env_, source_language_),
- includer);
+ bool success = shader.parse(
+ &shaderc_util::kDefaultTBuiltInResource, default_version_,
+ default_profile_, force_version_profile_, kNotForwardCompatible,
+ GetMessageRules(target_env_, source_language_), includer);
success &= PrintFilteredErrors(error_tag, error_stream, warnings_as_errors_,
suppress_warnings_, shader.getInfoLog(),
@@ -246,7 +247,9 @@
void Compiler::SetTargetEnv(Compiler::TargetEnv env) { target_env_ = env; }
-void Compiler::SetSourceLanguage(Compiler::SourceLanguage lang) { source_language_ = lang; }
+void Compiler::SetSourceLanguage(Compiler::SourceLanguage lang) {
+ source_language_ = lang;
+}
void Compiler::SetForcedVersionProfile(int version, EProfile profile) {
default_version_ = version;
@@ -298,8 +301,8 @@
// The preprocessor might be sensitive to the target environment.
// So combine the existing rules with the just-give-me-preprocessor-output
// flag.
- const auto rules = static_cast<EShMessages>(EShMsgOnlyPreprocessor |
- GetMessageRules(target_env_, source_language_));
+ const auto rules = static_cast<EShMessages>(
+ EShMsgOnlyPreprocessor | GetMessageRules(target_env_, source_language_));
std::string preprocessed_shader;
const bool success = shader.preprocess(
diff --git a/libshaderc_util/src/compiler_test.cc b/libshaderc_util/src/compiler_test.cc
index 36931ff..3af7c22 100644
--- a/libshaderc_util/src/compiler_test.cc
+++ b/libshaderc_util/src/compiler_test.cc
@@ -16,7 +16,7 @@
#include <sstream>
-#include <gtest/gtest.h>
+#include <gmock/gmock.h>
#include "death_test.h"
#include "libshaderc_util/counting_includer.h"
@@ -24,6 +24,7 @@
namespace {
using shaderc_util::Compiler;
+using ::testing::HasSubstr;
// A trivial vertex shader
const char kVertexShader[] =
@@ -105,10 +106,6 @@
// shader stage.
bool SimpleCompilationSucceedsForOutputType(
std::string source, EShLanguage stage, Compiler::OutputType output_type) {
- std::function<EShLanguage(std::ostream*, const shaderc_util::string_piece&)>
- stage_callback = [](std::ostream*, const shaderc_util::string_piece&) {
- return EShLangCount;
- };
std::stringstream errors;
size_t total_warnings = 0;
size_t total_errors = 0;
@@ -116,7 +113,7 @@
bool result = false;
DummyCountingIncluder dummy_includer;
std::tie(result, std::ignore, std::ignore) = compiler_.Compile(
- source, stage, "shader", stage_callback, dummy_includer,
+ source, stage, "shader", "main", dummy_stage_callback_, dummy_includer,
Compiler::OutputType::SpirvBinary, &errors, &total_warnings,
&total_errors, &initializer);
errors_ = errors.str();
@@ -134,6 +131,11 @@
Compiler compiler_;
// The error string from the most recent compilation.
std::string errors_;
+ std::function<EShLanguage(std::ostream*, const shaderc_util::string_piece&)>
+ dummy_stage_callback_ =
+ [](std::ostream*, const shaderc_util::string_piece&) {
+ return EShLangCount;
+ };
};
TEST_F(CompilerTest, SimpleVertexShaderCompilesSuccessfullyToBinary) {
@@ -337,5 +339,25 @@
EXPECT_FALSE(SimpleCompilationSucceeds(kVulkanVertexShader, EShLangVertex));
}
+TEST_F(CompilerTest, EntryPointParameterTakesEffectForHLSL) {
+ compiler_.SetSourceLanguage(Compiler::SourceLanguage::HLSL);
+ std::stringstream errors;
+ size_t total_warnings = 0;
+ size_t total_errors = 0;
+ shaderc_util::GlslangInitializer initializer;
+ bool result = false;
+ DummyCountingIncluder dummy_includer;
+ std::vector<uint32_t> words;
+ std::tie(result, words, std::ignore) =
+ compiler_.Compile(kHlslVertexShader, EShLangVertex, "shader",
+ "EntryPoint", dummy_stage_callback_, dummy_includer,
+ Compiler::OutputType::SpirvAssemblyText, &errors,
+ &total_warnings, &total_errors, &initializer);
+ EXPECT_TRUE(result);
+ std::string assembly(reinterpret_cast<char*>(words.data()));
+ EXPECT_THAT(assembly,
+ HasSubstr("OpEntryPoint Vertex %EntryPoint \"EntryPoint\""))
+ << assembly;
+}
} // anonymous namespace
