source: icGREP/icgrep-devel/icgrep/pablo/pabloAST.cpp @ 4415

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

More work on usedef info.

File size: 6.8 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 "pabloAST.h"
8#include "pe_advance.h"
9#include "pe_and.h"
10#include "pe_call.h"
11#include "pe_matchstar.h"
12#include "pe_not.h"
13#include "pe_or.h"
14#include "pabloAST.h"
15#include "pe_scanthru.h"
16#include "pe_sel.h"
17#include "pe_var.h"
18#include "pe_xor.h"
19#include "pe_zeroes.h"
20#include "pe_ones.h"
21#include <pablo/codegenstate.h>
22#include <llvm/Support/Compiler.h>
23
24namespace pablo {
25
26PabloAST::Allocator PabloAST::mAllocator;
27
28/*
29
30    Return true if expr1 and expr2 can be proven equivalent according to some rules,
31    false otherwise.  Note that false may be returned i some cases when the exprs are
32    equivalent.
33
34*/
35
36bool equals(const PabloAST * expr1, const PabloAST * expr2) {
37    assert (expr1 && expr2);
38    if (expr1->getClassTypeId() == expr2->getClassTypeId()) {
39        if ((isa<const Zeroes>(expr1)) || (isa<const Ones>(expr1))) {
40            return true;
41        }
42        else if (const Var * var1 = dyn_cast<const Var>(expr1)) {
43            if (const Var * var2 = cast<const Var>(expr2)) {
44                return (var1->getName() == var2->getName());
45            }
46        }
47        else if (const Not* not1 = dyn_cast<const Not>(expr1)) {
48            if (const Not* not2 = cast<const Not>(expr2)) {
49                return equals(not1->getExpr(), not2->getExpr());
50            }
51        }
52        else if (const And* and1 = dyn_cast<const And>(expr1)) {
53            if (const And* and2 = cast<const And>(expr2)) {
54                if (equals(and1->getExpr1(), and2->getExpr1())) {
55                    return equals(and1->getExpr2(), and2->getExpr2());
56                }
57                else if (equals(and1->getExpr1(), and2->getExpr2())) {
58                    return equals(and1->getExpr2(), and2->getExpr1());
59                }
60            }
61        }
62        else if (const Or * or1 = dyn_cast<const Or>(expr1)) {
63            if (const Or* or2 = cast<const Or>(expr2)) {
64                if (equals(or1->getExpr1(), or2->getExpr1())) {
65                    return equals(or1->getExpr2(), or2->getExpr2());
66                }
67                else if (equals(or1->getExpr1(), or2->getExpr2())) {
68                    return equals(or1->getExpr2(), or2->getExpr1());
69                }
70            }
71        }
72        else if (const Xor * xor1 = dyn_cast<const Xor>(expr1)) {
73            if (const Xor * xor2 = cast<const Xor>(expr2)) {
74                if (equals(xor1->getExpr1(), xor2->getExpr1())) {
75                    return equals(xor1->getExpr2(), xor2->getExpr2());
76                }
77                else if (equals(xor1->getExpr1(), xor2->getExpr2())) {
78                    return equals(xor1->getExpr2(), xor2->getExpr1());
79                }
80            }
81        }
82        else if (const Sel* sel1 = dyn_cast<const Sel>(expr1)) {
83            if (const Sel* sel2 = cast<const Sel>(expr2)) {
84                if (equals(sel1->getCondition(), sel2->getCondition())) {
85                    if (equals(sel1->getTrueExpr(), sel2->getTrueExpr())) {
86                        return equals(sel1->getFalseExpr(), sel2->getFalseExpr());
87                    }
88                }
89            }
90        }
91    }
92    return false;
93}
94
95void PabloAST::setMetadata(const std::string & name, PMDNode * node) {
96    if (LLVM_UNLIKELY(mMetadataMap == nullptr)) {
97        mMetadataMap = new PMDNodeMap();
98    }
99    mMetadataMap->insert(std::make_pair(name, node));
100}
101
102PMDNode * PabloAST::getMetadata(const std::string & name) {
103    if (LLVM_UNLIKELY(mMetadataMap == nullptr)) {
104        return nullptr;
105    }
106    auto f = mMetadataMap->find(name);
107    if (f == mMetadataMap->end()) {
108        return nullptr;
109    }
110    return f->second;
111}
112
113PabloAST * Statement::setOperand(const unsigned index, PabloAST * value) {
114    assert (index < getNumOperands());
115    return mParent->setOperandOf(this, index, value);
116}
117
118void Statement::insertBefore(Statement * const statement) {
119    assert (statement);
120    assert (statement != this);
121    assert (statement->mParent);
122    removeFromParent();
123    mParent = statement->mParent;
124    if (LLVM_UNLIKELY(mParent->mFirst == statement)) {
125        mParent->mFirst = this;
126    }
127    mNext = statement;
128    mPrev = statement->mPrev;
129    statement->mPrev = this;
130    if (LLVM_LIKELY(mPrev != nullptr)) {
131        mPrev->mNext = this;
132    }
133}
134
135void Statement::insertAfter(Statement * const statement) {
136    assert (statement);
137    assert (statement != this);
138    assert (statement->mParent);
139    removeFromParent();
140    mParent = statement->mParent;
141    if (LLVM_UNLIKELY(mParent->mLast == statement)) {
142        mParent->mLast = this;
143    }
144    mPrev = statement;
145    mNext = statement->mNext;
146    statement->mNext = this;
147    if (LLVM_LIKELY(mNext != nullptr)) {
148        mNext->mPrev = this;
149    }
150}
151
152void Statement::removeFromParent() {
153    if (LLVM_LIKELY(mParent != nullptr)) {
154        if (LLVM_UNLIKELY(mParent->mFirst == this)) {
155            mParent->mFirst = mNext;
156        }
157        if (LLVM_UNLIKELY(mParent->mLast == this)) {
158            mParent->mLast = mPrev;
159        }
160        if (mParent->mInsertionPoint == this) {
161            mParent->mInsertionPoint = mParent->mInsertionPoint->mPrev;
162        }
163        if (LLVM_LIKELY(mPrev != nullptr)) {
164            mPrev->mNext = mNext;
165        }
166        if (LLVM_LIKELY(mNext != nullptr)) {
167            mNext->mPrev = mPrev;
168        }
169    }   
170    mPrev = nullptr;
171    mNext = nullptr;
172    mParent = nullptr;
173}
174
175void Statement::replaceWith(Statement * const statement) {
176    if (statement != this) {
177        statement->removeFromParent();
178        statement->mParent = mParent;
179        statement->mNext = mNext;
180        statement->mPrev = mPrev;
181        if (LLVM_LIKELY(mPrev != nullptr)) {
182            mPrev->mNext = statement;
183        }
184        if (LLVM_LIKELY(mNext != nullptr)) {
185            mNext->mPrev = statement;
186        }
187        mParent=nullptr;
188        mNext=nullptr;
189        mPrev=nullptr;
190    }
191}
192
193Statement::~Statement() {
194
195}
196
197void StatementList::setInsertPoint(Statement * const statement) {
198    mInsertionPoint = statement;
199}
200
201void StatementList::setInsertPoint(StatementList * const list) {
202    mInsertionPoint = list->mLast;
203}
204
205void StatementList::insert(Statement * const statement) {
206    if (LLVM_UNLIKELY(mInsertionPoint == nullptr)) {
207        statement->mNext = mFirst;
208        if (mFirst) {
209            assert (mFirst->mPrev == nullptr);
210            mFirst->mPrev = statement;
211        }
212        mLast = (mLast == nullptr) ? statement : mLast;
213        mInsertionPoint = mFirst = statement;
214    }
215    else {
216        statement->insertAfter(mInsertionPoint);
217        mLast = (mLast == mInsertionPoint) ? statement : mLast;
218        mInsertionPoint = statement;
219    }
220}
221
222void StatementList::insertAfterLastOperand(Statement * const statement) {
223    assert (false);
224}
225
226}
Note: See TracBrowser for help on using the repository browser.