X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Famd%2Fcommon%2Fac_llvm_helper.cpp;h=d392c0ece7f3db3901348ca9bae777b890f5dd37;hb=d9f33951df9c107e7e6b88ec7cc884f38f92c52b;hp=125f5f3d7a9d7594eccddb4a8425ce67ad287fa7;hpb=8eabee9ec0c164bd18babfe15311db14040ad337;p=mesa.git

diff --git a/src/amd/common/ac_llvm_helper.cpp b/src/amd/common/ac_llvm_helper.cpp
index 125f5f3d7a9..d392c0ece7f 100644
--- a/src/amd/common/ac_llvm_helper.cpp
+++ b/src/amd/common/ac_llvm_helper.cpp
@@ -26,20 +26,263 @@
 /* based on Marek's patch to lp_bld_misc.cpp */
 
 // Workaround http://llvm.org/PR23628
-#if HAVE_LLVM >= 0x0307
-#  pragma push_macro("DEBUG")
-#  undef DEBUG
-#endif
+#pragma push_macro("DEBUG")
+#undef DEBUG
 
+#include <cstring>
+
+#include "ac_binary.h"
 #include "ac_llvm_util.h"
+#include "ac_llvm_build.h"
+
+#include "util/macros.h"
+
 #include <llvm-c/Core.h>
