Ignore:
Timestamp:
Aug 21, 2015, 4:12:09 PM (4 years ago)
Author:
nmedfort
Message:

Initial stages of a simple boolean equation reassociation pass.

File:
1 edited

Legend:

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

    r4718 r4736  
    221221}
    222222
    223 
    224 
    225 
    226223PabloAST * PabloBlock::createAnd(PabloAST * expr1, PabloAST * expr2) {
    227224    assert (expr1 && expr2);
    228225    if (isa<Zeroes>(expr2) || isa<Ones>(expr1)) {
    229226        return expr2;
    230     }
    231     else if (isa<Zeroes>(expr1) || isa<Ones>(expr2) || equals(expr1, expr2)){
     227    } else if (isa<Zeroes>(expr1) || isa<Ones>(expr2) || equals(expr1, expr2)){
    232228        return expr1;
    233     }
    234     else if (Not * not1 = dyn_cast<Not>(expr1)) {
     229    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
    235230        if (Not * not2 = dyn_cast<Not>(expr2)) {
    236231            return createNot(createOr(not1->getExpr(), not2->getExpr()));
    237         }
    238         else if (equals(not1->getExpr(), expr2)) {
     232        } else if (equals(not1->getExpr(), expr2)) {
    239233            return createZeroes();
    240234        }
    241     }
    242     else if (Not * not2 = dyn_cast<Not>(expr2)) {
     235    } else if (Not * not2 = dyn_cast<Not>(expr2)) {
    243236        if (equals(expr1, not2->getExpr())) {
    244237            return createZeroes();
    245238        }
     239    } else if (Or * or1 = dyn_cast<Or>(expr1)) {
     240        if (equals(or1->getExpr1(), expr2) || equals(or1->getExpr2(), expr2)) {
     241            return expr2;
     242        }
     243    } else if (Or * or2 = dyn_cast<Or>(expr2)) {
     244        if (equals(or2->getExpr1(), expr1) || equals(or2->getExpr2(), expr1)) {
     245            return expr1;
     246        }
    246247    }
    247248    if (isa<Not>(expr1) || expr1 > expr2) {
     
    250251    return insertAtInsertionPoint(new And(expr1, expr2, makeName("and_")));
    251252}
    252 
    253253
    254254PabloAST * PabloBlock::createAnd(PabloAST * expr1, PabloAST * expr2, const std::string prefix) {
     
    256256    if (isa<Zeroes>(expr2) || isa<Ones>(expr1)) {
    257257        return renameNonNamedNode(expr2, std::move(prefix));
    258     }
    259     else if (isa<Zeroes>(expr1) || isa<Ones>(expr2) || equals(expr1, expr2)){
     258    } else if (isa<Zeroes>(expr1) || isa<Ones>(expr2) || equals(expr1, expr2)){
    260259        return renameNonNamedNode(expr1, std::move(prefix));
    261     }
    262     else if (Not * not1 = dyn_cast<Not>(expr1)) {
     260    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
    263261        if (Not * not2 = dyn_cast<Not>(expr2)) {
    264262            return createNot(createOr(not1->getExpr(), not2->getExpr()), prefix);
     
    267265            return createZeroes();
    268266        }
    269     }
    270     else if (Not * not2 = dyn_cast<Not>(expr2)) {
     267    } else if (Not * not2 = dyn_cast<Not>(expr2)) {
    271268        if (equals(expr1, not2->getExpr())) {
    272269            return createZeroes();
     270        }
     271    } else if (Or * or1 = dyn_cast<Or>(expr1)) {
     272        if (equals(or1->getExpr1(), expr2) || equals(or1->getExpr2(), expr2)) {
     273            return expr2;
     274        }
     275    } else if (Or * or2 = dyn_cast<Or>(expr2)) {
     276        if (equals(or2->getExpr1(), expr1) || equals(or2->getExpr2(), expr1)) {
     277            return expr1;
    273278        }
    274279    }
     
    286291    if (isa<Zeroes>(expr2) || isa<Ones>(expr1) || equals(expr1, expr2)) {
    287292        return expr1;
    288     }
    289     else if (Not * not1 = dyn_cast<Not>(expr1)) {
     293    } else if (Not * not1 = dyn_cast<Not>(expr1)) {
    290294        // ¬a√b = ¬¬(¬a√b) = ¬(a ∧ ¬b)
    291295        return createNot(createAnd(not1->getExpr(), createNot(expr2)));
    292     }
    293     else if (Not * not2 = dyn_cast<Not>(expr2)) {
     296    } else if (Not * not2 = dyn_cast<Not>(expr2)) {
    294297        // a√¬b = ¬¬(¬b√a) = ¬(b ∧ ¬a)
    295298        return createNot(createAnd(not2->getExpr(), createNot(expr1)));
    296     }
    297     else if (equals(expr1, expr2)) {
     299    } else if (equals(expr1, expr2)) {
    298300        return expr1;
    299     }
    300     else if (And * and_expr1 = dyn_cast<And>(expr1)) {
    301         if (And * and_expr2 = dyn_cast<And>(expr2)) {
    302             PabloAST * const expr1a = and_expr1->getExpr1();
    303             PabloAST * const expr1b = and_expr1->getExpr2();
    304             PabloAST * const expr2a = and_expr2->getExpr1();
    305             PabloAST * const expr2b = and_expr2->getExpr2();
     301    } else if (And * and1 = dyn_cast<And>(expr1)) {
     302        if (And * and2 = dyn_cast<And>(expr2)) {
     303            PabloAST * const expr1a = and1->getExpr1();
     304            PabloAST * const expr1b = and1->getExpr2();
     305            PabloAST * const expr2a = and2->getExpr1();
     306            PabloAST * const expr2b = and2->getExpr2();
    306307            //These optimizations factor out common components that can occur when sets are formed by union
    307308            //(e.g., union of [a-z] and [A-Z].
    308309            if (equals(expr1a, expr2a)) {
    309310                return createAnd(expr1a, createOr(expr1b, expr2b));
    310             }
    311             else if (equals(expr1b, expr2b)) {
     311            } else if (equals(expr1b, expr2b)) {
    312312                return createAnd(expr1b, createOr(expr1a, expr2a));
    313             }
    314             else if (equals(expr1a, expr2b)) {
     313            } else if (equals(expr1a, expr2b)) {
    315314                return createAnd(expr1a, createOr(expr1b, expr2a));
    316             }
    317             else if (equals(expr1b, expr2a)) {
     315            } else if (equals(expr1b, expr2a)) {
    318316                return createAnd(expr1b, createOr(expr1a, expr2b));
    319317            }
     318        } else if (equals(and1->getExpr1(), expr2) || equals(and1->getExpr2(), expr2)){
     319            // (a∧b) √ a = a
     320            return expr2;
     321        }
     322    } else if (And * and2 = dyn_cast<And>(expr2)) {
     323        if (equals(and2->getExpr1(), expr1) || equals(and2->getExpr2(), expr1)) {
     324            return expr1;
    320325        }
    321326    }
     
    342347        return createNot(createAnd(not2->getExpr(), createNot(expr1)), prefix);
    343348    }
    344     else if (And * and_expr1 = dyn_cast<And>(expr1)) {
    345         if (And * and_expr2 = dyn_cast<And>(expr2)) {
    346             PabloAST * const expr1a = and_expr1->getExpr1();
    347             PabloAST * const expr1b = and_expr1->getExpr2();
    348             PabloAST * const expr2a = and_expr2->getExpr1();
    349             PabloAST * const expr2b = and_expr2->getExpr2();
     349    else if (And * and1 = dyn_cast<And>(expr1)) {
     350        if (And * and2 = dyn_cast<And>(expr2)) {
     351            PabloAST * const expr1a = and1->getExpr1();
     352            PabloAST * const expr1b = and1->getExpr2();
     353            PabloAST * const expr2a = and2->getExpr1();
     354            PabloAST * const expr2b = and2->getExpr2();
    350355            //These optimizations factor out common components that can occur when sets are formed by union
    351356            //(e.g., union of [a-z] and [A-Z].
     
    362367                return createAnd(expr1b, createOr(expr1a, expr2b), prefix);
    363368            }
     369        } else if (equals(and1->getExpr1(), expr2) || equals(and1->getExpr2(), expr2)) {
     370            // (a∧b) √ a = a
     371            return expr2;
     372        }
     373    } else if (And * and2 = dyn_cast<And>(expr2)) {
     374        if (equals(and2->getExpr1(), expr1) || equals(and2->getExpr2(), expr1)) {
     375            return expr1;
    364376        }
    365377    }
Note: See TracChangeset for help on using the changeset viewer.