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

Last change on this file since 6194 was 6194, checked in by cameron, 5 months ago

Canonicalize property names for lookup

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