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

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

Removed Variadic functionality; allowed for deferred creation of statement names

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