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

Last change on this file since 5353 was 5329, checked in by nmedfort, 2 years ago

Continued work on parenthesis matching; addition of Pablo ScanTo? and AdvanceThenScanTo/Thru? statements. Bug fix for Pablo Compiler for escaping variables.

File size: 8.4 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 * createLookahead(PabloAST * expr, const int64_t shiftAmount) {
107        if (shiftAmount == 0) {
108            return expr;
109        }
110        return createLookahead(expr, mPb->getInteger(shiftAmount));
111    }
112
113    PabloAST * createLookahead(PabloAST * expr, PabloAST * shiftAmount);
114
115    inline PabloAST * createLookahead(PabloAST * expr, const int64_t shiftAmount, const llvm::StringRef & prefix) {
116        if (shiftAmount == 0) {
117            return expr;
118        }
119        return createLookahead(expr, mPb->getInteger(shiftAmount), prefix);
120    }
121
122    PabloAST * createLookahead(PabloAST * expr, PabloAST * shiftAmount, const llvm::StringRef & prefix);
123
124    PabloAST * createAssign(PabloAST * const variable, PabloAST * const value);
125
126    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2);
127
128    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix);
129
130    PabloAST * createNot(PabloAST * expr);
131
132    PabloAST * createNot(PabloAST * expr, const llvm::StringRef & prefix);
133
134    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2);
135
136    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix);
137
138    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2);
139
140    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix);
141
142    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass);
143
144    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass, const llvm::StringRef & prefix);
145
146    PabloAST * createScanThru(PabloAST * from, PabloAST * thru);
147
148    PabloAST * createScanThru(PabloAST * from, PabloAST * thru, const llvm::StringRef & prefix);
149
150    PabloAST * createScanTo(PabloAST * from, PabloAST * to);
151
152    PabloAST * createScanTo(PabloAST * from, PabloAST * to, const llvm::StringRef & prefix);
153
154    PabloAST * createAdvanceThenScanThru(PabloAST * from, PabloAST * thru);
155
156    PabloAST * createAdvanceThenScanThru(PabloAST * from, PabloAST * thru, const llvm::StringRef & prefix);
157
158    PabloAST * createAdvanceThenScanTo(PabloAST * from, PabloAST * to);
159
160    PabloAST * createAdvanceThenScanTo(PabloAST * from, PabloAST * to, const llvm::StringRef & prefix);
161
162    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr);
163
164    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const llvm::StringRef & prefix);
165
166    PabloAST * createCount(PabloAST * expr);
167   
168    PabloAST * createCount(PabloAST * expr, const llvm::StringRef & prefix);
169
170    PabloAST * createInFile(PabloAST * expr);
171   
172    PabloAST * createInFile(PabloAST * expr, const llvm::StringRef & prefix);
173   
174    PabloAST * createAtEOF(PabloAST * expr);
175   
176    PabloAST * createAtEOF(PabloAST * expr, const llvm::StringRef & prefix);
177   
178    PabloAST * createAdd(PabloAST * expr1, PabloAST * expr2);
179
180    PabloAST * createSubtract(PabloAST * expr1, PabloAST * expr2);
181
182    PabloAST * createLessThan(PabloAST * expr1, PabloAST * expr2);
183
184    inline If * createIf(PabloAST * condition, PabloBlock * body) {
185        return mPb->createIf(condition, body);
186    }
187
188    inline If * createIf(PabloAST * condition, PabloBuilder & builder) {
189        return mPb->createIf(condition, builder.mPb);
190    }
191
192    inline While * createWhile(PabloAST * condition, PabloBlock * body) {
193        return mPb->createWhile(condition, body);
194    }
195
196    inline While * createWhile(PabloAST * condition, PabloBuilder & builder) {
197        return mPb->createWhile(condition, builder.mPb);
198    }
199
200//    llvm::Type * getStreamTy(const unsigned FieldWidth = 1) {
201//        return mPb->getStreamTy(FieldWidth);
202//    }
203   
204    llvm::Type * getStreamSetTy(const unsigned NumElements = 1, const unsigned FieldWidth = 1) {
205        return mPb->getStreamSetTy(NumElements, FieldWidth);
206    }
207   
208    /// Statement Iterator Wrappers
209
210    iterator begin() {
211        return mPb->begin();
212    }
213
214    iterator end() {
215        return mPb->end();
216    }
217
218    const_iterator begin() const {
219        return mPb->cbegin();
220    }
221
222    const_iterator end() const {
223        return mPb->cend();
224    }
225
226    const_iterator cbegin() const {
227        return mPb->cbegin();
228    }
229
230    const_iterator cend() const {
231        return mPb->cend();
232    }
233
234    inline Statement * front() const {
235        return mPb->front();
236    }
237
238    inline Statement * back() const {
239        return mPb->back();
240    }
241
242    inline Statement * getInsertPoint() const {
243        return mPb->getInsertPoint();
244    }
245
246    inline PabloBlock * getPabloBlock() const {
247        return mPb;
248    }
249
250    inline PabloBuilder * getParent() const {
251        return mParent;
252    }
253
254    inline String * makeName(const llvm::StringRef & prefix) const {
255        return mPb->makeName(prefix);
256    }
257
258    inline Integer * getInteger(const uint64_t value) const {
259        return mPb->getInteger(value);
260    }
261
262    inline void print(llvm::raw_ostream & O, const bool expandNested = true) const {
263        mPb->print(O, expandNested);
264    }
265
266protected:
267
268    explicit PabloBuilder(PabloBlock * block, PabloBuilder & parent)
269    : mPb(block), mParent(&parent), mExprTable(&(parent.mExprTable)) {
270
271    }
272
273private:
274
275    PabloBlock *        mPb;
276    PabloBuilder *      mParent;
277    ExpressionTable     mExprTable;
278};
279
280
281}
282
283
284#endif // BUILDER_HPP
Note: See TracBrowser for help on using the repository browser.