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

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

Mod64Advance, Mod64MatchStar, Mod64ScanThru ops; -mod64-approximate command-line option

File size: 8.3 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(PabloBuilder & parent) noexcept {
34        return std::move(PabloBuilder(PabloBlock::Create(*(parent.mPb)), parent));
35    }
36
37    inline Zeroes * createZeroes() const {
38        return mPb->createZeroes();
39    }
40
41    inline Ones * createOnes() const {
42        return mPb->createOnes();
43    }
44
45    inline Var * createVar(const std::string name) {
46        return mPb->createVar(name);
47    }
48
49    inline Var * createVar(String * const name) {
50        return mPb->createVar(name);
51    }
52
53    inline Var * createVar(PabloAST * const name) {
54        return mPb->createVar(name);
55    }
56
57    inline Call * createCall(Prototype * prototype, const std::vector<Var *> & args) {
58        return createCall(prototype, reinterpret_cast<const std::vector<PabloAST *> &>(args));
59    }
60
61    Call * createCall(Prototype * prototype, const std::vector<PabloAST *> &vars);
62
63    Assign * createAssign(const std::string && prefix, PabloAST * expr) {
64        return mPb->createAssign(std::move(prefix), expr);
65    }
66
67    inline PabloAST * createAdvance(PabloAST * expr, const Integer::Type shiftAmount) {
68        if (shiftAmount == 0) {
69            return expr;
70        }
71        return createAdvance(expr, mPb->getInteger(shiftAmount));
72    }
73
74    PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount);
75
76    inline PabloAST * createAdvance(PabloAST * expr, const Integer::Type shiftAmount, const std::string prefix) {
77        if (shiftAmount == 0) {
78            return expr;
79        }
80        return createAdvance(expr, mPb->getInteger(shiftAmount), prefix);
81    }
82
83    PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix);
84
85    inline Next * createNext(Assign * assign, PabloAST * expr) {
86        return mPb->createNext(assign, expr);
87    }
88
89    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2);
90
91    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
92
93    PabloAST * createNot(PabloAST * expr);
94
95    PabloAST * createNot(PabloAST * expr, const std::string prefix);
96
97    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2);
98
99    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
100
101    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2);
102
103    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
104
105    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass);
106
107    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass, const std::string prefix);
108
109    PabloAST * createScanThru(PabloAST * from, PabloAST * thru);
110
111    PabloAST * createScanThru(PabloAST * from, PabloAST * thru, const std::string prefix);
112
113    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr);
114
115    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const std::string prefix);
116   
117    /// Mod64 approximate function wrappers.
118   
119    PabloAST * createMod64Advance(PabloAST * expr, PabloAST * shiftAmount);
120
121    inline PabloAST * createMod64Advance(PabloAST * expr, const Integer::Type shiftAmount, const std::string prefix) {
122        if (shiftAmount == 0) {
123            return expr;
124        }
125        return createMod64Advance(expr, mPb->getInteger(shiftAmount), prefix);
126    }
127
128    PabloAST * createMod64Advance(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix);
129
130    PabloAST * createMod64MatchStar(PabloAST * marker, PabloAST * charclass);
131
132    PabloAST * createMod64MatchStar(PabloAST * marker, PabloAST * charclass, const std::string prefix);
133
134    PabloAST * createMod64ScanThru(PabloAST * from, PabloAST * thru);
135
136    PabloAST * createMod64ScanThru(PabloAST * from, PabloAST * thru, const std::string prefix);
137
138
139    /// CreateIf Wrappers
140
141    inline If * createIf(PabloAST * condition, std::initializer_list<Assign *> definedVars, PabloBlock & body) {
142        return mPb->createIf(condition, std::move(definedVars), body);
143    }
144
145    inline If * createIf(PabloAST * condition, const std::vector<Assign *> & definedVars, PabloBlock & body) {
146        return mPb->createIf(condition, definedVars, body);
147    }
148
149    inline If * createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBlock & body) {
150        return mPb->createIf(condition, std::move(definedVars), body);
151    }
152
153    inline If * createIf(PabloAST * condition, std::initializer_list<Assign *> definedVars, PabloBuilder & builder) {
154        return mPb->createIf(condition, std::move(definedVars), *builder.mPb);
155    }
156
157    inline If * createIf(PabloAST * condition, const std::vector<Assign *> & definedVars, PabloBuilder & builder) {
158        return mPb->createIf(condition, definedVars, *builder.mPb);
159    }
160
161    inline If * createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBuilder & builder) {
162        return mPb->createIf(condition, std::move(definedVars), *builder.mPb);
163    }
164
165    /// CreateWhile Wrappers
166
167    inline While * createWhile(PabloAST * condition, const std::initializer_list<Next *> nextVars, PabloBlock & body) {
168        return mPb->createWhile(condition, nextVars, body);
169    }
170
171    inline While * createWhile(PabloAST * condition, const std::vector<Next *> & nextVars, PabloBlock & body) {
172        return mPb->createWhile(condition, nextVars, body);
173    }
174
175    inline While * createWhile(PabloAST * condition, std::vector<Next *> && nextVars, PabloBlock & body) {
176        return mPb->createWhile(condition, std::move(nextVars), body);
177    }
178
179    inline While * createWhile(PabloAST * condition, const std::initializer_list<Next *> nextVars, PabloBuilder & builder) {
180        return mPb->createWhile(condition, nextVars, *builder.mPb);
181    }
182
183    inline While * createWhile(PabloAST * condition, const std::vector<Next *> & nextVars, PabloBuilder & builder) {
184        return mPb->createWhile(condition, nextVars, *builder.mPb);
185    }
186
187    inline While * createWhile(PabloAST * condition, std::vector<Next *> && nextVars, PabloBuilder & builder) {
188        return mPb->createWhile(condition, std::move(nextVars), *builder.mPb);
189    }
190
191    /// Statement Iterator Wrappers
192
193    iterator begin() {
194        return mPb->begin();
195    }
196
197    iterator end() {
198        return mPb->end();
199    }
200
201    const_iterator begin() const {
202        return mPb->cbegin();
203    }
204
205    const_iterator end() const {
206        return mPb->cend();
207    }
208
209    const_iterator cbegin() const {
210        return mPb->cbegin();
211    }
212
213    const_iterator cend() const {
214        return mPb->cend();
215    }
216
217    inline Statement * front() const {
218        return mPb->front();
219    }
220
221    inline Statement * back() const {
222        return mPb->back();
223    }
224
225    inline String * getName(const std::string name, const bool generated = true) const {
226        return mPb->getName(std::move(name), generated);
227    }
228
229    inline String * makeName(const std::string prefix, const bool generated = true) const {
230        return mPb->makeName(std::move(prefix), generated);
231    }
232
233    inline Integer * getInteger(Integer::Type value) {
234        return mPb->getInteger(value);
235    }
236
237
238    inline Statement * getInsertPoint() const {
239        return mPb->getInsertPoint();
240    }
241
242    inline PabloBlock * getPabloBlock() {
243        return mPb;
244    }
245
246    inline PabloBuilder * getParent() {
247        return mParent;
248    }
249
250    inline void record(Statement * stmt) {
251        mExprTable.findOrAdd(stmt);
252    }
253
254private:
255
256    PabloBlock *        mPb;
257    PabloBuilder *      mParent;
258    ExpressionTable     mExprTable;
259};
260
261
262}
263
264
265#endif // BUILDER_HPP
Note: See TracBrowser for help on using the repository browser.