Ignore:
Timestamp:
Jan 14, 2015, 3:58:52 PM (5 years ago)
Author:
nmedfort
Message:

Some code clean up and improvements to the CSE optimization.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.cpp

    r4416 r4419  
    3131
    3232PabloAST * PabloBlock::createNot(PabloAST * expr) {
    33     OptimizeNot op;
    34     return op(expr, this);
    35 }
    36 
    37 Not * PabloBlock::createNotImm(PabloAST * expr) {
     33    if (isa<Ones>(expr)) {
     34        return createZeroes();
     35    }
     36    else if (isa<Zeroes>(expr)){
     37        return createOnes();
     38    }
     39    else if (Not * not1 = dyn_cast<Not>(expr)) {
     40        return not1->getExpr();
     41    }
    3842    return insertAtInsertionPoint(new Not(expr, this));
    3943}
     
    6872
    6973PabloAST * PabloBlock::createAnd(PabloAST * expr1, PabloAST * expr2) {
    70     if (expr1 < expr2) {
     74    if (isa<Zeroes>(expr2) || isa<Ones>(expr1)) {
     75        return expr2;
     76    }
     77    else if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
     78        return expr1;
     79    }
     80    else if (equals(expr1, expr2)) {
     81        return expr1;
     82    }
     83    else if (Not * not1 = dyn_cast<Not>(expr1)) {
     84        if (Not * not2 = dyn_cast<Not>(expr2)) {
     85            return createNot(createOr(not1->getExpr(), not2->getExpr()));
     86        }
     87        else if (equals(not1->getExpr(), expr2)) {
     88            return createZeroes();
     89        }
     90    }
     91    else if (Not * not2 = dyn_cast<Not>(expr2)) {
     92        if (equals(expr1, not2->getExpr())) {
     93            return createZeroes();
     94        }
     95    }
     96    if (isa<Not>(expr1)) {
    7197        std::swap(expr1, expr2);
    7298    }
    73     OptimizeAnd op;
    74     return op(expr1, expr2, this);
    75 }
    76 
    77 And * PabloBlock::createAndImm(PabloAST * expr1, PabloAST * expr2) {
    7899    return insertAtInsertionPoint(new And(expr1, expr2, this));
    79100}
    80101
     102
    81103PabloAST * PabloBlock::createOr(PabloAST * expr1, PabloAST * expr2) {
    82     if (expr1 < expr2) {
    83         std::swap(expr1, expr2);
    84     }
    85     OptimizeOr op;
    86     return op(expr1, expr2, this);
    87 }
    88 
    89 Or * PabloBlock::createOrImm(PabloAST * expr1, PabloAST * expr2) {
     104    if (isa<Zeroes>(expr2) || isa<Ones>(expr1)) {
     105        return expr1;
     106    }
     107    else if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
     108        return expr2;
     109    }
     110    else if (equals(expr1, expr2)) {
     111        return expr1;
     112    }
     113    else if (Not * not1 = dyn_cast<Not>(expr1)) {
     114        // ¬a√b = ¬¬(¬a√b) = ¬(a ∧ ¬b)
     115        return createNot(createAnd(not1->getExpr(), createNot(expr2)));
     116    }
     117    else if (Not * not2 = dyn_cast<Not>(expr2)) {
     118        // a√¬b = ¬¬(¬b√a) = ¬(b ∧ ¬a)
     119        return createNot(createAnd(not2->getExpr(), createNot(expr1)));
     120    }
     121    else if (equals(expr1, expr2)) {
     122        return expr1;
     123    }
     124    else if (And * and_expr1 = dyn_cast<And>(expr1)) {
     125        if (And * and_expr2 = dyn_cast<And>(expr2)) {
     126            PabloAST * const expr1a = and_expr1->getExpr1();
     127            PabloAST * const expr1b = and_expr1->getExpr2();
     128            PabloAST * const expr2a = and_expr2->getExpr1();
     129            PabloAST * const expr2b = and_expr2->getExpr2();
     130            //These optimizations factor out common components that can occur when sets are formed by union
     131            //(e.g., union of [a-z] and [A-Z].
     132            if (equals(expr1a, expr2a)) {
     133                return createAnd(expr1a, createOr(expr1b, expr2b));
     134            }
     135            else if (equals(expr1b, expr2b)) {
     136                return createAnd(expr1b, createOr(expr1a, expr2a));
     137            }
     138            else if (equals(expr1a, expr2b)) {
     139                return createAnd(expr1a, createOr(expr1b, expr2a));
     140            }
     141            else if (equals(expr1b, expr2a)) {
     142                return createAnd(expr1b, createOr(expr1a, expr2b));
     143            }
     144        }
     145    }
    90146    return insertAtInsertionPoint(new Or(expr1, expr2, this));
    91147}
    92148
    93149PabloAST * PabloBlock::createXor(PabloAST * expr1, PabloAST * expr2) {
    94     if (expr1 < expr2) {
    95         std::swap(expr1, expr2);
    96     }
    97     OptimizeXor op;
    98     return op(expr1, expr2, this);
    99 }
    100 
    101 Xor * PabloBlock::createXorImm(PabloAST * expr1, PabloAST * expr2) {
     150    if (isa<Ones>(expr1)) {
     151        return createNot(expr2);
     152    }
     153    else if (isa<Zeroes>(expr1)){
     154        return expr2;
     155    }
     156    else if (isa<Ones>(expr2)) {
     157        return createNot(expr1);
     158    }
     159    else if (isa<Zeroes>(expr2)){
     160        return expr1;
     161    }
     162    else if (Not * not1 = dyn_cast<Not>(expr1)) {
     163        if (Not * not2 = dyn_cast<Not>(expr2)) {
     164            return createXor(not1->getExpr(), not2->getExpr());
     165        }
     166    }
    102167    return insertAtInsertionPoint(new Xor(expr1, expr2,  this));
    103168}
     
    106171
    107172PabloAST * PabloBlock::createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
    108     OptimizeSel op;
    109     return op(condition, trueExpr, falseExpr, this);
    110 }
    111 
    112 Sel * PabloBlock::createSelImm(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
     173    assert (condition && trueExpr && falseExpr && pb);
     174
     175    if (isa<Ones>(condition)) {
     176        return trueExpr;
     177    }
     178    else if (isa<Zeroes>(condition)){
     179        return falseExpr;
     180    }
     181    else if (isa<Ones>(trueExpr)) {
     182        return createOr(condition, falseExpr);
     183    }
     184    else if (isa<Zeroes>(trueExpr)){
     185        return createAnd(createNot(condition), falseExpr);
     186    }
     187    else if (isa<Ones>(falseExpr)) {
     188        return createOr(createNot(condition), trueExpr);
     189    }
     190    else if (isa<Zeroes>(falseExpr)){
     191        return createAnd(condition, trueExpr);
     192    }
     193    else if (equals(trueExpr, falseExpr)) {
     194        return trueExpr;
     195    }
     196    else if (isa<Not>(trueExpr) && equals(cast<Not>(trueExpr)->getExpr(), falseExpr)) {
     197        return createXor(condition, falseExpr);
     198    }
     199    else if (isa<Not>(falseExpr) && equals(trueExpr, cast<Not>(falseExpr)->getExpr())){
     200        return createXor(condition, falseExpr);
     201    }
    113202    return insertAtInsertionPoint(new Sel(condition, trueExpr, falseExpr, this));
    114203}
    115 
    116204
    117205If * PabloBlock::createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBlock & body) {
Note: See TracChangeset for help on using the changeset viewer.