source: icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.h @ 4661

Last change on this file since 4661 was 4661, checked in by nmedfort, 4 years ago

Start of work to make the pablo compiler reenterant. Fixed bug that prevented it from using Less optimization level.

File size: 5.5 KB
Line 
1/*
2 *  Copyright (c) 2014 International Characters.
3 *  This software is licensed to the public under the Open Software License 3.0.
4 *  icgrep is a trademark of International Characters.
5 */
6
7#ifndef PABLO_COMPILER_H
8#define PABLO_COMPILER_H
9
10//indicates that we use llvm.uadd.with.overflow.carryin for genAddWithCarry
11//#define USE_UADD_OVERFLOW
12//#define USE_LONG_INTEGER_SHIFT
13//#define USE_TWO_UADD_OVERFLOW
14
15#if defined(USE_TWO_UADD_OVERFLOW) && !defined(USE_UADD_OVERFLOW)
16static_assert(false, "Need to turn on them together.");
17#endif
18
19//Pablo Expressions
20#include <string>
21#include <list>
22#include <vector>
23#include <map>
24#include <algorithm>
25#include <unordered_map>
26#include <pablo/pe_string.h>
27#include <pablo/carry_manager.h>
28#include <llvm/ADT/Twine.h>
29#include <llvm/IR/IRBuilder.h>
30
31namespace llvm {
32    class Value;
33    class Module;
34    class ExecutionEngine;
35    class VectorType;
36    class PointerType;
37    class ConstantAggregateZero;
38    class Constant;
39    class FunctionType;
40    class Function;
41    class BasicBlock;
42}
43
44namespace pablo {
45
46using namespace llvm;
47
48class PabloAST;
49class PabloBlock;
50class PabloFunction;
51class String;
52class Var;
53class Statement;
54class StatementList;
55class If;
56class While;
57
58static IRBuilder<> LLVM_Builder(getGlobalContext());
59
60struct CompiledPabloFunction {
61    const size_t        CarryDataSize;
62    void * const        FunctionPointer;
63private:
64    Function *          mFunction;
65    ExecutionEngine *   mExecutionEngine;
66public:
67    CompiledPabloFunction(size_t carryDataSize, Function * function, ExecutionEngine * executionEngine);
68
69    inline Function * getLLVMFunction() const {
70        return mFunction;
71    }
72
73    inline ExecutionEngine * getExecutionEngine() const {
74        return mExecutionEngine;
75    }
76
77    inline CompiledPabloFunction(CompiledPabloFunction && cpf)
78    : CarryDataSize(cpf.CarryDataSize)
79    , FunctionPointer(cpf.FunctionPointer)
80    , mFunction(cpf.mFunction)
81    , mExecutionEngine(cpf.mExecutionEngine)
82    {
83        cpf.mFunction = nullptr;
84        cpf.mExecutionEngine = nullptr;
85    }
86
87    ~CompiledPabloFunction();
88
89};
90#if (BLOCK_SIZE==256)
91#define USE_UADD_OVERFLOW
92#define USE_TWO_UADD_OVERFLOW
93#endif
94
95class PabloCompiler {
96    #ifdef USE_UADD_OVERFLOW
97    struct SumWithOverflowPack {
98        Value * sum;
99        Value * obit;
100    };
101    #endif
102
103    typedef std::unordered_map<const pablo::PabloAST *, Value*>    ASTToValueMap;
104    typedef std::unordered_map<const pablo::String *, Value*>      StringToValueMap;
105    typedef std::vector<Value*>                                    CarryQueueVector;
106
107public:
108    PabloCompiler();
109    ~PabloCompiler();
110    void InstallExternalFunction(std::string C_fn_name, void * fn_ptr);
111    CompiledPabloFunction compile(pablo::PabloFunction & function);
112    Module * getModule();
113private:
114    void GenerateFunction(PabloFunction & function);
115    void DeclareFunctions(ExecutionEngine * ee);
116    void Examine(PabloBlock & blk);
117    void DeclareCallFunctions(ExecutionEngine * ee);
118    void SetOutputValue(Value * marker, const unsigned index);
119
120    void genPrintRegister(std::string regName, Value * bitblockValue);
121    void compileBlock(PabloBlock & block);
122    void compileStatement(const Statement * stmt);
123    void compileIf(const If * ifStmt);
124    void compileWhile(const While * whileStmt);
125    Value* compileExpression(const PabloAST * expr);
126    Value* genAddWithCarry(Value* e1, Value* e2, unsigned localIndex);
127    Value* genUnitAdvanceWithCarry(Value* e1, unsigned localIndex);
128    Value* genShortAdvanceWithCarry(Value* e1, unsigned localIndex, int shift_amount);
129    Value* genLongAdvanceWithCarry(Value* e1, unsigned localIndex, int shift_amount);
130    Value* genBitBlockAny(Value* test);
131    Value* genShiftHighbitToLow(unsigned FieldWidth, Value * op);
132    Value* genShiftLeft64(Value* e, const Twine & namehint = "") ;
133    Value* genNot(Value* expr);
134
135    #ifdef USE_UADD_OVERFLOW
136    #ifdef USE_TWO_UADD_OVERFLOW
137    Function* mFunctionUaddOverflow;
138    SumWithOverflowPack callUaddOverflow(Value *e1, Value *e2);
139    #else
140    Function* mFunctionUaddOverflowCarryin;
141    SumWithOverflowPack callUaddOverflow(Value *e1, Value *e2, Value *cin);
142    #endif
143    #endif
144
145
146    ASTToValueMap                       mMarkerMap;
147    CarryQueueVector                    mCarryInVector;
148    CarryQueueVector                    mCarryOutVector;
149
150#ifdef USE_LLVM_3_5
151    Module* const                       mMod;
152#else
153    std::unique_ptr<Module>             mModOwner;
154    Module *                            mMod;
155#endif
156    IRBuilder <> *                      mBuilder;
157    CarryManager *                      mCarryManager;
158
159    VectorType* const                   mBitBlockType;
160    PointerType*                        mInputPtr;
161
162    PabloBlock *                        mPabloBlock;
163   
164    Value*                              mCarryDataPtr;
165    unsigned                            mWhileDepth;
166    unsigned                            mIfDepth;
167
168    ConstantAggregateZero* const        mZeroInitializer;
169    Constant* const                     mOneInitializer;
170
171    Function *                          mFunction;
172    Value *                             mInputAddressPtr;
173    Value *                             mOutputAddressPtr;
174
175    unsigned                            mMaxWhileDepth;
176
177    std::map<std::string, void *>       mExternalMap;
178    StringToValueMap                    mCalleeMap;
179
180    Constant *                          mPrintRegisterFunction;
181};
182
183inline Module * PabloCompiler::getModule() {
184    return mMod;
185}
186
187}
188
189#endif // LLVM_GENERATOR_H
Note: See TracBrowser for help on using the repository browser.