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

Last change on this file since 5829 was 5828, checked in by nmedfort, 21 months ago

Pablo support for byte comparisions; LineFeed? kernel processes byte streams directly. Some clean up of PabloBuilder? functionality.

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