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

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

Merged PabloFunction? and PabloKernel? classes. Updated projects where necessary.

File size: 7.8 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 * createAdd(PabloAST * expr1, PabloAST * expr2, const std::string & prefix);
174
175    PabloAST * createSubtract(PabloAST * expr1, PabloAST * expr2);
176
177    PabloAST * createSubtract(PabloAST * expr1, PabloAST * expr2, const std::string & prefix);
178
179    inline If * createIf(PabloAST * condition, PabloBlock * body) {
180        return mPb->createIf(condition, body);
181    }
182
183    inline If * createIf(PabloAST * condition, PabloBuilder & builder) {
184        return mPb->createIf(condition, builder.mPb);
185    }
186
187    inline While * createWhile(PabloAST * condition, PabloBlock * body) {
188        return mPb->createWhile(condition, body);
189    }
190
191    inline While * createWhile(PabloAST * condition, PabloBuilder & builder) {
192        return mPb->createWhile(condition, builder.mPb);
193    }
194
195    /// Statement Iterator Wrappers
196
197    iterator begin() {
198        return mPb->begin();
199    }
200
201    iterator end() {
202        return mPb->end();
203    }
204
205    const_iterator begin() const {
206        return mPb->cbegin();
207    }
208
209    const_iterator end() const {
210        return mPb->cend();
211    }
212
213    const_iterator cbegin() const {
214        return mPb->cbegin();
215    }
216
217    const_iterator cend() const {
218        return mPb->cend();
219    }
220
221    inline Statement * front() const {
222        return mPb->front();
223    }
224
225    inline Statement * back() const {
226        return mPb->back();
227    }
228
229    inline Statement * getInsertPoint() const {
230        return mPb->getInsertPoint();
231    }
232
233    inline PabloBlock * getPabloBlock() const {
234        return mPb;
235    }
236
237    inline PabloBuilder * getParent() const {
238        return mParent;
239    }
240
241    inline String * getName(const std::string & name) const {
242        return mPb->getName(name);
243    }
244
245    inline String * makeName(const std::string & prefix) const {
246        return mPb->makeName(prefix);
247    }
248
249    inline Integer * getInteger(const uint64_t value) const {
250        return mPb->getInteger(value);
251    }
252
253protected:
254
255    explicit PabloBuilder(PabloBlock * block, PabloBuilder & parent)
256    : mPb(block), mParent(&parent), mExprTable(&(parent.mExprTable)) {
257
258    }
259
260private:
261
262    PabloBlock *        mPb;
263    PabloBuilder *      mParent;
264    ExpressionTable     mExprTable;
265};
266
267
268}
269
270
271#endif // BUILDER_HPP
Note: See TracBrowser for help on using the repository browser.