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

Last change on this file since 4410 was 4410, checked in by nmedfort, 5 years ago

Changes to support 3-operand form for all instructions. CSE disabled but partially redundant now.

File size: 8.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#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
102//PabloAST * PabloBlock::replaceUsesOfWith(PabloAST * inst, PabloAST * from, PabloAST * to) {
103//    if (from == to) {
104//        return inst;
105//    }
106//    switch (inst->getClassTypeId()) {
107//        case PabloAST::ClassTypeId::Advance:
108//            {
109//                Advance * n = cast<Advance>(inst);
110//                if (n->getExpr() == from) {
111//                    return createAdvance(to, n->getAdvanceAmount());
112//                }
113//                return inst;
114//            }
115//        case PabloAST::ClassTypeId::Assign:
116//            {
117//                Assign * n = cast<Assign>(inst);
118//                if (n->getExpr() == from) {
119//                    Assign * assign = createAssign(to);
120//                    n->replaceWith(assign);
121//                    return assign;
122//                }
123//                return inst;
124//            }
125//        case PabloAST::ClassTypeId::Var:
126//            {
127//                Var * n = cast<Var>(inst);
128//                if (n->getVar() == from) {
129//                    return createVar(to);
130//                }
131//                return inst;
132//            }
133//        case PabloAST::ClassTypeId::Next:
134//            {
135//                Next * n = cast<Next>(inst);
136//                if (n->getInitial() == from || n->getExpr() == from) {
137//                    return createNext(n->getInitial() == from ? to : n->getInitial(),
138//                                      n->getExpr() == from ? to : n->getExpr());
139//                }
140//                return inst;
141//            }
142////        case PabloAST::ClassTypeId::Call:
143////            {
144////                Call * n = cast<Call>(node);
145////                if (n->getCallee() == from) {
146////                    return createCall(to, n->getExpr());
147////                }
148////                return node;
149////            }
150//        case PabloAST::ClassTypeId::Not:
151//            {
152//                Not * n = cast<Not>(inst);
153//                if (n->getExpr() == from) {
154//                    return createNot(to);
155//                }
156//                return inst;
157//            }
158//        case PabloAST::ClassTypeId::And:
159//            {
160//                And * n = cast<And>(inst);
161//                if (n->getExpr1() == from || n->getExpr2() == from) {
162//                    return createAnd(n->getExpr1() == from ? to : n->getExpr1(),
163//                                     n->getExpr2() == from ? to : n->getExpr2());
164//                }
165//                return inst;
166//            }
167//        case PabloAST::ClassTypeId::Or:
168//            {
169//                Or * n = cast<Or>(inst);
170//                if (n->getExpr1() == from || n->getExpr2() == from) {
171//                    return createOr(n->getExpr1() == from ? to : n->getExpr1(),
172//                                    n->getExpr2() == from ? to : n->getExpr2());
173//                }
174//                return inst;
175//            }
176//        case PabloAST::ClassTypeId::Xor:
177//            {
178//                Xor * n = cast<Xor>(inst);
179//                if (n->getExpr1() == from || n->getExpr2() == from) {
180//                    return createXor(n->getExpr1() == from ? to : n->getExpr1(),
181//                                     n->getExpr2() == from ? to : n->getExpr2());
182//                }
183//                return inst;
184//            }
185//        case PabloAST::ClassTypeId::ScanThru:
186//            {
187//                ScanThru * n = cast<ScanThru>(inst);
188//                if (n->getScanFrom() == from || n->getScanThru() == from) {
189//                    return createScanThru(n->getScanFrom() == from ? to : n->getScanFrom(),
190//                                          n->getScanThru() == from ? to : n->getScanThru());
191//                }
192//                return inst;
193//            }
194//        case PabloAST::ClassTypeId::MatchStar:
195//            {
196//                MatchStar * n = cast<MatchStar>(inst);
197//                if (n->getMarker() == from || n->getScanThru() == from) {
198//                    return createMatchStar(n->getMarker() == from ? to : n->getMarker(),
199//                                           n->getScanThru() == from ? to : n->getScanThru());
200//                }
201//                return inst;
202//            }
203//        case PabloAST::ClassTypeId::Ones:
204//        case PabloAST::ClassTypeId::Zeroes:
205//        case PabloAST::ClassTypeId::If:
206//        case PabloAST::ClassTypeId::While:
207//            return inst;
208//        default:
209//            throw std::runtime_error("Unhandled node type (" + std::to_string(inst->getClassTypeId()) +
210//                                     ") given to PabloBlock::replaceUsesOfWith(...)")
211//    }
212
213//}
214
215
216}
Note: See TracBrowser for help on using the repository browser.