Ignore:
Timestamp:
Nov 19, 2015, 4:47:28 PM (4 years ago)
Author:
nmedfort
Message:

More work towards n-ary And/Or/Xor? functions.

File:
1 edited

Legend:

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

    r4873 r4876  
    225225}
    226226
     227
    227228PabloAST * PabloBlock::createAnd(PabloAST * expr1, PabloAST * expr2) {
    228229    assert (expr1 && expr2);
     
    232233        return expr1;
    233234    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
    234         if (Not * not2 = dyn_cast<Not>(expr2)) {
    235             return createNot(createOr(not1->getExpr(), not2->getExpr()));
    236         } else if (equals(not1->getExpr(), expr2)) {
     235        if (equals(not1->getExpr(), expr2)) {
    237236            return createZeroes();
    238237        }
     
    250249        }
    251250    }
    252     if (isa<Not>(expr1) || expr1 > expr2) {
    253         std::swap(expr1, expr2);
    254     }
    255251    return insertAtInsertionPoint(new And(expr1, expr2, makeName("and_")));
    256252}
     
    259255    assert (expr1 && expr2);
    260256    if (isa<Zeroes>(expr2) || isa<Ones>(expr1)) {
    261         return renameNonNamedNode(expr2, std::move(prefix));
    262     }
    263     else if (isa<Zeroes>(expr1) || isa<Ones>(expr2) || equals(expr1, expr2)){
    264         return renameNonNamedNode(expr1, std::move(prefix));
     257        return expr2;
     258    } else if (isa<Zeroes>(expr1) || isa<Ones>(expr2) || equals(expr1, expr2)){
     259        return expr1;
    265260    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
    266         if (Not * not2 = dyn_cast<Not>(expr2)) {
    267             return createNot(createOr(not1->getExpr(), not2->getExpr()), prefix);
    268         }
    269         else if (equals(not1->getExpr(), expr2)) {
     261        if (equals(not1->getExpr(), expr2)) {
    270262            return createZeroes();
    271263        }
     
    274266            return createZeroes();
    275267        }
    276     } else if (Or * or1 = dyn_cast<Or>(expr1)) {
     268    } if (Or * or1 = dyn_cast<Or>(expr1)) {
    277269        if (equals(or1->getOperand(0), expr2) || equals(or1->getOperand(1), expr2)) {
    278             return expr2;
     270            return expr2; // (a √ b) ∧ a = a
    279271        }
    280272    } else if (Or * or2 = dyn_cast<Or>(expr2)) {
     
    282274            return expr1;
    283275        }
    284     }
    285     if (isa<Not>(expr1) || expr1 > expr2) {
    286         std::swap(expr1, expr2);
    287276    }
    288277    return insertAtInsertionPoint(new And(expr1, expr2, makeName(prefix, false)));
     
    293282    if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
    294283        return expr2;
    295     }
    296     if (isa<Zeroes>(expr2) || isa<Ones>(expr1) || equals(expr1, expr2)) {
    297         return expr1;
    298     } else if (Not * not1 = dyn_cast<Not>(expr1)) {
    299         // ¬a√b = ¬¬(¬a√b) = ¬(a ∧ ¬b)
    300         return createNot(createAnd(not1->getExpr(), createNot(expr2)));
    301     } else if (Not * not2 = dyn_cast<Not>(expr2)) {
    302         // a√¬b = ¬¬(¬b√a) = ¬(b ∧ ¬a)
    303         return createNot(createAnd(not2->getExpr(), createNot(expr1)));
    304     } else if (equals(expr1, expr2)) {
     284    } else if (isa<Zeroes>(expr2) || isa<Ones>(expr1) || equals(expr1, expr2)) {
    305285        return expr1;
    306286    } else if (And * and1 = dyn_cast<And>(expr1)) {
    307         if (And * and2 = dyn_cast<And>(expr2)) {
    308             PabloAST * const expr1a = and1->getOperand(0);
    309             PabloAST * const expr1b = and1->getOperand(1);
    310             PabloAST * const expr2a = and2->getOperand(0);
    311             PabloAST * const expr2b = and2->getOperand(1);
    312             //These optimizations factor out common components that can occur when sets are formed by union
    313             //(e.g., union of [a-z] and [A-Z].
    314             if (equals(expr1a, expr2a)) {
    315                 return createAnd(expr1a, createOr(expr1b, expr2b));
    316             } else if (equals(expr1b, expr2b)) {
    317                 return createAnd(expr1b, createOr(expr1a, expr2a));
    318             } else if (equals(expr1a, expr2b)) {
    319                 return createAnd(expr1a, createOr(expr1b, expr2a));
    320             } else if (equals(expr1b, expr2a)) {
    321                 return createAnd(expr1b, createOr(expr1a, expr2b));
    322             }
    323         } else if (equals(and1->getOperand(0), expr2) || equals(and1->getOperand(1), expr2)){
    324             // (a∧b) √ a = a
    325             return expr2;
     287        if (equals(and1->getOperand(0), expr2) || equals(and1->getOperand(1), expr2)){
     288            return expr2; // (a ∧ b) √ a = a
    326289        }
    327290    } else if (And * and2 = dyn_cast<And>(expr2)) {
     
    330293        }
    331294    }
    332     if (expr1 > expr2) {
    333         std::swap(expr1, expr2);
    334     }
    335295    return insertAtInsertionPoint(new Or(expr1, expr2, makeName("or_")));
    336296}
     
    339299    assert (expr1 && expr2);
    340300    if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
    341         return renameNonNamedNode(expr2, std::move(prefix));
    342     }
    343     else if (isa<Zeroes>(expr2) || isa<Ones>(expr1) || equals(expr1, expr2)) {
    344         return renameNonNamedNode(expr1, std::move(prefix));
    345     } else if (Not * not1 = dyn_cast<Not>(expr1)) {
    346         // ¬a√b = ¬¬(¬a√b) = ¬(a ∧ ¬b)
    347         return createNot(createAnd(not1->getExpr(), createNot(expr2)), prefix);
    348     } else if (Not * not2 = dyn_cast<Not>(expr2)) {
    349         // a√¬b = ¬¬(¬b√a) = ¬(b ∧ ¬a)
    350         return createNot(createAnd(not2->getExpr(), createNot(expr1)), prefix);
     301        return expr2;
     302    } else if (isa<Zeroes>(expr2) || isa<Ones>(expr1) || equals(expr1, expr2)) {
     303        return expr1;
    351304    } else if (And * and1 = dyn_cast<And>(expr1)) {
    352         if (And * and2 = dyn_cast<And>(expr2)) {
    353             PabloAST * const expr1a = and1->getOperand(0);
    354             PabloAST * const expr1b = and1->getOperand(1);
    355             PabloAST * const expr2a = and2->getOperand(0);
    356             PabloAST * const expr2b = and2->getOperand(1);
    357             //These optimizations factor out common components that can occur when sets are formed by union
    358             //(e.g., union of [a-z] and [A-Z].
    359             if (equals(expr1a, expr2a)) {
    360                 return createAnd(expr1a, createOr(expr1b, expr2b), prefix);
    361             } else if (equals(expr1b, expr2b)) {
    362                 return createAnd(expr1b, createOr(expr1a, expr2a), prefix);
    363             } else if (equals(expr1a, expr2b)) {
    364                 return createAnd(expr1a, createOr(expr1b, expr2a), prefix);
    365             } else if (equals(expr1b, expr2a)) {
    366                 return createAnd(expr1b, createOr(expr1a, expr2b), prefix);
    367             }
    368         } else if (equals(and1->getOperand(0), expr2) || equals(and1->getOperand(1), expr2)) {
    369             // (a∧b) √ a = a
    370             return expr2;
     305        if (equals(and1->getOperand(0), expr2) || equals(and1->getOperand(1), expr2)){
     306            return expr2; // (a ∧ b) √ a = a
    371307        }
    372308    } else if (And * and2 = dyn_cast<And>(expr2)) {
     
    374310            return expr1;
    375311        }
    376     }
    377     if (expr1 > expr2) {
    378         std::swap(expr1, expr2);
    379312    }
    380313    return insertAtInsertionPoint(new Or(expr1, expr2, makeName(prefix, false)));
     
    385318    if (expr1 == expr2) {
    386319        return PabloBlock::createZeroes();
    387     }
    388     if (isa<Ones>(expr1)) {
    389         return createNot(expr2);
    390320    } else if (isa<Zeroes>(expr1)){
    391321        return expr2;
    392     } else if (isa<Ones>(expr2)) {
    393         return createNot(expr1);
    394322    } else if (isa<Zeroes>(expr2)){
    395323        return expr1;
    396     } else if (Not * not1 = dyn_cast<Not>(expr1)) {
    397         if (Not * not2 = dyn_cast<Not>(expr2)) {
    398             return createXor(not1->getExpr(), not2->getExpr());
    399         }
    400     }
    401     if (expr1 > expr2) {
    402         std::swap(expr1, expr2);
     324    } else if (isa<Not>(expr1) && isa<Not>(expr2)) {
     325        return createXor(cast<Not>(expr1)->getExpr(), cast<Not>(expr2)->getExpr());
    403326    }
    404327    return insertAtInsertionPoint(new Xor(expr1, expr2, makeName("xor_")));
     
    409332    if (expr1 == expr2) {
    410333        return PabloBlock::createZeroes();
    411     }
    412     if (isa<Ones>(expr1)) {
    413         return createNot(expr2, prefix);
    414334    } else if (isa<Zeroes>(expr1)){
    415335        return expr2;
    416     } else if (isa<Ones>(expr2)) {
    417         return createNot(expr1, prefix);
    418336    } else if (isa<Zeroes>(expr2)){
    419337        return expr1;
    420     } else if (Not * not1 = dyn_cast<Not>(expr1)) {
    421         if (Not * not2 = dyn_cast<Not>(expr2)) {
    422             return createXor(not1->getExpr(), not2->getExpr(), prefix);
    423         }
    424     }
    425     if (expr1 > expr2) {
    426         std::swap(expr1, expr2);
     338    } else if (isa<Not>(expr1) && isa<Not>(expr2)) {
     339        return createXor(cast<Not>(expr1)->getExpr(), cast<Not>(expr2)->getExpr());
    427340    }
    428341    return insertAtInsertionPoint(new Xor(expr1, expr2, makeName(prefix, false)));
    429342}
     343
     344
     345//PabloAST * PabloBlock::createAnd(PabloAST * expr1, PabloAST * expr2) {
     346//    assert (expr1 && expr2);
     347//    if (isa<Zeroes>(expr2) || isa<Ones>(expr1)) {
     348//        return expr2;
     349//    } else if (isa<Zeroes>(expr1) || isa<Ones>(expr2) || equals(expr1, expr2)){
     350//        return expr1;
     351//    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
     352//        if (Not * not2 = dyn_cast<Not>(expr2)) {
     353//            return createNot(createOr(not1->getExpr(), not2->getExpr()));
     354//        } else if (equals(not1->getExpr(), expr2)) {
     355//            return createZeroes();
     356//        }
     357//    } else if (Not * not2 = dyn_cast<Not>(expr2)) {
     358//        if (equals(expr1, not2->getExpr())) {
     359//            return createZeroes();
     360//        }
     361//    } else if (Or * or1 = dyn_cast<Or>(expr1)) {
     362//        if (equals(or1->getOperand(0), expr2) || equals(or1->getOperand(1), expr2)) {
     363//            return expr2;
     364//        }
     365//    } else if (Or * or2 = dyn_cast<Or>(expr2)) {
     366//        if (equals(or2->getOperand(0), expr1) || equals(or2->getOperand(1), expr1)) {
     367//            return expr1;
     368//        }
     369//    }
     370//    if (isa<Not>(expr1) || expr1 > expr2) {
     371//        std::swap(expr1, expr2);
     372//    }
     373//    return insertAtInsertionPoint(new And(expr1, expr2, makeName("and_")));
     374//}
     375
     376//PabloAST * PabloBlock::createAnd(PabloAST * expr1, PabloAST * expr2, const std::string prefix) {
     377//    assert (expr1 && expr2);
     378//    if (isa<Zeroes>(expr2) || isa<Ones>(expr1)) {
     379//        return renameNonNamedNode(expr2, std::move(prefix));
     380//    } else if (isa<Zeroes>(expr1) || isa<Ones>(expr2) || equals(expr1, expr2)){
     381//        return renameNonNamedNode(expr1, std::move(prefix));
     382//    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
     383//        if (Not * not2 = dyn_cast<Not>(expr2)) {
     384//            return createNot(createOr(not1->getExpr(), not2->getExpr()), prefix);
     385//        }
     386//        else if (equals(not1->getExpr(), expr2)) {
     387//            return createZeroes();
     388//        }
     389//    } else if (Not * not2 = dyn_cast<Not>(expr2)) {
     390//        if (equals(expr1, not2->getExpr())) {
     391//            return createZeroes();
     392//        }
     393//    } else if (Or * or1 = dyn_cast<Or>(expr1)) {
     394//        if (equals(or1->getOperand(0), expr2) || equals(or1->getOperand(1), expr2)) {
     395//            return expr2;
     396//        }
     397//    } else if (Or * or2 = dyn_cast<Or>(expr2)) {
     398//        if (equals(or2->getOperand(0), expr1) || equals(or2->getOperand(1), expr1)) {
     399//            return expr1;
     400//        }
     401//    }
     402//    if (isa<Not>(expr1) || expr1 > expr2) {
     403//        std::swap(expr1, expr2);
     404//    }
     405//    return insertAtInsertionPoint(new And(expr1, expr2, makeName(prefix, false)));
     406//}
     407
     408//PabloAST * PabloBlock::createOr(PabloAST * expr1, PabloAST * expr2) {
     409//    assert (expr1 && expr2);
     410//    if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
     411//        return expr2;
     412//    }
     413//    if (isa<Zeroes>(expr2) || isa<Ones>(expr1) || equals(expr1, expr2)) {
     414//        return expr1;
     415//    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
     416//        // ¬a√b = ¬¬(¬a√b) = ¬(a ∧ ¬b)
     417//        return createNot(createAnd(not1->getExpr(), createNot(expr2)));
     418//    } else if (Not * not2 = dyn_cast<Not>(expr2)) {
     419//        // a√¬b = ¬¬(¬b√a) = ¬(b ∧ ¬a)
     420//        return createNot(createAnd(not2->getExpr(), createNot(expr1)));
     421//    } else if (equals(expr1, expr2)) {
     422//        return expr1;
     423//    } else if (And * and1 = dyn_cast<And>(expr1)) {
     424//        if (And * and2 = dyn_cast<And>(expr2)) {
     425//            PabloAST * const expr1a = and1->getOperand(0);
     426//            PabloAST * const expr1b = and1->getOperand(1);
     427//            PabloAST * const expr2a = and2->getOperand(0);
     428//            PabloAST * const expr2b = and2->getOperand(1);
     429//            //These optimizations factor out common components that can occur when sets are formed by union
     430//            //(e.g., union of [a-z] and [A-Z].
     431//            if (equals(expr1a, expr2a)) {
     432//                return createAnd(expr1a, createOr(expr1b, expr2b));
     433//            } else if (equals(expr1b, expr2b)) {
     434//                return createAnd(expr1b, createOr(expr1a, expr2a));
     435//            } else if (equals(expr1a, expr2b)) {
     436//                return createAnd(expr1a, createOr(expr1b, expr2a));
     437//            } else if (equals(expr1b, expr2a)) {
     438//                return createAnd(expr1b, createOr(expr1a, expr2b));
     439//            }
     440//        } else if (equals(and1->getOperand(0), expr2) || equals(and1->getOperand(1), expr2)){
     441//            // (a∧b) √ a = a
     442//            return expr2;
     443//        }
     444//    } else if (And * and2 = dyn_cast<And>(expr2)) {
     445//        if (equals(and2->getOperand(0), expr1) || equals(and2->getOperand(1), expr1)) {
     446//            return expr1;
     447//        }
     448//    }
     449//    if (expr1 > expr2) {
     450//        std::swap(expr1, expr2);
     451//    }
     452//    return insertAtInsertionPoint(new Or(expr1, expr2, makeName("or_")));
     453//}
     454
     455//PabloAST * PabloBlock::createOr(PabloAST * expr1, PabloAST * expr2, const std::string prefix) {
     456//    assert (expr1 && expr2);
     457//    if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
     458//        return renameNonNamedNode(expr2, std::move(prefix));
     459//    }
     460//    else if (isa<Zeroes>(expr2) || isa<Ones>(expr1) || equals(expr1, expr2)) {
     461//        return renameNonNamedNode(expr1, std::move(prefix));
     462//    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
     463//        // ¬a√b = ¬¬(¬a√b) = ¬(a ∧ ¬b)
     464//        return createNot(createAnd(not1->getExpr(), createNot(expr2)), prefix);
     465//    } else if (Not * not2 = dyn_cast<Not>(expr2)) {
     466//        // a√¬b = ¬¬(¬b√a) = ¬(b ∧ ¬a)
     467//        return createNot(createAnd(not2->getExpr(), createNot(expr1)), prefix);
     468//    } else if (And * and1 = dyn_cast<And>(expr1)) {
     469//        if (And * and2 = dyn_cast<And>(expr2)) {
     470//            PabloAST * const expr1a = and1->getOperand(0);
     471//            PabloAST * const expr1b = and1->getOperand(1);
     472//            PabloAST * const expr2a = and2->getOperand(0);
     473//            PabloAST * const expr2b = and2->getOperand(1);
     474//            //These optimizations factor out common components that can occur when sets are formed by union
     475//            //(e.g., union of [a-z] and [A-Z].
     476//            if (equals(expr1a, expr2a)) {
     477//                return createAnd(expr1a, createOr(expr1b, expr2b), prefix);
     478//            } else if (equals(expr1b, expr2b)) {
     479//                return createAnd(expr1b, createOr(expr1a, expr2a), prefix);
     480//            } else if (equals(expr1a, expr2b)) {
     481//                return createAnd(expr1a, createOr(expr1b, expr2a), prefix);
     482//            } else if (equals(expr1b, expr2a)) {
     483//                return createAnd(expr1b, createOr(expr1a, expr2b), prefix);
     484//            }
     485//        } else if (equals(and1->getOperand(0), expr2) || equals(and1->getOperand(1), expr2)) {
     486//            // (a∧b) √ a = a
     487//            return expr2;
     488//        }
     489//    } else if (And * and2 = dyn_cast<And>(expr2)) {
     490//        if (equals(and2->getOperand(0), expr1) || equals(and2->getOperand(1), expr1)) {
     491//            return expr1;
     492//        }
     493//    }
     494//    if (expr1 > expr2) {
     495//        std::swap(expr1, expr2);
     496//    }
     497//    return insertAtInsertionPoint(new Or(expr1, expr2, makeName(prefix, false)));
     498//}
     499
     500//PabloAST * PabloBlock::createXor(PabloAST * expr1, PabloAST * expr2) {
     501//    assert (expr1 && expr2);
     502//    if (expr1 == expr2) {
     503//        return PabloBlock::createZeroes();
     504//    }
     505//    if (isa<Ones>(expr1)) {
     506//        return createNot(expr2);
     507//    } else if (isa<Zeroes>(expr1)){
     508//        return expr2;
     509//    } else if (isa<Ones>(expr2)) {
     510//        return createNot(expr1);
     511//    } else if (isa<Zeroes>(expr2)){
     512//        return expr1;
     513//    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
     514//        if (Not * not2 = dyn_cast<Not>(expr2)) {
     515//            return createXor(not1->getExpr(), not2->getExpr());
     516//        }
     517//    }
     518//    if (expr1 > expr2) {
     519//        std::swap(expr1, expr2);
     520//    }
     521//    return insertAtInsertionPoint(new Xor(expr1, expr2, makeName("xor_")));
     522//}
     523
     524//PabloAST * PabloBlock::createXor(PabloAST * expr1, PabloAST * expr2, const std::string prefix) {
     525//    assert (expr1 && expr2);
     526//    if (expr1 == expr2) {
     527//        return PabloBlock::createZeroes();
     528//    }
     529//    if (isa<Ones>(expr1)) {
     530//        return createNot(expr2, prefix);
     531//    } else if (isa<Zeroes>(expr1)){
     532//        return expr2;
     533//    } else if (isa<Ones>(expr2)) {
     534//        return createNot(expr1, prefix);
     535//    } else if (isa<Zeroes>(expr2)){
     536//        return expr1;
     537//    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
     538//        if (Not * not2 = dyn_cast<Not>(expr2)) {
     539//            return createXor(not1->getExpr(), not2->getExpr(), prefix);
     540//        }
     541//    }
     542//    if (expr1 > expr2) {
     543//        std::swap(expr1, expr2);
     544//    }
     545//    return insertAtInsertionPoint(new Xor(expr1, expr2, makeName(prefix, false)));
     546//}
    430547
    431548/// TERNARY CREATE FUNCTION
Note: See TracChangeset for help on using the changeset viewer.