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

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

Created an "insertion friendly" Pablo AST structure similar to LLVM; fixed engine builder bug when creating a unicode class.

File size: 3.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 "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 <llvm/Support/Compiler.h>
22
23namespace pablo {
24
25PabloAST::Allocator PabloAST::mAllocator;
26
27/*
28
29    Return true if expr1 and expr2 can be proven equivalent according to some rules,
30    false otherwise.  Note that false may be returned i some cases when the exprs are
31    equivalent.
32
33*/
34
35bool equals(const PabloAST * expr1, const PabloAST * expr2) {
36    assert (expr1 && expr2);
37    if (expr1->getClassTypeId() == expr2->getClassTypeId()) {
38        if ((isa<const Zeroes>(expr1)) || (isa<const Ones>(expr1))) {
39            return true;
40        }
41        else if (const Var * var1 = dyn_cast<const Var>(expr1)) {
42            if (const Var * var2 = cast<const Var>(expr2)) {
43                return (var1->getName() == var2->getName());
44            }
45        }
46        else if (const Not* not1 = dyn_cast<const Not>(expr1)) {
47            if (const Not* not2 = cast<const Not>(expr2)) {
48                return equals(not1->getExpr(), not2->getExpr());
49            }
50        }
51        else if (const And* and1 = dyn_cast<const And>(expr1)) {
52            if (const And* and2 = cast<const And>(expr2)) {
53                if (equals(and1->getExpr1(), and2->getExpr1())) {
54                    return equals(and1->getExpr2(), and2->getExpr2());
55                }
56                else if (equals(and1->getExpr1(), and2->getExpr2())) {
57                    return equals(and1->getExpr2(), and2->getExpr1());
58                }
59            }
60        }
61        else if (const Or * or1 = dyn_cast<const Or>(expr1)) {
62            if (const Or* or2 = cast<const Or>(expr2)) {
63                if (equals(or1->getExpr1(), or2->getExpr1())) {
64                    return equals(or1->getExpr2(), or2->getExpr2());
65                }
66                else if (equals(or1->getExpr1(), or2->getExpr2())) {
67                    return equals(or1->getExpr2(), or2->getExpr1());
68                }
69            }
70        }
71        else if (const Xor * xor1 = dyn_cast<const Xor>(expr1)) {
72            if (const Xor * xor2 = cast<const Xor>(expr2)) {
73                if (equals(xor1->getExpr1(), xor2->getExpr1())) {
74                    return equals(xor1->getExpr2(), xor2->getExpr2());
75                }
76                else if (equals(xor1->getExpr1(), xor2->getExpr2())) {
77                    return equals(xor1->getExpr2(), xor2->getExpr1());
78                }
79            }
80        }
81        else if (const Sel* sel1 = dyn_cast<const Sel>(expr1)) {
82            if (const Sel* sel2 = cast<const Sel>(expr2)) {
83                if (equals(sel1->getCondition(), sel2->getCondition())) {
84                    if (equals(sel1->getTrueExpr(), sel2->getTrueExpr())) {
85                        return equals(sel1->getFalseExpr(), sel2->getFalseExpr());
86                    }
87                }
88            }
89        }
90    }
91    return false;
92}
93
94void StatementList::push_back(Statement * const statement) {
95    if (LLVM_UNLIKELY(mLast == nullptr)) {
96        mFirst = mLast = statement;
97    }
98    else {
99        statement->insertAfter(mLast);
100        mLast = statement;
101    }
102}
103
104}
Note: See TracBrowser for help on using the repository browser.