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

Last change on this file since 5935 was 5935, checked in by cameron, 14 months ago

Direct CC builder work

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