---
src/gallium/state_trackers/clover/api/program.cpp | 6 +-
.../state_trackers/clover/core/compiler.hpp | 7 +-
src/gallium/state_trackers/clover/core/error.hpp | 21 ++
src/gallium/state_trackers/clover/core/program.cpp | 93 ++++++-
src/gallium/state_trackers/clover/core/program.hpp | 10 +-
.../state_trackers/clover/llvm/invocation.cpp | 281 +++++++++++++++------
6 files changed, 323 insertions(+), 95 deletions(-)
diff --git a/src/gallium/state_trackers/clover/api/program.cpp
b/src/gallium/state_trackers/clover/api/program.cpp
index e9b1f38..2441d81 100644
--- a/src/gallium/state_trackers/clover/api/program.cpp
+++ b/src/gallium/state_trackers/clover/api/program.cpp
@@ -184,10 +184,6 @@ clBuildProgram(cl_program d_prog, cl_uint num_devs,
prog.build(devs, opts);
return CL_SUCCESS;
} catch (error &e) {
- if (e.get() == CL_INVALID_COMPILER_OPTIONS)
- return CL_INVALID_BUILD_OPTIONS;
- if (e.get() == CL_COMPILE_PROGRAM_FAILURE)
- return CL_BUILD_PROGRAM_FAILURE;
return e.get();
}
@@ -224,7 +220,7 @@ clCompileProgram(cl_program d_prog, cl_uint num_devs,
range(header_names, num_headers),
objs<allow_empty_tag>(d_header_progs, num_headers));
- prog.build(devs, opts, headers);
+ prog.compile(devs, opts, headers);
return CL_SUCCESS;
} catch (error &e) {
diff --git a/src/gallium/state_trackers/clover/core/compiler.hpp
b/src/gallium/state_trackers/clover/core/compiler.hpp
index c68aa39..31fb6ee 100644
--- a/src/gallium/state_trackers/clover/core/compiler.hpp
+++ b/src/gallium/state_trackers/clover/core/compiler.hpp
@@ -32,11 +32,16 @@ namespace clover {
module compile_program_llvm(const std::string &source,
const header_map &headers,
- pipe_shader_ir ir,
const std::string &target,
const std::string &opts,
std::string &r_log);
+ module link_program_llvm(const std::vector<module> &modules,
+ enum pipe_shader_ir ir,
+ const std::string &target,
+ const std::string &opts,
+ std::string &r_log);
+
module compile_program_tgsi(const std::string &source);
}
diff --git a/src/gallium/state_trackers/clover/core/error.hpp
b/src/gallium/state_trackers/clover/core/error.hpp
index 780b973..3c1bf90 100644
--- a/src/gallium/state_trackers/clover/core/error.hpp
+++ b/src/gallium/state_trackers/clover/core/error.hpp
@@ -68,10 +68,31 @@ namespace clover {
class build_error : public error {
public:
build_error(const std::string &what = "") :
+ error(CL_BUILD_PROGRAM_FAILURE, what) {
+ }
+ };
+
+ class compile_error : public error {
+ public:
+ compile_error(const std::string &what = "") :
error(CL_COMPILE_PROGRAM_FAILURE, what) {
}
};
+ class link_error : public error {
+ public:
+ link_error(const std::string &what = "") :
+ error(CL_LINK_PROGRAM_FAILURE, what) {
+ }
+ };
+
+ class link_option_error : public error {
+ public:
+ link_option_error(const std::string &what = "") :
+ error(CL_INVALID_LINKER_OPTIONS , what) {
+ }
+ };
+
template<typename O>
class invalid_object_error;
diff --git a/src/gallium/state_trackers/clover/core/program.cpp
b/src/gallium/state_trackers/clover/core/program.cpp
index 0d6cc40..21faf4e 100644
--- a/src/gallium/state_trackers/clover/core/program.cpp
+++ b/src/gallium/state_trackers/clover/core/program.cpp
@@ -40,15 +40,37 @@ program::program(clover::context &ctx,
}
void
-program::build(const ref_vector<device> &devs, const char *opts,
- const header_map &headers) {
+program::build(const ref_vector<device> &devs, const char *opts) {
+
+ if (has_source) {
+ try {
+ compile(devs, opts, {});
+ if (!link(devs, opts, {*this}, true))
+ throw error(CL_BUILD_PROGRAM_FAILURE);
+ } catch (error &e) {
+ switch (e.get()) {
+ case CL_INVALID_COMPILER_OPTIONS:
+ case CL_INVALID_LINKER_OPTIONS:
+ e = error(CL_INVALID_BUILD_OPTIONS);
+ break;
+ case CL_COMPILE_PROGRAM_FAILURE:
+ case CL_LINK_PROGRAM_FAILURE:
+ e = error(CL_BUILD_PROGRAM_FAILURE);
+ break;
+ }
+ throw;
+ }
+ }
+}
+
+void
+program::compile(const ref_vector<device> &devs, const char *opts,
+ const header_map &headers) {
if (has_source) {
_devices = devs;
for (auto &dev : devs) {
- _binaries.erase(&dev);
- _logs.erase(&dev);
- _opts.erase(&dev);
+ clean(&dev);
_opts.insert({ &dev, opts });
@@ -58,12 +80,11 @@ program::build(const ref_vector<device> &devs, const char
*opts,
auto module = (dev.ir_format() == PIPE_SHADER_IR_TGSI ?
compile_program_tgsi(_source) :
compile_program_llvm(_source, headers,
- dev.ir_format(),
dev.ir_target(),
build_opts(dev),
log));
_binaries.insert({ &dev, module });
_logs.insert({ &dev, log });
- } catch (const build_error &) {
+ } catch (const compile_error &) {
_logs.insert({ &dev, log });
throw;
}
@@ -71,6 +92,64 @@ program::build(const ref_vector<device> &devs, const char
*opts,
}
}
+bool
+program::link(const ref_vector<device> &devs, const char *opts,
+ const ref_vector<program> &progs, bool keep_log) {
+
+ bool r = true;
+
+ _devices = devs;
+
+ for (auto &dev : devs) {
+ std::vector<module> mods;
+ mods.reserve(progs.size());
+ for (auto &prog : progs)
+ mods.push_back(prog.binary(dev));
+
+ clean(&dev, keep_log);
+
+ _opts.insert({ &dev, opts });
+
+ if (mods.size() == 0) {
+ append_to_log(&dev, "Nothing to link.");
+ r = false;
+ continue;
+ }
+
+ std::string log;
+
+ try {
+ auto module = link_program_llvm(mods,
+ dev.ir_format(), dev.ir_target(),
+ opts, log);
+ _binaries.insert({ &dev, module });
+ append_to_log(&dev, log);
+ } catch (const link_option_error &) {
+ append_to_log(&dev, log);
+ throw;
+ } catch (const error &) {
+ append_to_log(&dev, log);
+ r = false;
+ }
+ }
+
+ return r;
+}
+
+void
+program::clean(const device *dev, bool keep_log) {
+ _binaries.erase(dev);
+ _opts.erase(dev);
+ if (!keep_log)
+ _logs.erase(dev);
+}
+
+void
+program::append_to_log(const device *dev, const std::string &log) {
+ std::string &l = _logs[dev];
+ l.empty() ? l = log : l + "\n" + log;
+}
+
const std::string &
program::source() const {
return _source;
diff --git a/src/gallium/state_trackers/clover/core/program.hpp
b/src/gallium/state_trackers/clover/core/program.hpp
index 183145e..314979b 100644
--- a/src/gallium/state_trackers/clover/core/program.hpp
+++ b/src/gallium/state_trackers/clover/core/program.hpp
@@ -47,8 +47,11 @@ namespace clover {
program &
operator=(const program &prog) = delete;
- void build(const ref_vector<device> &devs, const char *opts,
- const header_map &headers = {});
+ void build(const ref_vector<device> &devs, const char *opts);
+ void compile(const ref_vector<device> &devs, const char *opts,
+ const header_map &headers);
+ bool link(const ref_vector<device> &devs, const char *opts,
+ const ref_vector<program> &progs, bool keep_log = false);
const bool has_source;
const std::string &source() const;
@@ -69,6 +72,9 @@ namespace clover {
friend class kernel;
private:
+ void clean(const device *dev, bool keep_log = false);
+ void append_to_log(const device *dev, const std::string &log);
+
std::vector<intrusive_ref<device>> _devices;
std::map<const device *, module> _binaries;
std::map<const device *, std::string> _logs;
diff --git a/src/gallium/state_trackers/clover/llvm/invocation.cpp
b/src/gallium/state_trackers/clover/llvm/invocation.cpp
index 9b91fee..ce5e3f2 100644
--- a/src/gallium/state_trackers/clover/llvm/invocation.cpp
+++ b/src/gallium/state_trackers/clover/llvm/invocation.cpp
@@ -108,7 +108,7 @@ namespace {
name, llvm::MemoryBuffer::getMemBuffer(source));
if (!c.ExecuteAction(act))
- throw build_error(log);
+ throw compile_error(log);
}
module
@@ -130,22 +130,15 @@ namespace {
}
}
- llvm::Module *
- compile_llvm(llvm::LLVMContext &llvm_ctx, const std::string &source,
- const header_map &headers,
- const std::string &name, const std::string &triple,
- const std::string &processor, const std::string &opts,
- clang::LangAS::Map& address_spaces, unsigned
&optimization_level,
- std::string &r_log) {
+ bool
+ create_from_arg_llvm(clang::CompilerInstance &c,
+ const std::string &target, const std::string &opts,
+ llvm::raw_string_ostream &log) {
- clang::CompilerInstance c;
- clang::EmitLLVMOnlyAction act(&llvm_ctx);
- std::string log;
- llvm::raw_string_ostream s_log(log);
- std::string libclc_path = LIBCLC_LIBEXECDIR + processor + "-"
- + triple + ".bc";
-
- // Parse the compiler options:
+ // Parse the compiler options.
+ // A file name should be present at the end
+ // and must have the .cl extension in order for the
+ // CompilerInvocation class to recognize it as an OpenCL source file.
std::vector<std::string> opts_array;
std::istringstream ss(opts);
@@ -155,8 +148,6 @@ namespace {
opts_array.push_back(opt);
}
- opts_array.push_back(name);
-
std::vector<const char *> opts_carray;
for (unsigned i = 0; i < opts_array.size(); i++) {
opts_carray.push_back(opts_array.at(i).c_str());
@@ -171,15 +162,59 @@ namespace {
DiagsBuffer = new clang::TextDiagnosticBuffer();
clang::DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer);
- bool Success;
+ bool Success;
Success = clang::CompilerInvocation::CreateFromArgs(c.getInvocation(),
opts_carray.data(),
opts_carray.data() +
opts_carray.size(),
Diags);
- if (!Success) {
+
+ if (Success) {
+ const size_t processor_str_len = target.find_first_of("-");
+ const std::string processor(target, 0, processor_str_len);
+ const std::string triple(target.begin() + processor_str_len + 1,
+ target.end());
+
+ c.getLangOpts().NoBuiltin = true;
+ c.getTargetOpts().Triple = triple;
+ c.getTargetOpts().CPU = processor;
+
+ // This is a workaround for a Clang bug which causes the number
+ // of warnings and errors to be printed to stderr.
+ // http://www.llvm.org/bugs/show_bug.cgi?id=19735
+ c.getDiagnosticOpts().ShowCarets = false;
+ c.getInvocation().setLangDefaults(c.getLangOpts(), clang::IK_OpenCL,
+ clang::LangStandard::lang_opencl11);
+ c.createDiagnostics(
+ new clang::TextDiagnosticPrinter(
+ log, &c.getDiagnosticOpts())
+ );
+
+ c.setTarget(clang::TargetInfo::CreateTargetInfo(c.getDiagnostics(),
+ c.getInvocation().TargetOpts));
+ }
+
+ return Success;
+ }
+
+ llvm::Module *
+ compile_llvm(llvm::LLVMContext &llvm_ctx, const std::string &source,
+ const header_map &headers,
+ const std::string &target, const std::string &opts,
+ clang::LangAS::Map& address_spaces, unsigned
&optimization_level,
+ std::string &r_log) {
+
+ clang::CompilerInstance c;
+ clang::EmitLLVMOnlyAction act(&llvm_ctx);
+ std::string log;
+ llvm::raw_string_ostream s_log(log);
+ const std::string name = "compile.cl";
+
+ if (!create_from_arg_llvm(c, target, opts + " " + name, s_log)) {
+ r_log = log;
throw error(CL_INVALID_COMPILER_OPTIONS);
}
+
c.getFrontendOpts().ProgramAction = clang::frontend::EmitLLVMOnly;
c.getHeaderSearchOpts().UseBuiltinIncludes = true;
c.getHeaderSearchOpts().UseStandardSystemIncludes = true;
@@ -196,22 +231,6 @@ namespace {
// clc.h requires that this macro be defined:
c.getPreprocessorOpts().addMacroDef("cl_clang_storage_class_specifiers");
-
- c.getLangOpts().NoBuiltin = true;
- c.getTargetOpts().Triple = triple;
- c.getTargetOpts().CPU = processor;
-
- // This is a workaround for a Clang bug which causes the number
- // of warnings and errors to be printed to stderr.
- // http://www.llvm.org/bugs/show_bug.cgi?id=19735
- c.getDiagnosticOpts().ShowCarets = false;
- c.getInvocation().setLangDefaults(c.getLangOpts(), clang::IK_OpenCL,
- clang::LangStandard::lang_opencl11);
- c.createDiagnostics(
- new clang::TextDiagnosticPrinter(
- s_log,
- &c.getDiagnosticOpts()));
-
#if HAVE_LLVM >= 0x0306
c.getPreprocessorOpts().addRemappedFile(name,
llvm::MemoryBuffer::getMemBuffer(source).release());
@@ -247,6 +266,7 @@ namespace {
// attribute. This attribute will prevent Clang from creating
// illegal uses of barrier() (e.g. Moving barrier() inside a conditional
// that is no executed by all threads) during its optimizaton passes.
+ const std::string libclc_path = LIBCLC_LIBEXECDIR + target + ".bc";
c.getCodeGenOpts().LinkBitcodeFile = libclc_path;
optimization_level = c.getCodeGenOpts().OptimizationLevel;
@@ -256,7 +276,7 @@ namespace {
r_log = log;
if (!ExecSuccess)
- throw build_error();
+ throw compile_error();
// Get address spaces map to be able to find kernel argument address
space
memcpy(address_spaces, c.getTarget().getAddressSpaceMap(),
@@ -485,7 +505,7 @@ namespace {
LLVMDisposeMessage(err_message);
if (err) {
- throw build_error();
+ throw link_error();
}
}
@@ -505,7 +525,7 @@ namespace {
if (LLVMGetTargetFromTriple(triple.c_str(), &target, &error_message)) {
r_log = std::string(error_message);
LLVMDisposeMessage(error_message);
- throw build_error();
+ throw link_error();
}
LLVMTargetMachineRef tm = LLVMCreateTargetMachine(
@@ -514,7 +534,7 @@ namespace {
if (!tm) {
r_log = "Could not create TargetMachine: " + triple;
- throw build_error();
+ throw link_error();
}
if (dump_asm) {
@@ -567,7 +587,7 @@ namespace {
const char *name;
if (gelf_getshdr(section, &symtab_header) != &symtab_header) {
r_log = "Failed to read ELF section header.";
- throw build_error();
+ throw link_error();
}
name = elf_strptr(elf, section_str_index, symtab_header.sh_name);
if (!strcmp(name, ".symtab")) {
@@ -577,9 +597,9 @@ namespace {
}
if (!symtab) {
r_log = "Unable to find symbol table.";
- throw build_error();
+ throw link_error();
}
- } catch (build_error &e) {
+ } catch (link_error &e) {
elf_end(elf);
throw e;
}
@@ -640,6 +660,7 @@ namespace {
return m;
}
+ template<typename T>
void
diagnostic_handler(const llvm::DiagnosticInfo &di, void *data) {
if (di.getSeverity() == llvm::DS_Error) {
@@ -650,7 +671,7 @@ namespace {
stream.flush();
*(std::string*)data = message;
- throw build_error();
+ throw T();
}
}
@@ -689,38 +710,28 @@ namespace {
module
clover::compile_program_llvm(const std::string &source,
- const header_map &headers,
- enum pipe_shader_ir ir,
- const std::string &target,
- const std::string &opts,
- std::string &r_log) {
+ const header_map &headers,
+ const std::string &target,
+ const std::string &opts,
+ std::string &r_log) {
init_targets();
- std::vector<llvm::Function *> kernels;
- size_t processor_str_len = std::string(target).find_first_of("-");
- std::string processor(target, 0, processor_str_len);
- std::string triple(target, processor_str_len + 1,
- target.size() - processor_str_len - 1);
clang::LangAS::Map address_spaces;
llvm::LLVMContext llvm_ctx;
unsigned optimization_level;
- llvm_ctx.setDiagnosticHandler(diagnostic_handler, &r_log);
+ llvm_ctx.setDiagnosticHandler(diagnostic_handler<compile_error>, &r_log);
if (get_debug_flags() & DBG_CLC)
- debug_log("// Build options: " + opts + '\n' + source, ".cl");
+ debug_log("// options: " + opts + '\n' + source, ".cl");
// The input file name must have the .cl extension in order for the
// CompilerInvocation class to recognize it as an OpenCL source file.
- llvm::Module *mod = compile_llvm(llvm_ctx, source, headers, "input.cl",
- triple, processor, opts, address_spaces,
+ llvm::Module *mod = compile_llvm(llvm_ctx, source, headers,
+ target, opts, address_spaces,
optimization_level, r_log);
- find_kernels(mod, kernels);
-
- optimize(mod, optimization_level, kernels);
-
if (get_debug_flags() & DBG_LLVM) {
std::string log;
llvm::raw_string_ostream s_log(log);
@@ -729,25 +740,18 @@ clover::compile_program_llvm(const std::string &source,
debug_log(log, ".ll");
}
+ //serialize for later use
module m;
- // Build the clover::module
- switch (ir) {
- case PIPE_SHADER_IR_TGSI:
- //XXX: Handle TGSI
- assert(0);
- m = module();
- break;
- case PIPE_SHADER_IR_LLVM:
- m = build_module_llvm(mod, kernels, address_spaces);
- break;
- case PIPE_SHADER_IR_NATIVE: {
- std::vector<char> code = compile_native(mod, triple, processor,
- get_debug_flags() & DBG_ASM,
- r_log);
- m = build_module_native(code, mod, kernels, address_spaces, r_log);
- break;
- }
- }
+ llvm::SmallVector<char, 1024> llvm_bitcode;
+ llvm::raw_svector_ostream bitcode_ostream(llvm_bitcode);
+ llvm::BitstreamWriter writer(llvm_bitcode);
+ llvm::WriteBitcodeToFile(mod, bitcode_ostream);
+ bitcode_ostream.flush();
+
+ std::vector<char> data(llvm_bitcode.begin(), llvm_bitcode.end());
+ m.secs.push_back(module::section(0, module::section::text,
+ data.size(), data));
+
#if HAVE_LLVM >= 0x0306
// LLVM 3.6 and newer, the user takes ownership of the module.
delete mod;
@@ -755,3 +759,120 @@ clover::compile_program_llvm(const std::string &source,
return m;
}
+
+
+module
+clover::link_program_llvm(const std::vector<module> &modules,
+ enum pipe_shader_ir ir,
+ const std::string &target,
+ const std::string &opts,
+ std::string &r_log) {
+
+ init_targets();
+
+ std::string options = opts;
+ bool create_library = false;
+ size_t pos = options.find("-create-library");
+ if (pos != std::string::npos) {
+ create_library = true;
+ options.erase(pos, 15);
+ }
+ options += " link.cl";
+
+ llvm::LLVMContext llvm_ctx;
+ llvm_ctx.setDiagnosticHandler(diagnostic_handler<link_error>, &r_log);
+
+ std::string ci_log;
+ llvm::raw_string_ostream rso(ci_log);
+ clang::CompilerInstance c;
+ if (!create_from_arg_llvm(c, target, options, rso)) {
+ r_log = ci_log;
+ throw link_option_error();
+ }
+
+ llvm::Module linked_mod("link", llvm_ctx);
+ llvm::Linker linker(&linked_mod);
+
+ for (const auto &mod : modules) {
+ const auto s = llvm::StringRef(mod.secs[0].data.data(),
+ mod.secs[0].data.size());
+
+ auto m =
+ llvm::parseBitcodeFile(llvm::MemoryBufferRef(s, " "), llvm_ctx);
+
+ if (!m) {
+ r_log = m.getError().message();
+ throw error(CL_INVALID_PROGRAM);
+ }
+
+#if HAVE_LLVM < 0x0306
+ if (linker.linkInModule(*m, &r_log))
+#elif HAVE_LLVM < 0x0307
+ if (linker.linkInModule(*m))
+#else
+ if (linker.linkInModule((*m).get()))
+#endif
+ throw link_error();
+ }
+
+ module m;
+ std::vector<llvm::Function *> kernels;
+
+ //optimize
+ if (!create_library)
+ find_kernels(&linked_mod, kernels);
+
+ unsigned optimization_level = c.getCodeGenOpts().OptimizationLevel;
+ optimize(&linked_mod, optimization_level, kernels);
+
+
+ unsigned debug_flags = get_debug_flags();
+
+ if (debug_flags & DBG_LLVM) {
+ std::string log;
+ llvm::raw_string_ostream s_log(log);
+ linked_mod.print(s_log, NULL);
+ s_log.flush();
+ debug_log(log, ".ll");
+ }
+
+ if (create_library) {
+ //serialize for later use
+ llvm::SmallVector<char, 1024> llvm_bitcode;
+ llvm::raw_svector_ostream bitcode_ostream(llvm_bitcode);
+ llvm::BitstreamWriter writer(llvm_bitcode);
+ llvm::WriteBitcodeToFile(&linked_mod, bitcode_ostream);
+ bitcode_ostream.flush();
+
+ std::vector<char> data(llvm_bitcode.begin(), llvm_bitcode.end());
+ m.secs.push_back(module::section(0, module::section::text,
+ data.size(), data));
+
+ } else {
+ // Get address spaces map to be able to find kernel argument address
space
+ clang::LangAS::Map address_spaces;
+ memcpy(address_spaces, c.getTarget().getAddressSpaceMap(),
+
sizeof(address_spaces));
+
+ // Build the clover::module
+ switch (ir) {
+ case PIPE_SHADER_IR_TGSI:
+ assert(0); // not supported
+ break;
+ case PIPE_SHADER_IR_LLVM:
+ m = build_module_llvm(&linked_mod, kernels, address_spaces);
+ break;
+ case PIPE_SHADER_IR_NATIVE: {
+ auto code = compile_native(&linked_mod, c.getTargetOpts().Triple,
+ c.getTargetOpts().CPU,
+ debug_flags & DBG_ASM, r_log);
+ m = build_module_native(code, &linked_mod, kernels, address_spaces,
+ r_log);
+ break;
+ }
+ }
+
+ }
+
+ return m;
+}
--
2.4.3
_______________________________________________
mesa-dev mailing list
mesa-dev@lists.freedesktop.org
http://lists.freedesktop.org/mailman/listinfo/mesa-dev
