#include <stddef.h>
+// Workaround http://llvm.org/PR23628
+#if HAVE_LLVM >= 0x0307
+# pragma push_macro("DEBUG")
+# undef DEBUG
+#endif
+
#include <llvm-c/Core.h>
#include <llvm-c/ExecutionEngine.h>
#include <llvm/Target/TargetOptions.h>
#include <llvm/ExecutionEngine/ExecutionEngine.h>
#include <llvm/ADT/Triple.h>
+#if HAVE_LLVM >= 0x0307
+#include <llvm/Analysis/TargetLibraryInfo.h>
+#else
+#include <llvm/Target/TargetLibraryInfo.h>
+#endif
#if HAVE_LLVM < 0x0306
#include <llvm/ExecutionEngine/JITMemoryManager.h>
#else
#include <llvm/Support/TargetSelect.h>
+#if HAVE_LLVM >= 0x0305
+#include <llvm/IR/CallSite.h>
+#endif
#include <llvm/IR/IRBuilder.h>
#include <llvm/IR/Module.h>
#include <llvm/Support/CBindingWrapping.h>
+#include <llvm/Config/llvm-config.h>
+#if LLVM_USE_INTEL_JITEVENTS
+#include <llvm/ExecutionEngine/JITEventListener.h>
+#endif
+
+// Workaround http://llvm.org/PR23628
+#if HAVE_LLVM >= 0x0307
+# pragma pop_macro("DEBUG")
+#endif
+
+#include "c11/threads.h"
+#include "os/os_thread.h"
#include "pipe/p_config.h"
#include "util/u_debug.h"
#include "util/u_cpu_detect.h"
}
+static once_flag init_native_targets_once_flag = ONCE_FLAG_INIT;
+
+static void init_native_targets()
+{
+ // If we have a native target, initialize it to ensure it is linked in and
+ // usable by the JIT.
+ llvm::InitializeNativeTarget();
+
+ llvm::InitializeNativeTargetAsmPrinter();
+
+ llvm::InitializeNativeTargetDisassembler();
+}
+
+/**
+ * The llvm target registry is not thread-safe, so drivers and state-trackers
+ * that want to initialize targets should use the gallivm_init_llvm_targets()
+ * function to safely initialize targets.
+ *
+ * LLVM targets should be initialized before the driver or state-tracker tries
+ * to access the registry.
+ */
+extern "C" void
+gallivm_init_llvm_targets(void)
+{
+ call_once(&init_native_targets_once_flag, init_native_targets);
+}
+
extern "C" void
lp_set_target_options(void)
{
llvm::DisablePrettyStackTrace = true;
#endif
- // If we have a native target, initialize it to ensure it is linked in and
- // usable by the JIT.
- llvm::InitializeNativeTarget();
-
- llvm::InitializeNativeTargetAsmPrinter();
-
- llvm::InitializeNativeTargetDisassembler();
+ gallivm_init_llvm_targets();
}
-
extern "C"
-LLVMValueRef
-lp_build_load_volatile(LLVMBuilderRef B, LLVMValueRef PointerVal,
- const char *Name)
+LLVMTargetLibraryInfoRef
+gallivm_create_target_library_info(const char *triple)
{
- return llvm::wrap(llvm::unwrap(B)->CreateLoad(llvm::unwrap(PointerVal), true, Name));
+ return reinterpret_cast<LLVMTargetLibraryInfoRef>(
+#if HAVE_LLVM < 0x0307
+ new llvm::TargetLibraryInfo(
+#else
+ new llvm::TargetLibraryInfoImpl(
+#endif
+ llvm::Triple(triple)));
}
-
extern "C"
void
-lp_set_load_alignment(LLVMValueRef Inst,
- unsigned Align)
+gallivm_dispose_target_library_info(LLVMTargetLibraryInfoRef library_info)
{
- llvm::unwrap<llvm::LoadInst>(Inst)->setAlignment(Align);
+ delete reinterpret_cast<
+#if HAVE_LLVM < 0x0307
+ llvm::TargetLibraryInfo
+#else
+ llvm::TargetLibraryInfoImpl
+#endif
+ *>(library_info);
}
+
+#if HAVE_LLVM < 0x0304
+
extern "C"
void
-lp_set_store_alignment(LLVMValueRef Inst,
- unsigned Align)
+LLVMSetAlignmentBackport(LLVMValueRef V,
+ unsigned Bytes)
{
- llvm::unwrap<llvm::StoreInst>(Inst)->setAlignment(Align);
+ switch (LLVMGetInstructionOpcode(V)) {
+ case LLVMLoad:
+ llvm::unwrap<llvm::LoadInst>(V)->setAlignment(Bytes);
+ break;
+ case LLVMStore:
+ llvm::unwrap<llvm::StoreInst>(V)->setAlignment(Bytes);
+ break;
+ default:
+ assert(0);
+ break;
+ }
}
+#endif
+
#if HAVE_LLVM < 0x0306
typedef llvm::JITMemoryManager BaseMemoryManager;
#endif
#endif
-#if defined(DEBUG)
+#if defined(DEBUG) && HAVE_LLVM < 0x0307
options.JITEmitDebugInfo = true;
#endif
#if HAVE_LLVM < 0x0304
options.NoFramePointerElimNonLeaf = true;
#endif
+#if HAVE_LLVM < 0x0307
options.NoFramePointerElim = true;
+#endif
#endif
builder.setEngineKind(EngineKind::JIT)
#ifdef _WIN32
/*
* MCJIT works on Windows, but currently only through ELF object format.
+ *
+ * XXX: We could use `LLVM_HOST_TRIPLE "-elf"` but LLVM_HOST_TRIPLE has
+ * different strings for MinGW/MSVC, so better play it safe and be
+ * explicit.
*/
- std::string targetTriple = llvm::sys::getProcessTriple();
- targetTriple.append("-elf");
- unwrap(M)->setTargetTriple(targetTriple);
+# ifdef _WIN64
+ LLVMSetTarget(M, "x86_64-pc-win32-elf");
+# else
+ LLVMSetTarget(M, "i686-pc-win32-elf");
+# endif
#endif
}
- llvm::SmallVector<std::string, 1> MAttrs;
- if (util_cpu_caps.has_avx) {
+ llvm::SmallVector<std::string, 16> MAttrs;
+
+#if defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)
+ /*
+ * We need to unset attributes because sometimes LLVM mistakenly assumes
+ * certain features are present given the processor name.
+ *
+ * https://bugs.freedesktop.org/show_bug.cgi?id=92214
+ * http://llvm.org/PR25021
+ * http://llvm.org/PR19429
+ * http://llvm.org/PR16721
+ */
+ MAttrs.push_back(util_cpu_caps.has_sse ? "+sse" : "-sse" );
+ MAttrs.push_back(util_cpu_caps.has_sse2 ? "+sse2" : "-sse2" );
+ MAttrs.push_back(util_cpu_caps.has_sse3 ? "+sse3" : "-sse3" );
+ MAttrs.push_back(util_cpu_caps.has_ssse3 ? "+ssse3" : "-ssse3" );
+#if HAVE_LLVM >= 0x0304
+ MAttrs.push_back(util_cpu_caps.has_sse4_1 ? "+sse4.1" : "-sse4.1");
+#else
+ MAttrs.push_back(util_cpu_caps.has_sse4_1 ? "+sse41" : "-sse41" );
+#endif
+#if HAVE_LLVM >= 0x0304
+ MAttrs.push_back(util_cpu_caps.has_sse4_2 ? "+sse4.2" : "-sse4.2");
+#else
+ MAttrs.push_back(util_cpu_caps.has_sse4_2 ? "+sse42" : "-sse42" );
+#endif
+ /*
+ * AVX feature is not automatically detected from CPUID by the X86 target
+ * yet, because the old (yet default) JIT engine is not capable of
+ * emitting the opcodes. On newer llvm versions it is and at least some
+ * versions (tested with 3.3) will emit avx opcodes without this anyway.
+ */
+ MAttrs.push_back(util_cpu_caps.has_avx ? "+avx" : "-avx");
+ MAttrs.push_back(util_cpu_caps.has_f16c ? "+f16c" : "-f16c");
+ if (HAVE_LLVM >= 0x0304) {
+ MAttrs.push_back(util_cpu_caps.has_fma ? "+fma" : "-fma");
+ } else {
/*
- * AVX feature is not automatically detected from CPUID by the X86 target
- * yet, because the old (yet default) JIT engine is not capable of
- * emitting the opcodes. On newer llvm versions it is and at least some
- * versions (tested with 3.3) will emit avx opcodes without this anyway.
+ * The old JIT in LLVM 3.3 has a bug encoding llvm.fmuladd.f32 and
+ * llvm.fmuladd.v2f32 intrinsics when FMA is available.
*/
- MAttrs.push_back("+avx");
- if (util_cpu_caps.has_f16c) {
- MAttrs.push_back("+f16c");
- }
- builder.setMAttrs(MAttrs);
+ MAttrs.push_back("-fma");
}
+ MAttrs.push_back(util_cpu_caps.has_avx2 ? "+avx2" : "-avx2");
+ /* disable avx512 and all subvariants */
+#if HAVE_LLVM >= 0x0304
+ MAttrs.push_back("-avx512cd");
+ MAttrs.push_back("-avx512er");
+ MAttrs.push_back("-avx512f");
+ MAttrs.push_back("-avx512pf");
+#endif
+#if HAVE_LLVM >= 0x0305
+ MAttrs.push_back("-avx512bw");
+ MAttrs.push_back("-avx512dq");
+ MAttrs.push_back("-avx512vl");
+#endif
+#endif
+
+#if defined(PIPE_ARCH_PPC)
+ MAttrs.push_back(util_cpu_caps.has_altivec ? "+altivec" : "-altivec");
+#if HAVE_LLVM >= 0x0304
+ /*
+ * Make sure VSX instructions are disabled
+ * See LLVM bug https://llvm.org/bugs/show_bug.cgi?id=25503#c7
+ */
+ if (util_cpu_caps.has_altivec) {
+ MAttrs.push_back("-vsx");
+ }
+#endif
+#endif
+
+ builder.setMAttrs(MAttrs);
#if HAVE_LLVM >= 0x0305
StringRef MCPU = llvm::sys::getHostCPUName();
ShaderMemoryManager *MM = NULL;
if (useMCJIT) {
-#if HAVE_LLVM > 0x0303
BaseMemoryManager* JMM = reinterpret_cast<BaseMemoryManager*>(CMM);
MM = new ShaderMemoryManager(JMM);
*OutCode = MM->getGeneratedCode();
#if HAVE_LLVM >= 0x0306
builder.setMCJITMemoryManager(std::unique_ptr<RTDyldMemoryManager>(MM));
-#else
+ MM = NULL; // ownership taken by std::unique_ptr
+#elif HAVE_LLVM > 0x0303
builder.setMCJITMemoryManager(MM);
-#endif
+#else
+ builder.setJITMemoryManager(MM);
#endif
} else {
#if HAVE_LLVM < 0x0306
ExecutionEngine *JIT;
JIT = builder.create();
+#if LLVM_USE_INTEL_JITEVENTS
+ JITEventListener *JEL = JITEventListener::createIntelJITEventListener();
+ JIT->RegisterJITEventListener(JEL);
+#endif
if (JIT) {
*OutJIT = wrap(JIT);
return 0;
{
delete reinterpret_cast<BaseMemoryManager*>(memorymgr);
}
+
+extern "C" void
+lp_add_attr_dereferenceable(LLVMValueRef val, uint64_t bytes)
+{
+#if HAVE_LLVM >= 0x0306
+ 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));
+#endif
+}
+
+extern "C" LLVMValueRef
+lp_get_called_value(LLVMValueRef call)
+{
+#if HAVE_LLVM >= 0x0309
+ return LLVMGetCalledValue(call);
+#elif HAVE_LLVM >= 0x0305
+ return llvm::wrap(llvm::CallSite(llvm::unwrap<llvm::Instruction>(call)).getCalledValue());
+#else
+ return NULL; /* radeonsi doesn't support so old LLVM. */
+#endif
+}
+
+extern "C" bool
+lp_is_function(LLVMValueRef v)
+{
+#if HAVE_LLVM >= 0x0309
+ return LLVMGetValueKind(v) == LLVMFunctionValueKind;
+#else
+ return llvm::isa<llvm::Function>(llvm::unwrap(v));
+#endif
+}
projects / mesa.git / blobdiff