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

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

createIndexedAdvance

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