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

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

Continued work on eliminating BlockNo?

File size: 8.2 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        return createScanThru(from, createNot(to));
152    }
153
154    PabloAST * createScanTo(PabloAST * from, PabloAST * to, const llvm::StringRef & prefix) {
155        return createScanThru(from, createNot(to), prefix);
156    }
157
158    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr);
159
160    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const llvm::StringRef & prefix);
161
162    PabloAST * createCount(PabloAST * expr);
163   
164    PabloAST * createCount(PabloAST * expr, const llvm::StringRef & prefix);
165
166    PabloAST * createInFile(PabloAST * expr);
167   
168    PabloAST * createInFile(PabloAST * expr, const llvm::StringRef & prefix);
169   
170    PabloAST * createAtEOF(PabloAST * expr);
171   
172    PabloAST * createAtEOF(PabloAST * expr, const llvm::StringRef & prefix);
173   
174    PabloAST * createAdd(PabloAST * expr1, PabloAST * expr2);
175
176    PabloAST * createSubtract(PabloAST * expr1, PabloAST * expr2);
177
178    PabloAST * createLessThan(PabloAST * expr1, PabloAST * expr2);
179
180    inline If * createIf(PabloAST * condition, PabloBlock * body) {
181        return mPb->createIf(condition, body);
182    }
183
184    inline If * createIf(PabloAST * condition, PabloBuilder & builder) {
185        return mPb->createIf(condition, builder.mPb);
186    }
187
188    inline While * createWhile(PabloAST * condition, PabloBlock * body) {
189        return mPb->createWhile(condition, body);
190    }
191
192    inline While * createWhile(PabloAST * condition, PabloBuilder & builder) {
193        return mPb->createWhile(condition, builder.mPb);
194    }
195
196//    llvm::Type * getStreamTy(const unsigned FieldWidth = 1) {
197//        return mPb->getStreamTy(FieldWidth);
198//    }
199   
200    llvm::Type * getStreamSetTy(const unsigned NumElements = 1, const unsigned FieldWidth = 1) {
201        return mPb->getStreamSetTy(NumElements, FieldWidth);
202    }
203   
204    /// Statement Iterator Wrappers
205
206    iterator begin() {
207        return mPb->begin();
208    }
209
210    iterator end() {
211        return mPb->end();
212    }
213
214    const_iterator begin() const {
215        return mPb->cbegin();
216    }
217
218    const_iterator end() const {
219        return mPb->cend();
220    }
221
222    const_iterator cbegin() const {
223        return mPb->cbegin();
224    }
225
226    const_iterator cend() const {
227        return mPb->cend();
228    }
229
230    inline Statement * front() const {
231        return mPb->front();
232    }
233
234    inline Statement * back() const {
235        return mPb->back();
236    }
237
238    inline Statement * getInsertPoint() const {
239        return mPb->getInsertPoint();
240    }
241
242    inline PabloBlock * getPabloBlock() const {
243        return mPb;
244    }
245
246    inline PabloBuilder * getParent() const {
247        return mParent;
248    }
249
250    inline String * makeName(const llvm::StringRef & prefix) const {
251        return mPb->makeName(prefix);
252    }
253
254    inline Integer * getInteger(const uint64_t value) const {
255        return mPb->getInteger(value);
256    }
257
258    inline void print(llvm::raw_ostream & O, const bool expandNested = true) const {
259        mPb->print(O, expandNested);
260    }
261
262protected:
263
264    explicit PabloBuilder(PabloBlock * block, PabloBuilder & parent)
265    : mPb(block), mParent(&parent), mExprTable(&(parent.mExprTable)) {
266
267    }
268
269private:
270
271    PabloBlock *        mPb;
272    PabloBuilder *      mParent;
273    ExpressionTable     mExprTable;
274};
275
276
277}
278
279
280#endif // BUILDER_HPP
Note: See TracBrowser for help on using the repository browser.