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

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

Some work towards maintaining UseDef? information. Use PabloBlock::Create() instead of the PabloBlock? constructors.

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