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

Last change on this file since 5229 was 5229, checked in by cameron, 3 years ago

Distinguishing between StreamType? and StreamSetType?; fixing StreamSetBlock? pointer calculations

File size: 8.0 KB
Line 
1#ifndef BUILDER_HPP
2#define BUILDER_HPP
3
4#include <pablo/codegenstate.h>
5#include <pablo/expression_map.hpp>
6
7namespace pablo {
8
9class PabloBuilder {
10public:
11
12    template<typename T>
13    struct not_null {
14        inline not_null(T const value) : _value(value) { assert(_value); }
15        inline not_null(std::nullptr_t) = delete;
16        inline not_null(unsigned) = delete;
17        operator T() const { return _value; }
18        T operator-> () const { return _value; }
19        T get() const { return _value; }
20    private:
21        T const  _value;
22    };
23
24    explicit PabloBuilder(PabloBlock * block)
25    : mPb(block), mParent(nullptr), mExprTable(nullptr) {
26
27    }
28
29    PabloBuilder & operator=(PabloBuilder) = delete;
30
31    PabloBuilder & operator=(PabloBuilder &) = delete;
32
33    PabloBuilder(PabloBuilder && builder)
34    : mPb(builder.mPb)
35    , mParent(builder.mParent)
36    , mExprTable(std::move(builder.mExprTable)) {
37
38    }
39
40    PabloBuilder & operator=(PabloBuilder && builder) {
41        mPb = builder.mPb;
42        mParent = builder.mParent;
43        mExprTable = std::move(builder.mExprTable);
44        return *this;
45    }
46
47    using iterator = PabloBlock::iterator;
48
49    using const_iterator = PabloBlock::const_iterator;
50
51    inline static PabloBuilder Create(PabloBlock * block) noexcept {
52        return PabloBuilder(block);
53    }
54
55    inline static PabloBuilder Create(PabloBuilder & builder) noexcept {
56        return PabloBuilder(PabloBlock::Create(builder.getPabloBlock()), builder);
57    }
58
59    inline Zeroes * createZeroes(Type * const type = nullptr) {
60        return mPb->createZeroes(type);
61    }
62
63    inline Ones * createOnes(Type * const type = nullptr) {
64        return mPb->createOnes(type);
65    }
66
67    inline Var * createVar(const std::string name, Type * const type = nullptr) {
68        return createVar(makeName(name), type);
69    }
70
71    inline Var * createVar(const std::string name, PabloAST * value) {
72        Var * var = createVar(name, value->getType());
73        createAssign(var, value);
74        return var;
75    }
76
77    inline Var * createVar(String * const name, Type * const type = nullptr) {
78        return mPb->createVar(name, type);
79    }
80
81    Extract * createExtract(PabloAST * value, not_null<PabloAST *> index);
82
83    inline Extract * createExtract(PabloAST * value, const int64_t index) {
84        return createExtract(value, getInteger(index));
85    }
86
87    Extract * createExtract(PabloAST * value, not_null<PabloAST *> index, const std::string & prefix);
88
89    inline Extract * createExtract(PabloAST * value, const int64_t index, const std::string & prefix) {
90        return createExtract(value, getInteger(index), prefix);
91    }
92
93    inline Call * createCall(Prototype * prototype, const std::vector<Var *> & args) {
94        return createCall(prototype, reinterpret_cast<const std::vector<PabloAST *> &>(args));
95    }
96
97    Call * createCall(Prototype * prototype, const std::vector<PabloAST *> &vars);
98
99    inline PabloAST * createAdvance(PabloAST * expr, const int64_t shiftAmount) {
100        return createAdvance(expr, mPb->getInteger(shiftAmount));
101    }
102
103    PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount);
104
105    inline PabloAST * createAdvance(PabloAST * expr, const int64_t shiftAmount, const std::string & prefix) {
106        return createAdvance(expr, mPb->getInteger(shiftAmount), prefix);
107    }
108
109    PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount, const std::string & prefix);
110
111    inline PabloAST * createLookahead(PabloAST * expr, const int64_t shiftAmount) {
112        if (shiftAmount == 0) {
113            return expr;
114        }
115        return createLookahead(expr, mPb->getInteger(shiftAmount));
116    }
117
118    PabloAST * createLookahead(PabloAST * expr, PabloAST * shiftAmount);
119
120    inline PabloAST * createLookahead(PabloAST * expr, const int64_t shiftAmount, const std::string & prefix) {
121        if (shiftAmount == 0) {
122            return expr;
123        }
124        return createLookahead(expr, mPb->getInteger(shiftAmount), prefix);
125    }
126
127    PabloAST * createLookahead(PabloAST * expr, PabloAST * shiftAmount, const std::string & prefix);
128
129    PabloAST * createAssign(PabloAST * const variable, PabloAST * const value);
130
131    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2);
132
133    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2, const std::string & prefix);
134
135    PabloAST * createNot(PabloAST * expr);
136
137    PabloAST * createNot(PabloAST * expr, const std::string & prefix);
138
139    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2);
140
141    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2, const std::string & prefix);
142
143    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2);
144
145    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2, const std::string & prefix);
146
147    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass);
148
149    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass, const std::string & prefix);
150
151    PabloAST * createScanThru(PabloAST * from, PabloAST * thru);
152
153    PabloAST * createScanThru(PabloAST * from, PabloAST * thru, const std::string & prefix);
154
155    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr);
156
157    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const std::string & prefix);
158
159    PabloAST * createCount(PabloAST * expr);
160   
161    PabloAST * createCount(PabloAST * expr, const std::string & prefix);
162
163    PabloAST * createInFile(PabloAST * expr);
164   
165    PabloAST * createInFile(PabloAST * expr, const std::string & prefix);
166   
167    PabloAST * createAtEOF(PabloAST * expr);
168   
169    PabloAST * createAtEOF(PabloAST * expr, const std::string & prefix);
170   
171    PabloAST * createAdd(PabloAST * expr1, PabloAST * expr2);
172
173    PabloAST * createSubtract(PabloAST * expr1, PabloAST * expr2);
174
175    PabloAST * createLessThan(PabloAST * expr1, PabloAST * expr2);
176
177    inline If * createIf(PabloAST * condition, PabloBlock * body) {
178        return mPb->createIf(condition, body);
179    }
180
181    inline If * createIf(PabloAST * condition, PabloBuilder & builder) {
182        return mPb->createIf(condition, builder.mPb);
183    }
184
185    inline While * createWhile(PabloAST * condition, PabloBlock * body) {
186        return mPb->createWhile(condition, body);
187    }
188
189    inline While * createWhile(PabloAST * condition, PabloBuilder & builder) {
190        return mPb->createWhile(condition, builder.mPb);
191    }
192
193    Type * getStreamTy(const uint64_t FieldWidth = 1) {
194        return mPb->getStreamTy(FieldWidth);
195    }
196   
197    Type * getStreamSetTy(const uint64_t NumElements = 1, const uint64_t FieldWidth = 1) {
198        return mPb->getStreamSetTy(NumElements, FieldWidth);
199    }
200   
201    /// Statement Iterator Wrappers
202
203    iterator begin() {
204        return mPb->begin();
205    }
206
207    iterator end() {
208        return mPb->end();
209    }
210
211    const_iterator begin() const {
212        return mPb->cbegin();
213    }
214
215    const_iterator end() const {
216        return mPb->cend();
217    }
218
219    const_iterator cbegin() const {
220        return mPb->cbegin();
221    }
222
223    const_iterator cend() const {
224        return mPb->cend();
225    }
226
227    inline Statement * front() const {
228        return mPb->front();
229    }
230
231    inline Statement * back() const {
232        return mPb->back();
233    }
234
235    inline Statement * getInsertPoint() const {
236        return mPb->getInsertPoint();
237    }
238
239    inline PabloBlock * getPabloBlock() const {
240        return mPb;
241    }
242
243    inline PabloBuilder * getParent() const {
244        return mParent;
245    }
246
247    inline String * getName(const std::string & name) const {
248        return mPb->getName(name);
249    }
250
251    inline String * makeName(const std::string & prefix) const {
252        return mPb->makeName(prefix);
253    }
254
255    inline Integer * getInteger(const uint64_t value) const {
256        return mPb->getInteger(value);
257    }
258
259protected:
260
261    explicit PabloBuilder(PabloBlock * block, PabloBuilder & parent)
262    : mPb(block), mParent(&parent), mExprTable(&(parent.mExprTable)) {
263
264    }
265
266private:
267
268    PabloBlock *        mPb;
269    PabloBuilder *      mParent;
270    ExpressionTable     mExprTable;
271};
272
273
274}
275
276
277#endif // BUILDER_HPP
Note: See TracBrowser for help on using the repository browser.