1 /* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     2  *

     3  * Permission is hereby granted, free of charge, to any person obtaining a

     4  * copy of this software and /or associated documentation files

     5  * (the "Materials "), to deal in the Materials without restriction,

     6  * including without limitation the rights to use, copy, modify, merge,

     7  * publish, distribute, sublicense, and/or sell copies of the Materials,

     8  * and to permit persons to whom the Materials are furnished to do so,

     9  * subject to the following conditions:

    10  *

    11  * The above copyright notice and this permission notice shall be included

    12  * in all copies or substantial portions of the Materials.

    13  *

    14  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    15  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    16  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

    17  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

    18  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

    19  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR

    20  * THE USE OR OTHER DEALINGS IN THE MATERIALS.

    21  */

    22 

    23 #ifndef __SFCOMPILER_H

    24 #define __SFCOMPILER_H

    25 

    26 #include <string>

    27 

    28 #ifndef __SFDYNAMICPIXELPIPE_H

    29 #   include "sfDynamicPixelPipe.h"

    30 #endif

    31 

    32 #ifndef __SFDYNAMICBLITTER_H

    33 #   include "sfDynamicBlitter.h"

    34 #endif

    35 

    36 #ifndef __RIPIXELPIPE_H

    37 #   include "riPixelPipe.h"

    38 #endif

    39 

    40 #ifndef __SFFUNCTIONCACHE_H

    41 #   include "sfFunctionCache.h"

    42 #endif

    43 

    44 #include "llvm/LLVMContext.h"

    45 

    46 // \note PPCompiler class also caches a certain amount of compiled functions.

    47 // It may make sense to move the cache into a separate container.

    48 

    49 // LLVM forward declarations

    50 namespace llvm { 

    51     class Type;

    52     class Constant;

    53     class Function;

    54     class Module;

    55     class ExecutionEngine;

    56 }

    57 

    58 namespace OpenVGRI {

    59 

    60 // Pixel-pipeline function with constant state removed:

    61 typedef void (*PixelPipeFunction)(const PixelPipe::PPUniforms&, PixelPipe::PPVariants&, const Span*, int);

    62 // Image-blitting function with constant state removed:

    63 typedef void (*BlitterFunction)(const DynamicBlitter::BlitUniforms&);

    64 

    65 class PPCompiler

    66 {

    67 public:

    68     typedef int PixelPipeHandle;

    69     typedef int BlitterHandle;

    70 private:

    71     // Function that generates LLVM-constant from a pixel-pipeline:

    72     typedef ::llvm::Constant* (*ConstantGenFunc)(const void* structure, ::llvm::LLVMContext& llvmContext, const ::llvm::Type* structType);

    73 

    74     struct PPCompilerContext {

    75         PPCompilerContext();

    76         ~PPCompilerContext();

    77         // Stores persistent objects related to each component (pixelpipe or blitter).

    78         // Note that the execution engine must be a per-process singleton for LLVM before

    79         // version 2.7!

    80         ::llvm::Module* module;

    81         ::llvm::Function* llvmFunction; 

    82     };

    83 

    84     struct PartialEvalFunc

    85     {

    86         ::llvm::Function*   llvmFunc;

    87         ::llvm::GlobalVariable*   llvmConst;

    88     };

    89 

    90 public:

    91     PPCompiler();

    92     ~PPCompiler();

    93 

    94     static PartialEvalFunc compilePixelPipeline(::llvm::LLVMContext& llvmContext, PPCompilerContext& compilerContext, ConstantGenFunc constGenFunc, const void* state, const std::string& newFuntionName);

    95 

    96     // These functions get an reserve a handle to a pixelpipe/blitter. MUST use release

    97     // after done with the function.

    98     PixelPipeHandle     compilePixelPipeline(const PixelPipe::SignatureState& state);

    99     BlitterHandle       compileBlitter(const DynamicBlitter::BlitSignatureState& state);

   100 

   101     PixelPipeFunction   getPixelPipePtr(PixelPipeHandle handle);

   102     BlitterFunction     getBlitterPtr(BlitterHandle handle);

   103 

   104     void releasePixelPipeline(PixelPipeHandle handle);

   105     void releaseBlitter(BlitterHandle handle);

   106 

   107     bool init();

   108 

   109     // It seems that under VS, the static init order is not correct so the compiler has to be created

   110     // during run-time.

   111     static PPCompiler&  getCompiler() { if(!s_compiler) { s_compiler = new PPCompiler(); } return *s_compiler; }

   112 

   113 private:

   114     bool initPPContext(PPCompilerContext& context, const unsigned char* data, size_t dataSize, const char* functionName);

   115     //void* compileRenderingFunction(const void* signatureState, RenderingFunctionType type);

   116 

   117     static ::llvm::Constant* createConstantStruct(const void* structure, size_t structureSize, ::llvm::LLVMContext& llvmContext, const ::llvm::Type* structType);

   118     static ::llvm::Constant* createPPConstant(const void* signatureState, ::llvm::LLVMContext& llvmContext, const ::llvm::Type* structType);

   119     static ::llvm::Constant* createBlitterConstant(const void* signatureState, ::llvm::LLVMContext& llvmContext, const ::llvm::Type* structType);

   120     static ::llvm::Function* findFunctionWithString(::llvm::Module* module, const char* namepart);

   121     static void llvmCheckPtrError(const void* ptr, std::string& err);

   122 

   123     static std::string stringOfArray(const RIuint32* arr, int nElems);

   124 

   125 private:

   126     //::llvm::LLVMContext& getLLVMContext() { return ::llvm::getGlobalContext(); }

   127     ::llvm::LLVMContext& getLLVMContext() { return m_llvmContext; }

   128 

   129     // The order is important atm. because llvm context must be destroyed last:

   130     //::llvm::LLVMContext& m_llvmContext;

   131     PPCompilerContext m_blitterContext;

   132     PPCompilerContext m_ppContext;

   133     ::llvm::ExecutionEngine* m_executionEngine;

   134 

   135     // \note Loading a system with LLVM already consumes a lot of memory, so

   136     // the amount of cached functions can be grown substantially depending on

   137     // requirements.

   138     enum { NUM_CACHED_PIXELPIPES = 64 };

   139     enum { NUM_CACHED_BLITTERS = NUM_CACHED_PIXELPIPES };

   140     

   141     FunctionCache<PixelPipeHash> m_ppCache;

   142     FunctionCache<BlitterHash> m_blitterCache;

   143     typedef FunctionCache<PixelPipeHash>::EntryHandle PixelPipeEntryHandle;

   144     typedef FunctionCache<BlitterHash>::EntryHandle BlitterEntryHandle;

   145     //std::vector<CacheEntry<BlitterHash> > blitterCache;

   146     

   147     ::llvm::LLVMContext m_llvmContext;

   148 

   149     static PPCompiler* s_compiler;

   150 };

   151 

   152 }

   153 

   154 

   155 #endif

   156