*/
-#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
#include <stddef.h>
+#include <llvm/Config/llvm-config.h>
+
+#if LLVM_VERSION_MAJOR < 7
+// Workaround http://llvm.org/PR23628
+#pragma push_macro("DEBUG")
+#undef DEBUG
+#endif
+
+#include <llvm/Config/llvm-config.h>
#include <llvm-c/Core.h>
+#include <llvm-c/Support.h>
#include <llvm-c/ExecutionEngine.h>
#include <llvm/Target/TargetOptions.h>
#include <llvm/ExecutionEngine/ExecutionEngine.h>
-#if HAVE_LLVM >= 0x0301
#include <llvm/ADT/Triple.h>
-#include <llvm/ExecutionEngine/JITMemoryManager.h>
-#endif
+#include <llvm/Analysis/TargetLibraryInfo.h>
+#include <llvm/ExecutionEngine/SectionMemoryManager.h>
#include <llvm/Support/CommandLine.h>
+#include <llvm/Support/Host.h>
#include <llvm/Support/PrettyStackTrace.h>
-#if HAVE_LLVM >= 0x0300
#include <llvm/Support/TargetSelect.h>
-#else /* HAVE_LLVM < 0x0300 */
-#include <llvm/Target/TargetSelect.h>
-#endif /* HAVE_LLVM < 0x0300 */
-#if HAVE_LLVM >= 0x0303
+#if LLVM_VERSION_MAJOR < 11
+#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
+
+#if LLVM_VERSION_MAJOR < 7
+// Workaround http://llvm.org/PR23628
+#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"
#include "lp_bld_misc.h"
+#include "lp_bld_debug.h"
namespace {
public:
LLVMEnsureMultithreaded()
{
-#if HAVE_LLVM < 0x0303
- if (!llvm::llvm_is_multithreaded()) {
- llvm::llvm_start_multithreaded();
- }
-#else
if (!LLVMIsMultithreaded()) {
LLVMStartMultithreaded();
}
-#endif
}
};
}
-extern "C" void
-lp_set_target_options(void)
-{
-#if HAVE_LLVM <= 0x0300
-#if defined(DEBUG)
-#if HAVE_LLVM >= 0x0207
- llvm::JITEmitDebugInfo = true;
-#endif
-#endif
-
- /*
- * LLVM revision 123367 switched the default stack alignment to 16 bytes on
- * Linux (and several other Unices in later revisions), to match recent gcc
- * versions.
- *
- * However our drivers can be loaded by old binary applications, still
- * maintaining a 4 bytes stack alignment. Therefore we must tell LLVM here
- * to only assume a 4 bytes alignment for backwards compatibility.
- */
-#if defined(PIPE_ARCH_X86)
-#if HAVE_LLVM == 0x0300
- llvm::StackAlignmentOverride = 4;
-#else
- llvm::StackAlignment = 4;
-#endif
-#endif
-
-#if defined(DEBUG) || defined(PROFILE)
- llvm::NoFramePointerElim = true;
-#if HAVE_LLVM >= 0x0208
- llvm::NoFramePointerElimNonLeaf = true;
-#endif
-#endif
-
- llvm::NoExcessFPPrecision = false;
-
- /* XXX: Investigate this */
-#if 0
- llvm::UnsafeFPMath = true;
-#endif
-#endif /* HAVE_LLVM <= 0x0300 */
-
-#if HAVE_LLVM < 0x0209
- /*
- * LLVM will generate MMX instructions for vectors <= 64 bits, leading to
- * innefficient code, and in 32bit systems, to the corruption of the FPU
- * stack given that it expects the user to generate the EMMS instructions.
- *
- * See also:
- * - http://llvm.org/bugs/show_bug.cgi?id=3287
- * - http://l4.me.uk/post/2009/06/07/llvm-wrinkle-3-configuration-what-configuration/
- *
- * The -disable-mmx global option can be specified only once since we
- * dynamically link against LLVM it will reside in a separate shared object,
- * which may or not be delete when this shared object is, so we use the
- * llvm::DisablePrettyStackTrace variable (which we set below and should
- * reside in the same shared library) to determine whether the -disable-mmx
- * option has been set or not.
- *
- * Thankfully this ugly hack is not necessary on LLVM 2.9 onwards.
- */
- if (!llvm::DisablePrettyStackTrace) {
- static boolean first = TRUE;
- static const char* options[] = {
- "prog",
- "-disable-mmx"
- };
- assert(first);
- llvm::cl::ParseCommandLineOptions(2, const_cast<char**>(options));
- first = FALSE;
- }
-#endif
-
- /*
- * By default LLVM adds a signal handler to output a pretty stack trace.
- * This signal handler is never removed, causing problems when unloading the
- * shared object where the gallium driver resides.
- */
- llvm::DisablePrettyStackTrace = true;
+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();
-#if HAVE_LLVM >= 0x0208
llvm::InitializeNativeTargetAsmPrinter();
-#elif defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)
- LLVMInitializeX86AsmPrinter();
-#elif defined(PIPE_ARCH_ARM)
- LLVMInitializeARMAsmPrinter();
-#elif defined(PIPE_ARCH_PPC)
- LLVMInitializePowerPCAsmPrinter();
-#endif
-#if HAVE_LLVM >= 0x0207
-# if HAVE_LLVM >= 0x0301
llvm::InitializeNativeTargetDisassembler();
-# elif defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)
- LLVMInitializeX86Disassembler();
-# elif defined(PIPE_ARCH_ARM)
- LLVMInitializeARMDisassembler();
-# endif
+#if DEBUG
+ {
+ 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
-lp_func_delete_body(LLVMValueRef FF)
+lp_set_target_options(void)
{
- llvm::Function *func = llvm::unwrap<llvm::Function>(FF);
- func->deleteBody();
+ /* The llvm target registry is not thread-safe, so drivers and gallium frontends
+ * 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 gallium frontend tries
+ * to access the registry.
+ */
+ call_once(&init_native_targets_once_flag, init_native_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>(
+ new llvm::TargetLibraryInfoImpl(
+ 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<
+ llvm::TargetLibraryInfoImpl
+ *>(library_info);
}
-extern "C"
-void
-lp_set_store_alignment(LLVMValueRef Inst,
- unsigned Align)
-{
- llvm::unwrap<llvm::StoreInst>(Inst)->setAlignment(Align);
-}
+typedef llvm::RTDyldMemoryManager BaseMemoryManager;
+
+
+/*
+ * Delegating is tedious but the default manager class is hidden in an
+ * anonymous namespace in LLVM, so we cannot just derive from it to change
+ * its behavior.
+ */
+class DelegatingJITMemoryManager : public BaseMemoryManager {
+
+ protected:
+ virtual BaseMemoryManager *mgr() const = 0;
+
+ public:
+ /*
+ * From RTDyldMemoryManager
+ */
+ virtual uint8_t *allocateCodeSection(uintptr_t Size,
+ unsigned Alignment,
+ unsigned SectionID,
+ llvm::StringRef SectionName) {
+ return mgr()->allocateCodeSection(Size, Alignment, SectionID,
+ SectionName);
+ }
+ virtual uint8_t *allocateDataSection(uintptr_t Size,
+ unsigned Alignment,
+ unsigned SectionID,
+ llvm::StringRef SectionName,
+ bool IsReadOnly) {
+ return mgr()->allocateDataSection(Size, Alignment, SectionID,
+ SectionName,
+ IsReadOnly);
+ }
+ virtual void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) {
+ mgr()->registerEHFrames(Addr, LoadAddr, Size);
+ }
+#if LLVM_VERSION_MAJOR >= 5
+ virtual void deregisterEHFrames() {
+ mgr()->deregisterEHFrames();
+ }
+#else
+ 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) {
+ return mgr()->getPointerToNamedFunction(Name, AbortOnFailure);
+ }
+ virtual bool finalizeMemory(std::string *ErrMsg = 0) {
+ return mgr()->finalizeMemory(ErrMsg);
+ }
+};
+
+
+/*
+ * Delegate memory management to one shared manager for more efficient use
+ * of memory than creating a separate pool for each LLVM engine.
+ * Keep generated code until freeGeneratedCode() is called, instead of when
+ * memory manager is destroyed, which happens during engine destruction.
+ * This allows additional memory savings as we don't have to keep the engine
+ * around in order to use the code.
+ * All methods are delegated to the shared manager except destruction and
+ * deallocating code. For the latter we just remember what needs to be
+ * deallocated later. The shared manager is deleted once it is empty.
+ */
+class ShaderMemoryManager : public DelegatingJITMemoryManager {
+
+ BaseMemoryManager *TheMM;
+
+ struct GeneratedCode {
+ typedef std::vector<void *> Vec;
+ Vec FunctionBody, ExceptionTable;
+ BaseMemoryManager *TheMM;
+
+ GeneratedCode(BaseMemoryManager *MM) {
+ TheMM = MM;
+ }
+
+ ~GeneratedCode() {
+ }
+ };
+
+ GeneratedCode *code;
+
+ BaseMemoryManager *mgr() const {
+ return TheMM;
+ }
+
+ public:
+
+ ShaderMemoryManager(BaseMemoryManager* MM) {
+ TheMM = MM;
+ code = new GeneratedCode(MM);
+ }
+
+ virtual ~ShaderMemoryManager() {
+ /*
+ * 'code' is purposely not deleted. It is the user's responsibility
+ * to call getGeneratedCode() and freeGeneratedCode().
+ */
+ }
+
+ struct lp_generated_code *getGeneratedCode() {
+ return (struct lp_generated_code *) code;
+ }
+
+ static void freeGeneratedCode(struct lp_generated_code *code) {
+ delete (GeneratedCode *) code;
+ }
+
+ virtual void deallocateFunctionBody(void *Body) {
+ // remember for later deallocation
+ code->FunctionBody.push_back(Body);
+ }
+};
-#if HAVE_LLVM >= 0x301
/**
* Same as LLVMCreateJITCompilerForModule, but:
extern "C"
LLVMBool
lp_build_create_jit_compiler_for_module(LLVMExecutionEngineRef *OutJIT,
+ lp_generated_code **OutCode,
LLVMModuleRef M,
+ LLVMMCJITMemoryManagerRef CMM,
unsigned OptLevel,
- int useMCJIT,
char **OutError)
{
using namespace llvm;
std::string Error;
- EngineBuilder builder(unwrap(M));
+ EngineBuilder builder(std::unique_ptr<Module>(unwrap(M)));
/**
* LLVM 3.1+ haven't more "extern unsigned llvm::StackAlignmentOverride" and
TargetOptions options;
#if defined(PIPE_ARCH_X86)
options.StackAlignmentOverride = 4;
- options.RealignStack = true;
-#endif
-
-#if defined(DEBUG)
- options.JITEmitDebugInfo = true;
-#endif
-
-#if defined(DEBUG) || defined(PROFILE)
- options.NoFramePointerElimNonLeaf = true;
- options.NoFramePointerElim = true;
#endif
builder.setEngineKind(EngineKind::JIT)
.setTargetOptions(options)
.setOptLevel((CodeGenOpt::Level)OptLevel);
- if (useMCJIT) {
- builder.setUseMCJIT(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.
+ */
+# 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 LLVM_VERSION_MAJOR >= 4 && (defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64) || defined(PIPE_ARCH_ARM))
+ /* llvm-3.3+ implements sys::getHostCPUFeatures for Arm
+ * and llvm-3.7+ for x86, which allows us to enable/disable
+ * code generation based on the results of cpuid on these
+ * architectures.
+ */
+ 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());
+ }
+#elif 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" );
+ MAttrs.push_back(util_cpu_caps.has_sse4_1 ? "+sse4.1" : "-sse4.1");
+ MAttrs.push_back(util_cpu_caps.has_sse4_2 ? "+sse4.2" : "-sse4.2");
+ /*
+ * 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");
+ MAttrs.push_back(util_cpu_caps.has_fma ? "+fma" : "-fma");
+ MAttrs.push_back(util_cpu_caps.has_avx2 ? "+avx2" : "-avx2");
+ /* disable avx512 and all subvariants */
+ MAttrs.push_back("-avx512cd");
+ MAttrs.push_back("-avx512er");
+ MAttrs.push_back("-avx512f");
+ MAttrs.push_back("-avx512pf");
+ MAttrs.push_back("-avx512bw");
+ MAttrs.push_back("-avx512dq");
+ MAttrs.push_back("-avx512vl");
+#endif
+#if defined(PIPE_ARCH_ARM)
+ if (!util_cpu_caps.has_neon) {
+ MAttrs.push_back("-neon");
+ MAttrs.push_back("-crypto");
+ MAttrs.push_back("-vfp2");
}
+#endif
- llvm::SmallVector<std::string, 1> MAttrs;
- if (util_cpu_caps.has_avx) {
- /*
- * 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. But as we're using MCJIT here, it is safe to
- * add set this attribute.
- */
- MAttrs.push_back("+avx");
- if (util_cpu_caps.has_f16c) {
- MAttrs.push_back("+f16c");
+#if defined(PIPE_ARCH_PPC)
+ MAttrs.push_back(util_cpu_caps.has_altivec ? "+altivec" : "-altivec");
+#if (LLVM_VERSION_MAJOR < 4)
+ /*
+ * Make sure VSX instructions are disabled
+ * 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
+
+ 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");
}
- builder.setMAttrs(MAttrs);
}
- builder.setJITMemoryManager(JITMemoryManager::CreateDefaultMemManager());
- ExecutionEngine *JIT;
-#if 0
- JIT = builder.create();
-#else
+ StringRef MCPU = llvm::sys::getHostCPUName();
+ /*
+ * The cpu bits are no longer set automatically, so need to set mcpu manually.
+ * Note that the MAttrs set above will be sort of ignored (since we should
+ * not set any which would not be set by specifying the cpu anyway).
+ * It ought to be safe though since getHostCPUName() should include bits
+ * not only from the cpu but environment as well (for instance if it's safe
+ * to use avx instructions which need OS support). According to
+ * http://llvm.org/bugs/show_bug.cgi?id=19429 however if I understand this
+ * right it may be necessary to specify older cpu (or disable mattrs) though
+ * 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.
+ */
+
+#ifdef PIPE_ARCH_PPC_64
/*
- * Workaround http://llvm.org/bugs/show_bug.cgi?id=12833
+ * Large programs, e.g. gnome-shell and firefox, may tax the addressability
+ * of the Medium code model once dynamically generated JIT-compiled shader
+ * programs are linked in and relocated. Yet the default code model as of
+ * LLVM 8 is Medium or even Small.
+ * The cost of changing from Medium to Large is negligible:
+ * - an additional 8-byte pointer stored immediately before the shader entrypoint;
+ * - change an add-immediate (addis) instruction to a load (ld).
*/
- StringRef MArch = "";
- StringRef MCPU = "";
- Triple TT(unwrap(M)->getTargetTriple());
- JIT = builder.create(builder.selectTarget(TT, MArch, MCPU, MAttrs));
+ builder.setCodeModel(CodeModel::Large);
+
+#if UTIL_ARCH_LITTLE_ENDIAN
+ /*
+ * 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
+#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());
+ }
+
+ ShaderMemoryManager *MM = NULL;
+ BaseMemoryManager* JMM = reinterpret_cast<BaseMemoryManager*>(CMM);
+ MM = new ShaderMemoryManager(JMM);
+ *OutCode = MM->getGeneratedCode();
+
+ builder.setMCJITMemoryManager(std::unique_ptr<RTDyldMemoryManager>(MM));
+ MM = NULL; // ownership taken by std::unique_ptr
+
+ 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;
}
+ lp_free_generated_code(*OutCode);
+ *OutCode = 0;
+ delete MM;
*OutError = strdup(Error.c_str());
return 1;
}
-#endif /* HAVE_LLVM >= 0x301 */
+
+extern "C"
+void
+lp_free_generated_code(struct lp_generated_code *code)
+{
+ ShaderMemoryManager::freeGeneratedCode(code);
+}
+
+extern "C"
+LLVMMCJITMemoryManagerRef
+lp_get_default_memory_manager()
+{
+ BaseMemoryManager *mm;
+ mm = new llvm::SectionMemoryManager();
+ return reinterpret_cast<LLVMMCJITMemoryManagerRef>(mm);
+}
+
+extern "C"
+void
+lp_free_memory_manager(LLVMMCJITMemoryManagerRef memorymgr)
+{
+ delete reinterpret_cast<BaseMemoryManager*>(memorymgr);
+}
+
+extern "C" LLVMValueRef
+lp_get_called_value(LLVMValueRef call)
+{
+ return LLVMGetCalledValue(call);
+}
+
+extern "C" bool
+lp_is_function(LLVMValueRef v)
+{
+ return LLVMGetValueKind(v) == LLVMFunctionValueKind;
+}
projects / mesa.git / blobdiff