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

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

pablo.terminateAt

File size: 10.1 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 * createTerminateAt(PabloAST * strm, not_null<Integer *> code);
210   
211    PabloAST * createTerminateAt(PabloAST * strm, not_null<Integer *> code, const llvm::StringRef & prefix);
212   
213    PabloAST * createTerminateAt(PabloAST * strm, int64_t code) {
214        return createTerminateAt(strm, mPb->getInteger(code));
215    }
216   
217    PabloAST * createTerminateAt(PabloAST * strm, int64_t code, const llvm::StringRef & prefix) {
218        return createTerminateAt(strm, mPb->getInteger(code), prefix);
219    }
220   
221    PabloAST * createAdd(PabloAST * expr1, PabloAST * expr2);
222
223    PabloAST * createSubtract(PabloAST * expr1, PabloAST * expr2);
224
225    PabloAST * createLessThan(PabloAST * expr1, PabloAST * expr2);
226
227    PabloAST * createEquals(PabloAST * expr1, PabloAST * expr2);
228
229    If * createIf(PabloAST * condition, PabloBlock * body) {
230        return mPb->createIf(condition, body);
231    }
232
233    If * createIf(PabloAST * condition, PabloBuilder & builder) {
234        return mPb->createIf(condition, builder.mPb);
235    }
236
237    While * createWhile(PabloAST * condition, PabloBlock * body) {
238        return mPb->createWhile(condition, body);
239    }
240
241    While * createWhile(PabloAST * condition, PabloBuilder & builder) {
242        return mPb->createWhile(condition, builder.mPb);
243    }
244   
245    /// Statement Iterator Wrappers
246
247    iterator begin() {
248        return mPb->begin();
249    }
250
251    iterator end() {
252        return mPb->end();
253    }
254
255    const_iterator begin() const {
256        return mPb->cbegin();
257    }
258
259    const_iterator end() const {
260        return mPb->cend();
261    }
262
263    const_iterator cbegin() const {
264        return mPb->cbegin();
265    }
266
267    const_iterator cend() const {
268        return mPb->cend();
269    }
270
271    Statement * front() const {
272        return mPb->front();
273    }
274
275    Statement * back() const {
276        return mPb->back();
277    }
278
279    Statement * getInsertPoint() const {
280        return mPb->getInsertPoint();
281    }
282
283    PabloBlock * getPabloBlock() const {
284        return mPb;
285    }
286
287    PabloBuilder * getParent() const {
288        return mParent;
289    }
290
291    String * makeName(const llvm::StringRef & prefix) const {
292        return mPb->makeName(prefix);
293    }
294
295    Integer * getInteger(const uint64_t value) const {
296        return mPb->getInteger(value);
297    }
298
299    void print(llvm::raw_ostream & O, const bool expandNested = true) const {
300        mPb->print(O, expandNested);
301    }
302
303protected:
304
305    PabloBuilder(not_null<PabloBlock *> block, not_null<PabloBuilder *> parent)
306    : mPb(block), mParent(parent), mExprTable(&(parent->mExprTable)) {
307
308    }
309
310private:
311
312    PabloBlock * const          mPb;
313    PabloBuilder * const        mParent;
314    ExpressionTable             mExprTable;
315};
316
317
318}
319
320
321#endif // BUILDER_HPP
Note: See TracBrowser for help on using the repository browser.