Ignore:
Timestamp:
Jan 23, 2015, 1:52:33 PM (5 years ago)
Author:
nmedfort
Message:

Preliminary steps for removal of superfluous Assigns.

File:
1 edited

Legend:

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

    r4437 r4438  
    99namespace pablo {
    1010
     11inline PabloAST * PabloBlock::renameNonNamedNode(PabloAST * expr, const std::string && prefix) {
     12    if (Statement * stmt = dyn_cast<Statement>(expr)) {
     13        if (stmt->getName()->isGenerated()) {
     14            stmt->setName(makeName(prefix, false));
     15        }
     16    }
     17    return expr;
     18}
     19
    1120/// UNARY CREATE FUNCTIONS
    1221
     
    1928        return expr;
    2029    }
    21     return insertAtInsertionPoint(new Advance(expr, shiftAmount, mSymbolGenerator, this));
     30    return insertAtInsertionPoint(new Advance(expr, shiftAmount, makeName("advance"), this));
     31}
     32
     33PabloAST * PabloBlock::createAdvance(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix) {
     34    if (isa<Zeroes>(expr) || cast<Integer>(shiftAmount)->value() == 0) {
     35        return expr;
     36    }
     37    return insertAtInsertionPoint(new Advance(expr, shiftAmount, makeName(prefix, false), this));
    2238}
    2339
     
    2541    if (isa<Zeroes>(expr) || shiftAmount == 0) {
    2642        return expr;
     43    }
     44    return insertAtInsertionPoint(new Advance(expr, mSymbolGenerator->getInteger(shiftAmount), makeName("advance"), this));
     45}
     46
     47PabloAST * PabloBlock::createAdvance(PabloAST * expr, const int shiftAmount, const std::string prefix) {
     48    if (isa<Zeroes>(expr) || shiftAmount == 0) {
     49        return renameNonNamedNode(expr, std::move(prefix));
    2750    }   
    28     return insertAtInsertionPoint(new Advance(expr, mSymbolGenerator->getInteger(shiftAmount), mSymbolGenerator, this));
     51    return insertAtInsertionPoint(new Advance(expr, mSymbolGenerator->getInteger(shiftAmount), makeName(prefix, false), this));
    2952}
    3053
     
    4568        return not1->getExpr();
    4669    }
    47     return insertAtInsertionPoint(new Not(expr, this));
     70    return insertAtInsertionPoint(new Not(expr, makeName("not"), this));
     71}
     72
     73PabloAST * PabloBlock::createNot(PabloAST * expr, const std::string prefix) {
     74    assert (expr);
     75    if (isa<Ones>(expr)) {
     76        return createZeroes();
     77    }
     78    else if (isa<Zeroes>(expr)){
     79        return createOnes();
     80    }
     81    else if (Not * not1 = dyn_cast<Not>(expr)) {       
     82        return renameNonNamedNode(not1->getExpr(), std::move(prefix));
     83    }
     84    return insertAtInsertionPoint(new Not(expr, makeName(prefix, false), this));
    4885}
    4986
     
    65102        return marker;
    66103    }
    67     return insertAtInsertionPoint(new MatchStar(marker, charclass, mSymbolGenerator, this));
     104    return insertAtInsertionPoint(new MatchStar(marker, charclass, makeName("matchstar"), this));
     105}
     106
     107PabloAST * PabloBlock::createMatchStar(PabloAST * marker, PabloAST * charclass, const std::string prefix) {
     108    assert (marker && charclass);
     109    if (isa<Zeroes>(marker) || isa<Zeroes>(charclass)) {
     110        return renameNonNamedNode(marker, std::move(prefix));
     111    }
     112    return insertAtInsertionPoint(new MatchStar(marker, charclass, makeName(prefix, false), this));
    68113}
    69114
     
    73118        return from;
    74119    }
    75     return insertAtInsertionPoint(new ScanThru(from, thru, mSymbolGenerator, this));
     120    return insertAtInsertionPoint(new ScanThru(from, thru, makeName("scanthru"), this));
     121}
     122
     123PabloAST * PabloBlock::createScanThru(PabloAST * from, PabloAST * thru, const std::string prefix) {
     124    assert (from && thru);
     125    if (isa<Zeroes>(from) || isa<Zeroes>(thru)) {       
     126        return renameNonNamedNode(from, std::move(prefix));
     127    }
     128    return insertAtInsertionPoint(new ScanThru(from, thru, makeName(prefix, false), this));
    76129}
    77130
     
    81134        return expr2;
    82135    }
    83     else if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
    84         return expr1;
    85     }
    86     else if (equals(expr1, expr2)) {
     136    else if (isa<Zeroes>(expr1) || isa<Ones>(expr2) || equals(expr1, expr2)){
    87137        return expr1;
    88138    }
     
    103153        std::swap(expr1, expr2);
    104154    }
    105     return insertAtInsertionPoint(new And(expr1, expr2, this));
    106 }
    107 
     155    return insertAtInsertionPoint(new And(expr1, expr2, makeName("and"), this));
     156}
     157
     158
     159PabloAST * PabloBlock::createAnd(PabloAST * expr1, PabloAST * expr2, const std::string prefix) {
     160    assert (expr1 && expr2);
     161    if (isa<Zeroes>(expr2) || isa<Ones>(expr1)) {
     162        return renameNonNamedNode(expr2, std::move(prefix));
     163    }
     164    else if (isa<Zeroes>(expr1) || isa<Ones>(expr2) || equals(expr1, expr2)){
     165        return renameNonNamedNode(expr1, std::move(prefix));
     166    }
     167    else if (Not * not1 = dyn_cast<Not>(expr1)) {
     168        if (Not * not2 = dyn_cast<Not>(expr2)) {
     169            return createNot(createOr(not1->getExpr(), not2->getExpr()), prefix);
     170        }
     171        else if (equals(not1->getExpr(), expr2)) {
     172            return createZeroes();
     173        }
     174    }
     175    else if (Not * not2 = dyn_cast<Not>(expr2)) {
     176        if (equals(expr1, not2->getExpr())) {
     177            return createZeroes();
     178        }
     179    }
     180    if (isa<Not>(expr1)) {
     181        std::swap(expr1, expr2);
     182    }
     183    return insertAtInsertionPoint(new And(expr1, expr2, makeName(prefix, false), this));
     184}
    108185
    109186PabloAST * PabloBlock::createOr(PabloAST * expr1, PabloAST * expr2) {
    110187    assert (expr1 && expr2);
    111     if (isa<Zeroes>(expr2) || isa<Ones>(expr1)) {
    112         return expr1;
    113     }
    114     else if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
     188    if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
    115189        return expr2;
    116190    }
    117     else if (equals(expr1, expr2)) {
     191    if (isa<Zeroes>(expr2) || isa<Ones>(expr1) || equals(expr1, expr2)) {
    118192        return expr1;
    119193    }
     
    151225        }
    152226    }
    153     return insertAtInsertionPoint(new Or(expr1, expr2, this));
     227    return insertAtInsertionPoint(new Or(expr1, expr2, makeName("or"), this));
     228}
     229
     230PabloAST * PabloBlock::createOr(PabloAST * expr1, PabloAST * expr2, const std::string prefix) {
     231    assert (expr1 && expr2);
     232    if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
     233        return renameNonNamedNode(expr2, std::move(prefix));
     234    }
     235    if (isa<Zeroes>(expr2) || isa<Ones>(expr1) || equals(expr1, expr2)) {
     236        return renameNonNamedNode(expr1, std::move(prefix));
     237    }
     238    else if (Not * not1 = dyn_cast<Not>(expr1)) {
     239        // ¬a√b = ¬¬(¬a√b) = ¬(a ∧ ¬b)
     240        return createNot(createAnd(not1->getExpr(), createNot(expr2)), prefix);
     241    }
     242    else if (Not * not2 = dyn_cast<Not>(expr2)) {
     243        // a√¬b = ¬¬(¬b√a) = ¬(b ∧ ¬a)
     244        return createNot(createAnd(not2->getExpr(), createNot(expr1)), prefix);
     245    }
     246    else if (And * and_expr1 = dyn_cast<And>(expr1)) {
     247        if (And * and_expr2 = dyn_cast<And>(expr2)) {
     248            PabloAST * const expr1a = and_expr1->getExpr1();
     249            PabloAST * const expr1b = and_expr1->getExpr2();
     250            PabloAST * const expr2a = and_expr2->getExpr1();
     251            PabloAST * const expr2b = and_expr2->getExpr2();
     252            //These optimizations factor out common components that can occur when sets are formed by union
     253            //(e.g., union of [a-z] and [A-Z].
     254            if (equals(expr1a, expr2a)) {
     255                return createAnd(expr1a, createOr(expr1b, expr2b), prefix);
     256            }
     257            else if (equals(expr1b, expr2b)) {
     258                return createAnd(expr1b, createOr(expr1a, expr2a), prefix);
     259            }
     260            else if (equals(expr1a, expr2b)) {
     261                return createAnd(expr1a, createOr(expr1b, expr2a), prefix);
     262            }
     263            else if (equals(expr1b, expr2a)) {
     264                return createAnd(expr1b, createOr(expr1a, expr2b), prefix);
     265            }
     266        }
     267    }
     268    return insertAtInsertionPoint(new Or(expr1, expr2, makeName(prefix, false), this));
    154269}
    155270
     
    173288        }
    174289    }
    175     return insertAtInsertionPoint(new Xor(expr1, expr2,  this));
     290    return insertAtInsertionPoint(new Xor(expr1, expr2, makeName("xor"), this));
     291}
     292
     293PabloAST * PabloBlock::createXor(PabloAST * expr1, PabloAST * expr2, const std::string prefix) {
     294    assert (expr1 && expr2);
     295    if (isa<Ones>(expr1)) {
     296        return createNot(expr2, prefix);
     297    }
     298    else if (isa<Zeroes>(expr1)){
     299        return expr2;
     300    }
     301    else if (isa<Ones>(expr2)) {
     302        return createNot(expr1, prefix);
     303    }
     304    else if (isa<Zeroes>(expr2)){
     305        return expr1;
     306    }
     307    else if (Not * not1 = dyn_cast<Not>(expr1)) {
     308        if (Not * not2 = dyn_cast<Not>(expr2)) {
     309            return createXor(not1->getExpr(), not2->getExpr(), prefix);
     310        }
     311    }
     312    return insertAtInsertionPoint(new Xor(expr1, expr2, makeName(prefix, false), this));
    176313}
    177314
     
    208345        return createXor(condition, falseExpr);
    209346    }
    210     return insertAtInsertionPoint(new Sel(condition, trueExpr, falseExpr, this));
     347    return insertAtInsertionPoint(new Sel(condition, trueExpr, falseExpr, makeName("sel"), this));
     348}
     349
     350PabloAST * PabloBlock::createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const std::string prefix) {
     351    assert (condition && trueExpr && falseExpr);
     352
     353    if (isa<Zeroes>(condition)){
     354        return renameNonNamedNode(falseExpr, std::move(prefix));
     355    }
     356    else if (isa<Ones>(condition) || equals(trueExpr, falseExpr)) {
     357        return renameNonNamedNode(trueExpr, std::move(prefix));
     358    }
     359    else if (isa<Ones>(trueExpr)) {
     360        return createOr(condition, falseExpr, prefix);
     361    }
     362    else if (isa<Zeroes>(trueExpr)){
     363        return createAnd(createNot(condition), falseExpr, prefix);
     364    }
     365    else if (isa<Ones>(falseExpr)) {
     366        return createOr(createNot(condition), trueExpr, prefix);
     367    }
     368    else if (isa<Zeroes>(falseExpr)){
     369        return createAnd(condition, trueExpr, prefix);
     370    }
     371    else if (isa<Not>(trueExpr) && equals(cast<Not>(trueExpr)->getExpr(), falseExpr)) {
     372        return createXor(condition, falseExpr, prefix);
     373    }
     374    else if (isa<Not>(falseExpr) && equals(trueExpr, cast<Not>(falseExpr)->getExpr())){
     375        return createXor(condition, falseExpr, prefix);
     376    }
     377    return insertAtInsertionPoint(new Sel(condition, trueExpr, falseExpr, makeName(prefix, false), this));
    211378}
    212379
Note: See TracChangeset for help on using the changeset viewer.