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

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

Separate CarryIn? and CarryOut? data; introduce mIfDepth and mWhileDepth

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