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

Last change on this file was 6215, checked in by cameron, 3 months ago

pablo.terminateAt

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