/* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and /or associated documentation files
* (the "Materials "), to deal in the Materials without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Materials,
* and to permit persons to whom the Materials are furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Materials.
*
* THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
* THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/
#ifndef __SFCOMPILER_H
#define __SFCOMPILER_H
#include <string>
#ifndef __SFDYNAMICPIXELPIPE_H
# include "sfDynamicPixelPipe.h"
#endif
#ifndef __SFDYNAMICBLITTER_H
# include "sfDynamicBlitter.h"
#endif
#ifndef __RIPIXELPIPE_H
# include "riPixelPipe.h"
#endif
#ifndef __SFFUNCTIONCACHE_H
# include "sfFunctionCache.h"
#endif
#include "llvm/LLVMContext.h"
// \note PPCompiler class also caches a certain amount of compiled functions.
// It may make sense to move the cache into a separate container.
// LLVM forward declarations
namespace llvm {
class Type;
class Constant;
class Function;
class Module;
class ExecutionEngine;
}
namespace OpenVGRI {
// Pixel-pipeline function with constant state removed:
typedef void (*PixelPipeFunction)(const PixelPipe::PPUniforms&, PixelPipe::PPVariants&, const Span*, int);
// Image-blitting function with constant state removed:
typedef void (*BlitterFunction)(const DynamicBlitter::BlitUniforms&);
class PPCompiler
{
public:
typedef int PixelPipeHandle;
typedef int BlitterHandle;
private:
// Function that generates LLVM-constant from a pixel-pipeline:
typedef ::llvm::Constant* (*ConstantGenFunc)(const void* structure, ::llvm::LLVMContext& llvmContext, const ::llvm::Type* structType);
struct PPCompilerContext {
PPCompilerContext();
~PPCompilerContext();
// Stores persistent objects related to each component (pixelpipe or blitter).
// Note that the execution engine must be a per-process singleton for LLVM before
// version 2.7!
::llvm::Module* module;
::llvm::Function* llvmFunction;
};
struct PartialEvalFunc
{
::llvm::Function* llvmFunc;
::llvm::GlobalVariable* llvmConst;
};
public:
PPCompiler();
~PPCompiler();
static PartialEvalFunc compilePixelPipeline(::llvm::LLVMContext& llvmContext, PPCompilerContext& compilerContext, ConstantGenFunc constGenFunc, const void* state, const std::string& newFuntionName);
// These functions get an reserve a handle to a pixelpipe/blitter. MUST use release
// after done with the function.
PixelPipeHandle compilePixelPipeline(const PixelPipe::SignatureState& state);
BlitterHandle compileBlitter(const DynamicBlitter::BlitSignatureState& state);
PixelPipeFunction getPixelPipePtr(PixelPipeHandle handle);
BlitterFunction getBlitterPtr(BlitterHandle handle);
void releasePixelPipeline(PixelPipeHandle handle);
void releaseBlitter(BlitterHandle handle);
bool init();
// It seems that under VS, the static init order is not correct so the compiler has to be created
// during run-time.
static PPCompiler& getCompiler() { if(!s_compiler) { s_compiler = new PPCompiler(); } return *s_compiler; }
private:
bool initPPContext(PPCompilerContext& context, const unsigned char* data, size_t dataSize, const char* functionName);
//void* compileRenderingFunction(const void* signatureState, RenderingFunctionType type);
static ::llvm::Constant* createConstantStruct(const void* structure, size_t structureSize, ::llvm::LLVMContext& llvmContext, const ::llvm::Type* structType);
static ::llvm::Constant* createPPConstant(const void* signatureState, ::llvm::LLVMContext& llvmContext, const ::llvm::Type* structType);
static ::llvm::Constant* createBlitterConstant(const void* signatureState, ::llvm::LLVMContext& llvmContext, const ::llvm::Type* structType);
static ::llvm::Function* findFunctionWithString(::llvm::Module* module, const char* namepart);
static void llvmCheckPtrError(const void* ptr, std::string& err);
static std::string stringOfArray(const RIuint32* arr, int nElems);
private:
//::llvm::LLVMContext& getLLVMContext() { return ::llvm::getGlobalContext(); }
::llvm::LLVMContext& getLLVMContext() { return m_llvmContext; }
// The order is important atm. because llvm context must be destroyed last:
//::llvm::LLVMContext& m_llvmContext;
PPCompilerContext m_blitterContext;
PPCompilerContext m_ppContext;
::llvm::ExecutionEngine* m_executionEngine;
// \note Loading a system with LLVM already consumes a lot of memory, so
// the amount of cached functions can be grown substantially depending on
// requirements.
enum { NUM_CACHED_PIXELPIPES = 64 };
enum { NUM_CACHED_BLITTERS = NUM_CACHED_PIXELPIPES };
FunctionCache<PixelPipeHash> m_ppCache;
FunctionCache<BlitterHash> m_blitterCache;
typedef FunctionCache<PixelPipeHash>::EntryHandle PixelPipeEntryHandle;
typedef FunctionCache<BlitterHash>::EntryHandle BlitterEntryHandle;
//std::vector<CacheEntry<BlitterHash> > blitterCache;
::llvm::LLVMContext m_llvmContext;
static PPCompiler* s_compiler;
};
}
#endif