source: icGREP/icgrep-devel/icgrep/pablo/codegenstate.cpp @ 4414

Last change on this file since 4414 was 4414, checked in by nmedfort, 4 years ago

Minor changes towards maintaining UseDef? information.

File size: 8.2 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#include <pablo/codegenstate.h>
8#include <iostream>
9
10namespace pablo {
11
12/// UNARY CREATE FUNCTIONS
13
14PabloAST * PabloBlock::createAdvance(PabloAST * expr, const int shiftAmount) {
15    if (isa<Zeroes>(expr) || shiftAmount == 0) {
16        return expr;
17    }
18    return appendIfNew(mUnaryWithInt.findOrMake<Advance>(PabloAST::ClassTypeId::Advance, expr, shiftAmount, mSymbolGenerator, this));
19}
20
21Call * PabloBlock::createCall(const std::string name) {
22    return appendIfNew(mUnary.findOrMake<Call>(PabloAST::ClassTypeId::Call, mSymbolGenerator->get(name), this));
23}
24
25PabloAST * PabloBlock::createNot(PabloAST * expr) {
26    return mUnary.findOrCall<OptimizeNot>(PabloAST::ClassTypeId::Not, expr, this);
27}
28
29Not * PabloBlock::createNotImm(PabloAST * expr) {
30    return appendIfNew(mUnary.findOrMake<Not>(PabloAST::ClassTypeId::Not, expr, this));
31}
32
33
34Var * PabloBlock::createVar(const std::string name) {
35    return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, mSymbolGenerator->get(name), this).first;
36}
37
38/// BINARY CREATE FUNCTIONS
39
40Next * PabloBlock::createNext(Assign * assign, PabloAST * expr) {
41    return appendIfNew(mBinary.findOrMake<Next>(PabloAST::ClassTypeId::Next, assign, expr, this));
42}
43
44PabloAST * PabloBlock::createMatchStar(PabloAST * marker, PabloAST * charclass) {
45    if (isa<Zeroes>(marker) || isa<Zeroes>(charclass)) {
46        return marker;
47    }
48    return appendIfNew(mBinary.findOrMake<MatchStar>(PabloAST::ClassTypeId::MatchStar, marker, charclass, mSymbolGenerator, this));
49}
50
51PabloAST * PabloBlock::createScanThru(PabloAST * from, PabloAST * thru) {
52    if (isa<Zeroes>(from) || isa<Zeroes>(thru)) {
53        return from;
54    }
55    return appendIfNew(mBinary.findOrMake<ScanThru>(PabloAST::ClassTypeId::ScanThru, from, thru, mSymbolGenerator, this));
56}
57
58PabloAST * PabloBlock::createAnd(PabloAST * expr1, PabloAST * expr2) {
59    if (expr1 < expr2) {
60        std::swap(expr1, expr2);
61    }
62    return mBinary.findOrCall<OptimizeAnd>(PabloAST::ClassTypeId::And, expr1, expr2, this);
63}
64
65And * PabloBlock::createAndImm(PabloAST * expr1, PabloAST * expr2) {
66    return appendIfNew(mBinary.findOrMake<And>(PabloAST::ClassTypeId::And, expr1, expr2, this));
67}
68
69PabloAST * PabloBlock::createOr(PabloAST * expr1, PabloAST * expr2) {
70    if (expr1 < expr2) {
71        std::swap(expr1, expr2);
72    }
73    return mBinary.findOrCall<OptimizeOr>(PabloAST::ClassTypeId::Or, expr1, expr2, this);
74}
75
76Or * PabloBlock::createOrImm(PabloAST * expr1, PabloAST * expr2) {
77    return appendIfNew(mBinary.findOrMake<Or>(PabloAST::ClassTypeId::Or, expr1, expr2, this));
78}
79
80PabloAST * PabloBlock::createXor(PabloAST * expr1, PabloAST * expr2) {
81    if (expr1 < expr2) {
82        std::swap(expr1, expr2);
83    }
84    return mBinary.findOrCall<OptimizeXor>(PabloAST::ClassTypeId::Xor, expr1, expr2, this);
85}
86
87Xor * PabloBlock::createXorImm(PabloAST * expr1, PabloAST * expr2) {
88    return appendIfNew(mBinary.findOrMake<Xor>(PabloAST::ClassTypeId::Xor, expr1, expr2,  this));
89}
90
91/// TERNARY CREATE FUNCTION
92
93PabloAST * PabloBlock::createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
94    return mTernary.findOrCall<OptimizeSel>(PabloAST::ClassTypeId::Sel, condition, trueExpr, falseExpr, this);
95}
96
97Sel * PabloBlock::createSelImm(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
98    return appendIfNew(mTernary.findOrMake<Sel>(PabloAST::ClassTypeId::Sel, condition, trueExpr, falseExpr, this));
99}
100
101//PabloAST * PabloBlock::replaceUsesOfWith(PabloAST * inst, PabloAST * from, PabloAST * to) {
102
103
104
105
106//}
107
108//PabloAST * PabloBlock::replaceUsesOfWith(PabloAST * inst, PabloAST * from, PabloAST * to) {
109//    if (from == to) {
110//        return inst;
111//    }
112//    switch (inst->getClassTypeId()) {
113//        case PabloAST::ClassTypeId::Advance:
114//            {
115//                Advance * n = cast<Advance>(inst);
116//                if (n->getExpr() == from) {
117//                    return createAdvance(to, n->getAdvanceAmount());
118//                }
119//                return inst;
120//            }
121//        case PabloAST::ClassTypeId::Assign:
122//            {
123//                Assign * n = cast<Assign>(inst);
124//                if (n->getExpr() == from) {
125//                    Assign * assign = createAssign(to);
126//                    n->replaceWith(assign);
127//                    return assign;
128//                }
129//                return inst;
130//            }
131//        case PabloAST::ClassTypeId::Var:
132//            {
133//                Var * n = cast<Var>(inst);
134//                if (n->getVar() == from) {
135//                    return createVar(to);
136//                }
137//                return inst;
138//            }
139//        case PabloAST::ClassTypeId::Next:
140//            {
141//                Next * n = cast<Next>(inst);
142//                if (n->getInitial() == from || n->getExpr() == from) {
143//                    return createNext(n->getInitial() == from ? to : n->getInitial(),
144//                                      n->getExpr() == from ? to : n->getExpr());
145//                }
146//                return inst;
147//            }
148////        case PabloAST::ClassTypeId::Call:
149////            {
150////                Call * n = cast<Call>(node);
151////                if (n->getCallee() == from) {
152////                    return createCall(to, n->getExpr());
153////                }
154////                return node;
155////            }
156//        case PabloAST::ClassTypeId::Not:
157//            {
158//                Not * n = cast<Not>(inst);
159//                if (n->getExpr() == from) {
160//                    return createNot(to);
161//                }
162//                return inst;
163//            }
164//        case PabloAST::ClassTypeId::And:
165//            {
166//                And * n = cast<And>(inst);
167//                if (n->getExpr1() == from || n->getExpr2() == from) {
168//                    return createAnd(n->getExpr1() == from ? to : n->getExpr1(),
169//                                     n->getExpr2() == from ? to : n->getExpr2());
170//                }
171//                return inst;
172//            }
173//        case PabloAST::ClassTypeId::Or:
174//            {
175//                Or * n = cast<Or>(inst);
176//                if (n->getExpr1() == from || n->getExpr2() == from) {
177//                    return createOr(n->getExpr1() == from ? to : n->getExpr1(),
178//                                    n->getExpr2() == from ? to : n->getExpr2());
179//                }
180//                return inst;
181//            }
182//        case PabloAST::ClassTypeId::Xor:
183//            {
184//                Xor * n = cast<Xor>(inst);
185//                if (n->getExpr1() == from || n->getExpr2() == from) {
186//                    return createXor(n->getExpr1() == from ? to : n->getExpr1(),
187//                                     n->getExpr2() == from ? to : n->getExpr2());
188//                }
189//                return inst;
190//            }
191//        case PabloAST::ClassTypeId::ScanThru:
192//            {
193//                ScanThru * n = cast<ScanThru>(inst);
194//                if (n->getScanFrom() == from || n->getScanThru() == from) {
195//                    return createScanThru(n->getScanFrom() == from ? to : n->getScanFrom(),
196//                                          n->getScanThru() == from ? to : n->getScanThru());
197//                }
198//                return inst;
199//            }
200//        case PabloAST::ClassTypeId::MatchStar:
201//            {
202//                MatchStar * n = cast<MatchStar>(inst);
203//                if (n->getMarker() == from || n->getScanThru() == from) {
204//                    return createMatchStar(n->getMarker() == from ? to : n->getMarker(),
205//                                           n->getScanThru() == from ? to : n->getScanThru());
206//                }
207//                return inst;
208//            }
209//        case PabloAST::ClassTypeId::Ones:
210//        case PabloAST::ClassTypeId::Zeroes:
211//        case PabloAST::ClassTypeId::If:
212//        case PabloAST::ClassTypeId::While:
213//            return inst;
214//        default:
215//            throw std::runtime_error("Unhandled node type (" + std::to_string(inst->getClassTypeId()) +
216//                                     ") given to PabloBlock::replaceUsesOfWith(...)")
217//    }
218
219//}
220
221
222}
Note: See TracBrowser for help on using the repository browser.