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

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

Direct CC builder work

File size: 10.0 KB
RevLine 
[4432]1#ifndef BUILDER_HPP
2#define BUILDER_HPP
3
[4683]4#include <pablo/codegenstate.h>
5#include <pablo/expression_map.hpp>
[5267]6#include <pablo/pe_var.h>
[4432]7
8namespace pablo {
9
[4443]10class PabloBuilder {
[4432]11public:
12
[5202]13    template<typename T>
14    struct not_null {
[5828]15        not_null(T const value) : _value(value) { assert(_value); }
16        not_null(std::nullptr_t) = delete;
17        not_null(unsigned) = delete;
[5202]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    };
[4443]24
[4711]25    using iterator = PabloBlock::iterator;
26
27    using const_iterator = PabloBlock::const_iterator;
28
[5836]29    PabloBuilder(not_null<PabloBlock *> block)
30    : mPb(block), mParent(nullptr), mExprTable(nullptr) {
31
[4617]32    }
33
[5836]34    PabloBuilder createScope() noexcept {
[5889]35        return PabloBuilder(mPb->createScope(), this);
[4870]36    }
37
[5828]38    Zeroes * createZeroes(llvm::Type * const type = nullptr) {
[5160]39        return mPb->createZeroes(type);
[4432]40    }
41
[5828]42    Ones * createOnes(llvm::Type * const type = nullptr) {
[5160]43        return mPb->createOnes(type);
[4432]44    }
45
[5828]46    Var * createVar(const llvm::StringRef & name, llvm::Type * const type = nullptr) {
[5202]47        return createVar(makeName(name), type);
[4443]48    }
49
[5828]50    Var * createVar(const llvm::StringRef & name, PabloAST * value) {
51        Var * const var = createVar(name, value->getType());
[5202]52        createAssign(var, value);
53        return var;
[4612]54    }
[4443]55
[5828]56    Var * createVar(String * const name, llvm::Type * const type = nullptr) {
[5160]57        return mPb->createVar(name, type);
[4443]58    }
59
[5828]60    Extract * createExtract(Var * const array, not_null<Integer *> index);
[5202]61
[5828]62    Extract * createExtract(Var * const array, const int64_t index) {
63        return createExtract(array, getInteger(index));
[5202]64    }
65
[5828]66    Var * createExtract(Var * const array, not_null<Integer *> index, const llvm::StringRef & name) {
67        return createVar(name, createExtract(array, index));
68    }
[5202]69
[5828]70    Var * createExtract(Var * const array, const int64_t index, const llvm::StringRef & name) {
71        return createVar(name, createExtract(array, index));
[5202]72    }
73
[5828]74    PabloAST * createAdvance(PabloAST * expr, const int64_t shiftAmount) {
75        if (shiftAmount == 0) {
76            return expr;
77        }
[4641]78        return createAdvance(expr, mPb->getInteger(shiftAmount));
[4432]79    }
80
[5828]81    PabloAST * createAdvance(PabloAST * expr, not_null<Integer *> shiftAmount);
[4432]82
[5828]83    PabloAST * createAdvance(PabloAST * expr, const int64_t shiftAmount, const llvm::StringRef & prefix) {
84        if (shiftAmount == 0) {
85            return expr;
86        }
[4641]87        return createAdvance(expr, mPb->getInteger(shiftAmount), prefix);
[4622]88    }
89
[5828]90    PabloAST * createAdvance(PabloAST * expr, not_null<Integer *> shiftAmount, const llvm::StringRef & prefix);
[4603]91
[5828]92    PabloAST * createIndexedAdvance(PabloAST * expr, PabloAST * indexStream, const int64_t shiftAmount) {
93        if (shiftAmount == 0) {
94            return expr;
95        }
[5709]96        return createIndexedAdvance(expr, indexStream, mPb->getInteger(shiftAmount));
97    }
98   
[5828]99    PabloAST * createIndexedAdvance(PabloAST * expr, PabloAST * indexStream, not_null<Integer *> shiftAmount);
[5709]100   
[5828]101    PabloAST * createIndexedAdvance(PabloAST * expr, PabloAST * indexStream, const int64_t shiftAmount, const llvm::StringRef & prefix) {
102        if (shiftAmount == 0) {
103            return expr;
104        }
[5709]105        return createIndexedAdvance(expr, indexStream, mPb->getInteger(shiftAmount), prefix);
106    }
107   
[5828]108    PabloAST * createIndexedAdvance(PabloAST * expr, PabloAST * indexStream, not_null<Integer *> shiftAmount, const llvm::StringRef & prefix);
[5709]109   
[5828]110    PabloAST * createLookahead(PabloAST * expr, const int64_t shiftAmount) {
[4959]111        if (shiftAmount == 0) {
112            return expr;
113        }
114        return createLookahead(expr, mPb->getInteger(shiftAmount));
115    }
116
[5828]117    PabloAST * createLookahead(PabloAST * expr, not_null<Integer *> shiftAmount);
[4959]118
[5828]119    PabloAST * createLookahead(PabloAST * expr, const int64_t shiftAmount, const llvm::StringRef & prefix) {
[4959]120        if (shiftAmount == 0) {
121            return expr;
122        }
123        return createLookahead(expr, mPb->getInteger(shiftAmount), prefix);
124    }
125
[5828]126    PabloAST * createLookahead(PabloAST * expr, not_null<Integer *> shiftAmount, const llvm::StringRef & prefix);
[4959]127
[5828]128    Assign * createAssign(PabloAST * const variable, PabloAST * const value){
129        return mPb->createAssign(variable, value);
130    }
[4432]131
132    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2);
133
[5283]134    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix);
[4622]135
[4432]136    PabloAST * createNot(PabloAST * expr);
137
[5283]138    PabloAST * createNot(PabloAST * expr, const llvm::StringRef & prefix);
[4622]139
[5828]140    PabloAST * createRepeat(const int64_t fieldWidth, const int64_t value) {
[5935]141        std::stringstream name;
142        name << "repeating<" << fieldWidth << ">(" << std::hex << value << ")";
143        return createRepeat(mPb->getInteger(fieldWidth), mPb->getInteger(value), name.str());
[5828]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);
[5889]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);
[5828]173
[5889]174
[4432]175    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2);
176
[5283]177    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix);
[4622]178
[4432]179    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2);
180
[5283]181    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix);
[4622]182
[4432]183    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass);
184
[5283]185    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass, const llvm::StringRef & prefix);
[4622]186
[4432]187    PabloAST * createScanThru(PabloAST * from, PabloAST * thru);
188
[5283]189    PabloAST * createScanThru(PabloAST * from, PabloAST * thru, const llvm::StringRef & prefix);
[4622]190
[5329]191    PabloAST * createScanTo(PabloAST * from, PabloAST * to);
[5245]192
[5329]193    PabloAST * createScanTo(PabloAST * from, PabloAST * to, const llvm::StringRef & prefix);
[5245]194
[5329]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
[4432]203    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr);
204
[5283]205    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const llvm::StringRef & prefix);
[5202]206
207    PabloAST * createCount(PabloAST * expr);
[4717]208   
[5283]209    PabloAST * createCount(PabloAST * expr, const llvm::StringRef & prefix);
[5202]210
[5023]211    PabloAST * createInFile(PabloAST * expr);
212   
[5283]213    PabloAST * createInFile(PabloAST * expr, const llvm::StringRef & prefix);
[5023]214   
[5042]215    PabloAST * createAtEOF(PabloAST * expr);
216   
[5283]217    PabloAST * createAtEOF(PabloAST * expr, const llvm::StringRef & prefix);
[5042]218   
[5217]219    PabloAST * createAdd(PabloAST * expr1, PabloAST * expr2);
220
221    PabloAST * createSubtract(PabloAST * expr1, PabloAST * expr2);
222
[5227]223    PabloAST * createLessThan(PabloAST * expr1, PabloAST * expr2);
[5217]224
[5828]225    PabloAST * createEquals(PabloAST * expr1, PabloAST * expr2);
226
227    If * createIf(PabloAST * condition, PabloBlock * body) {
[5202]228        return mPb->createIf(condition, body);
[4443]229    }
[4432]230
[5828]231    If * createIf(PabloAST * condition, PabloBuilder & builder) {
[5202]232        return mPb->createIf(condition, builder.mPb);
[4622]233    }
234
[5828]235    While * createWhile(PabloAST * condition, PabloBlock * body) {
[5202]236        return mPb->createWhile(condition, body);
[4602]237    }
238
[5828]239    While * createWhile(PabloAST * condition, PabloBuilder & builder) {
[5202]240        return mPb->createWhile(condition, builder.mPb);
[4622]241    }
[5229]242   
[4711]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
[5828]269    Statement * front() const {
[4641]270        return mPb->front();
271    }
272
[5828]273    Statement * back() const {
[4641]274        return mPb->back();
275    }
276
[5828]277    Statement * getInsertPoint() const {
[5202]278        return mPb->getInsertPoint();
[4680]279    }
280
[5828]281    PabloBlock * getPabloBlock() const {
[5202]282        return mPb;
[4680]283    }
284
[5828]285    PabloBuilder * getParent() const {
[5202]286        return mParent;
[4680]287    }
288
[5828]289    String * makeName(const llvm::StringRef & prefix) const {
[5202]290        return mPb->makeName(prefix);
[4603]291    }
292
[5828]293    Integer * getInteger(const uint64_t value) const {
[5202]294        return mPb->getInteger(value);
[4617]295    }
296
[5828]297    void print(llvm::raw_ostream & O, const bool expandNested = true) const {
[5245]298        mPb->print(O, expandNested);
299    }
300
[5202]301protected:
302
[5836]303    PabloBuilder(not_null<PabloBlock *> block, not_null<PabloBuilder *> parent)
304    : mPb(block), mParent(parent), mExprTable(&(parent->mExprTable)) {
[5202]305
[4711]306    }
307
[4432]308private:
309
[5836]310    PabloBlock * const          mPb;
311    PabloBuilder * const        mParent;
312    ExpressionTable             mExprTable;
[4432]313};
314
315
316}
317
318
319#endif // BUILDER_HPP
Note: See TracBrowser for help on using the repository browser.