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

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

Added optional CMake command -DDISABLE_PREGENERATED_UCD_FUNCTIONS.

File size: 5.3 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#include <IDISA/idisa_builder.h>
31
32namespace llvm {
33    class Value;
34    class Module;
35    class ExecutionEngine;
36    class VectorType;
37    class PointerType;
38    class ConstantAggregateZero;
39    class Constant;
40    class FunctionType;
41    class Function;
42    class BasicBlock;
43}
44
45namespace pablo {
46
47using namespace llvm;
48
49class PabloAST;
50class PabloBlock;
51class PabloFunction;
52class String;
53class Var;
54class Statement;
55class StatementList;
56class If;
57class While;
58
59struct CompiledPabloFunction {
60    const size_t        CarryDataSize;
61    void * const        FunctionPointer;
62private:
63    Function *          mFunction;
64    ExecutionEngine *   mExecutionEngine;
65public:
66    CompiledPabloFunction(size_t carryDataSize, Function * function, ExecutionEngine * executionEngine);
67
68    inline Function * getLLVMFunction() const {
69        return mFunction;
70    }
71
72    inline ExecutionEngine * getExecutionEngine() const {
73        return mExecutionEngine;
74    }
75
76    inline CompiledPabloFunction(CompiledPabloFunction && cpf)
77    : CarryDataSize(cpf.CarryDataSize)
78    , FunctionPointer(cpf.FunctionPointer)
79    , mFunction(cpf.mFunction)
80    , mExecutionEngine(cpf.mExecutionEngine)
81    {
82        cpf.mFunction = nullptr;
83        cpf.mExecutionEngine = nullptr;
84    }
85
86    ~CompiledPabloFunction();
87
88};
89#if (BLOCK_SIZE==256)
90#define USE_UADD_OVERFLOW
91#define USE_TWO_UADD_OVERFLOW
92#endif
93
94class PabloCompiler {
95    #ifdef USE_UADD_OVERFLOW
96    struct SumWithOverflowPack {
97        Value * sum;
98        Value * obit;
99    };
100    #endif
101
102    typedef std::unordered_map<const pablo::PabloAST *, Value *>   ASTToValueMap;
103    typedef std::vector<Value*>                                    CarryQueueVector;
104
105public:
106    PabloCompiler();
107    ~PabloCompiler();
108    CompiledPabloFunction compile(pablo::PabloFunction & function);
109    std::pair<Function *, size_t> compile(pablo::PabloFunction & function, Module *module);
110    Module *getModule();
111private:
112    void GenerateFunction(PabloFunction & function);
113    void DeclareDebugFunctions();
114    void Examine(PabloFunction & function);
115    void Examine(PabloBlock & block);
116
117    void SetOutputValue(Value * marker, const unsigned index);
118
119    void genPrintRegister(std::string regName, Value * bitblockValue);
120    void compileBlock(PabloBlock & block);
121    void compileStatement(const Statement * stmt);
122    Value * genBitTest2(Value * e1, Value * e2);
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* genShiftHighbitToLow(unsigned FieldWidth, Value * op);
131    Value* genShiftLeft64(Value* e, const Twine & namehint = "") ;
132    Value* genNot(Value* expr);
133
134    #ifdef USE_UADD_OVERFLOW
135    #ifdef USE_TWO_UADD_OVERFLOW
136    Function* mFunctionUaddOverflow;
137    SumWithOverflowPack callUaddOverflow(Value *e1, Value *e2);
138    #else
139    Function* mFunctionUaddOverflowCarryin;
140    SumWithOverflowPack callUaddOverflow(Value *e1, Value *e2, Value *cin);
141    #endif
142    #endif
143
144    ASTToValueMap                       mMarkerMap;
145    CarryQueueVector                    mCarryInVector;
146    CarryQueueVector                    mCarryOutVector;
147
148
149    Module *                            mMod;
150    ExecutionEngine *                   mExecutionEngine;
151    IRBuilder <> *                      mBuilder;
152
153    CarryManager *                      mCarryManager;
154    size_t                              mCarryOffset;
155
156    VectorType* const                   mBitBlockType;
157    IDISA::IDISA_Builder                iBuilder;
158    PointerType*                        mInputType;
159
160    PabloBlock *                        mPabloBlock;
161   
162    Value*                              mCarryDataPtr;
163    unsigned                            mWhileDepth;
164    unsigned                            mIfDepth;
165
166    ConstantAggregateZero* const        mZeroInitializer;
167    Constant* const                     mOneInitializer;
168
169    Function *                          mFunction;
170    Value *                             mInputAddressPtr;
171    Value *                             mOutputAddressPtr;
172
173    unsigned                            mMaxWhileDepth;
174
175    Constant *                          mPrintRegisterFunction;
176};
177
178inline Module * PabloCompiler::getModule() {
179    return mMod;
180}
181
182}
183
184#endif // LLVM_GENERATOR_H
Note: See TracBrowser for help on using the repository browser.