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

Last change on this file since 5751 was 5709, checked in by cameron, 2 years ago

createIndexedAdvance

File size: 11.4 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 IndexedAdvance; }
18namespace pablo { class AdvanceThenScanThru; }
19namespace pablo { class AdvanceThenScanTo; }
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; }
30namespace pablo { class Lookahead; }
31namespace pablo { class MatchStar; }
32namespace pablo { class Not; }
33namespace pablo { class Ones; }
34namespace pablo { class Or; }
35namespace pablo { class PabloKernel; }
36namespace pablo { class Phi; }
37namespace pablo { class ScanThru; }
38namespace pablo { class ScanTo; }
39namespace pablo { class Sel; }
40namespace pablo { class String; }
41namespace pablo { class Subtract; }
42namespace pablo { class Var; }
43namespace pablo { class Xor; }
44namespace pablo { class Zeroes; }
45
46namespace pablo {
47
48class PabloBlock : public PabloAST, public StatementList {
49    friend class PabloAST;
50    friend class Branch;
51    friend class PabloBuilder;
52    friend class PabloKernel;
53public:
54
55    static inline bool classof(const PabloBlock *) {
56        return true;
57    }
58    static inline bool classof(const Statement *) {
59        return false;
60    }
61    static inline bool classof(const PabloAST * e) {
62        return e->getClassTypeId() == ClassTypeId::Block;
63    }
64    static inline bool classof(const void *) {
65        return false;
66    }
67
68    static PabloBlock * Create(PabloKernel * const parent) noexcept;
69
70    Advance * createAdvance(PabloAST * expr, PabloAST * shiftAmount) {
71        return createAdvance(expr, shiftAmount, nullptr);
72    }
73   
74    Advance * createAdvance(PabloAST * expr, PabloAST * shiftAmount, const llvm::StringRef & prefix) {
75        return createAdvance(expr, shiftAmount, makeName(prefix));
76    }
77   
78    Advance * createAdvance(PabloAST * expr, PabloAST * shiftAmount, String * name);
79   
80    IndexedAdvance * createIndexedAdvance(PabloAST * expr, PabloAST * indexStream, PabloAST * shiftAmount) {
81        return createIndexedAdvance(expr, indexStream, shiftAmount, nullptr);
82    }
83   
84    IndexedAdvance * createIndexedAdvance(PabloAST * expr, PabloAST * indexStream, PabloAST * shiftAmount, const llvm::StringRef & prefix) {
85        return createIndexedAdvance(expr, indexStream, shiftAmount, makeName(prefix));
86    }
87   
88    IndexedAdvance * createIndexedAdvance(PabloAST * expr, PabloAST * indexStream, PabloAST * shiftAmount, String * name);
89   
90    Lookahead * createLookahead(PabloAST * expr, PabloAST * shiftAmount) {
91        return createLookahead(expr, shiftAmount, nullptr);
92    }
93
94    Lookahead * createLookahead(PabloAST * expr, PabloAST * shiftAmount, const llvm::StringRef & prefix) {
95        return createLookahead(expr, shiftAmount, makeName(prefix));
96    }
97
98    Lookahead * createLookahead(PabloAST * expr, PabloAST * shiftAmount, String * name);
99
100    inline Zeroes * createZeroes(llvm::Type * const type = nullptr) {
101        return mParent->getNullValue(type);
102    }
103
104    inline Ones * createOnes(llvm::Type * const type = nullptr) {
105        return mParent->getAllOnesValue(type);
106    }
107
108    Not * createNot(PabloAST * expr) {
109        return createNot(expr, nullptr);
110    }
111
112    Not * createNot(PabloAST * expr, const llvm::StringRef & prefix) {
113        return createNot(expr, makeName(prefix));
114    }
115
116    Not * createNot(PabloAST * expr, String * name);
117
118    inline Var * createVar(const llvm::StringRef & name, llvm::Type * const type = nullptr) {
119        return createVar(makeName(name), type);
120    }
121
122    inline Var * createVar(String * name, llvm::Type * const type = nullptr) {
123        return createVar(reinterpret_cast<PabloAST *>(name), type);
124    }
125
126    Count * createCount(PabloAST * expr);
127
128    Count * createCount(PabloAST * expr, const llvm::StringRef & prefix);
129
130    InFile * createInFile(PabloAST * expr) {
131        return createInFile(expr, nullptr);
132    }
133
134    InFile * createInFile(PabloAST * expr, const llvm::StringRef & prefix) {
135        return createInFile(expr, makeName(prefix));
136    }
137
138    InFile * createInFile(PabloAST * expr, String * name);
139
140    AtEOF * createAtEOF(PabloAST * expr) {
141        return createAtEOF(expr, nullptr);
142    }
143
144    AtEOF * createAtEOF(PabloAST * expr, const llvm::StringRef & prefix) {
145        return createAtEOF(expr, makeName(prefix));
146    }
147
148    AtEOF * createAtEOF(PabloAST * expr, String * name);
149
150    inline Extract * createExtract(PabloAST * array, PabloAST * index) {
151        return createExtract(array, index, nullptr);
152    }
153
154    Extract * createExtract(PabloAST * array, PabloAST * index, const llvm::StringRef & prefix) {
155        return createExtract(array, index, makeName(prefix));
156    }
157
158    Extract * createExtract(PabloAST * array, const int64_t index) {
159        return createExtract(array, getInteger(index), nullptr);
160    }
161
162    Extract * createExtract(PabloAST * array, const int64_t index, const llvm::StringRef & prefix) {
163        return createExtract(array, getInteger(index), makeName(prefix));
164    }
165
166    Extract * createExtract(PabloAST * array, PabloAST * index, String * name);
167
168    Assign * createAssign(PabloAST * const var, PabloAST * const value);
169
170    And * createAnd(PabloAST * expr1, PabloAST * expr2) {
171        return createAnd(expr1, expr2, nullptr);
172    }
173
174    And * createAnd(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix) {
175        return createAnd(expr1, expr2, makeName(prefix));
176    }
177
178    And * createAnd(PabloAST * expr1, PabloAST * expr2, String * name);
179
180    And * createAnd(llvm::Type * const type, const unsigned reserved) {
181        return createAnd(type, reserved, nullptr);
182    }
183
184    And * createAnd(llvm::Type * const type, const unsigned reserved, String * name);
185
186    Or * createOr(PabloAST * expr1, PabloAST * expr2) {
187        return createOr(expr1, expr2, nullptr);
188    }
189
190    Or * createOr(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix) {
191        return createOr(expr1, expr2, makeName(prefix));
192    }
193
194    Or * createOr(PabloAST * expr1, PabloAST * expr2, String * name);
195
196    Or * createOr(llvm::Type * const type, const unsigned reserved) {
197        return createOr(type, reserved, nullptr);
198    }
199
200    Or * createOr(llvm::Type * const type, const unsigned reserved, String * name);
201
202    Xor * createXor(PabloAST * expr1, PabloAST * expr2) {
203        return createXor(expr1, expr2, nullptr);
204    }
205
206    Xor * createXor(PabloAST * expr1, PabloAST * expr2, const llvm::StringRef & prefix) {
207        return createXor(expr1, expr2, makeName(prefix));
208    }
209
210    Xor * createXor(PabloAST * expr1, PabloAST * expr2, String * name);
211
212    Xor * createXor(llvm::Type * const type, const unsigned reserved) {
213        return createXor(type, reserved, nullptr);
214    }
215
216    Xor * createXor(llvm::Type * const type, const unsigned reserved, String * name);
217
218    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
219        return createSel(condition, trueExpr, falseExpr, nullptr);
220    }
221
222    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const llvm::StringRef & prefix) {
223        return createSel(condition, trueExpr, falseExpr, makeName(prefix));
224    }
225
226    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, String * name);
227
228    Add * createAdd(PabloAST * expr1, PabloAST * expr2);
229
230    Subtract * createSubtract(PabloAST * expr1, PabloAST * expr2);
231
232    LessThan * createLessThan(PabloAST * expr1, PabloAST * expr2);
233
234    MatchStar * createMatchStar(PabloAST * marker, PabloAST * charclass) {
235        return createMatchStar(marker, charclass, nullptr);
236    }
237
238    MatchStar * createMatchStar(PabloAST * marker, PabloAST * charclass, const llvm::StringRef & prefix) {
239        return createMatchStar(marker, charclass, makeName(prefix));
240    }
241
242    MatchStar * createMatchStar(PabloAST * marker, PabloAST * charclass, String * name);
243
244    ScanThru * createScanThru(PabloAST * from, PabloAST * thru) {
245        return createScanThru(from, thru, nullptr);
246    }
247
248    ScanThru * createScanThru(PabloAST * from, PabloAST * thru, const llvm::StringRef & prefix) {
249        return createScanThru(from, thru, makeName(prefix));
250    }
251
252    ScanThru * createScanThru(PabloAST * from, PabloAST * thru, String * name);
253
254    ScanTo * createScanTo(PabloAST * from, PabloAST * to) {
255        return createScanTo(from, to, nullptr);
256    }
257
258    ScanTo * createScanTo(PabloAST * from, PabloAST * to, const llvm::StringRef & prefix) {
259        return createScanTo(from, to, makeName(prefix));
260    }
261
262    ScanTo * createScanTo(PabloAST * from, PabloAST * to, String * name);
263
264    AdvanceThenScanThru * createAdvanceThenScanThru(PabloAST * from, PabloAST * thru) {
265        return createAdvanceThenScanThru(from, thru, nullptr);
266    }
267
268    AdvanceThenScanThru * createAdvanceThenScanThru(PabloAST * from, PabloAST * thru, const llvm::StringRef & prefix) {
269        return createAdvanceThenScanThru(from, thru, makeName(prefix));
270    }
271
272    AdvanceThenScanThru * createAdvanceThenScanThru(PabloAST * from, PabloAST * thru, String * name);
273
274    AdvanceThenScanTo * createAdvanceThenScanTo(PabloAST * from, PabloAST * to) {
275        return createAdvanceThenScanTo(from, to, nullptr);
276    }
277
278    AdvanceThenScanTo * createAdvanceThenScanTo(PabloAST * from, PabloAST * to, const llvm::StringRef & prefix) {
279        return createAdvanceThenScanTo(from, to, makeName(prefix));
280    }
281
282    AdvanceThenScanTo * createAdvanceThenScanTo(PabloAST * from, PabloAST * to, String * name);
283
284    If * createIf(PabloAST * condition, PabloBlock * body);
285
286    While * createWhile(PabloAST * condition, PabloBlock * body);
287
288    Phi * createPhi(llvm::Type * type);
289
290    PabloBlock * getPredecessor() const;
291
292    inline PabloKernel * getParent() const {
293        return mParent;
294    }
295
296    void insert(Statement * const statement);
297
298    void eraseFromParent(const bool recursively = false);
299
300    inline Branch * getBranch() const {
301        return mBranch;
302    }
303
304    inline void setBranch(Branch * const branch) {
305        mBranch = branch;
306    }
307
308    inline String * makeName(const llvm::StringRef & prefix) const {
309        return mParent->makeName(prefix);
310    }
311
312    inline Integer * getInteger(const int64_t value) const {
313        return mParent->getInteger(value);
314    }
315
316    void print(llvm::raw_ostream & O, const bool expandNested = true) const;
317
318    virtual ~PabloBlock() {}
319
320protected:
321
322    PabloBlock(PabloKernel * const parent, Allocator & allocator) noexcept
323    : PabloAST(PabloAST::ClassTypeId::Block, nullptr, allocator)
324    , mParent(parent)
325    , mBranch(nullptr)
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    Allocator &                 mAllocator;
344};
345
346}
347
348#endif // PS_PABLOS_H
Note: See TracBrowser for help on using the repository browser.