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

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

Continued refactoring work. PabloKernel? now abstract base type with a 'generatePabloMethod' hook to generate Pablo code.

File size: 10.8 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; }
[5329]17namespace pablo { class AdvanceThenScanThru; }
18namespace pablo { class AdvanceThenScanTo; }
[5267]19namespace pablo { class And; }
20namespace pablo { class Assign; }
21namespace pablo { class AtEOF; }
22namespace pablo { class Branch; }
23namespace pablo { class If; }
24namespace pablo { class While; }
25namespace pablo { class Count; }
26namespace pablo { class Extract; }
27namespace pablo { class InFile; }
28namespace pablo { class LessThan; }
29namespace pablo { class Lookahead; }
30namespace pablo { class MatchStar; }
31namespace pablo { class Not; }
32namespace pablo { class Ones; }
33namespace pablo { class Or; }
34namespace pablo { class PabloKernel; }
[5368]35namespace pablo { class Phi; }
[5267]36namespace pablo { class ScanThru; }
[5329]37namespace pablo { class ScanTo; }
[5267]38namespace pablo { class Sel; }
39namespace pablo { class String; }
40namespace pablo { class Subtract; }
41namespace pablo { class Var; }
42namespace pablo { class Xor; }
43namespace pablo { class Zeroes; }
[5217]44
[4206]45namespace pablo {
46
[4432]47class PabloBlock : public PabloAST, public StatementList {
[4602]48    friend class PabloAST;
[5202]49    friend class Branch;
[4602]50    friend class PabloBuilder;
[5227]51    friend class PabloKernel;
[4227]52public:
[4206]53
[4432]54    static inline bool classof(const PabloBlock *) {
55        return true;
56    }
57    static inline bool classof(const Statement *) {
58        return false;
59    }
60    static inline bool classof(const PabloAST * e) {
61        return e->getClassTypeId() == ClassTypeId::Block;
62    }
63    static inline bool classof(const void *) {
64        return false;
65    }
66
[5267]67    static PabloBlock * Create(PabloKernel * const parent) noexcept;
[4210]68
[5202]69    Advance * createAdvance(PabloAST * expr, PabloAST * shiftAmount) {
70        return createAdvance(expr, shiftAmount, nullptr);
71    }
[4214]72
[5283]73    Advance * createAdvance(PabloAST * expr, PabloAST * shiftAmount, const llvm::StringRef & prefix) {
[5202]74        return createAdvance(expr, shiftAmount, makeName(prefix));
75    }
[4432]76
[5227]77    Advance * createAdvance(PabloAST * expr, PabloAST * shiftAmount, String * name);
[4438]78
[5202]79    Lookahead * createLookahead(PabloAST * expr, PabloAST * shiftAmount) {
80        return createLookahead(expr, shiftAmount, nullptr);
81    }
[4438]82
[5283]83    Lookahead * createLookahead(PabloAST * expr, PabloAST * shiftAmount, const llvm::StringRef & prefix) {
[5202]84        return createLookahead(expr, shiftAmount, makeName(prefix));
85    }
[4959]86
[5227]87    Lookahead * createLookahead(PabloAST * expr, PabloAST * shiftAmount, String * name);
[4959]88
[5267]89    inline Zeroes * createZeroes(llvm::Type * const type = nullptr) {
[5160]90        return mParent->getNullValue(type);
[4211]91    }
[4210]92
[5267]93    inline Ones * createOnes(llvm::Type * const type = nullptr) {
[5160]94        return mParent->getAllOnesValue(type);
[4247]95    }
96
[5202]97    Not * createNot(PabloAST * expr) {
98        return createNot(expr, nullptr);
[4432]99    }
[4254]100
[5283]101    Not * createNot(PabloAST * expr, const llvm::StringRef & prefix) {
[5202]102        return createNot(expr, makeName(prefix));
[4252]103    }
104
[5227]105    Not * createNot(PabloAST * expr, String * name);
[4252]106
[5283]107    inline Var * createVar(const llvm::StringRef & name, llvm::Type * const type = nullptr) {
[5202]108        return createVar(makeName(name), type);
109    }
[4209]110
[5267]111    inline Var * createVar(String * name, llvm::Type * const type = nullptr) {
112        return createVar(reinterpret_cast<PabloAST *>(name), type);
[5202]113    }
[4885]114
[5202]115    Count * createCount(PabloAST * expr);
[4878]116
[5283]117    Count * createCount(PabloAST * expr, const llvm::StringRef & prefix);
[4890]118
[5202]119    InFile * createInFile(PabloAST * expr) {
120        return createInFile(expr, nullptr);
121    }
[4438]122
[5283]123    InFile * createInFile(PabloAST * expr, const llvm::StringRef & prefix) {
[5202]124        return createInFile(expr, makeName(prefix));
125    }
[4927]126
[5227]127    InFile * createInFile(PabloAST * expr, String * name);
[4209]128
[5202]129    AtEOF * createAtEOF(PabloAST * expr) {
130        return createAtEOF(expr, nullptr);
131    }
[4438]132
[5283]133    AtEOF * createAtEOF(PabloAST * expr, const llvm::StringRef & prefix) {
[5202]134        return createAtEOF(expr, makeName(prefix));
135    }
[4209]136
[5227]137    AtEOF * createAtEOF(PabloAST * expr, String * name);
[4885]138
[5202]139    inline Extract * createExtract(PabloAST * array, PabloAST * index) {
140        return createExtract(array, index, nullptr);
141    }
[4927]142
[5283]143    Extract * createExtract(PabloAST * array, PabloAST * index, const llvm::StringRef & prefix) {
[5202]144        return createExtract(array, index, makeName(prefix));
145    }
[4878]146
[5267]147    Extract * createExtract(PabloAST * array, const int64_t index) {
148        return createExtract(array, getInteger(index), nullptr);
149    }
150
[5283]151    Extract * createExtract(PabloAST * array, const int64_t index, const llvm::StringRef & prefix) {
[5202]152        return createExtract(array, getInteger(index), makeName(prefix));
153    }
[4890]154
[5227]155    Extract * createExtract(PabloAST * array, PabloAST * index, String * name);
[4209]156
[5202]157    Assign * createAssign(PabloAST * const var, PabloAST * const value);
[4438]158
[5202]159    And * createAnd(PabloAST * expr1, PabloAST * expr2) {
160        return createAnd(expr1, expr2, nullptr);
161    }
[4885]162
[5283]163    And * createAnd(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix) {
[5245]164        return createAnd(expr1, expr2, makeName(prefix));
[5202]165    }
[4927]166
[5227]167    And * createAnd(PabloAST * expr1, PabloAST * expr2, String * name);
[4886]168
[5267]169    And * createAnd(llvm::Type * const type, const unsigned reserved) {
[5202]170        return createAnd(type, reserved, nullptr);
171    }
[4890]172
[5267]173    And * createAnd(llvm::Type * const type, const unsigned reserved, String * name);
[4207]174
[5202]175    Or * createOr(PabloAST * expr1, PabloAST * expr2) {
176        return createOr(expr1, expr2, nullptr);
177    }
[4438]178
[5283]179    Or * createOr(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix) {
[5202]180        return createOr(expr1, expr2, makeName(prefix));
181    }
[4209]182
[5227]183    Or * createOr(PabloAST * expr1, PabloAST * expr2, String * name);
[4438]184
[5267]185    Or * createOr(llvm::Type * const type, const unsigned reserved) {
[5202]186        return createOr(type, reserved, nullptr);
187    }
[4207]188
[5267]189    Or * createOr(llvm::Type * const type, const unsigned reserved, String * name);
[4438]190
[5202]191    Xor * createXor(PabloAST * expr1, PabloAST * expr2) {
192        return createXor(expr1, expr2, nullptr);
193    }
[4215]194
[5283]195    Xor * createXor(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix) {
[5202]196        return createXor(expr1, expr2, makeName(prefix));
197    }
[4511]198
[5227]199    Xor * createXor(PabloAST * expr1, PabloAST * expr2, String * name);
[4511]200
[5267]201    Xor * createXor(llvm::Type * const type, const unsigned reserved) {
[5202]202        return createXor(type, reserved, nullptr);
203    }
[4215]204
[5267]205    Xor * createXor(llvm::Type * const type, const unsigned reserved, String * name);
[4641]206
[5217]207    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
208        return createSel(condition, trueExpr, falseExpr, nullptr);
209    }
210
[5283]211    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const llvm::StringRef & prefix) {
[5217]212        return createSel(condition, trueExpr, falseExpr, makeName(prefix));
213    }
214
[5227]215    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, String * name);
[5217]216
[5227]217    Add * createAdd(PabloAST * expr1, PabloAST * expr2);
[5217]218
[5227]219    Subtract * createSubtract(PabloAST * expr1, PabloAST * expr2);
[5217]220
[5227]221    LessThan * createLessThan(PabloAST * expr1, PabloAST * expr2);
[5217]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
[5371]277    Phi * createPhi(llvm::Type * type);
[5368]278
[5267]279    PabloBlock * getPredecessor() const;
[5160]280
[5217]281    inline PabloKernel * getParent() const {
[4521]282        return mParent;
283    }
[5160]284
[4650]285    void insert(Statement * const statement);
286
[4870]287    void eraseFromParent(const bool recursively = false);
288
[5202]289    inline Branch * getBranch() const {
[4896]290        return mBranch;
291    }
292
[5202]293    inline void setBranch(Branch * const branch) {
294        mBranch = branch;
295    }
296
[5283]297    inline String * makeName(const llvm::StringRef & prefix) const {
[5217]298        return mParent->makeName(prefix);
[5202]299    }
300
[5217]301    inline Integer * getInteger(const int64_t value) const {
302        return mParent->getInteger(value);
[5202]303    }
304
[5267]305    void print(llvm::raw_ostream & O, const bool expandNested = true) const;
[5245]306
[5217]307    virtual ~PabloBlock() {}
[5160]308
[4404]309protected:
[4680]310
[5340]311    PabloBlock(PabloKernel * const parent, Allocator & allocator) noexcept
[5283]312    : PabloAST(PabloAST::ClassTypeId::Block, nullptr, allocator)
[5217]313    , mParent(parent)
314    , mBranch(nullptr)
[5230]315    , mAllocator(allocator) {
[4276]316
[5217]317    }
318
[4410]319    template<typename Type>
[4416]320    inline Type * insertAtInsertionPoint(Type * expr) {
[5267]321        if (llvm::isa<Statement>(expr)) {
322            insert(llvm::cast<Statement>(expr));
[4410]323        }
[4416]324        return expr;
[4410]325    }
[4692]326
[5267]327    Var * createVar(PabloAST * name, llvm::Type * const type);
[4602]328
[4258]329private:       
[5217]330    PabloKernel * const         mParent;
331    Branch *                    mBranch;
[5230]332    Allocator &                 mAllocator;
[4197]333};
334
[4206]335}
336
[3850]337#endif // PS_PABLOS_H
Note: See TracBrowser for help on using the repository browser.