Changeset 4876 for icGREP


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

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

Location:
icGREP/icgrep-devel/icgrep
Files:
3 added
17 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/CMakeLists.txt

    r4868 r4876  
    7070SET(PABLO_SRC ${PABLO_SRC} pablo/pablo_compiler.cpp pablo/carry_manager.cpp pablo/carry_data.cpp IDISA/idisa_builder.cpp)
    7171SET(PABLO_SRC ${PABLO_SRC} pablo/analysis/pabloverifier.cpp)
    72 SET(PABLO_SRC ${PABLO_SRC} pablo/optimizers/pablo_simplifier.cpp pablo/optimizers/codemotionpass.cpp pablo/optimizers/booleanreassociationpass.cpp)
     72SET(PABLO_SRC ${PABLO_SRC} pablo/optimizers/pablo_simplifier.cpp pablo/optimizers/codemotionpass.cpp pablo/passes/flattenassociativedfg.cpp)
     73SET(PABLO_SRC ${PABLO_SRC} pablo/optimizers/booleanreassociationpass.cpp)
    7374IF (ENABLE_MULTIPLEXING)
    7475SET(PABLO_SRC ${PABLO_SRC} pablo/optimizers/pablo_automultiplexing.cpp pablo/optimizers/pablo_bddminimization.cpp)
  • icGREP/icgrep-devel/icgrep/icgrep-devel.files

    r4868 r4876  
    484484UCD/unicode_set.h
    485485UCD/unicode_set.cpp
     486pablo/passes/flattenassociativedfg.h
     487pablo/passes/flattenassociativedfg.cpp
  • icGREP/icgrep-devel/icgrep/icgrep-devel.includes

    r4868 r4876  
    1111../cudd-2.5.1/cudd
    1212../buddy-2.4/src
     13pablo/passes
  • icGREP/icgrep-devel/icgrep/pablo/analysis/pabloverifier.cpp

    r4870 r4876  
    102102                str << "PabloVerifier: def-use error: ";
    103103                PabloPrinter::print(stmt, str);
    104                 str << " is not a user of ";
     104                str << " is not recorded in ";
    105105                PabloPrinter::print(def, str);
     106                str << "'s user list";
    106107                throw std::runtime_error(str.str());
    107108            }
     
    295296            const PabloAST * const op = stmt->getOperand(i);
    296297            if (LLVM_UNLIKELY((isa<Statement>(op) || isa<Var>(op)) && ov.count(op) == 0)) {
    297 
    298298                std::string tmp;
    299299                raw_string_ostream str(tmp);
     
    301301                if (LLVM_UNLIKELY(recursivelyDefined(stmt))) {
    302302                    PabloPrinter::print(stmt, str);
    303                     str << " is recursively defined!";
     303                    str << " is defined by a recursive function!";
    304304                    throw std::runtime_error(str.str());
    305305                }
     
    308308
    309309                str << "function is not topologically ordered! ";
    310                 PabloPrinter::print(stmt->getOperand(i), str);
    311                 str << " was used before definition by ";
     310                PabloAST * op = stmt->getOperand(i);
     311                PabloPrinter::print(op, str);
     312                if (LLVM_UNLIKELY(isa<Statement>(op) && unreachable(stmt, cast<Statement>(op)->getParent()))) {
     313                    str << " was defined in a scope that is unreachable by ";
     314                } else {
     315                    str << " was used before definition by ";
     316                }
    312317                PabloPrinter::print(stmt, str);
    313318                throw std::runtime_error(str.str());
  • 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
  • icGREP/icgrep-devel/icgrep/pablo/expression_map.hpp

    r4718 r4876  
    113113        }
    114114
     115        inline Key(PabloAST::ClassTypeId type, const Variadic * stmt, Allocator & allocator)
     116        : mType(type)
     117        , mArgs(stmt->getNumOperands())
     118        , mArg(allocator.Allocate<const PabloAST *>(mArgs)) {
     119            unsigned i = 0;
     120            for (PabloAST * arg : *stmt) {
     121                mArg[i++] = arg;
     122            }
     123        }
     124
    115125        inline Key(const Key & key) = default;
    116126
     
    168178    }
    169179
    170     inline std::pair<PabloAST *, bool> findOrAdd(PabloAST * object, const PabloAST::ClassTypeId type, PabloAST * arg1, const std::vector<PabloAST *> & args) {
    171         Key key(type, arg1, args, mAllocator);
     180    inline std::pair<PabloAST *, bool> findOrAdd(Variadic * object, const PabloAST::ClassTypeId type) {
     181        Key key(type, object, mAllocator);
    172182        PabloAST * const entry = find(key);
    173183        if (entry) {
     
    265275            case PabloAST::ClassTypeId::Or:
    266276            case PabloAST::ClassTypeId::Xor:
    267                 // test whether the communative version of this statement exists
    268                 if (PabloAST * commExpr = mBinary.find(stmt->getClassTypeId(), stmt->getOperand(1), stmt->getOperand(0))) {
    269                     return std::make_pair(commExpr, false);
    270                 }
     277                return mVariable.findOrAdd(cast<Variadic>(stmt), stmt->getClassTypeId());
    271278            case PabloAST::ClassTypeId::Advance:
    272279            case PabloAST::ClassTypeId::ScanThru:
  • icGREP/icgrep-devel/icgrep/pablo/function.h

    r4870 r4876  
    5858class PabloFunction : public Prototype {
    5959    friend class PabloBlock;
    60     using ParamAllocator = VectorAllocator::rebind<Var *>::other;
    61     using ResultAllocator = VectorAllocator::rebind<Assign *>::other;
     60    using ParamAllocator = Allocator::rebind<Var *>::other;
     61    using ResultAllocator = Allocator::rebind<Assign *>::other;
    6262public:
    6363
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/pablo_simplifier.cpp

    r4871 r4876  
    3636
    3737/** ------------------------------------------------------------------------------------------------------------- *
     38 * @brief isReassociatable
     39 ** ------------------------------------------------------------------------------------------------------------- */
     40inline bool isReassociatable(const Statement * const stmt) {
     41    switch (stmt->getClassTypeId()) {
     42        case PabloAST::ClassTypeId::And:
     43        case PabloAST::ClassTypeId::Or:
     44        case PabloAST::ClassTypeId::Xor:
     45            return true;
     46        default: return false;
     47    }
     48}
     49
     50/** ------------------------------------------------------------------------------------------------------------- *
     51 * @brief foldReassociativeFunction
     52 ** ------------------------------------------------------------------------------------------------------------- */
     53PabloAST * Simplifier::foldReassociativeFunction(Variadic * const var, PabloBlock * const block) {
     54
     55    assert (var);
     56
     57    // Ensure all operands of a reassociatiable function are consistently ordered.
     58    std::sort(var->begin(), var->end());
     59
     60    // Apply the idempotence law to any And and Or statement and the identity law to any Xor
     61    for (unsigned i = 1; i < var->getNumOperands(); ) {
     62        if (var->getOperand(i - 1) == var->getOperand(i)) {
     63            var->removeOperand(i);
     64            if (LLVM_UNLIKELY(isa<Xor>(var))) {
     65                var->removeOperand(i - 1);
     66                if (LLVM_UNLIKELY(var->getNumOperands() == 0)) {
     67                    return PabloBlock::createZeroes();
     68                }
     69            }
     70            continue;
     71        }
     72        ++i;
     73    }
     74
     75    // Apply the complementation law whenever possible.
     76    bool negated = false;
     77    for (unsigned i = 0; i < var->getNumOperands(); ++i) {
     78        if (isa<Not>(var->getOperand(i))) {
     79            PabloAST * const negatedOp = cast<Not>(var->getOperand(i))->getOperand(0);
     80            bool complementation = false;
     81            for (unsigned j = 0; j != var->getNumOperands(); ++j) {
     82                if (LLVM_UNLIKELY(var->getOperand(j) == negatedOp)) {
     83                    if (isa<And>(var)) { // (A ∧ ¬A) ∧ B = 0 for any B
     84                        return PabloBlock::createZeroes();
     85                    } else if (isa<Or>(var)) { // (A √ ¬A) √ B = 1 for any B
     86                        return PabloBlock::createOnes();
     87                    }
     88                    var->removeOperand(i); // (A ⊕ ¬A) ⊕ B = 1 ⊕ B = ¬B for any B
     89                    var->removeOperand(j);
     90                    negated = !negated;
     91                    complementation = true;
     92                    break;
     93                }
     94            }
     95            if (complementation) {
     96                continue;
     97            }
     98        }
     99        ++i;
     100    }
     101
     102    // Apply the annihilator and identity laws
     103    for (unsigned i = 0; i != var->getNumOperands(); ) {
     104        if (LLVM_UNLIKELY(isa<Zeroes>(var->getOperand(i)))) {
     105            if (isa<And>(var)) {
     106                return PabloBlock::createZeroes();
     107            }
     108            var->removeOperand(i);
     109            continue;
     110        } else if (LLVM_UNLIKELY(isa<Ones>(var->getOperand(i)))) {
     111            if (isa<Or>(var)) {
     112                return PabloBlock::createOnes();
     113            } else if (isa<Xor>(var)) {
     114                negated = !negated;
     115            }
     116            var->removeOperand(i);
     117            continue;
     118        }
     119        ++i;
     120    }
     121
     122    PabloAST * replacement = nullptr;
     123    if (LLVM_UNLIKELY(var->getNumOperands() < 2)) {
     124        replacement = (var->getNumOperands() == 0) ? PabloBlock::createZeroes() : var->getOperand(0);
     125    }
     126    if (LLVM_UNLIKELY(negated)) {
     127        block->setInsertPoint(var);
     128        if (replacement) {
     129            replacement = block->createNot(replacement);
     130        } else {
     131            var->replaceAllUsesWith(block->createNot(var));
     132        }
     133    }
     134    return replacement;
     135}
     136
     137/** ------------------------------------------------------------------------------------------------------------- *
    38138 * @brief canTriviallyFold
    39139 ** ------------------------------------------------------------------------------------------------------------- */
     
    42142        if (LLVM_UNLIKELY(isa<Zeroes>(stmt->getOperand(i)))) {
    43143            switch (stmt->getClassTypeId()) {
    44                 case PabloAST::ClassTypeId::And:
    45144                case PabloAST::ClassTypeId::Advance:
    46145                    return block->createZeroes();
    47                 case PabloAST::ClassTypeId::Xor:
    48                 case PabloAST::ClassTypeId::Or:
    49                     return stmt->getOperand(1 - i);
    50146                case PabloAST::ClassTypeId::Not:
    51147                    return block->createOnes();
     
    65161            block->setInsertPoint(stmt->getPrevNode());
    66162            switch (stmt->getClassTypeId()) {
    67                 case PabloAST::ClassTypeId::And:
    68                     return stmt->getOperand(1 - i);
    69                 case PabloAST::ClassTypeId::Or:
    70                     return block->createOnes();
    71                 case PabloAST::ClassTypeId::Xor:
    72                     return block->createNot(stmt->getOperand(1 - i));
    73163                case PabloAST::ClassTypeId::Not:
    74164                    return block->createZeroes();
     
    240330            replaceReachableUsersOfWith(next, next->getExpr());
    241331        } else if (If * ifNode = dyn_cast<If>(stmt)) {
     332            // Test whether we can ever take this branch
     333            if (LLVM_UNLIKELY(isa<Zeroes>(cast<If>(stmt)->getCondition()))) {
     334                stmt = stmt->eraseFromParent();
     335                continue;
     336            }
    242337            // Test whether all of the defined variables are necessary
    243338            If::DefinedVars & defs = ifNode->getDefined();
     
    282377
    283378        } else if (While * whileNode = dyn_cast<While>(stmt)) {
     379            // Test whether we can ever take this branch
     380            const PabloAST * initial = cast<While>(stmt)->getCondition();
     381            if (LLVM_LIKELY(isa<Next>(initial))) {
     382                initial = cast<Next>(initial)->getInitial();
     383            }
     384            if (LLVM_UNLIKELY(isa<Zeroes>(initial))) {
     385                stmt = stmt->eraseFromParent();
     386                continue;
     387            }
    284388            eliminateRedundantCode(whileNode->getBody(), &encountered);
    285389            removeIdenticalEscapedValues(whileNode->getVariants());
    286390            // If the condition's Next state is Zero, we can eliminate the loop after copying the internal
    287391            // statements into the body.
    288 
    289 
    290         } else if (PabloAST * expr = canTriviallyFold(stmt, block)) {
    291             stmt = stmt->replaceWith(expr, true);
    292             continue;
    293392        } else {
     393            PabloAST * folded = nullptr;
     394            if (isReassociatable(stmt)) {
     395                folded =  foldReassociativeFunction(cast<Variadic>(stmt), block);
     396            } else {
     397                folded = canTriviallyFold(stmt, block);
     398            }
     399            if (folded) {
     400                // If we determine we can fold this statement,
     401                Statement * const prior = stmt->getPrevNode();
     402                stmt->replaceWith(folded, true);
     403                stmt = prior ? prior->getNextNode() : block->front();
     404                continue;
     405            }
    294406            // When we're creating the Pablo program, it's possible to have multiple instances of an "identical"
    295407            // statement. By recording which statements have already been seen, we can detect the redundant statements
     
    301413                continue;
    302414            }
     415
    303416        }
    304417        stmt = stmt->getNextNode();
     
    313426    while (stmt) {
    314427        if (isa<If>(stmt)) {
    315             if (LLVM_UNLIKELY(isa<Zeroes>(cast<If>(stmt)->getCondition()))) {
    316                 stmt = stmt->eraseFromParent();
    317                 continue;
    318             }
    319428            deadCodeElimination(cast<If>(stmt)->getBody());
    320429        } else if (isa<While>(stmt)) {
    321             const PabloAST * initial = cast<While>(stmt)->getCondition();
    322             if (LLVM_LIKELY(isa<Next>(initial))) {
    323                 initial = cast<Next>(initial)->getInitial();
    324             }
    325             if (LLVM_UNLIKELY(isa<Zeroes>(initial))) {
    326                 stmt = stmt->eraseFromParent();
    327                 continue;
    328             }
    329430            deadCodeElimination(cast<While>(stmt)->getBody());
    330431        } else if (stmt->getNumUses() == 0){
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/pablo_simplifier.hpp

    r4871 r4876  
    1010
    1111class Simplifier {
     12    friend class FlattenAssociativeDFG;
    1213public:
    1314    static bool optimize(PabloFunction & function);
     
    1617private:
    1718    static void eliminateRedundantCode(PabloBlock * const block, ExpressionTable * predecessor = nullptr);
     19    static PabloAST * foldReassociativeFunction(Variadic * const var, PabloBlock * const block);
    1820    static void deadCodeElimination(PabloBlock * const block);
    1921    static void eliminateRedundantEquations(PabloBlock * const block);
  • icGREP/icgrep-devel/icgrep/pablo/pabloAST.cpp

    r4873 r4876  
    1010#include <pablo/printer_pablos.h>
    1111#include <llvm/ADT/SmallVector.h>
     12#include <iostream>
    1213
    1314namespace pablo {
     
    1516PabloAST::Allocator PabloAST::mAllocator;
    1617
    17 /*
    18 
    19     Return true if expr1 and expr2 can be proven equivalent according to some rules,
    20     false otherwise.  Note that false may be returned i some cases when the exprs are
    21     equivalent.
    22 
    23 */
    24 
    2518/** ------------------------------------------------------------------------------------------------------------- *
    2619 * @brief equals
     20 *
     21 *  Return true if expr1 and expr2 can be proven equivalent according to some rules, false otherwise.  Note that
     22 *  false may be returned i some cases when the exprs are equivalent.
    2723 ** ------------------------------------------------------------------------------------------------------------- */
    2824bool equals(const PabloAST * expr1, const PabloAST * expr2) {
     
    8783 ** ------------------------------------------------------------------------------------------------------------- */
    8884void PabloAST::replaceAllUsesWith(PabloAST * expr) {
     85    assert (expr);
    8986    if (LLVM_UNLIKELY(this == expr)) {
    9087        return;
    9188    }
    92     Statement * replacements[mUsers.size()];
    93     Vector::size_type users = 0;
    94     bool exprIsAUser = false;
    95     assert (expr);
     89    Statement * replacement[mUsers.size()];
     90    Users::size_type replacements = 0;
     91    PabloAST * last = nullptr;
    9692    for (PabloAST * user : mUsers) {
    97         if (LLVM_UNLIKELY(user == expr)) {
    98             exprIsAUser = true;
     93        if (LLVM_UNLIKELY(user == expr || user == last)) {
    9994            continue;
    100         }
    101         replacements[users++] = cast<Statement>(user);
    102     }
    103     mUsers.clear();
    104     if (LLVM_UNLIKELY(exprIsAUser)) {
    105         mUsers.push_back(expr);
    106     }
    107     for (Vector::size_type i = 0; i != users; ++i) {
    108         replacements[i]->replaceUsesOfWith(this, expr);
     95        } else if (isa<Statement>(user)) {
     96            replacement[replacements++] = cast<Statement>(user);
     97            last = user;
     98        }
     99    }
     100    for (Users::size_type i = 0; i != replacements; ++i) {
     101        replacement[i]->replaceUsesOfWith(this, expr);
    109102    }
    110103}
     
    161154 ** ------------------------------------------------------------------------------------------------------------- */
    162155void Statement::setOperand(const unsigned index, PabloAST * const value) {
    163     assert (value);
     156    assert ("No operand can be null!" && value);
    164157    assert (index < getNumOperands());
    165     PabloAST * const priorValue = getOperand(index);
    166     if (LLVM_UNLIKELY(priorValue == value)) {
     158    PabloAST * const prior = getOperand(index);
     159    assert ("No operand can be null!" && prior);
     160    if (LLVM_UNLIKELY(prior == value)) {
    167161        return;
    168162    }   
    169     if (LLVM_LIKELY(priorValue != nullptr)) {
    170         // Test just to be sure that we don't have multiple operands pointing to
    171         // what we're replacing. If not, remove this from the prior value's
    172         // user list.
    173         unsigned count = 0;
    174         for (unsigned i = 0; i != getNumOperands(); ++i) {
    175             count += (getOperand(i) == priorValue) ? 1 : 0;
    176         }
    177         assert (count >= 1);
    178         if (LLVM_LIKELY(count == 1)) {
    179             priorValue->removeUser(this);
    180         }
    181     }
     163    prior->removeUser(this);
    182164    mOperand[index] = value;
    183165    value->addUser(this);
     
    336318        if (LLVM_UNLIKELY(redundantBranches.size() != 0)) {
    337319            // By eliminating this redundant branch, we may inadvertantly delete the scope block this statement
    338             // resides within. Check and return null if so.
     320            // resides within. Return null if so.
    339321            bool eliminatedScope = false;
    340322            for (Statement * br : redundantBranches) {
     
    376358 * @brief addOperand
    377359 ** ------------------------------------------------------------------------------------------------------------- */
    378 void Variadic::addOperand(PabloAST * expr) {
    379     unsigned index = 0;
    380     for (; index != mOperands; ++index) {
    381         if (mOperand[index] > expr) {
    382             break;
    383         }
    384     }
    385     if (mOperands == mCapacity) {
     360void Variadic::addOperand(PabloAST * const expr) {
     361    if (LLVM_UNLIKELY(mOperands == mCapacity)) {
    386362        mCapacity = std::max<unsigned>(mCapacity * 2, 2);
    387         PabloAST ** expandedArray = reinterpret_cast<PabloAST**>(mAllocator.allocate(mOperands * sizeof(PabloAST *)));
    388         std::memcpy(expandedArray, mOperand, mOperands * sizeof(PabloAST *));
     363        PabloAST ** expandedOperandSpace = reinterpret_cast<PabloAST**>(mAllocator.allocate(mCapacity * sizeof(PabloAST *)));
     364        for (unsigned i = 0; i != mOperands; ++i) {
     365            expandedOperandSpace[i] = mOperand[i];
     366        }
    389367        mAllocator.deallocate(reinterpret_cast<Allocator::pointer>(mOperand));
    390         mOperand = expandedArray;
    391     }
    392     std::memcpy(mOperand + index + 1, mOperand + index, (mOperands - index) * sizeof(PabloAST *));
    393     mOperand[index] = expr;
    394     ++mOperands;
     368        mOperand = expandedOperandSpace;
     369    }
     370    mOperand[mOperands++] = expr;
     371    expr->addUser(this);
    395372}
    396373
     
    398375 * @brief removeOperand
    399376 ** ------------------------------------------------------------------------------------------------------------- */
    400 void Variadic::removeOperand(const unsigned index) {
    401     assert (index < getNumOperands());
    402     std::memcpy(mOperand + index, mOperand + index + 1, (mOperands - index - 1) * sizeof(PabloAST *));
     377PabloAST * Variadic::removeOperand(const unsigned index) {
     378    assert (index < mOperands);
     379    PabloAST * const expr = mOperand[index];
    403380    --mOperands;
     381    for (unsigned i = index; i != mOperands; ++i) {
     382        mOperand[i] = mOperand[i + 1];
     383    }
     384    mOperand[mOperands] = nullptr;
     385    expr->removeUser(this);
     386    return expr;
    404387}
    405388
     
    414397    }
    415398    return false;
    416 }
    417 
    418 StatementList::~StatementList() {
    419 
    420399}
    421400
  • icGREP/icgrep-devel/icgrep/pablo/pabloAST.h

    r4873 r4876  
    1414#include <iterator>
    1515#include <unordered_map>
     16#include <boost/iterator/iterator_facade.hpp>
    1617
    1718using namespace llvm;
     
    2526class PabloAST {
    2627    friend class Statement;
     28    friend class Variadic;
    2729    friend class StatementList;
    2830    friend class Var;
     
    3739    using Allocator = SlabAllocator<u_int8_t>;
    3840    using VectorAllocator = Allocator::rebind<PabloAST *>::other;
    39     using Vector = std::vector<PabloAST*, VectorAllocator>;
    40     using user_iterator = Vector::iterator;
    41     using const_user_iterator = Vector::const_iterator;
     41    using Users = std::vector<PabloAST *, VectorAllocator>;
     42    using user_iterator = Users::iterator;
     43    using const_user_iterator = Users::const_iterator;
    4244
    4345    enum class ClassTypeId : unsigned {
     
    99101    }
    100102
    101     inline Vector & users() {
     103    inline Users & users() {
    102104        return mUsers;
    103105    }
    104106
    105     inline const Vector & users() const {
     107    inline const Users & users() const {
    106108        return mUsers;
    107109    }
     
    109111    void replaceAllUsesWith(PabloAST * expr);
    110112
    111     inline Vector::size_type getNumUses() const {
     113    inline Users::size_type getNumUses() const {
    112114        return mUsers.size();
    113115    }
     
    128130
    129131    }
    130     inline void addUser(PabloAST * user) {
    131         assert (user);
    132         auto pos = std::lower_bound(mUsers.begin(), mUsers.end(), user);
    133         if (LLVM_UNLIKELY(pos != mUsers.end() && *pos == user)) {
    134             return;
    135         }
    136         mUsers.insert(pos, user);
    137     }
    138     inline void removeUser(PabloAST * user) {
    139         assert (user);
    140         if (mUsers.empty()) {
    141             return;
    142         }
    143         auto pos = std::lower_bound(mUsers.begin(), mUsers.end(), user);
    144         if (LLVM_UNLIKELY(pos == mUsers.end() || *pos != user)) {
    145             return;
    146         }
    147         mUsers.erase(pos);
    148     }
     132    void addUser(PabloAST * user);
     133    void removeUser(PabloAST * user);
    149134    virtual ~PabloAST() {
    150135        mUsers.clear();
     
    153138private:
    154139    const ClassTypeId       mClassTypeId;
    155     Vector                  mUsers;
     140    Users                   mUsers;
    156141};
    157142
     
    259244class Variadic : public Statement {
    260245public:
    261     void addOperand(PabloAST * expr);
    262     void removeOperand(const unsigned index);
     246
     247    static inline bool classof(const PabloAST * e) {
     248        switch (e->getClassTypeId()) {
     249            case PabloAST::ClassTypeId::And:
     250            case PabloAST::ClassTypeId::Or:
     251            case PabloAST::ClassTypeId::Xor:
     252                return true;
     253            default: return false;
     254        }
     255    }
     256    static inline bool classof(const Variadic *) {
     257        return true;
     258    }
     259    static inline bool classof(const void *) {
     260        return false;
     261    }
     262
     263    class iterator : public boost::iterator_facade<iterator, PabloAST *, boost::random_access_traversal_tag> {
     264        friend class Variadic;
     265        friend class boost::iterator_core_access;
     266    protected:
     267
     268        iterator(PabloAST ** pointer) : mCurrent(pointer) { }
     269        inline void increment() { ++mCurrent; }
     270        inline void decrement() { --mCurrent; }
     271        inline void advance(const unsigned n) { mCurrent += n; }
     272        inline std::ptrdiff_t distance_to(const iterator & other) const { return other.mCurrent - mCurrent; }
     273        inline PabloAST *& dereference() const { return *mCurrent; }
     274
     275        inline bool equal(const iterator & other) const { return (mCurrent == other.mCurrent); }
     276
     277    private:
     278        PabloAST **        mCurrent;
     279    };
     280
     281    using const_iterator = iterator;
     282
     283    void addOperand(PabloAST * const expr);
     284
     285    PabloAST * removeOperand(const unsigned index);
     286
     287    inline iterator erase(iterator itr) {
     288        removeOperand(itr.distance_to(begin()));
     289        return itr;
     290    }
     291
     292    iterator begin() {
     293        return iterator(mOperand);
     294    }
     295
     296    const_iterator begin() const {
     297        return iterator(mOperand);
     298    }
     299
     300    iterator end() {
     301        return iterator(mOperand + mOperands);
     302    }
     303
     304    const_iterator end() const {
     305        return iterator(mOperand + mOperands);
     306    }
     307
    263308protected:
    264309    Variadic(const ClassTypeId id, std::initializer_list<PabloAST *> operands, const String * const name)
     
    430475    : mInsertionPoint(nullptr)
    431476    , mFirst(nullptr)
    432     , mLast(nullptr)
    433     {
     477    , mLast(nullptr) {
    434478
    435479    }
    436480
    437481    StatementList(StatementList && other)
    438     : mFirst(other.mFirst)
    439     , mLast(other.mLast)
    440     {
     482    : mInsertionPoint(nullptr)
     483    , mFirst(other.mFirst)
     484    , mLast(other.mLast) {
     485        other.mInsertionPoint = nullptr;
    441486        other.mFirst = nullptr;
    442487        other.mLast = nullptr;
     
    508553    }
    509554
    510     ~StatementList();
    511 
    512555    bool contains(Statement * const statement);
     556
     557protected:
     558
     559    ~StatementList() = default;
    513560
    514561private:
     
    519566};
    520567
     568/** ------------------------------------------------------------------------------------------------------------- *
     569 * @brief addUser
     570 ** ------------------------------------------------------------------------------------------------------------- */
     571inline void PabloAST::addUser(PabloAST *user) {
     572    assert (user);
     573    // Note: for the rare situation that this node is used multiple times by a statement, duplicates are allowed.
     574    mUsers.insert(std::lower_bound(mUsers.begin(), mUsers.end(), user), user);
    521575}
    522576
     577/** ------------------------------------------------------------------------------------------------------------- *
     578 * @brief removeUser
     579 ** ------------------------------------------------------------------------------------------------------------- */
     580inline void PabloAST::removeUser(PabloAST * user) {
     581    assert (user);
     582    auto pos = std::lower_bound(mUsers.begin(), mUsers.end(), user);
     583    assert ("Could not find user to remove!" && (pos != mUsers.end() && *pos == user));
     584    mUsers.erase(pos);
     585}
     586
     587}
     588
    523589#endif // PE_PabloAST_H
    524 
    525 
    526 
  • icGREP/icgrep-devel/icgrep/pablo/pe_next.h

    r4650 r4876  
    2828    explicit Next(PabloAST * initial, PabloAST * expr)
    2929    : Statement(ClassTypeId::Next, {expr, cast<Assign>(initial)}, cast<Assign>(initial)->getName()) {
    30         this->addUser(initial);
     30
    3131    }
    3232};
  • icGREP/icgrep-devel/icgrep/pablo/printer_pablos.cpp

    r4873 r4876  
    5454    } else if (const Call * call = dyn_cast<const Call>(stmt)) {
    5555        out << " = " << call->getCallee() << "()";
    56     } else if (const And * pablo_and = dyn_cast<const And>(stmt)) {
    57         out << pablo_and->getName() << " = (";
    58         for (unsigned i = 0; i != pablo_and->getNumOperands(); ++i) {
     56    } else if (const And * andNode = dyn_cast<const And>(stmt)) {
     57        out << andNode->getName() << " = (";
     58        for (unsigned i = 0; i != andNode->getNumOperands(); ++i) {
    5959            if (i) out << " & ";
    60             print(pablo_and->getOperand(i), out);
     60            print(andNode->getOperand(i), out);
    6161        }
    6262        out << ")";
    63     } else if (const Or * pablo_or = dyn_cast<const Or>(stmt)) {
    64         out << pablo_or->getName() << " = (";
    65         for (unsigned i = 0; i != pablo_or->getNumOperands(); ++i) {
     63    } else if (const Or * orNode = dyn_cast<const Or>(stmt)) {
     64        out << orNode->getName() << " = (";
     65        for (unsigned i = 0; i != orNode->getNumOperands(); ++i) {
    6666            if (i) out << " | ";
    67             print(pablo_or->getOperand(i), out);
     67            print(orNode->getOperand(i), out);
    6868        }
    6969        out << ")";
    70     } else if (const Xor * pablo_xor = dyn_cast<const Xor>(stmt)) {
    71         out << pablo_xor->getName() << " = (";
    72         for (unsigned i = 0; i != pablo_xor->getNumOperands(); ++i) {
     70    } else if (const Xor * xorNode = dyn_cast<const Xor>(stmt)) {
     71        out << xorNode->getName() << " = (";
     72        for (unsigned i = 0; i != xorNode->getNumOperands(); ++i) {
    7373            if (i) out << " ^ ";
    74             print(pablo_xor->getOperand(i), out);
     74            print(xorNode->getOperand(i), out);
    7575        }
    7676        out << ")";
    77     } else if (const Sel * pablo_sel = dyn_cast<const Sel>(stmt)) {
    78         out << pablo_sel->getName() << " = (";
    79         print(pablo_sel->getCondition(), out);
     77    } else if (const Sel * selNode = dyn_cast<const Sel>(stmt)) {
     78        out << selNode->getName() << " = (";
     79        print(selNode->getCondition(), out);
    8080        out << " ? ";
    81         print(pablo_sel->getTrueExpr(), out);
     81        print(selNode->getTrueExpr(), out);
    8282        out << " : ";
    83         print(pablo_sel->getFalseExpr(), out);
     83        print(selNode->getFalseExpr(), out);
    8484        out << ")";
    85     } else if (const Not * pablo_not = dyn_cast<const Not>(stmt)) {
    86         out << pablo_not->getName() << " = (~";
    87         print(pablo_not->getExpr(), out);
     85    } else if (const Not * notNode = dyn_cast<const Not>(stmt)) {
     86        out << notNode->getName() << " = (~";
     87        print(notNode->getExpr(), out);
    8888        out << ")";
    8989    } else if (const Advance * adv = dyn_cast<const Advance>(stmt)) {
  • icGREP/icgrep-devel/icgrep/pablo/ps_if.cpp

    r4870 r4876  
    2121    // of it.
    2222
    23     for (PabloAST * def : mDefined) {
     23    for (Assign * def : mDefined) {
    2424        def->addUser(this);
    2525        this->addUser(def);
     
    3232, mDefined(definedVars.begin(), definedVars.end(), reinterpret_cast<DefinedAllocator &>(mAllocator))
    3333{
    34     for (PabloAST * def : mDefined) {
     34    for (Assign * def : mDefined) {
    3535        def->addUser(this);
    3636        this->addUser(def);
  • icGREP/icgrep-devel/icgrep/pablo/ps_while.cpp

    r4870 r4876  
    77: Statement(ClassTypeId::While, {expr}, nullptr)
    88, mBody(body)
    9 , mNext(nextVars.begin(), nextVars.end(), reinterpret_cast<NextAllocator &>(mAllocator)) {
     9, mVariant(nextVars.begin(), nextVars.end(), reinterpret_cast<NextAllocator &>(mAllocator)) {
    1010    for (Next * variant : nextVars) {
    1111        variant->addUser(this);
     
    1717: Statement(ClassTypeId::While, {expr}, nullptr)
    1818, mBody(body)
    19 , mNext(nextVars.begin(), nextVars.end(), reinterpret_cast<NextAllocator &>(mAllocator)) {
     19, mVariant(nextVars.begin(), nextVars.end(), reinterpret_cast<NextAllocator &>(mAllocator)) {
    2020    for (Next * variant : nextVars) {
    2121        variant->addUser(this);
  • icGREP/icgrep-devel/icgrep/pablo/ps_while.h

    r4870 r4876  
    3333    }
    3434    inline Variants & getVariants() {
    35         return mNext;
     35        return mVariant;
    3636    }
    3737    inline const Variants & getVariants() const {
    38         return mNext;
     38        return mVariant;
    3939    }
    4040    inline PabloBlock * getBody() {
     
    5151private:
    5252    PabloBlock *    mBody;
    53     Variants        mNext;
     53    Variants        mVariant;
    5454};
    5555
  • icGREP/icgrep-devel/icgrep/toolchain.cpp

    r4871 r4876  
    3737#include <pablo/optimizers/pablo_simplifier.hpp>
    3838#include <pablo/optimizers/codemotionpass.h>
     39#include <pablo/passes/flattenassociativedfg.h>
    3940#ifdef ENABLE_MULTIPLEXING
    4041#include <pablo/optimizers/pablo_automultiplexing.hpp>
     
    143144        Simplifier::optimize(*function);
    144145    }
     146    // FlattenAssociativeDFG::process(*function);
    145147    if (PabloSinkingPass) {
    146148        CodeMotionPass::optimize(*function);
Note: See TracChangeset for help on using the changeset viewer.