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

Last change on this file since 5889 was 5889, checked in by cameron, 17 months ago

BitByteGrepKernel? initial check-in

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