-#include <llvm/Target/TargetOptions.h>
-#include <llvm/ExecutionEngine/ExecutionEngine.h>
+#include <llvm/Target/TargetMachine.h>
+#include <llvm/IR/IRBuilder.h>
+#include <llvm/Analysis/TargetLibraryInfo.h>
+#include <llvm/Transforms/IPO.h>
+
+#include <llvm/IR/LegacyPassManager.h>
 
 void ac_add_attr_dereferenceable(LLVMValueRef val, uint64_t bytes)
 {
    llvm::Argument *A = llvm::unwrap<llvm::Argument>(val);
-   llvm::AttrBuilder B;
-   B.addDereferenceableAttr(bytes);
-   A->addAttr(llvm::AttributeSet::get(A->getContext(), A->getArgNo() + 1,  B));
+   A->addAttr(llvm::Attribute::getWithDereferenceableBytes(A->getContext(), bytes));
+}
+
+bool ac_is_sgpr_param(LLVMValueRef arg)
+{
+	llvm::Argument *A = llvm::unwrap<llvm::Argument>(arg);
+	llvm::AttributeList AS = A->getParent()->getAttributes();
+	unsigned ArgNo = A->getArgNo();
+	return AS.hasAttribute(ArgNo + 1, llvm::Attribute::InReg);
+}
+
+LLVMValueRef ac_llvm_get_called_value(LLVMValueRef call)
+{
+	return LLVMGetCalledValue(call);
+}
+
+bool ac_llvm_is_function(LLVMValueRef v)
+{
+	return LLVMGetValueKind(v) == LLVMFunctionValueKind;
+}
+
+LLVMModuleRef ac_create_module(LLVMTargetMachineRef tm, LLVMContextRef ctx)
+{
+   llvm::TargetMachine *TM = reinterpret_cast<llvm::TargetMachine*>(tm);
+   LLVMModuleRef module = LLVMModuleCreateWithNameInContext("mesa-shader", ctx);
+
+   llvm::unwrap(module)->setTargetTriple(TM->getTargetTriple().getTriple());
+   llvm::unwrap(module)->setDataLayout(TM->createDataLayout());
+   return module;
+}
+
+LLVMBuilderRef ac_create_builder(LLVMContextRef ctx,
+				 enum ac_float_mode float_mode)
+{
+	LLVMBuilderRef builder = LLVMCreateBuilderInContext(ctx);
+
+	llvm::FastMathFlags flags;
+
+	switch (float_mode) {
+	case AC_FLOAT_MODE_DEFAULT:
+		break;
+	case AC_FLOAT_MODE_NO_SIGNED_ZEROS_FP_MATH:
+		flags.setNoSignedZeros();
+		llvm::unwrap(builder)->setFastMathFlags(flags);
+		break;
+	case AC_FLOAT_MODE_UNSAFE_FP_MATH:
+		flags.setFast();
+		llvm::unwrap(builder)->setFastMathFlags(flags);
+		break;
+	}
+
+	return builder;
+}
+
+LLVMTargetLibraryInfoRef
+ac_create_target_library_info(const char *triple)
+{
+	return reinterpret_cast<LLVMTargetLibraryInfoRef>(new llvm::TargetLibraryInfoImpl(llvm::Triple(triple)));
+}
+
+void
+ac_dispose_target_library_info(LLVMTargetLibraryInfoRef library_info)
+{
+	delete reinterpret_cast<llvm::TargetLibraryInfoImpl *>(library_info);
+}
+
+/* Implementation of raw_pwrite_stream that works on malloc()ed memory for
+ * better compatibility with C code. */
+struct raw_memory_ostream : public llvm::raw_pwrite_stream {
+	char *buffer;
+	size_t written;
+	size_t bufsize;
+
+	raw_memory_ostream()
+	{
+		buffer = NULL;
+		written = 0;
+		bufsize = 0;
+		SetUnbuffered();
+	}
+
+	~raw_memory_ostream()
+	{
+		free(buffer);
+	}
+
+	void clear()
+	{
+		written = 0;
+	}
+
+	void take(char *&out_buffer, size_t &out_size)
+	{
+		out_buffer = buffer;
+		out_size = written;
+		buffer = NULL;
+		written = 0;
+		bufsize = 0;
+	}
+
+	void flush() = delete;
+
+	void write_impl(const char *ptr, size_t size) override
+	{
+		if (unlikely(written + size < written))
+			abort();
+		if (written + size > bufsize) {
+			bufsize = MAX3(1024, written + size, bufsize / 3 * 4);
+			buffer = (char *)realloc(buffer, bufsize);
+			if (!buffer) {
+				fprintf(stderr, "amd: out of memory allocating ELF buffer\n");
+				abort();
+			}
+		}
+		memcpy(buffer + written, ptr, size);
+		written += size;
+	}
+
+	void pwrite_impl(const char *ptr, size_t size, uint64_t offset) override
+	{
+		assert(offset == (size_t)offset &&
+		       offset + size >= offset && offset + size <= written);
+		memcpy(buffer + offset, ptr, size);
+	}
+
+	uint64_t current_pos() const override
+	{
+		return written;
+	}
+};
+
+/* The LLVM compiler is represented as a pass manager containing passes for
+ * optimizations, instruction selection, and code generation.
+ */
+struct ac_compiler_passes {
+	raw_memory_ostream ostream; /* ELF shader binary stream */
+	llvm::legacy::PassManager passmgr; /* list of passes */
+};
+
+struct ac_compiler_passes *ac_create_llvm_passes(LLVMTargetMachineRef tm)
+{
+	struct ac_compiler_passes *p = new ac_compiler_passes();
+	if (!p)
+		return NULL;
+
+	llvm::TargetMachine *TM = reinterpret_cast<llvm::TargetMachine*>(tm);
+
+	if (TM->addPassesToEmitFile(p->passmgr, p->ostream,
+				    nullptr,
+				    llvm::TargetMachine::CGFT_ObjectFile)) {
+		fprintf(stderr, "amd: TargetMachine can't emit a file of this type!\n");
+		delete p;
+		return NULL;
+	}
+	return p;
+}
+
+void ac_destroy_llvm_passes(struct ac_compiler_passes *p)
+{
+	delete p;
+}
+
+/* This returns false on failure. */
+bool ac_compile_module_to_elf(struct ac_compiler_passes *p, LLVMModuleRef module,
+			      char **pelf_buffer, size_t *pelf_size)
+{
+	p->passmgr.run(*llvm::unwrap(module));
+	p->ostream.take(*pelf_buffer, *pelf_size);
+	return true;
+}
+
+void ac_llvm_add_barrier_noop_pass(LLVMPassManagerRef passmgr)
+{
+	llvm::unwrap(passmgr)->add(llvm::createBarrierNoopPass());
+}
+
+void ac_enable_global_isel(LLVMTargetMachineRef tm)
+{
+  reinterpret_cast<llvm::TargetMachine*>(tm)->setGlobalISel(true);
+}
+
+LLVMValueRef ac_build_atomic_rmw(struct ac_llvm_context *ctx, LLVMAtomicRMWBinOp op,
+				 LLVMValueRef ptr, LLVMValueRef val,
+				 const char *sync_scope) {
+	llvm::AtomicRMWInst::BinOp binop;
+	switch (op) {
+	case LLVMAtomicRMWBinOpXchg:
+		binop = llvm::AtomicRMWInst::Xchg;
+		break;
+	case LLVMAtomicRMWBinOpAdd:
+		binop = llvm::AtomicRMWInst::Add;
+		break;
+	case LLVMAtomicRMWBinOpSub:
+		binop = llvm::AtomicRMWInst::Sub;
+		break;
+	case LLVMAtomicRMWBinOpAnd:
+		binop = llvm::AtomicRMWInst::And;
+		break;
+	case LLVMAtomicRMWBinOpNand:
+		binop = llvm::AtomicRMWInst::Nand;
+		break;
+	case LLVMAtomicRMWBinOpOr:
+		binop = llvm::AtomicRMWInst::Or;
+		break;
+	case LLVMAtomicRMWBinOpXor:
+		binop = llvm::AtomicRMWInst::Xor;
+		break;
+	case LLVMAtomicRMWBinOpMax:
+		binop = llvm::AtomicRMWInst::Max;
+		break;
+	case LLVMAtomicRMWBinOpMin:
+		binop = llvm::AtomicRMWInst::Min;
+		break;
+	case LLVMAtomicRMWBinOpUMax:
+		binop = llvm::AtomicRMWInst::UMax;
+		break;
+	case LLVMAtomicRMWBinOpUMin:
+		binop = llvm::AtomicRMWInst::UMin;
+		break;
+	default:
+		unreachable(!"invalid LLVMAtomicRMWBinOp");
+	   break;
+	}
+	unsigned SSID = llvm::unwrap(ctx->context)->getOrInsertSyncScopeID(sync_scope);
+	return llvm::wrap(llvm::unwrap(ctx->builder)->CreateAtomicRMW(
+		binop, llvm::unwrap(ptr), llvm::unwrap(val),
+		llvm::AtomicOrdering::SequentiallyConsistent, SSID));
+}
+
+LLVMValueRef ac_build_atomic_cmp_xchg(struct ac_llvm_context *ctx, LLVMValueRef ptr,
+				      LLVMValueRef cmp, LLVMValueRef val,
+				      const char *sync_scope) {
+	unsigned SSID = llvm::unwrap(ctx->context)->getOrInsertSyncScopeID(sync_scope);
+	return llvm::wrap(llvm::unwrap(ctx->builder)->CreateAtomicCmpXchg(
+			  llvm::unwrap(ptr), llvm::unwrap(cmp), llvm::unwrap(val),
+			  llvm::AtomicOrdering::SequentiallyConsistent,
+			  llvm::AtomicOrdering::SequentiallyConsistent, SSID));
 }