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

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

Continued work on parenthesis matching; addition of Pablo ScanTo? and AdvanceThenScanTo/Thru? statements. Bug fix for Pablo Compiler for escaping variables.

File size: 11.1 KB
Line 
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
10#include <pablo/pabloAST.h>
11#include <pablo/pablo_kernel.h>
12#include <pablo/pe_integer.h>
13namespace llvm { class Type; }
14namespace llvm { class raw_ostream; }
15namespace pablo { class Add; }
16namespace pablo { class Advance; }
17namespace pablo { class AdvanceThenScanThru; }
18namespace pablo { class AdvanceThenScanTo; }
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; }
35namespace pablo { class ScanThru; }
36namespace pablo { class ScanTo; }
37namespace pablo { class Sel; }
38namespace pablo { class String; }
39namespace pablo { class Subtract; }
40namespace pablo { class Var; }
41namespace pablo { class Xor; }
42namespace pablo { class Zeroes; }
43
44
45namespace pablo {
46
47class PabloBlock : public PabloAST, public StatementList {
48    friend class PabloAST;
49    friend class Branch;
50    friend class PabloBuilder;
51    friend class PabloKernel;
52public:
53
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
67    static PabloBlock * Create(PabloKernel * const parent) noexcept;
68
69    Advance * createAdvance(PabloAST * expr, PabloAST * shiftAmount) {
70        return createAdvance(expr, shiftAmount, nullptr);
71    }
72
73    Advance * createAdvance(PabloAST * expr, PabloAST * shiftAmount, const llvm::StringRef & prefix) {
74        return createAdvance(expr, shiftAmount, makeName(prefix));
75    }
76
77    Advance * createAdvance(PabloAST * expr, PabloAST * shiftAmount, String * name);
78
79    Lookahead * createLookahead(PabloAST * expr, PabloAST * shiftAmount) {
80        return createLookahead(expr, shiftAmount, nullptr);
81    }
82
83    Lookahead * createLookahead(PabloAST * expr, PabloAST * shiftAmount, const llvm::StringRef & prefix) {
84        return createLookahead(expr, shiftAmount, makeName(prefix));
85    }
86
87    Lookahead * createLookahead(PabloAST * expr, PabloAST * shiftAmount, String * name);
88
89    inline Zeroes * createZeroes(llvm::Type * const type = nullptr) {
90        return mParent->getNullValue(type);
91    }
92
93    inline Ones * createOnes(llvm::Type * const type = nullptr) {
94        return mParent->getAllOnesValue(type);
95    }
96
97    Not * createNot(PabloAST * expr) {
98        return createNot(expr, nullptr);
99    }
100
101    Not * createNot(PabloAST * expr, const llvm::StringRef & prefix) {
102        return createNot(expr, makeName(prefix));
103    }
104
105    Not * createNot(PabloAST * expr, String * name);
106
107    inline Var * createVar(const llvm::StringRef & name, llvm::Type * const type = nullptr) {
108        return createVar(makeName(name), type);
109    }
110
111    inline Var * createVar(String * name, llvm::Type * const type = nullptr) {
112        return createVar(reinterpret_cast<PabloAST *>(name), type);
113    }
114
115    Count * createCount(PabloAST * expr);
116
117    Count * createCount(PabloAST * expr, const llvm::StringRef & prefix);
118
119    InFile * createInFile(PabloAST * expr) {
120        return createInFile(expr, nullptr);
121    }
122
123    InFile * createInFile(PabloAST * expr, const llvm::StringRef & prefix) {
124        return createInFile(expr, makeName(prefix));
125    }
126
127    InFile * createInFile(PabloAST * expr, String * name);
128
129    AtEOF * createAtEOF(PabloAST * expr) {
130        return createAtEOF(expr, nullptr);
131    }
132
133    AtEOF * createAtEOF(PabloAST * expr, const llvm::StringRef & prefix) {
134        return createAtEOF(expr, makeName(prefix));
135    }
136
137    AtEOF * createAtEOF(PabloAST * expr, String * name);
138
139    inline Extract * createExtract(PabloAST * array, PabloAST * index) {
140        return createExtract(array, index, nullptr);
141    }
142
143    Extract * createExtract(PabloAST * array, PabloAST * index, const llvm::StringRef & prefix) {
144        return createExtract(array, index, makeName(prefix));
145    }
146
147    Extract * createExtract(PabloAST * array, const int64_t index) {
148        return createExtract(array, getInteger(index), nullptr);
149    }
150
151    Extract * createExtract(PabloAST * array, const int64_t index, const llvm::StringRef & prefix) {
152        return createExtract(array, getInteger(index), makeName(prefix));
153    }
154
155    Extract * createExtract(PabloAST * array, PabloAST * index, String * name);
156
157    Assign * createAssign(PabloAST * const var, PabloAST * const value);
158
159    And * createAnd(PabloAST * expr1, PabloAST * expr2) {
160        return createAnd(expr1, expr2, nullptr);
161    }
162
163    And * createAnd(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix) {
164        return createAnd(expr1, expr2, makeName(prefix));
165    }
166
167    And * createAnd(PabloAST * expr1, PabloAST * expr2, String * name);
168
169    And * createAnd(llvm::Type * const type, const unsigned reserved) {
170        return createAnd(type, reserved, nullptr);
171    }
172
173    And * createAnd(llvm::Type * const type, const unsigned reserved, String * name);
174
175    Or * createOr(PabloAST * expr1, PabloAST * expr2) {
176        return createOr(expr1, expr2, nullptr);
177    }
178
179    Or * createOr(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix) {
180        return createOr(expr1, expr2, makeName(prefix));
181    }
182
183    Or * createOr(PabloAST * expr1, PabloAST * expr2, String * name);
184
185    Or * createOr(llvm::Type * const type, const unsigned reserved) {
186        return createOr(type, reserved, nullptr);
187    }
188
189    Or * createOr(llvm::Type * const type, const unsigned reserved, String * name);
190
191    Xor * createXor(PabloAST * expr1, PabloAST * expr2) {
192        return createXor(expr1, expr2, nullptr);
193    }
194
195    Xor * createXor(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix) {
196        return createXor(expr1, expr2, makeName(prefix));
197    }
198
199    Xor * createXor(PabloAST * expr1, PabloAST * expr2, String * name);
200
201    Xor * createXor(llvm::Type * const type, const unsigned reserved) {
202        return createXor(type, reserved, nullptr);
203    }
204
205    Xor * createXor(llvm::Type * const type, const unsigned reserved, String * name);
206
207    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
208        return createSel(condition, trueExpr, falseExpr, nullptr);
209    }
210
211    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const llvm::StringRef & prefix) {
212        return createSel(condition, trueExpr, falseExpr, makeName(prefix));
213    }
214
215    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, String * name);
216
217    Add * createAdd(PabloAST * expr1, PabloAST * expr2);
218
219    Subtract * createSubtract(PabloAST * expr1, PabloAST * expr2);
220
221    LessThan * createLessThan(PabloAST * expr1, PabloAST * expr2);
222
223    MatchStar * createMatchStar(PabloAST * marker, PabloAST * charclass) {
224        return createMatchStar(marker, charclass, nullptr);
225    }
226
227    MatchStar * createMatchStar(PabloAST * marker, PabloAST * charclass, const llvm::StringRef & prefix) {
228        return createMatchStar(marker, charclass, makeName(prefix));
229    }
230
231    MatchStar * createMatchStar(PabloAST * marker, PabloAST * charclass, String * name);
232
233    ScanThru * createScanThru(PabloAST * from, PabloAST * thru) {
234        return createScanThru(from, thru, nullptr);
235    }
236
237    ScanThru * createScanThru(PabloAST * from, PabloAST * thru, const llvm::StringRef & prefix) {
238        return createScanThru(from, thru, makeName(prefix));
239    }
240
241    ScanThru * createScanThru(PabloAST * from, PabloAST * thru, String * name);
242
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
273    If * createIf(PabloAST * condition, PabloBlock * body);
274
275    While * createWhile(PabloAST * condition, PabloBlock * body);
276
277    llvm::Type * getStreamSetTy(const unsigned NumElements = 1, const unsigned FieldWidth = 1) {
278        return mParent->getStreamSetTy(NumElements, FieldWidth);
279    }
280   
281    PabloBlock * getPredecessor() const;
282
283    inline PabloKernel * getParent() const {
284        return mParent;
285    }
286
287    void insert(Statement * const statement);
288
289    inline void setScopeIndex(const unsigned index) {
290        mScopeIndex = index;
291    }
292
293    inline unsigned getScopeIndex() const {
294        return mScopeIndex;
295    }
296   
297    void eraseFromParent(const bool recursively = false);
298
299    inline Branch * getBranch() const {
300        return mBranch;
301    }
302
303    inline void setBranch(Branch * const branch) {
304        mBranch = branch;
305    }
306
307    inline String * makeName(const llvm::StringRef & prefix) const {
308        return mParent->makeName(prefix);
309    }
310
311    inline Integer * getInteger(const int64_t value) const {
312        return mParent->getInteger(value);
313    }
314
315    void print(llvm::raw_ostream & O, const bool expandNested = true) const;
316
317    virtual ~PabloBlock() {}
318
319protected:
320
321    explicit PabloBlock(PabloKernel * const parent, Allocator & allocator) noexcept
322    : PabloAST(PabloAST::ClassTypeId::Block, nullptr, allocator)
323    , mParent(parent)
324    , mBranch(nullptr)
325    , mScopeIndex(0)
326    , mAllocator(allocator) {
327
328    }
329
330    template<typename Type>
331    inline Type * insertAtInsertionPoint(Type * expr) {
332        if (llvm::isa<Statement>(expr)) {
333            insert(llvm::cast<Statement>(expr));
334        }
335        return expr;
336    }
337
338    Var * createVar(PabloAST * name, llvm::Type * const type);
339
340private:       
341    PabloKernel * const         mParent;
342    Branch *                    mBranch;
343    unsigned                    mScopeIndex;
344    Allocator &                 mAllocator;
345};
346
347}
348
349#endif // PS_PABLOS_H
Note: See TracBrowser for help on using the repository browser.