source: icGREP/icgrep-devel/icgrep/pablo/codegenstate.h @ 5828

Last change on this file since 5828 was 5828, checked in by nmedfort, 13 months ago

Pablo support for byte comparisions; LineFeed? kernel processes byte streams directly. Some clean up of PabloBuilder? functionality.

File size: 12.1 KB
RevLine 
[3850]1/*
2 *  Copyright (c) 2014 International Characters.
3 *  This software is licensed to the public under the Open Software License 3.0.
4 *  icgrep is a trademark of International Characters.
5 */
6
7#ifndef PS_PABLOS_H
8#define PS_PABLOS_H
9
[4244]10#include <pablo/pabloAST.h>
[5267]11#include <pablo/pablo_kernel.h>
[4415]12#include <pablo/pe_integer.h>
[5267]13namespace llvm { class Type; }
14namespace llvm { class raw_ostream; }
15namespace pablo { class Add; }
16namespace pablo { class Advance; }
[5709]17namespace pablo { class IndexedAdvance; }
[5329]18namespace pablo { class AdvanceThenScanThru; }
19namespace pablo { class AdvanceThenScanTo; }
[5267]20namespace pablo { class And; }
21namespace pablo { class Assign; }
22namespace pablo { class AtEOF; }
23namespace pablo { class Branch; }
24namespace pablo { class If; }
25namespace pablo { class While; }
26namespace pablo { class Count; }
27namespace pablo { class Extract; }
28namespace pablo { class InFile; }
29namespace pablo { class LessThan; }
[5828]30namespace pablo { class Equals; }
[5267]31namespace pablo { class Lookahead; }
32namespace pablo { class MatchStar; }
33namespace pablo { class Not; }
34namespace pablo { class Ones; }
35namespace pablo { class Or; }
36namespace pablo { class PabloKernel; }
[5828]37namespace pablo { class PackH; }
38namespace pablo { class PackL; }
[5267]39namespace pablo { class ScanThru; }
[5329]40namespace pablo { class ScanTo; }
[5267]41namespace pablo { class Sel; }
[5828]42namespace pablo { class Repeat; }
[5267]43namespace pablo { class String; }
44namespace pablo { class Subtract; }
45namespace pablo { class Var; }
46namespace pablo { class Xor; }
47namespace pablo { class Zeroes; }
[5217]48
[4206]49namespace pablo {
50
[4432]51class PabloBlock : public PabloAST, public StatementList {
[4602]52    friend class PabloAST;
[5202]53    friend class Branch;
[4602]54    friend class PabloBuilder;
[5227]55    friend class PabloKernel;
[4227]56public:
[4206]57
[4432]58    static inline bool classof(const PabloBlock *) {
59        return true;
60    }
61    static inline bool classof(const Statement *) {
62        return false;
63    }
64    static inline bool classof(const PabloAST * e) {
65        return e->getClassTypeId() == ClassTypeId::Block;
66    }
67    static inline bool classof(const void *) {
68        return false;
69    }
70
[5267]71    static PabloBlock * Create(PabloKernel * const parent) noexcept;
[4210]72
[5828]73    Advance * createAdvance(PabloAST * expr, Integer * shiftAmount) {
[5202]74        return createAdvance(expr, shiftAmount, nullptr);
75    }
[5709]76   
[5828]77    Advance * createAdvance(PabloAST * expr, Integer * shiftAmount, const llvm::StringRef & prefix) {
[5202]78        return createAdvance(expr, shiftAmount, makeName(prefix));
79    }
[5709]80   
[5828]81    Advance * createAdvance(PabloAST * expr, Integer * shiftAmount, String * name);
[5709]82   
[5828]83    IndexedAdvance * createIndexedAdvance(PabloAST * expr, PabloAST * indexStream, Integer * shiftAmount) {
[5709]84        return createIndexedAdvance(expr, indexStream, shiftAmount, nullptr);
85    }
86   
[5828]87    IndexedAdvance * createIndexedAdvance(PabloAST * expr, PabloAST * indexStream, Integer * shiftAmount, const llvm::StringRef & prefix) {
[5709]88        return createIndexedAdvance(expr, indexStream, shiftAmount, makeName(prefix));
89    }
90   
[5828]91    IndexedAdvance * createIndexedAdvance(PabloAST * expr, PabloAST * indexStream, Integer * shiftAmount, String * name);
[5709]92   
[5828]93    Lookahead * createLookahead(PabloAST * expr, Integer * shiftAmount) {
[5202]94        return createLookahead(expr, shiftAmount, nullptr);
95    }
[4438]96
[5828]97    Lookahead * createLookahead(PabloAST * expr, Integer * shiftAmount, const llvm::StringRef & prefix) {
[5202]98        return createLookahead(expr, shiftAmount, makeName(prefix));
99    }
[4959]100
[5828]101    Lookahead * createLookahead(PabloAST * expr, Integer * shiftAmount, String * name);
[4959]102
[5267]103    inline Zeroes * createZeroes(llvm::Type * const type = nullptr) {
[5160]104        return mParent->getNullValue(type);
[4211]105    }
[4210]106
[5267]107    inline Ones * createOnes(llvm::Type * const type = nullptr) {
[5160]108        return mParent->getAllOnesValue(type);
[4247]109    }
110
[5202]111    Not * createNot(PabloAST * expr) {
112        return createNot(expr, nullptr);
[4432]113    }
[4254]114
[5283]115    Not * createNot(PabloAST * expr, const llvm::StringRef & prefix) {
[5202]116        return createNot(expr, makeName(prefix));
[4252]117    }
118
[5227]119    Not * createNot(PabloAST * expr, String * name);
[4252]120
[5283]121    inline Var * createVar(const llvm::StringRef & name, llvm::Type * const type = nullptr) {
[5202]122        return createVar(makeName(name), type);
123    }
[4209]124
[5267]125    inline Var * createVar(String * name, llvm::Type * const type = nullptr) {
126        return createVar(reinterpret_cast<PabloAST *>(name), type);
[5202]127    }
[4885]128
[5202]129    Count * createCount(PabloAST * expr);
[4878]130
[5283]131    Count * createCount(PabloAST * expr, const llvm::StringRef & prefix);
[4890]132
[5202]133    InFile * createInFile(PabloAST * expr) {
134        return createInFile(expr, nullptr);
135    }
[4438]136
[5283]137    InFile * createInFile(PabloAST * expr, const llvm::StringRef & prefix) {
[5202]138        return createInFile(expr, makeName(prefix));
139    }
[4927]140
[5227]141    InFile * createInFile(PabloAST * expr, String * name);
[4209]142
[5202]143    AtEOF * createAtEOF(PabloAST * expr) {
144        return createAtEOF(expr, nullptr);
145    }
[4438]146
[5283]147    AtEOF * createAtEOF(PabloAST * expr, const llvm::StringRef & prefix) {
[5202]148        return createAtEOF(expr, makeName(prefix));
149    }
[4209]150
[5227]151    AtEOF * createAtEOF(PabloAST * expr, String * name);
[4885]152
[5828]153    Extract * createExtract(Var * array, Integer * index);
[4927]154
[5202]155    Assign * createAssign(PabloAST * const var, PabloAST * const value);
[4438]156
[5202]157    And * createAnd(PabloAST * expr1, PabloAST * expr2) {
158        return createAnd(expr1, expr2, nullptr);
159    }
[4885]160
[5283]161    And * createAnd(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix) {
[5245]162        return createAnd(expr1, expr2, makeName(prefix));
[5202]163    }
[4927]164
[5227]165    And * createAnd(PabloAST * expr1, PabloAST * expr2, String * name);
[4886]166
[5267]167    And * createAnd(llvm::Type * const type, const unsigned reserved) {
[5202]168        return createAnd(type, reserved, nullptr);
169    }
[4890]170
[5267]171    And * createAnd(llvm::Type * const type, const unsigned reserved, String * name);
[4207]172
[5202]173    Or * createOr(PabloAST * expr1, PabloAST * expr2) {
174        return createOr(expr1, expr2, nullptr);
175    }
[4438]176
[5283]177    Or * createOr(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix) {
[5202]178        return createOr(expr1, expr2, makeName(prefix));
179    }
[4209]180
[5227]181    Or * createOr(PabloAST * expr1, PabloAST * expr2, String * name);
[4438]182
[5267]183    Or * createOr(llvm::Type * const type, const unsigned reserved) {
[5202]184        return createOr(type, reserved, nullptr);
185    }
[4207]186
[5267]187    Or * createOr(llvm::Type * const type, const unsigned reserved, String * name);
[4438]188
[5202]189    Xor * createXor(PabloAST * expr1, PabloAST * expr2) {
190        return createXor(expr1, expr2, nullptr);
191    }
[4215]192
[5283]193    Xor * createXor(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix) {
[5202]194        return createXor(expr1, expr2, makeName(prefix));
195    }
[4511]196
[5227]197    Xor * createXor(PabloAST * expr1, PabloAST * expr2, String * name);
[4511]198
[5267]199    Xor * createXor(llvm::Type * const type, const unsigned reserved) {
[5202]200        return createXor(type, reserved, nullptr);
201    }
[4215]202
[5267]203    Xor * createXor(llvm::Type * const type, const unsigned reserved, String * name);
[4641]204
[5217]205    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
206        return createSel(condition, trueExpr, falseExpr, nullptr);
207    }
208
[5283]209    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const llvm::StringRef & prefix) {
[5217]210        return createSel(condition, trueExpr, falseExpr, makeName(prefix));
211    }
212
[5227]213    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, String * name);
[5217]214
[5227]215    Add * createAdd(PabloAST * expr1, PabloAST * expr2);
[5217]216
[5227]217    Subtract * createSubtract(PabloAST * expr1, PabloAST * expr2);
[5217]218
[5227]219    LessThan * createLessThan(PabloAST * expr1, PabloAST * expr2);
[5217]220
[5828]221    Equals * createEquals(PabloAST * expr1, PabloAST * expr2);
222
[5202]223    MatchStar * createMatchStar(PabloAST * marker, PabloAST * charclass) {
224        return createMatchStar(marker, charclass, nullptr);
225    }
[4641]226
[5283]227    MatchStar * createMatchStar(PabloAST * marker, PabloAST * charclass, const llvm::StringRef & prefix) {
[5202]228        return createMatchStar(marker, charclass, makeName(prefix));
[4276]229    }
230
[5227]231    MatchStar * createMatchStar(PabloAST * marker, PabloAST * charclass, String * name);
[5202]232
233    ScanThru * createScanThru(PabloAST * from, PabloAST * thru) {
234        return createScanThru(from, thru, nullptr);
[4210]235    }
[4416]236
[5283]237    ScanThru * createScanThru(PabloAST * from, PabloAST * thru, const llvm::StringRef & prefix) {
[5202]238        return createScanThru(from, thru, makeName(prefix));
[4410]239    }
[4416]240
[5227]241    ScanThru * createScanThru(PabloAST * from, PabloAST * thru, String * name);
[5202]242
[5329]243    ScanTo * createScanTo(PabloAST * from, PabloAST * to) {
244        return createScanTo(from, to, nullptr);
245    }
246
247    ScanTo * createScanTo(PabloAST * from, PabloAST * to, const llvm::StringRef & prefix) {
248        return createScanTo(from, to, makeName(prefix));
249    }
250
251    ScanTo * createScanTo(PabloAST * from, PabloAST * to, String * name);
252
253    AdvanceThenScanThru * createAdvanceThenScanThru(PabloAST * from, PabloAST * thru) {
254        return createAdvanceThenScanThru(from, thru, nullptr);
255    }
256
257    AdvanceThenScanThru * createAdvanceThenScanThru(PabloAST * from, PabloAST * thru, const llvm::StringRef & prefix) {
258        return createAdvanceThenScanThru(from, thru, makeName(prefix));
259    }
260
261    AdvanceThenScanThru * createAdvanceThenScanThru(PabloAST * from, PabloAST * thru, String * name);
262
263    AdvanceThenScanTo * createAdvanceThenScanTo(PabloAST * from, PabloAST * to) {
264        return createAdvanceThenScanTo(from, to, nullptr);
265    }
266
267    AdvanceThenScanTo * createAdvanceThenScanTo(PabloAST * from, PabloAST * to, const llvm::StringRef & prefix) {
268        return createAdvanceThenScanTo(from, to, makeName(prefix));
269    }
270
271    AdvanceThenScanTo * createAdvanceThenScanTo(PabloAST * from, PabloAST * to, String * name);
272
[5202]273    If * createIf(PabloAST * condition, PabloBlock * body);
274
275    While * createWhile(PabloAST * condition, PabloBlock * body);
276
[5828]277    Repeat * createRepeat(Integer * fieldWidth, PabloAST * value) {
278        return createRepeat(fieldWidth, value, nullptr);
279    }
[5368]280
[5828]281    Repeat * createRepeat(Integer * fieldWidth, PabloAST * value, const llvm::StringRef & prefix) {
282        return createRepeat(fieldWidth, value, makeName(prefix));
283    }
284
285    Repeat * createRepeat(Integer * fieldWidth, PabloAST * value, String * name);
286
287    PackH * createPackH(Integer * fieldWidth, PabloAST * value) {
288        return createPackH(fieldWidth, value, nullptr);
289    }
290
291    PackH * createPackH(Integer * width, PabloAST * value, const llvm::StringRef & prefix) {
292        return createPackH(width, value, makeName(prefix));
293    }
294
295    PackH * createPackH(Integer * fieldWidth, PabloAST * value, String * name);
296
297    PackL * createPackL(Integer * fieldWidth, PabloAST * value) {
298        return createPackL(fieldWidth, value, nullptr);
299    }
300
301    PackL * createPackL(Integer * fieldWidth, PabloAST * value, const llvm::StringRef & prefix) {
302        return createPackL(fieldWidth, value, makeName(prefix));
303    }
304
305    PackL * createPackL(Integer * fieldWidth, PabloAST * value, String * name);
306
[5267]307    PabloBlock * getPredecessor() const;
[5160]308
[5217]309    inline PabloKernel * getParent() const {
[4521]310        return mParent;
311    }
[5160]312
[4650]313    void insert(Statement * const statement);
314
[4870]315    void eraseFromParent(const bool recursively = false);
316
[5202]317    inline Branch * getBranch() const {
[4896]318        return mBranch;
319    }
320
[5202]321    inline void setBranch(Branch * const branch) {
322        mBranch = branch;
323    }
324
[5283]325    inline String * makeName(const llvm::StringRef & prefix) const {
[5217]326        return mParent->makeName(prefix);
[5202]327    }
328
[5217]329    inline Integer * getInteger(const int64_t value) const {
330        return mParent->getInteger(value);
[5202]331    }
332
[5828]333    llvm::LLVMContext & getContext() const {
334        return mParent->getContext();
335    }
336
[5267]337    void print(llvm::raw_ostream & O, const bool expandNested = true) const;
[5245]338
[5217]339    virtual ~PabloBlock() {}
[5160]340
[4404]341protected:
[4680]342
[5340]343    PabloBlock(PabloKernel * const parent, Allocator & allocator) noexcept
[5283]344    : PabloAST(PabloAST::ClassTypeId::Block, nullptr, allocator)
[5217]345    , mParent(parent)
346    , mBranch(nullptr)
[5230]347    , mAllocator(allocator) {
[4276]348
[5217]349    }
350
[4410]351    template<typename Type>
[4416]352    inline Type * insertAtInsertionPoint(Type * expr) {
[5267]353        if (llvm::isa<Statement>(expr)) {
354            insert(llvm::cast<Statement>(expr));
[4410]355        }
[4416]356        return expr;
[4410]357    }
[4692]358
[5267]359    Var * createVar(PabloAST * name, llvm::Type * const type);
[4602]360
[4258]361private:       
[5217]362    PabloKernel * const         mParent;
363    Branch *                    mBranch;
[5230]364    Allocator &                 mAllocator;
[4197]365};
366
[4206]367}
368
[3850]369#endif // PS_PABLOS_H
Note: See TracBrowser for help on using the repository browser.