#include <llvm/Target/TargetOptions.h>
#include <llvm/ExecutionEngine/ExecutionEngine.h>
#include <llvm/ADT/Triple.h>
+#if HAVE_LLVM < 0x0306
#include <llvm/ExecutionEngine/JITMemoryManager.h>
+#else
+#include <llvm/ExecutionEngine/SectionMemoryManager.h>
+#endif
#include <llvm/Support/CommandLine.h>
+#include <llvm/Support/Host.h>
#include <llvm/Support/PrettyStackTrace.h>
#include <llvm/Support/TargetSelect.h>
-#if HAVE_LLVM >= 0x0303
#include <llvm/IR/IRBuilder.h>
#include <llvm/IR/Module.h>
#include <llvm/Support/CBindingWrapping.h>
-#endif
#include "pipe/p_config.h"
#include "util/u_debug.h"
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_store_alignment(LLVMValueRef Inst,
- unsigned Align)
+ unsigned Align)
{
llvm::unwrap<llvm::StoreInst>(Inst)->setAlignment(Align);
}
+#if HAVE_LLVM < 0x0306
+typedef llvm::JITMemoryManager BaseMemoryManager;
+#else
+typedef llvm::RTDyldMemoryManager BaseMemoryManager;
+#endif
+
+
/*
* 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 llvm::JITMemoryManager {
+class DelegatingJITMemoryManager : public BaseMemoryManager {
protected:
- virtual llvm::JITMemoryManager *mgr() const = 0;
+ virtual BaseMemoryManager *mgr() const = 0;
public:
+#if HAVE_LLVM < 0x0306
/*
* From JITMemoryManager
*/
virtual unsigned GetNumStubSlabs() {
return mgr()->GetNumStubSlabs();
}
+#endif
/*
* From RTDyldMemoryManager
return mgr()->allocateCodeSection(Size, Alignment, SectionID);
}
#endif
-#if HAVE_LLVM >= 0x0303
virtual uint8_t *allocateDataSection(uintptr_t Size,
unsigned Alignment,
unsigned SectionID,
virtual void registerEHFrames(llvm::StringRef SectionData) {
mgr()->registerEHFrames(SectionData);
}
-#endif
-#else
- virtual uint8_t *allocateDataSection(uintptr_t Size,
- unsigned Alignment,
- unsigned SectionID) {
- return mgr()->allocateDataSection(Size, Alignment, SectionID);
- }
#endif
virtual void *getPointerToNamedFunction(const std::string &Name,
bool AbortOnFailure=true) {
return mgr()->getPointerToNamedFunction(Name, AbortOnFailure);
}
-#if HAVE_LLVM == 0x0303
+#if HAVE_LLVM <= 0x0303
virtual bool applyPermissions(std::string *ErrMsg = 0) {
return mgr()->applyPermissions(ErrMsg);
}
-#elif HAVE_LLVM > 0x0303
+#else
virtual bool finalizeMemory(std::string *ErrMsg = 0) {
return mgr()->finalizeMemory(ErrMsg);
}
*/
class ShaderMemoryManager : public DelegatingJITMemoryManager {
- static llvm::JITMemoryManager *TheMM;
- static unsigned NumUsers;
+ BaseMemoryManager *TheMM;
struct GeneratedCode {
typedef std::vector<void *> Vec;
Vec FunctionBody, ExceptionTable;
+ BaseMemoryManager *TheMM;
- GeneratedCode() {
- ++NumUsers;
+ GeneratedCode(BaseMemoryManager *MM) {
+ TheMM = MM;
}
~GeneratedCode() {
* Deallocate things as previously requested and
* free shared manager when no longer used.
*/
- Vec::iterator i;
+#if HAVE_LLVM < 0x0306
+ Vec::iterator i;
- assert(TheMM);
- for ( i = FunctionBody.begin(); i != FunctionBody.end(); ++i )
- TheMM->deallocateFunctionBody(*i);
+ assert(TheMM);
+ for ( i = FunctionBody.begin(); i != FunctionBody.end(); ++i )
+ TheMM->deallocateFunctionBody(*i);
#if HAVE_LLVM < 0x0304
- for ( i = ExceptionTable.begin(); i != ExceptionTable.end(); ++i )
- TheMM->deallocateExceptionTable(*i);
-#endif
- --NumUsers;
- if (NumUsers == 0) {
- delete TheMM;
- TheMM = 0;
- }
+ for ( i = ExceptionTable.begin(); i != ExceptionTable.end(); ++i )
+ TheMM->deallocateExceptionTable(*i);
+#endif /* HAVE_LLVM < 0x0304 */
+#endif /* HAVE_LLVM < 0x0306 */
}
};
GeneratedCode *code;
- llvm::JITMemoryManager *mgr() const {
- if (!TheMM) {
- TheMM = CreateDefaultMemManager();
- }
+ BaseMemoryManager *mgr() const {
return TheMM;
}
public:
- ShaderMemoryManager() {
- code = new GeneratedCode;
+ ShaderMemoryManager(BaseMemoryManager* MM) {
+ TheMM = MM;
+ code = new GeneratedCode(MM);
}
virtual ~ShaderMemoryManager() {
}
};
-llvm::JITMemoryManager *ShaderMemoryManager::TheMM = 0;
-unsigned ShaderMemoryManager::NumUsers = 0;
-
/**
* Same as LLVMCreateJITCompilerForModule, but:
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;
+#if HAVE_LLVM >= 0x0306
+ EngineBuilder builder(std::unique_ptr<Module>(unwrap(M)));
+#else
EngineBuilder builder(unwrap(M));
+#endif
/**
* LLVM 3.1+ haven't more "extern unsigned llvm::StackAlignmentOverride" and
options.JITEmitDebugInfo = true;
#endif
-#if defined(DEBUG) || defined(PROFILE)
+ /* XXX: Workaround http://llvm.org/PR21435 */
+#if defined(DEBUG) || defined(PROFILE) || \
+ (HAVE_LLVM >= 0x0303 && (defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)))
#if HAVE_LLVM < 0x0304
options.NoFramePointerElimNonLeaf = true;
#endif
.setOptLevel((CodeGenOpt::Level)OptLevel);
if (useMCJIT) {
+#if HAVE_LLVM < 0x0306
builder.setUseMCJIT(true);
+#endif
+#ifdef _WIN32
+ /*
+ * MCJIT works on Windows, but currently only through ELF object format.
+ */
+ std::string targetTriple = llvm::sys::getProcessTriple();
+ targetTriple.append("-elf");
+ unwrap(M)->setTargetTriple(targetTriple);
+#endif
}
llvm::SmallVector<std::string, 1> MAttrs;
/*
* 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.
+ * 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("+avx");
if (util_cpu_caps.has_f16c) {
builder.setMAttrs(MAttrs);
}
- ShaderMemoryManager *MM = new ShaderMemoryManager();
- *OutCode = MM->getGeneratedCode();
+#if HAVE_LLVM >= 0x0305
+ 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.
+ */
+ builder.setMCPU(MCPU);
+#endif
+
+ ShaderMemoryManager *MM = NULL;
+ if (useMCJIT) {
+#if HAVE_LLVM > 0x0303
+ BaseMemoryManager* JMM = reinterpret_cast<BaseMemoryManager*>(CMM);
+ MM = new ShaderMemoryManager(JMM);
+ *OutCode = MM->getGeneratedCode();
- builder.setJITMemoryManager(MM);
+#if HAVE_LLVM >= 0x0306
+ builder.setMCJITMemoryManager(std::unique_ptr<RTDyldMemoryManager>(MM));
+#else
+ builder.setMCJITMemoryManager(MM);
+#endif
+#endif
+ } else {
+#if HAVE_LLVM < 0x0306
+ BaseMemoryManager* JMM = reinterpret_cast<BaseMemoryManager*>(CMM);
+ MM = new ShaderMemoryManager(JMM);
+ *OutCode = MM->getGeneratedCode();
- ExecutionEngine *JIT;
-#if 0
- JIT = builder.create();
+ builder.setJITMemoryManager(MM);
#else
- /*
- * Workaround http://llvm.org/bugs/show_bug.cgi?id=12833
- */
- StringRef MArch = "";
- StringRef MCPU = "";
- Triple TT(unwrap(M)->getTargetTriple());
- JIT = builder.create(builder.selectTarget(TT, MArch, MCPU, MAttrs));
+ assert(0);
#endif
+ }
+
+ ExecutionEngine *JIT;
+
+ JIT = builder.create();
if (JIT) {
*OutJIT = wrap(JIT);
return 0;
{
ShaderMemoryManager::freeGeneratedCode(code);
}
+
+extern "C"
+LLVMMCJITMemoryManagerRef
+lp_get_default_memory_manager()
+{
+ BaseMemoryManager *mm;
+#if HAVE_LLVM < 0x0306
+ mm = llvm::JITMemoryManager::CreateDefaultMemManager();
+#else
+ mm = new llvm::SectionMemoryManager();
+#endif
+ return reinterpret_cast<LLVMMCJITMemoryManagerRef>(mm);
+}
+
+extern "C"
+void
+lp_free_memory_manager(LLVMMCJITMemoryManagerRef memorymgr)
+{
+ delete reinterpret_cast<BaseMemoryManager*>(memorymgr);
+}