Changeset 4873


Ignore:
Timestamp:
Nov 16, 2015, 10:01:04 PM (3 years ago)
Author:
nmedfort
Message:

First stage in making And/Or/Xor? statements n-ary statements.

Location:
icGREP/icgrep-devel/icgrep/pablo
Files:
8 edited

Legend:

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

    r4870 r4873  
    242242        }
    243243    } else if (Or * or1 = dyn_cast<Or>(expr1)) {
    244         if (equals(or1->getExpr1(), expr2) || equals(or1->getExpr2(), expr2)) {
     244        if (equals(or1->getOperand(0), expr2) || equals(or1->getOperand(1), expr2)) {
    245245            return expr2;
    246246        }
    247247    } else if (Or * or2 = dyn_cast<Or>(expr2)) {
    248         if (equals(or2->getExpr1(), expr1) || equals(or2->getExpr2(), expr1)) {
     248        if (equals(or2->getOperand(0), expr1) || equals(or2->getOperand(1), expr1)) {
    249249            return expr1;
    250250        }
     
    275275        }
    276276    } else if (Or * or1 = dyn_cast<Or>(expr1)) {
    277         if (equals(or1->getExpr1(), expr2) || equals(or1->getExpr2(), expr2)) {
     277        if (equals(or1->getOperand(0), expr2) || equals(or1->getOperand(1), expr2)) {
    278278            return expr2;
    279279        }
    280280    } else if (Or * or2 = dyn_cast<Or>(expr2)) {
    281         if (equals(or2->getExpr1(), expr1) || equals(or2->getExpr2(), expr1)) {
     281        if (equals(or2->getOperand(0), expr1) || equals(or2->getOperand(1), expr1)) {
    282282            return expr1;
    283283        }
     
    306306    } else if (And * and1 = dyn_cast<And>(expr1)) {
    307307        if (And * and2 = dyn_cast<And>(expr2)) {
    308             PabloAST * const expr1a = and1->getExpr1();
    309             PabloAST * const expr1b = and1->getExpr2();
    310             PabloAST * const expr2a = and2->getExpr1();
    311             PabloAST * const expr2b = and2->getExpr2();
     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);
    312312            //These optimizations factor out common components that can occur when sets are formed by union
    313313            //(e.g., union of [a-z] and [A-Z].
     
    321321                return createAnd(expr1b, createOr(expr1a, expr2b));
    322322            }
    323         } else if (equals(and1->getExpr1(), expr2) || equals(and1->getExpr2(), expr2)){
     323        } else if (equals(and1->getOperand(0), expr2) || equals(and1->getOperand(1), expr2)){
    324324            // (a∧b) √ a = a
    325325            return expr2;
    326326        }
    327327    } else if (And * and2 = dyn_cast<And>(expr2)) {
    328         if (equals(and2->getExpr1(), expr1) || equals(and2->getExpr2(), expr1)) {
     328        if (equals(and2->getOperand(0), expr1) || equals(and2->getOperand(1), expr1)) {
    329329            return expr1;
    330330        }
     
    351351    } else if (And * and1 = dyn_cast<And>(expr1)) {
    352352        if (And * and2 = dyn_cast<And>(expr2)) {
    353             PabloAST * const expr1a = and1->getExpr1();
    354             PabloAST * const expr1b = and1->getExpr2();
    355             PabloAST * const expr2a = and2->getExpr1();
    356             PabloAST * const expr2b = and2->getExpr2();
     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);
    357357            //These optimizations factor out common components that can occur when sets are formed by union
    358358            //(e.g., union of [a-z] and [A-Z].
     
    366366                return createAnd(expr1b, createOr(expr1a, expr2b), prefix);
    367367            }
    368         } else if (equals(and1->getExpr1(), expr2) || equals(and1->getExpr2(), expr2)) {
     368        } else if (equals(and1->getOperand(0), expr2) || equals(and1->getOperand(1), expr2)) {
    369369            // (a∧b) √ a = a
    370370            return expr2;
    371371        }
    372372    } else if (And * and2 = dyn_cast<And>(expr2)) {
    373         if (equals(and2->getExpr1(), expr1) || equals(and2->getExpr2(), expr1)) {
     373        if (equals(and2->getOperand(0), expr1) || equals(and2->getOperand(1), expr1)) {
    374374            return expr1;
    375375        }
  • icGREP/icgrep-devel/icgrep/pablo/pabloAST.cpp

    r4871 r4873  
    4343        } else if (const And* and1 = dyn_cast<const And>(expr1)) {
    4444            if (const And* and2 = cast<const And>(expr2)) {
    45                 if (equals(and1->getExpr1(), and2->getExpr1())) {
    46                     return equals(and1->getExpr2(), and2->getExpr2());
    47                 } else if (equals(and1->getExpr1(), and2->getExpr2())) {
    48                     return equals(and1->getExpr2(), and2->getExpr1());
     45                if (equals(and1->getOperand(0), and2->getOperand(0))) {
     46                    return equals(and1->getOperand(1), and2->getOperand(1));
     47                } else if (equals(and1->getOperand(0), and2->getOperand(1))) {
     48                    return equals(and1->getOperand(1), and2->getOperand(0));
    4949                }
    5050            }
    5151        } else if (const Or * or1 = dyn_cast<const Or>(expr1)) {
    5252            if (const Or* or2 = cast<const Or>(expr2)) {
    53                 if (equals(or1->getExpr1(), or2->getExpr1())) {
    54                     return equals(or1->getExpr2(), or2->getExpr2());
    55                 } else if (equals(or1->getExpr1(), or2->getExpr2())) {
    56                     return equals(or1->getExpr2(), or2->getExpr1());
     53                if (equals(or1->getOperand(0), or2->getOperand(0))) {
     54                    return equals(or1->getOperand(1), or2->getOperand(1));
     55                } else if (equals(or1->getOperand(0), or2->getOperand(1))) {
     56                    return equals(or1->getOperand(1), or2->getOperand(0));
    5757                }
    5858            }
    5959        } else if (const Xor * xor1 = dyn_cast<const Xor>(expr1)) {
    6060            if (const Xor * xor2 = cast<const Xor>(expr2)) {
    61                 if (equals(xor1->getExpr1(), xor2->getExpr1())) {
    62                     return equals(xor1->getExpr2(), xor2->getExpr2());
    63                 } else if (equals(xor1->getExpr1(), xor2->getExpr2())) {
    64                     return equals(xor1->getExpr2(), xor2->getExpr1());
     61                if (equals(xor1->getOperand(0), xor2->getOperand(0))) {
     62                    return equals(xor1->getOperand(1), xor2->getOperand(1));
     63                } else if (equals(xor1->getOperand(0), xor2->getOperand(1))) {
     64                    return equals(xor1->getOperand(1), xor2->getOperand(0));
    6565                }
    6666            }
     
    374374
    375375/** ------------------------------------------------------------------------------------------------------------- *
     376 * @brief addOperand
     377 ** ------------------------------------------------------------------------------------------------------------- */
     378void 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) {
     386        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 *));
     389        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;
     395}
     396
     397/** ------------------------------------------------------------------------------------------------------------- *
     398 * @brief removeOperand
     399 ** ------------------------------------------------------------------------------------------------------------- */
     400void Variadic::removeOperand(const unsigned index) {
     401    assert (index < getNumOperands());
     402    std::memcpy(mOperand + index, mOperand + index + 1, (mOperands - index - 1) * sizeof(PabloAST *));
     403    --mOperands;
     404}
     405
     406/** ------------------------------------------------------------------------------------------------------------- *
    376407 * @brief contains
    377408 ** ------------------------------------------------------------------------------------------------------------- */
  • icGREP/icgrep-devel/icgrep/pablo/pabloAST.h

    r4871 r4873  
    249249    void checkEscapedValueList(Statement * branch, PabloAST * const from, PabloAST * const to, ValueList & list);
    250250protected:   
    251     const String *              mName;
    252     Statement *                 mNext;
    253     Statement *                 mPrev;
    254     PabloBlock *                mParent;
    255     const unsigned              mOperands;
    256     // If we knew prior to construction how many operands were needed, we could
    257     // eliminate the mOperand pointer and simply use this[1] instead.
    258     PabloAST **                 mOperand;
     251    const String *  mName;
     252    Statement *     mNext;
     253    Statement *     mPrev;
     254    PabloBlock *    mParent;
     255    unsigned        mOperands;
     256    PabloAST **     mOperand;
     257};
     258
     259class Variadic : public Statement {
     260public:
     261    void addOperand(PabloAST * expr);
     262    void removeOperand(const unsigned index);
     263protected:
     264    Variadic(const ClassTypeId id, std::initializer_list<PabloAST *> operands, const String * const name)
     265    : Statement(id, operands, name)
     266    , mCapacity(operands.size()) {
     267
     268    }
     269private:
     270    unsigned        mCapacity;
    259271};
    260272
  • icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.cpp

    r4870 r4873  
    391391    }
    392392    else if (const And * pablo_and = dyn_cast<And>(stmt)) {
    393         expr = iBuilder.simd_and(compileExpression(pablo_and->getExpr1()), compileExpression(pablo_and->getExpr2()));
     393        expr = iBuilder.simd_and(compileExpression(pablo_and->getOperand(0)), compileExpression(pablo_and->getOperand(1)));
    394394    }
    395395    else if (const Or * pablo_or = dyn_cast<Or>(stmt)) {
    396         expr = iBuilder.simd_or(compileExpression(pablo_or->getExpr1()), compileExpression(pablo_or->getExpr2()));
     396        expr = iBuilder.simd_or(compileExpression(pablo_or->getOperand(0)), compileExpression(pablo_or->getOperand(1)));
    397397    }
    398398    else if (const Xor * pablo_xor = dyn_cast<Xor>(stmt)) {
    399         expr = iBuilder.simd_xor(compileExpression(pablo_xor->getExpr1()), compileExpression(pablo_xor->getExpr2()));
     399        expr = iBuilder.simd_xor(compileExpression(pablo_xor->getOperand(0)), compileExpression(pablo_xor->getOperand(1)));
    400400    }
    401401    else if (const Sel * sel = dyn_cast<Sel>(stmt)) {
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.h

    r4797 r4873  
    1212namespace pablo {
    1313
    14 class And : public Statement {
     14class And : public Variadic {
    1515    friend class PabloBlock;
    1616public:
     
    2121        return false;
    2222    }
    23     virtual ~And() {
    24     }
    25     PabloAST * getExpr1() const {
    26         return getOperand(0);
    27     }
    28     PabloAST * getExpr2() const {
    29         return getOperand(1);
    30     }
     23    virtual ~And() { }
    3124protected:
    3225    And(PabloAST * expr1, PabloAST * expr2, String * name)
    33     : Statement(ClassTypeId::And, {expr1, expr2}, name)
     26    : Variadic(ClassTypeId::And, {expr1, expr2}, name)
    3427    {
    35         assert (getNumOperands() == 2);
     28
    3629    }
    3730};
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.h

    r4797 r4873  
    1212namespace pablo {
    1313
    14 class Or : public Statement {
     14class Or : public Variadic {
    1515    friend class PabloBlock;
    1616public:
     
    2121        return false;
    2222    }
    23     virtual ~Or() {
    24     }
    25     PabloAST * getExpr1() const {
    26         return mOperand[0];
    27     }
    28     PabloAST * getExpr2() const {
    29         return mOperand[1];
    30     }
     23    virtual ~Or() { }
    3124protected:
    3225    Or(PabloAST * expr1, PabloAST * expr2, String * name)
    33     : Statement(ClassTypeId::Or, {expr1, expr2}, name)
     26    : Variadic(ClassTypeId::Or, {expr1, expr2}, name)
    3427    {
    35         assert (getNumOperands() == 2);
     28
    3629    }
    3730};
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.h

    r4797 r4873  
    99
    1010#include <pablo/pabloAST.h>
    11 #include <array>
    1211
    1312namespace pablo {
    1413
    15 class Xor : public Statement {
     14class Xor : public Variadic {
    1615    friend class PabloBlock;
    1716public:
     
    2221        return false;
    2322    }
    24     virtual ~Xor() {
    25     }
    26     PabloAST * getExpr1() const {
    27         return getOperand(0);
    28     }
    29     PabloAST * getExpr2() const {
    30         return getOperand(1);
    31     }
     23    virtual ~Xor() { }
    3224protected:
    3325    Xor(PabloAST * expr1, PabloAST * expr2, String * name)
    34     : Statement(ClassTypeId::Xor, {expr1, expr2}, name)
     26    : Variadic(ClassTypeId::Xor, {expr1, expr2}, name)
    3527    {
    36         assert (getNumOperands() == 2);
     28
    3729    }
    3830};
  • icGREP/icgrep-devel/icgrep/pablo/printer_pablos.cpp

    r4870 r4873  
    5656    } else if (const And * pablo_and = dyn_cast<const And>(stmt)) {
    5757        out << pablo_and->getName() << " = (";
    58         print(pablo_and->getExpr1(), out);
    59         out << " & ";
    60         print(pablo_and->getExpr2(), out);
     58        for (unsigned i = 0; i != pablo_and->getNumOperands(); ++i) {
     59            if (i) out << " & ";
     60            print(pablo_and->getOperand(i), out);
     61        }
    6162        out << ")";
    6263    } else if (const Or * pablo_or = dyn_cast<const Or>(stmt)) {
    6364        out << pablo_or->getName() << " = (";
    64         print(pablo_or->getExpr1(), out);
    65         out << " | ";
    66         print(pablo_or->getExpr2(), out);
     65        for (unsigned i = 0; i != pablo_or->getNumOperands(); ++i) {
     66            if (i) out << " | ";
     67            print(pablo_or->getOperand(i), out);
     68        }
    6769        out << ")";
    6870    } else if (const Xor * pablo_xor = dyn_cast<const Xor>(stmt)) {
    6971        out << pablo_xor->getName() << " = (";
    70         print(pablo_xor->getExpr1(), out);
    71         out << " ^ ";
    72         print(pablo_xor->getExpr2(), out);
     72        for (unsigned i = 0; i != pablo_xor->getNumOperands(); ++i) {
     73            if (i) out << " ^ ";
     74            print(pablo_xor->getOperand(i), out);
     75        }
    7376        out << ")";
    7477    } else if (const Sel * pablo_sel = dyn_cast<const Sel>(stmt)) {
Note: See TracChangeset for help on using the changeset viewer.