source: icGREP/icgrep-devel/icgrep/pablo/builder.hpp @ 4959

Last change on this file since 4959 was 4959, checked in by nmedfort, 3 years ago

Initial modifications to Pablo Compiler and Kernel Builder to support circular buffers for Lookahead.

File size: 10.2 KB
Line 
1#ifndef BUILDER_HPP
2#define BUILDER_HPP
3
4#include <pablo/codegenstate.h>
5#include <pablo/expression_map.hpp>
6
7namespace pablo {
8
9class PabloBuilder {
10public:
11
12    explicit PabloBuilder(PabloBlock * block) : mPb(block), mParent(nullptr), mExprTable(nullptr) {}
13
14    explicit PabloBuilder(PabloBlock * block, PabloBuilder & parent) : mPb(block), mParent(&parent), mExprTable(&(parent.mExprTable)) {}
15
16    PabloBuilder(PabloBuilder && builder) : mPb(builder.mPb), mParent(builder.mParent), mExprTable(std::move(builder.mExprTable)) {}
17
18    PabloBuilder & operator=(PabloBuilder) = delete;
19
20    PabloBuilder & operator=(PabloBuilder &) = delete;
21
22    PabloBuilder & operator=(PabloBuilder && builder) {
23        mPb = builder.mPb;
24        mParent = builder.mParent;
25        mExprTable = std::move(builder.mExprTable);
26        return *this;
27    }
28
29    using iterator = PabloBlock::iterator;
30
31    using const_iterator = PabloBlock::const_iterator;
32
33    inline static PabloBuilder Create(PabloBlock * block) noexcept {
34        return std::move(PabloBuilder(block));
35    }
36
37    inline static PabloBuilder Create(PabloBuilder & builder) noexcept {
38        return std::move(PabloBuilder(new PabloBlock(builder.mPb->mSymbolGenerator), builder));
39    }
40
41    static inline Zeroes * createZeroes() {
42        return PabloBlock::createZeroes();
43    }
44
45    static inline Ones * createOnes() {
46        return PabloBlock::createOnes();
47    }
48
49    inline Var * createVar(const std::string name) {
50        return mPb->createVar(name);
51    }
52
53    inline Var * createVar(String * const name) {
54        return mPb->createVar(name);
55    }
56
57    inline Var * createVar(PabloAST * const name) {
58        return mPb->createVar(name);
59    }
60
61    inline Call * createCall(Prototype * prototype, const std::vector<Var *> & args) {
62        return createCall(prototype, reinterpret_cast<const std::vector<PabloAST *> &>(args));
63    }
64
65    Call * createCall(Prototype * prototype, const std::vector<PabloAST *> &vars);
66
67    Assign * createAssign(const std::string && prefix, PabloAST * expr) {
68        return mPb->createAssign(std::move(prefix), expr);
69    }
70
71    inline PabloAST * createAdvance(PabloAST * expr, const Integer::Type shiftAmount) {
72        if (shiftAmount == 0) {
73            return expr;
74        }
75        return createAdvance(expr, mPb->getInteger(shiftAmount));
76    }
77
78    PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount);
79
80    inline PabloAST * createAdvance(PabloAST * expr, const Integer::Type shiftAmount, const std::string prefix) {
81        if (shiftAmount == 0) {
82            return expr;
83        }
84        return createAdvance(expr, mPb->getInteger(shiftAmount), prefix);
85    }
86
87    PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix);
88
89    inline PabloAST * createLookahead(PabloAST * expr, const Integer::Type shiftAmount) {
90        if (shiftAmount == 0) {
91            return expr;
92        }
93        return createLookahead(expr, mPb->getInteger(shiftAmount));
94    }
95
96    PabloAST * createLookahead(PabloAST * expr, PabloAST * shiftAmount);
97
98    inline PabloAST * createLookahead(PabloAST * expr, const Integer::Type shiftAmount, const std::string prefix) {
99        if (shiftAmount == 0) {
100            return expr;
101        }
102        return createLookahead(expr, mPb->getInteger(shiftAmount), prefix);
103    }
104
105    PabloAST * createLookahead(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix);
106
107    inline Next * createNext(Assign * assign, PabloAST * expr) {
108        return mPb->createNext(assign, expr);
109    }
110
111    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2);
112
113    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
114
115    PabloAST * createNot(PabloAST * expr);
116
117    PabloAST * createNot(PabloAST * expr, const std::string prefix);
118
119    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2);
120
121    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
122
123    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2);
124
125    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
126
127    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass);
128
129    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass, const std::string prefix);
130
131    PabloAST * createScanThru(PabloAST * from, PabloAST * thru);
132
133    PabloAST * createScanThru(PabloAST * from, PabloAST * thru, const std::string prefix);
134
135    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr);
136
137    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const std::string prefix);
138   
139    PabloAST * createCount(PabloAST * expr);
140   
141    PabloAST * createCount(PabloAST * expr, const std::string prefix);
142   
143    /// Mod64 approximate function wrappers.
144   
145    PabloAST * createMod64Advance(PabloAST * expr, PabloAST * shiftAmount);
146
147    inline PabloAST * createMod64Advance(PabloAST * expr, const Integer::Type shiftAmount) {
148        if (shiftAmount == 0) {
149            return expr;
150        }
151        return createMod64Advance(expr, mPb->getInteger(shiftAmount));
152    }
153
154    PabloAST * createMod64Advance(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix);
155
156    inline PabloAST * createMod64Advance(PabloAST * expr, const Integer::Type shiftAmount, const std::string prefix) {
157        if (shiftAmount == 0) {
158            return expr;
159        }
160        return createMod64Advance(expr, mPb->getInteger(shiftAmount), prefix);
161    }
162
163    PabloAST * createMod64Lookahead(PabloAST * expr, PabloAST * shiftAmount);
164
165    inline PabloAST * createMod64Lookahead(PabloAST * expr, const Integer::Type shiftAmount) {
166        if (shiftAmount == 0) {
167            return expr;
168        }
169        return createMod64Lookahead(expr, mPb->getInteger(shiftAmount));
170    }
171
172    PabloAST * createMod64Lookahead(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix);
173
174    inline PabloAST * createMod64Lookahead(PabloAST * expr, const Integer::Type shiftAmount, const std::string prefix) {
175        if (shiftAmount == 0) {
176            return expr;
177        }
178        return createMod64Lookahead(expr, mPb->getInteger(shiftAmount), prefix);
179    }
180
181    PabloAST * createMod64MatchStar(PabloAST * marker, PabloAST * charclass);
182
183    PabloAST * createMod64MatchStar(PabloAST * marker, PabloAST * charclass, const std::string prefix);
184
185    PabloAST * createMod64ScanThru(PabloAST * from, PabloAST * thru);
186
187    PabloAST * createMod64ScanThru(PabloAST * from, PabloAST * thru, const std::string prefix);
188
189
190    /// CreateIf Wrappers
191
192    inline If * createIf(PabloAST * condition, std::initializer_list<Assign *> definedVars, PabloBlock * body) {
193        return mPb->createIf(condition, std::move(definedVars), body);
194    }
195
196    inline If * createIf(PabloAST * condition, const std::vector<Assign *> & definedVars, PabloBlock * body) {
197        return mPb->createIf(condition, definedVars, body);
198    }
199
200    inline If * createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBlock * body) {
201        return mPb->createIf(condition, std::move(definedVars), body);
202    }
203
204    inline If * createIf(PabloAST * condition, std::initializer_list<Assign *> definedVars, PabloBuilder & builder) {
205        return mPb->createIf(condition, std::move(definedVars), builder.mPb);
206    }
207
208    inline If * createIf(PabloAST * condition, const std::vector<Assign *> & definedVars, PabloBuilder & builder) {
209        return mPb->createIf(condition, definedVars, builder.mPb);
210    }
211
212    inline If * createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBuilder & builder) {
213        return mPb->createIf(condition, std::move(definedVars), builder.mPb);
214    }
215
216    /// CreateWhile Wrappers
217
218    inline While * createWhile(PabloAST * condition, const std::initializer_list<Next *> nextVars, PabloBlock * body) {
219        return mPb->createWhile(condition, nextVars, body);
220    }
221
222    inline While * createWhile(PabloAST * condition, const std::vector<Next *> & nextVars, PabloBlock * body) {
223        return mPb->createWhile(condition, nextVars, body);
224    }
225
226    inline While * createWhile(PabloAST * condition, std::vector<Next *> && nextVars, PabloBlock * body) {
227        return mPb->createWhile(condition, std::move(nextVars), body);
228    }
229
230    inline While * createWhile(PabloAST * condition, const std::initializer_list<Next *> nextVars, PabloBuilder & builder) {
231        return mPb->createWhile(condition, std::move(nextVars), builder.mPb);
232    }
233
234    inline While * createWhile(PabloAST * condition, const std::vector<Next *> & nextVars, PabloBuilder & builder) {
235        return mPb->createWhile(condition, nextVars, builder.mPb);
236    }
237
238    inline While * createWhile(PabloAST * condition, std::vector<Next *> && nextVars, PabloBuilder & builder) {
239        return mPb->createWhile(condition, std::move(nextVars), builder.mPb);
240    }
241
242    /// Statement Iterator Wrappers
243
244    iterator begin() {
245        return mPb->begin();
246    }
247
248    iterator end() {
249        return mPb->end();
250    }
251
252    const_iterator begin() const {
253        return mPb->cbegin();
254    }
255
256    const_iterator end() const {
257        return mPb->cend();
258    }
259
260    const_iterator cbegin() const {
261        return mPb->cbegin();
262    }
263
264    const_iterator cend() const {
265        return mPb->cend();
266    }
267
268    inline Statement * front() const {
269        return mPb->front();
270    }
271
272    inline Statement * back() const {
273        return mPb->back();
274    }
275
276    inline String * getName(const std::string name, const bool generated = true) const {
277        return mPb->getName(std::move(name), generated);
278    }
279
280    inline String * makeName(const std::string prefix, const bool generated = true) const {
281        return mPb->makeName(std::move(prefix), generated);
282    }
283
284    inline Integer * getInteger(Integer::Type value) {
285        return mPb->getInteger(value);
286    }
287
288
289    inline Statement * getInsertPoint() const {
290        return mPb->getInsertPoint();
291    }
292
293    inline PabloBlock * getPabloBlock() {
294        return mPb;
295    }
296
297    inline PabloBuilder * getParent() {
298        return mParent;
299    }
300
301    inline void record(Statement * stmt) {
302        mExprTable.findOrAdd(stmt);
303    }
304
305private:
306
307    PabloBlock *        mPb;
308    PabloBuilder *      mParent;
309    ExpressionTable     mExprTable;
310};
311
312
313}
314
315
316#endif // BUILDER_HPP
Note: See TracBrowser for help on using the repository browser.