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

Last change on this file since 6184 was 6173, checked in by nmedfort, 8 months ago

Added RE_Inspector.

Migrated RE passes to RE_Transformer.

Incorporated Memoizer functionality into RE_Transformer/Inspector.

Removed Memoizer.

Bug fix for unicode_set.

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