// OTHER DEALINGS IN THE SOFTWARE.
//
-#include "llvm/compat.hpp"
-#include "core/compiler.hpp"
-#include "util/algorithm.hpp"
-
-#include <clang/Frontend/CompilerInstance.h>
-#include <clang/Frontend/TextDiagnosticBuffer.h>
-#include <clang/Frontend/TextDiagnosticPrinter.h>
-#include <clang/CodeGen/CodeGenAction.h>
-#include <clang/Basic/TargetInfo.h>
-#include <llvm/Bitcode/BitstreamWriter.h>
-#include <llvm/Bitcode/ReaderWriter.h>
-#include <llvm/Linker/Linker.h>
-#include <llvm/IR/DiagnosticInfo.h>
#include <llvm/IR/DiagnosticPrinter.h>
-#include <llvm/IR/DerivedTypes.h>
+#include <llvm/IR/DiagnosticInfo.h>
#include <llvm/IR/LLVMContext.h>
-#include <llvm/IR/Module.h>
-#include <llvm/Support/SourceMgr.h>
-#include <llvm/IRReader/IRReader.h>
-#include <llvm/Support/CodeGen.h>
-#include <llvm/Support/TargetSelect.h>
-#include <llvm/Support/MemoryBuffer.h>
-#include <llvm/Support/FormattedStream.h>
-#include <llvm/Support/TargetRegistry.h>
-#include <llvm/Transforms/IPO.h>
+#include <llvm/Support/raw_ostream.h>
#include <llvm/Transforms/IPO/PassManagerBuilder.h>
-#include <llvm/Transforms/Utils/Cloning.h>
-
+#include <llvm-c/Target.h>
+#ifdef HAVE_CLOVER_SPIRV
+#include <LLVMSPIRVLib/LLVMSPIRVLib.h>
+#endif
-#include <llvm/IR/DataLayout.h>
-#include <llvm/Target/TargetMachine.h>
-#include <llvm/Target/TargetOptions.h>
+#include <clang/CodeGen/CodeGenAction.h>
+#include <clang/Lex/PreprocessorOptions.h>
+#include <clang/Frontend/TextDiagnosticBuffer.h>
+#include <clang/Frontend/TextDiagnosticPrinter.h>
+#include <clang/Basic/TargetInfo.h>
-#include <llvm-c/Target.h>
-#include <llvm-c/TargetMachine.h>
-#include <llvm-c/Core.h>
+// We need to include internal headers last, because the internal headers
+// include CL headers which have #define's like:
+//
+//#define cl_khr_gl_sharing 1
+//#define cl_khr_icd 1
+//
+// Which will break the compilation of clang/Basic/OpenCLOptions.h
-#include "pipe/p_state.h"
-#include "util/u_memory.h"
-#include "util/u_math.h"
+#include "core/error.hpp"
+#include "llvm/codegen.hpp"
+#include "llvm/compat.hpp"
+#include "llvm/invocation.hpp"
+#include "llvm/metadata.hpp"
+#include "llvm/util.hpp"
+#ifdef HAVE_CLOVER_SPIRV
+#include "spirv/invocation.hpp"
+#endif
+#include "util/algorithm.hpp"
-#include <iostream>
-#include <iomanip>
-#include <fstream>
-#include <cstdio>
-#include <sstream>
-#include <libelf.h>
-#include <gelf.h>
using namespace clover;
using namespace clover::llvm;
using ::llvm::raw_string_ostream;
namespace {
- // XXX - Temporary hack to avoid breaking the build for the moment, will
- // get rid of this later.
- namespace llvm {
- using namespace ::llvm;
- }
-
- void debug_log(const std::string &msg, const std::string &suffix) {
- const char *dbg_file = debug_get_option("CLOVER_DEBUG_FILE", "stderr");
- if (!strcmp("stderr", dbg_file)) {
- std::cerr << msg;
- } else {
- std::ofstream file(dbg_file + suffix, std::ios::app);
- file << msg;
- }
- }
-
- inline std::vector<std::string>
- tokenize(const std::string &s) {
- std::vector<std::string> ss;
- std::istringstream iss(s);
- std::string t;
-
- while (getline(iss, t, ' '))
- ss.push_back(t);
- return ss;
- }
+ struct cl_version {
+ std::string version_str; // CL Version
+ unsigned version_number; // Numeric CL Version
+ };
+
+ static const unsigned ANY_VERSION = 999;
+ const cl_version cl_versions[] = {
+ { "1.0", 100},
+ { "1.1", 110},
+ { "1.2", 120},
+ { "2.0", 200},
+ { "2.1", 210},
+ { "2.2", 220},
+ };
- struct target {
- target(const std::string &s) :
- cpu(s.begin(), s.begin() + s.find_first_of("-")),
- triple(s.begin() + s.find_first_of("-") + 1, s.end()) {}
+ struct clc_version_lang_std {
+ unsigned version_number; // CLC Version
+ clang::LangStandard::Kind clc_lang_standard;
+ };
- std::string cpu;
- std::string triple;
- };
+ const clc_version_lang_std cl_version_lang_stds[] = {
+ { 100, compat::lang_opencl10},
+ { 110, clang::LangStandard::lang_opencl11},
+ { 120, clang::LangStandard::lang_opencl12},
+ { 200, clang::LangStandard::lang_opencl20},
+ };
void
init_targets() {
LLVMInitializeAllTargets();
LLVMInitializeAllTargetInfos();
LLVMInitializeAllTargetMCs();
+ LLVMInitializeAllAsmParsers();
LLVMInitializeAllAsmPrinters();
targets_initialized = true;
}
}
void
- diagnostic_handler(const llvm::DiagnosticInfo &di, void *data) {
- if (di.getSeverity() == llvm::DS_Error) {
- std::string message = *(std::string*)data;
- llvm::raw_string_ostream stream(message);
- llvm::DiagnosticPrinterRawOStream dp(stream);
- di.print(dp);
- stream.flush();
- *(std::string*)data = message;
-
- throw compile_error();
+ diagnostic_handler(const ::llvm::DiagnosticInfo &di, void *data) {
+ if (di.getSeverity() == ::llvm::DS_Error) {
+ raw_string_ostream os { *reinterpret_cast<std::string *>(data) };
+ ::llvm::DiagnosticPrinterRawOStream printer { os };
+ di.print(printer);
+ throw build_error();
}
}
create_context(std::string &r_log) {
init_targets();
std::unique_ptr<LLVMContext> ctx { new LLVMContext };
- ctx->setDiagnosticHandler(diagnostic_handler, &r_log);
+ compat::set_diagnostic_handler(*ctx, diagnostic_handler, &r_log);
return ctx;
}
+ const struct clc_version_lang_std&
+ get_cl_lang_standard(unsigned requested, unsigned max = ANY_VERSION) {
+ for (const struct clc_version_lang_std &version : cl_version_lang_stds) {
+ if (version.version_number == max ||
+ version.version_number == requested) {
+ return version;
+ }
+ }
+ throw build_error("Unknown/Unsupported language version");
+ }
+
+ const struct cl_version&
+ get_cl_version(const std::string &version_str,
+ unsigned max = ANY_VERSION) {
+ for (const struct cl_version &version : cl_versions) {
+ if (version.version_number == max || version.version_str == version_str) {
+ return version;
+ }
+ }
+ throw build_error("Unknown/Unsupported language version");
+ }
+
+ clang::LangStandard::Kind
+ get_lang_standard_from_version_str(const std::string &version_str,
+ bool is_build_opt = false) {
+
+ //Per CL 2.0 spec, section 5.8.4.5:
+ // If it's an option, use the value directly.
+ // If it's a device version, clamp to max 1.x version, a.k.a. 1.2
+ const cl_version version =
+ get_cl_version(version_str, is_build_opt ? ANY_VERSION : 120);
+
+ const struct clc_version_lang_std standard =
+ get_cl_lang_standard(version.version_number);
+
+ return standard.clc_lang_standard;
+ }
+
+ clang::LangStandard::Kind
+ get_language_version(const std::vector<std::string> &opts,
+ const std::string &device_version) {
+
+ const std::string search = "-cl-std=CL";
+
+ for (auto &opt: opts) {
+ auto pos = opt.find(search);
+ if (pos == 0){
+ const auto ver = opt.substr(pos + search.size());
+ const auto device_ver = get_cl_version(device_version);
+ const auto requested = get_cl_version(ver);
+ if (requested.version_number > device_ver.version_number) {
+ throw build_error();
+ }
+ return get_lang_standard_from_version_str(ver, true);
+ }
+ }
+
+ return get_lang_standard_from_version_str(device_version);
+ }
+
std::unique_ptr<clang::CompilerInstance>
- create_compiler_instance(const target &target,
+ create_compiler_instance(const device &dev, const std::string& ir_target,
const std::vector<std::string> &opts,
std::string &r_log) {
std::unique_ptr<clang::CompilerInstance> c { new clang::CompilerInstance };
+ clang::TextDiagnosticBuffer *diag_buffer = new clang::TextDiagnosticBuffer;
clang::DiagnosticsEngine diag { new clang::DiagnosticIDs,
- new clang::DiagnosticOptions, new clang::TextDiagnosticBuffer };
+ new clang::DiagnosticOptions, diag_buffer };
// Parse the compiler options. A file name should be present at the end
// and must have the .cl extension in order for the CompilerInvocation
const std::vector<const char *> copts =
map(std::mem_fn(&std::string::c_str), opts);
- if (!clang::CompilerInvocation::CreateFromArgs(
- c->getInvocation(), copts.data(), copts.data() + copts.size(), diag))
- throw error(CL_INVALID_COMPILER_OPTIONS);
+ const target &target = ir_target;
+ const std::string &device_clc_version = dev.device_clc_version();
+
+ if (!compat::create_compiler_invocation_from_args(
+ c->getInvocation(), copts, diag))
+ throw invalid_build_options_error();
+
+ diag_buffer->FlushDiagnostics(diag);
+ if (diag.hasErrorOccurred())
+ throw invalid_build_options_error();
c->getTargetOpts().CPU = target.cpu;
c->getTargetOpts().Triple = target.triple;
// http://www.llvm.org/bugs/show_bug.cgi?id=19735
c->getDiagnosticOpts().ShowCarets = false;
- compat::set_lang_defaults(c->getInvocation(), c->getLangOpts(),
- clang::IK_OpenCL, ::llvm::Triple(target.triple),
+ c->getInvocation().setLangDefaults(c->getLangOpts(),
+ compat::ik_opencl, ::llvm::Triple(target.triple),
c->getPreprocessorOpts(),
- clang::LangStandard::lang_opencl11);
+ get_language_version(opts, device_clc_version));
c->createDiagnostics(new clang::TextDiagnosticPrinter(
*new raw_string_ostream(r_log),
return c;
}
- llvm::Module *
- compile_llvm(LLVMContext &ctx, clang::CompilerInstance &c,
- const std::string &source, const header_map &headers,
- const std::string &name, const std::string &target,
- const std::string &opts, std::string &r_log) {
- clang::EmitLLVMOnlyAction act(&ctx);
-
+ std::unique_ptr<Module>
+ compile(LLVMContext &ctx, clang::CompilerInstance &c,
+ const std::string &name, const std::string &source,
+ const header_map &headers, const device &dev,
+ const std::string &opts, bool use_libclc, std::string &r_log) {
c.getFrontendOpts().ProgramAction = clang::frontend::EmitLLVMOnly;
c.getHeaderSearchOpts().UseBuiltinIncludes = true;
c.getHeaderSearchOpts().UseStandardSystemIncludes = true;
c.getHeaderSearchOpts().ResourceDir = CLANG_RESOURCE_DIR;
- // Add libclc generic search path
- c.getHeaderSearchOpts().AddPath(LIBCLC_INCLUDEDIR,
- clang::frontend::Angled,
- false, false
- );
+ if (use_libclc) {
+ // Add libclc generic search path
+ c.getHeaderSearchOpts().AddPath(LIBCLC_INCLUDEDIR,
+ clang::frontend::Angled,
+ false, false);
+
+ // Add libclc include
+ c.getPreprocessorOpts().Includes.push_back("clc/clc.h");
+ } else {
+ // Add opencl-c generic search path
+ c.getHeaderSearchOpts().AddPath(CLANG_RESOURCE_DIR,
+ clang::frontend::Angled,
+ false, false);
+
+ // Add opencl include
+ c.getPreprocessorOpts().Includes.push_back("opencl-c.h");
+ }
- // Add libclc include
- c.getPreprocessorOpts().Includes.push_back("clc/clc.h");
+ // Add definition for the OpenCL version
+ c.getPreprocessorOpts().addMacroDef("__OPENCL_VERSION__=" +
+ std::to_string(get_cl_version(
+ dev.device_version()).version_number));
// clc.h requires that this macro be defined:
c.getPreprocessorOpts().addMacroDef("cl_clang_storage_class_specifiers");
-
- c.getPreprocessorOpts().addRemappedFile(name,
- llvm::MemoryBuffer::getMemBuffer(source).release());
+ c.getPreprocessorOpts().addRemappedFile(
+ name, ::llvm::MemoryBuffer::getMemBuffer(source).release());
if (headers.size()) {
const std::string tmp_header_path = "/tmp/clover/";
c.getHeaderSearchOpts().AddPath(tmp_header_path,
clang::frontend::Angled,
- false, false
- );
-
- for (header_map::const_iterator it = headers.begin();
- it != headers.end(); ++it) {
- const std::string path = tmp_header_path + std::string(it->first);
- c.getPreprocessorOpts().addRemappedFile(path,
- llvm::MemoryBuffer::getMemBuffer(it->second.c_str()).release());
- }
+ false, false);
+
+ for (const auto &header : headers)
+ c.getPreprocessorOpts().addRemappedFile(
+ tmp_header_path + header.first,
+ ::llvm::MemoryBuffer::getMemBuffer(header.second).release());
}
// Tell clang to link this file before performing any
// 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.
- compat::add_link_bitcode_file(c.getCodeGenOpts(),
- LIBCLC_LIBEXECDIR + target + ".bc");
+ if (use_libclc)
+ compat::add_link_bitcode_file(c.getCodeGenOpts(),
+ LIBCLC_LIBEXECDIR + dev.ir_target() + ".bc");
// Compile the code
+ clang::EmitLLVMOnlyAction act(&ctx);
if (!c.ExecuteAction(act))
- throw compile_error();
+ throw build_error();
- return act.takeModule().release();
+ return act.takeModule();
}
+}
- std::vector<llvm::Function *>
- find_kernels(llvm::Module *mod) {
- std::vector<llvm::Function *> kernels;
-#if HAVE_LLVM >= 0x0309
- auto &list = mod->getFunctionList();
- for_each(list.begin(), list.end(), [&](llvm::Function &f){
- if (f.getMetadata("kernel_arg_type"))
- kernels.push_back(&f);
- });
- return kernels;
-#endif
- const llvm::NamedMDNode *kernel_node =
- mod->getNamedMetadata("opencl.kernels");
- // This means there are no kernels in the program. The spec does not
- // require that we return an error here, but there will be an error if
- // the user tries to pass this program to a clCreateKernel() call.
- if (!kernel_node) {
- return std::vector<llvm::Function *>();
- }
+module
+clover::llvm::compile_program(const std::string &source,
+ const header_map &headers,
+ const device &dev,
+ const std::string &opts,
+ std::string &r_log) {
+ if (has_flag(debug::clc))
+ debug::log(".cl", "// Options: " + opts + '\n' + source);
- kernels.reserve(kernel_node->getNumOperands());
- for (unsigned i = 0; i < kernel_node->getNumOperands(); ++i) {
- kernels.push_back(llvm::mdconst::dyn_extract<llvm::Function>(
- kernel_node->getOperand(i)->getOperand(0)));
- }
- return kernels;
- }
+ auto ctx = create_context(r_log);
+ auto c = create_compiler_instance(dev, dev.ir_target(),
+ tokenize(opts + " input.cl"), r_log);
+ auto mod = compile(*ctx, *c, "input.cl", source, headers, dev, opts, true,
+ r_log);
- void
- optimize(llvm::Module *mod, unsigned optimization_level) {
- compat::pass_manager PM;
+ if (has_flag(debug::llvm))
+ debug::log(".ll", print_module_bitcode(*mod));
+
+ return build_module_library(*mod, module::section::text_intermediate);
+}
- compat::add_data_layout_pass(PM);
+namespace {
+ void
+ optimize(Module &mod, unsigned optimization_level,
+ bool internalize_symbols) {
+ ::llvm::legacy::PassManager pm;
// By default, the function internalizer pass will look for a function
// called "main" and then mark all other functions as internal. Marking
// list of kernel functions to the internalizer. The internalizer will
// treat the functions in the list as "main" functions and internalize
// all of the other functions.
- compat::add_internalize_pass(PM, map(std::mem_fn(&Function::getName),
- find_kernels(mod)));
-
- llvm::PassManagerBuilder PMB;
- PMB.OptLevel = optimization_level;
- PMB.LibraryInfo = new compat::target_library_info(
- llvm::Triple(mod->getTargetTriple()));
- PMB.populateModulePassManager(PM);
- PM.run(*mod);
- }
-
- // Kernel metadata
-
- struct kernel_arg_md {
- llvm::StringRef type_name;
- llvm::StringRef access_qual;
- kernel_arg_md(llvm::StringRef type_name_, llvm::StringRef access_qual_):
- type_name(type_name_), access_qual(access_qual_) {}
- };
-#if HAVE_LLVM >= 0x0309
- std::vector<kernel_arg_md>
- get_kernel_arg_md(const llvm::Function *kernel_func) {
-
- size_t num_args = kernel_func->getArgumentList().size();
-
- auto aq = kernel_func->getMetadata("kernel_arg_access_qual");
- auto ty = kernel_func->getMetadata("kernel_arg_type");
-
- std::vector<kernel_arg_md> res;
- res.reserve(num_args);
- for (size_t i = 0; i < num_args; ++i) {
- res.push_back(kernel_arg_md(
- llvm::cast<llvm::MDString>(ty->getOperand(i))->getString(),
- llvm::cast<llvm::MDString>(aq->getOperand(i))->getString()));
- }
-
- return res;
- }
-
-#else
-
- const llvm::MDNode *
- get_kernel_metadata(const llvm::Function *kernel_func) {
- auto mod = kernel_func->getParent();
- auto kernels_node = mod->getNamedMetadata("opencl.kernels");
- if (!kernels_node) {
- return nullptr;
- }
-
- const llvm::MDNode *kernel_node = nullptr;
- for (unsigned i = 0; i < kernels_node->getNumOperands(); ++i) {
- auto func = llvm::mdconst::dyn_extract<llvm::Function>(
- kernels_node->getOperand(i)->getOperand(0));
- if (func == kernel_func) {
- kernel_node = kernels_node->getOperand(i);
- break;
- }
- }
-
- return kernel_node;
- }
-
- llvm::MDNode*
- node_from_op_checked(const llvm::MDOperand &md_operand,
- llvm::StringRef expect_name,
- unsigned expect_num_args)
- {
- auto node = llvm::cast<llvm::MDNode>(md_operand);
- assert(node->getNumOperands() == expect_num_args &&
- "Wrong number of operands.");
-
- auto str_node = llvm::cast<llvm::MDString>(node->getOperand(0));
- assert(str_node->getString() == expect_name &&
- "Wrong metadata node name.");
-
- return node;
- }
-
- std::vector<kernel_arg_md>
- get_kernel_arg_md(const llvm::Function *kernel_func) {
- auto num_args = kernel_func->getArgumentList().size();
-
- auto kernel_node = get_kernel_metadata(kernel_func);
- auto aq = node_from_op_checked(kernel_node->getOperand(2),
- "kernel_arg_access_qual", num_args + 1);
- auto ty = node_from_op_checked(kernel_node->getOperand(3),
- "kernel_arg_type", num_args + 1);
-
- std::vector<kernel_arg_md> res;
- res.reserve(num_args);
- for (unsigned i = 0; i < num_args; ++i) {
- res.push_back(kernel_arg_md(
- llvm::cast<llvm::MDString>(ty->getOperand(i+1))->getString(),
- llvm::cast<llvm::MDString>(aq->getOperand(i+1))->getString()));
+ if (internalize_symbols) {
+ std::vector<std::string> names =
+ map(std::mem_fn(&Function::getName), get_kernels(mod));
+ pm.add(::llvm::createInternalizePass(
+ [=](const ::llvm::GlobalValue &gv) {
+ return std::find(names.begin(), names.end(),
+ gv.getName()) != names.end();
+ }));
}
- return res;
+ ::llvm::PassManagerBuilder pmb;
+ pmb.OptLevel = optimization_level;
+ pmb.LibraryInfo = new ::llvm::TargetLibraryInfoImpl(
+ ::llvm::Triple(mod.getTargetTriple()));
+ pmb.populateModulePassManager(pm);
+ pm.run(mod);
}
-#endif
-
- std::vector<module::argument>
- get_kernel_args(const llvm::Module *mod, const std::string &kernel_name,
- const clang::CompilerInstance &c) {
- std::vector<module::argument> args;
- const auto address_spaces = c.getTarget().getAddressSpaceMap();
- llvm::Function *kernel_func = mod->getFunction(kernel_name);
- assert(kernel_func && "Kernel name not found in module.");
- auto arg_md = get_kernel_arg_md(kernel_func);
-
- llvm::DataLayout TD(mod);
- llvm::Type *size_type =
- TD.getSmallestLegalIntType(mod->getContext(), sizeof(cl_uint) * 8);
-
- for (const auto &arg: kernel_func->args()) {
-
- llvm::Type *arg_type = arg.getType();
- const unsigned arg_store_size = TD.getTypeStoreSize(arg_type);
-
- // OpenCL 1.2 specification, Ch. 6.1.5: "A built-in data
- // type that is not a power of two bytes in size must be
- // aligned to the next larger power of two". We need this
- // alignment for three element vectors, which have
- // non-power-of-2 store size.
- const unsigned arg_api_size = util_next_power_of_two(arg_store_size);
-
- llvm::Type *target_type = arg_type->isIntegerTy() ?
- TD.getSmallestLegalIntType(mod->getContext(), arg_store_size * 8)
- : arg_type;
- unsigned target_size = TD.getTypeStoreSize(target_type);
- unsigned target_align = TD.getABITypeAlignment(target_type);
-
- llvm::StringRef type_name = arg_md[arg.getArgNo()].type_name;
- llvm::StringRef access_qual = arg_md[arg.getArgNo()].access_qual;
-
- // Image
- const bool is_image2d = type_name == "image2d_t";
- const bool is_image3d = type_name == "image3d_t";
- if (is_image2d || is_image3d) {
- const bool is_write_only = access_qual == "write_only";
- const bool is_read_only = access_qual == "read_only";
-
- enum module::argument::type marg_type;
- if (is_image2d && is_read_only) {
- marg_type = module::argument::image2d_rd;
- } else if (is_image2d && is_write_only) {
- marg_type = module::argument::image2d_wr;
- } else if (is_image3d && is_read_only) {
- marg_type = module::argument::image3d_rd;
- } else if (is_image3d && is_write_only) {
- marg_type = module::argument::image3d_wr;
- } else {
- assert(0 && "Wrong image access qualifier");
- }
-
- args.push_back(module::argument(marg_type,
- arg_store_size, target_size,
- target_align,
- module::argument::zero_ext));
- continue;
- }
-
- // Image size implicit argument
- if (type_name == "__llvm_image_size") {
- args.push_back(module::argument(module::argument::scalar,
- sizeof(cl_uint),
- TD.getTypeStoreSize(size_type),
- TD.getABITypeAlignment(size_type),
- module::argument::zero_ext,
- module::argument::image_size));
- continue;
- }
-
- // Image format implicit argument
- if (type_name == "__llvm_image_format") {
- args.push_back(module::argument(module::argument::scalar,
- sizeof(cl_uint),
- TD.getTypeStoreSize(size_type),
- TD.getABITypeAlignment(size_type),
- module::argument::zero_ext,
- module::argument::image_format));
- continue;
- }
-
- // Other types
- if (llvm::isa<llvm::PointerType>(arg_type) && arg.hasByValAttr()) {
- arg_type =
- llvm::dyn_cast<llvm::PointerType>(arg_type)->getElementType();
- }
-
- if (arg_type->isPointerTy()) {
- unsigned address_space = llvm::cast<llvm::PointerType>(arg_type)->getAddressSpace();
- if (address_space == address_spaces[clang::LangAS::opencl_local
- - clang::LangAS::Offset]) {
- args.push_back(module::argument(module::argument::local,
- arg_api_size, target_size,
- target_align,
- module::argument::zero_ext));
- } else {
- // XXX: Correctly handle constant address space. There is no
- // way for r600g to pass a handle for constant buffers back
- // to clover like it can for global buffers, so
- // creating constant arguments will break r600g. For now,
- // continue treating constant buffers as global buffers
- // until we can come up with a way to create handles for
- // constant buffers.
- args.push_back(module::argument(module::argument::global,
- arg_api_size, target_size,
- target_align,
- module::argument::zero_ext));
- }
-
- } else {
- llvm::AttributeSet attrs = kernel_func->getAttributes();
- enum module::argument::ext_type ext_type =
- (attrs.hasAttribute(arg.getArgNo() + 1,
- llvm::Attribute::SExt) ?
- module::argument::sign_ext :
- module::argument::zero_ext);
-
- args.push_back(
- module::argument(module::argument::scalar, arg_api_size,
- target_size, target_align, ext_type));
- }
- }
-
- // Append implicit arguments. XXX - The types, ordering and
- // vector size of the implicit arguments should depend on the
- // target according to the selected calling convention.
- args.push_back(
- module::argument(module::argument::scalar, sizeof(cl_uint),
- TD.getTypeStoreSize(size_type),
- TD.getABITypeAlignment(size_type),
- module::argument::zero_ext,
- module::argument::grid_dimension));
-
- args.push_back(
- module::argument(module::argument::scalar, sizeof(cl_uint),
- TD.getTypeStoreSize(size_type),
- TD.getABITypeAlignment(size_type),
- module::argument::zero_ext,
- module::argument::grid_offset));
-
- return args;
- }
-
- module
- build_module_llvm(llvm::Module *mod,
- const clang::CompilerInstance &c) {
-
- module m;
- struct pipe_llvm_program_header header;
- llvm::SmallVector<char, 1024> llvm_bitcode;
- llvm::raw_svector_ostream bitcode_ostream(llvm_bitcode);
- llvm::BitstreamWriter writer(llvm_bitcode);
- llvm::WriteBitcodeToFile(mod, bitcode_ostream);
-#if HAVE_LLVM < 0x0308
- bitcode_ostream.flush();
-#endif
-
- const std::vector<llvm::Function *> kernels = find_kernels(mod);
- for (unsigned i = 0; i < kernels.size(); ++i) {
- std::string kernel_name = kernels[i]->getName();
- std::vector<module::argument> args =
- get_kernel_args(mod, kernel_name, c);
-
- m.syms.push_back(module::symbol(kernel_name, 0, i, args ));
- }
-
- header.num_bytes = llvm_bitcode.size();
- std::vector<char> data;
- data.insert(data.end(), (char*)(&header),
- (char*)(&header) + sizeof(header));
- data.insert(data.end(), llvm_bitcode.begin(),
- llvm_bitcode.end());
- m.secs.push_back(module::section(0, module::section::text,
- header.num_bytes, data));
+ std::unique_ptr<Module>
+ link(LLVMContext &ctx, const clang::CompilerInstance &c,
+ const std::vector<module> &modules, std::string &r_log) {
+ std::unique_ptr<Module> mod { new Module("link", ctx) };
+ std::unique_ptr< ::llvm::Linker> linker { new ::llvm::Linker(*mod) };
- return m;
- }
-
- void
- emit_code(LLVMTargetMachineRef tm, LLVMModuleRef mod,
- LLVMCodeGenFileType file_type,
- LLVMMemoryBufferRef *out_buffer,
- std::string &r_log) {
- LLVMBool err;
- char *err_message = NULL;
-
- err = LLVMTargetMachineEmitToMemoryBuffer(tm, mod, file_type,
- &err_message, out_buffer);
-
- if (err) {
- r_log = std::string(err_message);
+ for (auto &m : modules) {
+ if (linker->linkInModule(parse_module_library(m, ctx, r_log)))
+ throw build_error();
}
- LLVMDisposeMessage(err_message);
-
- if (err) {
- throw compile_error();
- }
+ return mod;
}
+}
- std::vector<char>
- compile_native(const llvm::Module *mod, const target &t, bool dump_asm,
- std::string &r_log) {
-
- std::string log;
- LLVMTargetRef target;
- char *error_message;
- LLVMMemoryBufferRef out_buffer;
- unsigned buffer_size;
- const char *buffer_data;
- LLVMModuleRef mod_ref = wrap(mod);
-
- if (LLVMGetTargetFromTriple(t.triple.c_str(), &target, &error_message)) {
- r_log = std::string(error_message);
- LLVMDisposeMessage(error_message);
- throw compile_error();
- }
+module
+clover::llvm::link_program(const std::vector<module> &modules,
+ const device &dev, const std::string &opts,
+ std::string &r_log) {
+ std::vector<std::string> options = tokenize(opts + " input.cl");
+ const bool create_library = count("-create-library", options);
+ erase_if(equals("-create-library"), options);
- LLVMTargetMachineRef tm = LLVMCreateTargetMachine(
- target, t.triple.c_str(), t.cpu.c_str(), "",
- LLVMCodeGenLevelDefault, LLVMRelocDefault, LLVMCodeModelDefault);
+ auto ctx = create_context(r_log);
+ auto c = create_compiler_instance(dev, dev.ir_target(), options, r_log);
+ auto mod = link(*ctx, *c, modules, r_log);
- if (!tm) {
- r_log = "Could not create TargetMachine: " + t.triple;
- throw compile_error();
- }
+ optimize(*mod, c->getCodeGenOpts().OptimizationLevel, !create_library);
- if (dump_asm) {
- LLVMSetTargetMachineAsmVerbosity(tm, true);
-#if HAVE_LLVM >= 0x0308
- LLVMModuleRef debug_mod = wrap(llvm::CloneModule(mod).release());
-#else
- LLVMModuleRef debug_mod = wrap(llvm::CloneModule(mod));
-#endif
- emit_code(tm, debug_mod, LLVMAssemblyFile, &out_buffer, r_log);
- buffer_size = LLVMGetBufferSize(out_buffer);
- buffer_data = LLVMGetBufferStart(out_buffer);
- debug_log(std::string(buffer_data, buffer_size), ".asm");
-
- LLVMSetTargetMachineAsmVerbosity(tm, false);
- LLVMDisposeMemoryBuffer(out_buffer);
- LLVMDisposeModule(debug_mod);
- }
+ static std::atomic_uint seq(0);
+ const std::string id = "." + mod->getModuleIdentifier() + "-" +
+ std::to_string(seq++);
- emit_code(tm, mod_ref, LLVMObjectFile, &out_buffer, r_log);
+ if (has_flag(debug::llvm))
+ debug::log(id + ".ll", print_module_bitcode(*mod));
- buffer_size = LLVMGetBufferSize(out_buffer);
- buffer_data = LLVMGetBufferStart(out_buffer);
+ if (create_library) {
+ return build_module_library(*mod, module::section::text_library);
- std::vector<char> code(buffer_data, buffer_data + buffer_size);
+ } else if (dev.ir_format() == PIPE_SHADER_IR_NATIVE) {
+ if (has_flag(debug::native))
+ debug::log(id + ".asm", print_module_native(*mod, dev.ir_target()));
- LLVMDisposeMemoryBuffer(out_buffer);
- LLVMDisposeTargetMachine(tm);
+ return build_module_native(*mod, dev.ir_target(), *c, r_log);
- return code;
+ } else {
+ unreachable("Unsupported IR.");
}
+}
- std::map<std::string, unsigned>
- get_kernel_offsets(std::vector<char> &code,
- const std::vector<llvm::Function *> &kernels,
- std::string &r_log) {
-
- // One of the libelf implementations
- // (http://www.mr511.de/software/english.htm) requires calling
- // elf_version() before elf_memory().
- //
- elf_version(EV_CURRENT);
-
- Elf *elf = elf_memory(&code[0], code.size());
- size_t section_str_index;
- elf_getshdrstrndx(elf, §ion_str_index);
- Elf_Scn *section = NULL;
- Elf_Scn *symtab = NULL;
- GElf_Shdr symtab_header;
-
- // Find the symbol table
- try {
- while ((section = elf_nextscn(elf, section))) {
- const char *name;
- if (gelf_getshdr(section, &symtab_header) != &symtab_header) {
- r_log = "Failed to read ELF section header.";
- throw compile_error();
- }
- name = elf_strptr(elf, section_str_index, symtab_header.sh_name);
- if (!strcmp(name, ".symtab")) {
- symtab = section;
- break;
- }
- }
- if (!symtab) {
- r_log = "Unable to find symbol table.";
- throw compile_error();
- }
- } catch (compile_error &e) {
- elf_end(elf);
- throw e;
- }
-
-
- // Extract symbol information from the table
- Elf_Data *symtab_data = NULL;
- GElf_Sym *symbol;
- GElf_Sym s;
-
- std::map<std::string, unsigned> kernel_offsets;
- symtab_data = elf_getdata(symtab, symtab_data);
+#ifdef HAVE_CLOVER_SPIRV
+module
+clover::llvm::compile_to_spirv(const std::string &source,
+ const header_map &headers,
+ const device &dev,
+ const std::string &opts,
+ std::string &r_log) {
+ if (has_flag(debug::clc))
+ debug::log(".cl", "// Options: " + opts + '\n' + source);
- // Determine the offsets for each kernel
- for (int i = 0; (symbol = gelf_getsym(symtab_data, i, &s)); i++) {
- char *name = elf_strptr(elf, symtab_header.sh_link, symbol->st_name);
- for (std::vector<llvm::Function*>::const_iterator it = kernels.begin(),
- e = kernels.end(); it != e; ++it) {
- llvm::Function *f = *it;
- if (f->getName() == std::string(name))
- kernel_offsets[f->getName()] = symbol->st_value;
- }
- }
- elf_end(elf);
- return kernel_offsets;
+ auto ctx = create_context(r_log);
+ const std::string target = dev.address_bits() == 32u ?
+ "-spir-unknown-unknown" :
+ "-spir64-unknown-unknown";
+ auto c = create_compiler_instance(dev, target,
+ tokenize(opts + " input.cl"), r_log);
+ auto mod = compile(*ctx, *c, "input.cl", source, headers, dev, opts, false,
+ r_log);
+
+ if (has_flag(debug::llvm))
+ debug::log(".ll", print_module_bitcode(*mod));
+
+ std::string error_msg;
+ if (!::llvm::regularizeLlvmForSpirv(mod.get(), error_msg)) {
+ r_log += "Failed to regularize LLVM IR for SPIR-V: " + error_msg + ".\n";
+ throw error(CL_INVALID_VALUE);
}
- module
- build_module_native(std::vector<char> &code,
- llvm::Module *mod,
- const clang::CompilerInstance &c,
- std::string &r_log) {
-
- const std::vector<llvm::Function *> kernels = find_kernels(mod);
-
- std::map<std::string, unsigned> kernel_offsets =
- get_kernel_offsets(code, kernels, r_log);
-
- // Begin building the clover module
- module m;
- struct pipe_llvm_program_header header;
-
- // Store the generated ELF binary in the module's text section.
- header.num_bytes = code.size();
- std::vector<char> data;
- data.insert(data.end(), (char*)(&header),
- (char*)(&header) + sizeof(header));
- data.insert(data.end(), code.begin(), code.end());
- m.secs.push_back(module::section(0, module::section::text,
- header.num_bytes, data));
-
- for (std::map<std::string, unsigned>::iterator i = kernel_offsets.begin(),
- e = kernel_offsets.end(); i != e; ++i) {
- std::vector<module::argument> args = get_kernel_args(mod, i->first, c);
- m.syms.push_back(module::symbol(i->first, 0, i->second, args ));
- }
-
- return m;
+ std::ostringstream os;
+ if (!::llvm::writeSpirv(mod.get(), os, error_msg)) {
+ r_log += "Translation from LLVM IR to SPIR-V failed: " + error_msg + ".\n";
+ throw error(CL_INVALID_VALUE);
}
-#define DBG_CLC (1 << 0)
-#define DBG_LLVM (1 << 1)
-#define DBG_ASM (1 << 2)
-
- unsigned
- get_debug_flags() {
- static const struct debug_named_value debug_options[] = {
- {"clc", DBG_CLC, "Dump the OpenCL C code for all kernels."},
- {"llvm", DBG_LLVM, "Dump the generated LLVM IR for all kernels."},
- {"asm", DBG_ASM, "Dump kernel assembly code for targets specifying "
- "PIPE_SHADER_IR_NATIVE"},
- DEBUG_NAMED_VALUE_END // must be last
- };
- static const unsigned debug_flags =
- debug_get_flags_option("CLOVER_DEBUG", debug_options, 0);
-
- return debug_flags;
+ const std::string osContent = os.str();
+ std::vector<char> binary(osContent.begin(), osContent.end());
+ if (binary.empty()) {
+ r_log += "Failed to retrieve SPIR-V binary.\n";
+ throw error(CL_INVALID_VALUE);
}
-} // End anonymous 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) {
- if (get_debug_flags() & DBG_CLC)
- debug_log("// Build options: " + opts + '\n' + source, ".cl");
+ if (has_flag(debug::spirv))
+ debug::log(".spvasm", spirv::print_module(binary, dev.device_version()));
- auto ctx = create_context(r_log);
- // The input file name must have the .cl extension in order for the
- // CompilerInvocation class to recognize it as an OpenCL source file.
- const auto c = create_compiler_instance(target, tokenize(opts + " input.cl"),
- r_log);
- Module *mod = compile_llvm(*ctx, *c, source, headers, "input.cl",
- target, opts, r_log);
-
- optimize(mod, c->getCodeGenOpts().OptimizationLevel);
-
- if (get_debug_flags() & DBG_LLVM) {
- std::string log;
- raw_string_ostream s_log(log);
- mod->print(s_log, NULL);
- s_log.flush();
- debug_log(log, ".ll");
- }
-
- module m;
- // Build the clover::module
- switch (ir) {
- case PIPE_SHADER_IR_NIR:
- case PIPE_SHADER_IR_TGSI:
- //XXX: Handle TGSI, NIR
- assert(0);
- m = module();
- break;
- case PIPE_SHADER_IR_LLVM:
- m = build_module_llvm(mod, *c);
- break;
- case PIPE_SHADER_IR_NATIVE: {
- std::vector<char> code = compile_native(mod, target,
- get_debug_flags() & DBG_ASM,
- r_log);
- m = build_module_native(code, mod, *c, r_log);
- break;
- }
- }
- // The user takes ownership of the module.
- delete mod;
- return m;
+ return spirv::compile_program(binary, dev, r_log);
}
+#endif
projects / mesa.git / blobdiff