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

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

Prepare for non-bitblock carry summaries; use IDISA bitblock_any

File size: 5.6 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
59static IRBuilder<> LLVM_Builder(getGlobalContext());
60
61struct CompiledPabloFunction {
62    const size_t        CarryDataSize;
63    void * const        FunctionPointer;
64private:
65    Function *          mFunction;
66    ExecutionEngine *   mExecutionEngine;
67public:
68    CompiledPabloFunction(size_t carryDataSize, Function * function, ExecutionEngine * executionEngine);
69
70    inline Function * getLLVMFunction() const {
71        return mFunction;
72    }
73
74    inline ExecutionEngine * getExecutionEngine() const {
75        return mExecutionEngine;
76    }
77
78    inline CompiledPabloFunction(CompiledPabloFunction && cpf)
79    : CarryDataSize(cpf.CarryDataSize)
80    , FunctionPointer(cpf.FunctionPointer)
81    , mFunction(cpf.mFunction)
82    , mExecutionEngine(cpf.mExecutionEngine)
83    {
84        cpf.mFunction = nullptr;
85        cpf.mExecutionEngine = nullptr;
86    }
87
88    ~CompiledPabloFunction();
89
90};
91#if (BLOCK_SIZE==256)
92#define USE_UADD_OVERFLOW
93#define USE_TWO_UADD_OVERFLOW
94#endif
95
96class PabloCompiler {
97    #ifdef USE_UADD_OVERFLOW
98    struct SumWithOverflowPack {
99        Value * sum;
100        Value * obit;
101    };
102    #endif
103
104    typedef std::unordered_map<const pablo::PabloAST *, Value*>    ASTToValueMap;
105    typedef std::unordered_map<const pablo::String *, Value*>      StringToValueMap;
106    typedef std::vector<Value*>                                    CarryQueueVector;
107
108public:
109    PabloCompiler();
110    ~PabloCompiler();
111    void InstallExternalFunction(std::string C_fn_name, void * fn_ptr);
112    CompiledPabloFunction compile(pablo::PabloFunction & function);
113    Module * getModule();
114private:
115    void GenerateFunction(PabloFunction & function);
116    void DeclareFunctions(ExecutionEngine * ee);
117    void Examine(PabloBlock & blk);
118    void DeclareCallFunctions(ExecutionEngine * ee);
119    void SetOutputValue(Value * marker, const unsigned index);
120
121    void genPrintRegister(std::string regName, Value * bitblockValue);
122    void compileBlock(PabloBlock & block);
123    void compileStatement(const Statement * stmt);
124    Value * genBitTest2(Value * e1, Value * e2);
125    void compileIf(const If * ifStmt);
126    void compileWhile(const While * whileStmt);
127    Value* compileExpression(const PabloAST * expr);
128    Value* genAddWithCarry(Value* e1, Value* e2, unsigned localIndex);
129    Value* genUnitAdvanceWithCarry(Value* e1, unsigned localIndex);
130    Value* genShortAdvanceWithCarry(Value* e1, unsigned localIndex, int shift_amount);
131    Value* genLongAdvanceWithCarry(Value* e1, unsigned localIndex, int shift_amount);
132    Value* genShiftHighbitToLow(unsigned FieldWidth, Value * op);
133    Value* genShiftLeft64(Value* e, const Twine & namehint = "") ;
134    Value* genNot(Value* expr);
135
136    #ifdef USE_UADD_OVERFLOW
137    #ifdef USE_TWO_UADD_OVERFLOW
138    Function* mFunctionUaddOverflow;
139    SumWithOverflowPack callUaddOverflow(Value *e1, Value *e2);
140    #else
141    Function* mFunctionUaddOverflowCarryin;
142    SumWithOverflowPack callUaddOverflow(Value *e1, Value *e2, Value *cin);
143    #endif
144    #endif
145
146
147    ASTToValueMap                       mMarkerMap;
148    CarryQueueVector                    mCarryInVector;
149    CarryQueueVector                    mCarryOutVector;
150
151#ifdef USE_LLVM_3_5
152    Module* const                       mMod;
153#else
154    std::unique_ptr<Module>             mModOwner;
155    Module *                            mMod;
156#endif
157    IRBuilder <> *                      mBuilder;
158
159    CarryManager *                      mCarryManager;
160
161    VectorType* const                   mBitBlockType;
162    IDISA::IDISA_Builder                iBuilder;
163    PointerType*                        mInputPtr;
164
165    PabloBlock *                        mPabloBlock;
166   
167    Value*                              mCarryDataPtr;
168    unsigned                            mWhileDepth;
169    unsigned                            mIfDepth;
170
171    ConstantAggregateZero* const        mZeroInitializer;
172    Constant* const                     mOneInitializer;
173
174    Function *                          mFunction;
175    Value *                             mInputAddressPtr;
176    Value *                             mOutputAddressPtr;
177
178    unsigned                            mMaxWhileDepth;
179
180    std::map<std::string, void *>       mExternalMap;
181    StringToValueMap                    mCalleeMap;
182
183    Constant *                          mPrintRegisterFunction;
184};
185
186inline Module * PabloCompiler::getModule() {
187    return mMod;
188}
189
190}
191
192#endif // LLVM_GENERATOR_H
Note: See TracBrowser for help on using the repository browser.