*/
-#ifndef __STDC_LIMIT_MACROS
-#define __STDC_LIMIT_MACROS
-#endif
-
-#ifndef __STDC_CONSTANT_MACROS
-#define __STDC_CONSTANT_MACROS
-#endif
-
// Undef these vars just to silence warnings
#undef PACKAGE_BUGREPORT
#undef PACKAGE_NAME
#endif
#include <llvm-c/Core.h>
+#if HAVE_LLVM >= 0x0306
+#include <llvm-c/Support.h>
+#endif
#include <llvm-c/ExecutionEngine.h>
#include <llvm/Target/TargetOptions.h>
#include <llvm/ExecutionEngine/ExecutionEngine.h>
#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")
#include "util/u_cpu_detect.h"
#include "lp_bld_misc.h"
+#include "lp_bld_debug.h"
namespace {
}
-static once_flag init_native_targets_once_flag;
+static once_flag init_native_targets_once_flag = ONCE_FLAG_INIT;
static void init_native_targets()
{
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);
+#if DEBUG && HAVE_LLVM >= 0x0306
+ {
+ char *env_llc_options = getenv("GALLIVM_LLC_OPTIONS");
+ if (env_llc_options) {
+ char *option;
+ char *options[64] = {(char *) "llc"}; // Warning without cast
+ int n;
+ for (n = 0, option = strtok(env_llc_options, " "); option; n++, option = strtok(NULL, " ")) {
+ options[n + 1] = option;
+ }
+ if (gallivm_debug & (GALLIVM_DEBUG_IR | GALLIVM_DEBUG_ASM | GALLIVM_DEBUG_DUMP_BC)) {
+ debug_printf("llc additional options (%d):\n", n);
+ for (int i = 1; i <= n; i++)
+ debug_printf("\t%s\n", options[i]);
+ debug_printf("\n");
+ }
+ LLVMParseCommandLineOptions(n + 1, options, NULL);
+ }
+ }
+#endif
}
extern "C" void
llvm::DisablePrettyStackTrace = true;
#endif
- gallivm_init_llvm_targets();
+ /* The llvm target registry is not thread-safe, so drivers and state-trackers
+ * that want to initialize targets should use the lp_set_target_options()
+ * function to safely initialize targets.
+ *
+ * LLVM targets should be initialized before the driver or state-tracker tries
+ * to access the registry.
+ */
+ call_once(&init_native_targets_once_flag, init_native_targets);
}
extern "C"
*>(library_info);
}
-extern "C"
-LLVMValueRef
-lp_build_load_volatile(LLVMBuilderRef B, LLVMValueRef PointerVal,
- const char *Name)
-{
- return llvm::wrap(llvm::unwrap(B)->CreateLoad(llvm::unwrap(PointerVal), true, Name));
-}
-
#if HAVE_LLVM < 0x0304
virtual void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) {
mgr()->registerEHFrames(Addr, LoadAddr, Size);
}
- virtual void deregisterEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) {
- mgr()->deregisterEHFrames(Addr, LoadAddr, Size);
- }
#else
virtual void registerEHFrames(llvm::StringRef SectionData) {
mgr()->registerEHFrames(SectionData);
}
+#endif
+#if HAVE_LLVM >= 0x0500
+ virtual void deregisterEHFrames() {
+ mgr()->deregisterEHFrames();
+ }
+#elif HAVE_LLVM >= 0x0304
+ virtual void deregisterEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) {
+ mgr()->deregisterEHFrames(Addr, LoadAddr, Size);
+ }
#endif
virtual void *getPointerToNamedFunction(const std::string &Name,
bool AbortOnFailure=true) {
#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, 16> MAttrs;
#if defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)
+#if HAVE_LLVM >= 0x0400
+ /* llvm-3.7+ implements sys::getHostCPUFeatures for x86,
+ * which allows us to enable/disable code generation based
+ * on the results of cpuid.
+ */
+ llvm::StringMap<bool> features;
+ llvm::sys::getHostCPUFeatures(features);
+
+ for (StringMapIterator<bool> f = features.begin();
+ f != features.end();
+ ++f) {
+ MAttrs.push_back(((*f).second ? "+" : "-") + (*f).first().str());
+ }
+#else
/*
* We need to unset attributes because sometimes LLVM mistakenly assumes
* certain features are present given the processor name.
*/
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 {
+ /*
+ * 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("-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
#endif
#if defined(PIPE_ARCH_PPC)
MAttrs.push_back(util_cpu_caps.has_altivec ? "+altivec" : "-altivec");
-#if HAVE_LLVM >= 0x0304
+#if (HAVE_LLVM >= 0x0304)
+#if (HAVE_LLVM < 0x0400)
/*
* Make sure VSX instructions are disabled
- * See LLVM bug https://llvm.org/bugs/show_bug.cgi?id=25503#c7
+ * See LLVM bugs:
+ * https://llvm.org/bugs/show_bug.cgi?id=25503#c7 (fixed in 3.8.1)
+ * https://llvm.org/bugs/show_bug.cgi?id=26775 (fixed in 3.8.1)
+ * https://llvm.org/bugs/show_bug.cgi?id=33531 (fixed in 4.0)
+ * https://llvm.org/bugs/show_bug.cgi?id=34647 (llc performance on certain unusual shader IR; intro'd in 4.0, pending as of 5.0)
*/
if (util_cpu_caps.has_altivec) {
MAttrs.push_back("-vsx");
}
+#else
+ /*
+ * Bug 25503 is fixed, by the same fix that fixed
+ * bug 26775, in versions of LLVM later than 3.8 (starting with 3.8.1).
+ * BZ 33531 actually comprises more than one bug, all of
+ * which are fixed in LLVM 4.0.
+ *
+ * With LLVM 4.0 or higher:
+ * Make sure VSX instructions are ENABLED (if supported), unless
+ * VSX instructions are explicitly enabled/disabled via GALLIVM_VSX=1 or 0.
+ */
+ if (util_cpu_caps.has_altivec) {
+ MAttrs.push_back(util_cpu_caps.has_vsx ? "+vsx" : "-vsx");
+ }
+#endif
#endif
#endif
builder.setMAttrs(MAttrs);
+ if (gallivm_debug & (GALLIVM_DEBUG_IR | GALLIVM_DEBUG_ASM | GALLIVM_DEBUG_DUMP_BC)) {
+ int n = MAttrs.size();
+ if (n > 0) {
+ debug_printf("llc -mattr option(s): ");
+ for (int i = 0; i < n; i++)
+ debug_printf("%s%s", MAttrs[i].c_str(), (i < n - 1) ? "," : "");
+ debug_printf("\n");
+ }
+ }
+
#if HAVE_LLVM >= 0x0305
StringRef MCPU = llvm::sys::getHostCPUName();
/*
* when not using MCJIT so no instructions are generated which the old JIT
* can't handle. Not entirely sure if we really need to do anything yet.
*/
+#if defined(PIPE_ARCH_LITTLE_ENDIAN) && defined(PIPE_ARCH_PPC_64)
+ /*
+ * Versions of LLVM prior to 4.0 lacked a table entry for "POWER8NVL",
+ * resulting in (big-endian) "generic" being returned on
+ * little-endian Power8NVL systems. The result was that code that
+ * attempted to load the least significant 32 bits of a 64-bit quantity
+ * from memory loaded the wrong half. This resulted in failures in some
+ * Piglit tests, e.g.
+ * .../arb_gpu_shader_fp64/execution/conversion/frag-conversion-explicit-double-uint
+ */
+ if (MCPU == "generic")
+ MCPU = "pwr8";
+#endif
builder.setMCPU(MCPU);
+ if (gallivm_debug & (GALLIVM_DEBUG_IR | GALLIVM_DEBUG_ASM | GALLIVM_DEBUG_DUMP_BC)) {
+ debug_printf("llc -mcpu option: %s\n", MCPU.str().c_str());
+ }
#endif
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));
MM = NULL; // ownership taken by std::unique_ptr
-#else
+#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" 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