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

Last change on this file since 4628 was 4628, checked in by cameron, 4 years ago

Use a single IRBuilder, calling SetInsertPoint? as appropriate

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 <llvm/ADT/Twine.h>
28#include <llvm/IR/IRBuilder.h>
29
30namespace llvm {
31    class Value;
32    class Module;
33    class ExecutionEngine;
34    class VectorType;
35    class PointerType;
36    class ConstantAggregateZero;
37    class Constant;
38    class FunctionType;
39    class Function;
40    class BasicBlock;
41}
42
43namespace pablo {
44
45using namespace llvm;
46
47class PabloAST;
48class PabloBlock;
49class String;
50class Var;
51class Statement;
52class StatementList;
53class If;
54class While;
55
56static IRBuilder<> LLVM_Builder(getGlobalContext());
57
58struct CompiledPabloFunction {
59    const size_t        CarryDataSize;
60    void * const        FunctionPointer;
61private:
62    Function *          mFunction;
63    ExecutionEngine *   mExecutionEngine;
64public:
65    CompiledPabloFunction(size_t carryDataSize, Function * function, ExecutionEngine * executionEngine);
66
67    inline CompiledPabloFunction(CompiledPabloFunction && cpf)
68    : CarryDataSize(cpf.CarryDataSize)
69    , FunctionPointer(cpf.FunctionPointer)
70    , mFunction(cpf.mFunction)
71    , mExecutionEngine(cpf.mExecutionEngine)
72    {
73        cpf.mFunction = nullptr;
74        cpf.mExecutionEngine = nullptr;
75    }
76
77    ~CompiledPabloFunction();
78
79};
80#if (BLOCK_SIZE==256)
81#define USE_UADD_OVERFLOW
82#define USE_TWO_UADD_OVERFLOW
83#endif
84
85class PabloCompiler {
86    #ifdef USE_UADD_OVERFLOW
87    struct SumWithOverflowPack {
88        Value * sum;
89        Value * obit;
90    };
91    #endif
92
93    typedef std::unordered_map<const pablo::PabloAST *, Value*>    ASTToValueMap;
94    typedef std::unordered_map<const pablo::String *, Value*>      StringToValueMap;
95    typedef std::vector<Value*>                                    CarryQueueVector;
96
97public:
98    PabloCompiler(const std::vector<Var *> & basisBitVars);
99    ~PabloCompiler();
100    void InstallExternalFunction(std::string C_fn_name, void * fn_ptr);
101    CompiledPabloFunction compile(PabloBlock & pb);
102private:
103    void DefineTypes();
104    void DeclareFunctions();
105    void Examine(PabloBlock & blk);
106    void DeclareCallFunctions();
107    void SetOutputValue(Value * marker, const unsigned index);
108
109    void genPrintRegister(std::string regName, Value * bitblockValue);
110    void compileBlock(const PabloBlock & blk);
111    void compileStatement(const Statement * stmt);
112    void compileIf(const If * ifStmt);
113    void compileWhile(const While * whileStmt);
114    Value* compileExpression(const PabloAST * expr);
115    Value* genCarryDataLoad(const unsigned index);
116    void   genCarryDataStore(Value* carryOut, const unsigned index);
117    Value* genAddWithCarry(Value* e1, Value* e2, unsigned localIndex, const PabloBlock * blk);
118    Value* genAdvanceWithCarry(Value* e1, int shift_amount, unsigned localIndex, const PabloBlock * blk);
119    Value* genUnitAdvanceWithCarry(Value* e1, unsigned localIndex, const PabloBlock * blk);
120    Value* genLongAdvanceWithCarry(Value* e1, int shift_amount, unsigned localIndex, const PabloBlock * blk);
121    Value* genBitBlockAny(Value* test);
122    Value* genShiftHighbitToLow(unsigned FieldWidth, Value * op);
123    Value* genShiftLeft64(Value* e, const Twine & namehint = "") ;
124    Value* genNot(Value* expr);
125
126    #ifdef USE_UADD_OVERFLOW
127    #ifdef USE_TWO_UADD_OVERFLOW
128    Function* mFunctionUaddOverflow;
129    SumWithOverflowPack callUaddOverflow(Value *e1, Value *e2);
130    #else
131    Function* mFunctionUaddOverflowCarryin;
132    SumWithOverflowPack callUaddOverflow(Value *e1, Value *e2, Value *cin);
133    #endif
134    #endif
135
136
137    ASTToValueMap                       mMarkerMap;
138    CarryQueueVector                    mCarryInVector;
139    CarryQueueVector                    mCarryOutVector;
140    std::vector<int>                    mCarryDataSummaryIdx;
141
142    const std::vector<Var *> &          mBasisBits;
143#ifdef USE_LLVM_3_5
144    Module* const                       mMod;
145#else
146    std::unique_ptr<Module>             mModOwner;
147    Module *                            mMod;
148#endif
149    IRBuilder <> *                      mBuilder;
150    ExecutionEngine*                    mExecutionEngine;
151
152    VectorType* const                   mBitBlockType;
153    PointerType*                        mBasisBitsInputPtr;
154
155    Value*                              mCarryDataPtr;
156    Value*                              mBlockNo;
157    unsigned                            mWhileDepth;
158    unsigned                            mIfDepth;
159
160    ConstantAggregateZero* const        mZeroInitializer;
161    Constant* const                     mOneInitializer;
162
163    FunctionType*                       mFunctionType;
164    Function*                           mFunction;
165
166
167    Value*                              mBasisBitsAddr;
168    Value*                              mOutputAddrPtr;
169
170    unsigned                            mMaxWhileDepth;
171
172    std::map<std::string, void *>       mExternalMap;
173    StringToValueMap                    mCalleeMap;
174
175    Constant *                          mPrintRegisterFunction;
176};
177
178}
179
180#endif // LLVM_GENERATOR_H
Note: See TracBrowser for help on using the repository browser.