Changeset 4414


Ignore:
Timestamp:
Jan 10, 2015, 10:27:13 AM (4 years ago)
Author:
nmedfort
Message:

Minor changes towards maintaining UseDef? information.

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

Legend:

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

    r4410 r4414  
    9999}
    100100
     101//PabloAST * PabloBlock::replaceUsesOfWith(PabloAST * inst, PabloAST * from, PabloAST * to) {
     102
     103
     104
     105
     106//}
    101107
    102108//PabloAST * PabloBlock::replaceUsesOfWith(PabloAST * inst, PabloAST * from, PabloAST * to) {
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.h

    r4410 r4414  
    3939class PabloBlock : public StatementList {
    4040    friend class pablo::PabloAST;
     41    friend struct OptimizeAnd;
     42    friend struct OptimizeOr;
     43    friend struct OptimizeSel;
     44    friend struct OptimizeXor;
     45    friend struct OptimizeNot;
    4146public:
    4247
     
    7075    }
    7176
    72     Var * createVar(const std::string);
     77    Var * createVar(const std::string name);
    7378
    7479    PabloAST * createVar(const PabloAST * const) {
    75         throw std::runtime_error("Var objects should only refer to external Vars (i.e., input basis bit streams). Use Assign object directly.");
     80        throw std::runtime_error("Var objects should only refer to external Vars (i.e., input basis bit streams). Use Assign objects directly.");
    7681    }
    7782
     
    134139            }
    135140            PabloAST * const expr = new Type(std::forward<Args>(args)..., std::forward<Params>(params)...);
    136             insert(std::move(key), expr);
     141            mMap.insert(std::make_pair(std::move(key), expr));
    137142            return std::make_pair(cast<Type>(expr), isa<Statement>(expr));
    138143        }
     
    147152            Functor mf;
    148153            PabloAST * const expr = mf(std::forward<Args>(args)..., std::forward<Params>(params)...);
    149             insert(std::move(key), expr);
     154            mMap.insert(std::make_pair(std::move(key), expr));
    150155            return expr;
    151156        }
    152157
    153         inline void insert(Key && key, PabloAST * expr) {
    154             mMap.insert(std::make_pair(std::move(key), expr));
     158        inline bool erase(const PabloAST::ClassTypeId type, Args... args) {
     159            Key key = std::make_tuple(type, args...);
     160            auto itr = mMap.find(key);
     161            if (itr == mMap.end()) {
     162                return mPredecessor ? mPredecessor->erase(type, args...) : false;
     163            }
     164            mMap.erase(itr);
     165            return true;
    155166        }
    156167
  • icGREP/icgrep-devel/icgrep/pablo/pabloAST.h

    r4410 r4414  
    2525class PabloAST {
    2626    friend class PMDNode;
    27     friend class Advance;
    28     friend class And;
    29     friend class Assign;
    30     friend class Call;
     27    friend class Statement;
     28    friend class Var;
    3129    friend class If;
    32     friend class MatchStar;
    33     friend class Next;
    34     friend class Not;
    35     friend class Ones;
    36     friend class Or;
    37     friend class ScanThru;
    38     friend class Sel;
    39     friend class String;
    40     friend class Var;
    4130    friend class While;
    42     friend class Xor;
    43     friend class Zeroes;
    4431    friend class PabloBlock;
    4532    friend class SymbolGenerator;
     
    9481        mUsers.remove(user);
    9582    }
    96     // virtual void removeUsageFromDefs() = 0;
    9783    static Allocator        mAllocator;
    9884private:
     
    130116
    131117    inline void replaceUsesOfWith(PabloAST * from, PabloAST * to) {
    132         if (from == to) {
     118        if (LLVM_UNLIKELY(from == to)) {
    133119            return;
    134120        }
     
    140126    }
    141127
    142     virtual PabloAST * getOperand(const unsigned index) const = 0;
    143 
    144     virtual unsigned getNumOperands() const = 0;
    145 
    146     virtual void setOperand(const unsigned index, PabloAST * value) = 0;
     128    PabloAST * getOperand(const unsigned index) const {
     129        assert (index < getNumOperands());
     130        return mOperand[index];
     131    }
     132
     133    unsigned getNumOperands() const {
     134        return mOperand.size();
     135    }
     136
     137    void setOperand(const unsigned index, PabloAST * value) {
     138        assert (index < getNumOperands());
     139        mOperand[index] = value;
     140    }
    147141
    148142    void insertBefore(Statement * const statement);
     
    164158    }
    165159protected:
    166     Statement(const ClassTypeId id, const String * name, PabloBlock * parent)
     160    Statement(const ClassTypeId id, std::vector<PabloAST *> && operands, const String * name, PabloBlock * parent)
    167161    : PabloAST(id)
    168162    , mName(name)
     
    170164    , mPrev(nullptr)
    171165    , mParent(parent)
     166    , mOperand(std::move(operands))
    172167    {
    173 
     168        for (PabloAST * op : mOperand) {
     169            op->addUser(this);
     170        }
    174171    }
    175172    virtual ~Statement() = 0;
    176173protected:
    177     const String * mName;
    178     Statement * mNext;
    179     Statement * mPrev;
    180     PabloBlock * mParent;
     174    const String *              mName;
     175    Statement *                 mNext;
     176    Statement *                 mPrev;
     177    PabloBlock *                mParent;
     178    std::vector<PabloAST *>     mOperand;
     179
    181180};
    182181
  • icGREP/icgrep-devel/icgrep/pablo/pe_advance.h

    r4410 r4414  
    2424    virtual ~Advance() {
    2525    }
    26     virtual PabloAST * getOperand(const unsigned index) const {
    27         assert (index == 0);
    28         return mExpr;
    29     }
    30     virtual void setOperand(const unsigned index, PabloAST * value) {
    31         assert (index == 0);
    32         mExpr = value;
    33     }
    34     virtual unsigned getNumOperands() const {
    35         return 1;
    36     }
    3726    inline PabloAST * getExpr() const {
    38         return mExpr;
     27        return mOperand[0];
    3928    }
    4029    inline int getAdvanceAmount() const {
     
    4332protected:
    4433    Advance(PabloAST * expr, int shiftAmount, SymbolGenerator * sg, PabloBlock * parent)
    45     : Statement(ClassTypeId::Advance, sg->make("advance"), parent)
    46     , mExpr(expr)
     34    : Statement(ClassTypeId::Advance, {expr}, sg->make("advance"), parent)
    4735        , mShiftAmount(shiftAmount) {
    48         expr->addUser(this);
     36
    4937    }
    5038private:
    51     PabloAST * mExpr;
    5239        int const mShiftAmount;
    5340};
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.cpp

    r4410 r4414  
    1111
    1212And::And(PabloAST * expr1, PabloAST * expr2, PabloBlock * parent)
    13 : Statement(ClassTypeId::And, parent->makeName("and"), parent)
    14 , mExprs({{expr1, expr2}})
     13: Statement(ClassTypeId::And, {{expr1, expr2}}, parent->makeName("and"), parent)
    1514{
    16     expr1->addUser(this);
    17     expr2->addUser(this);
     15
    1816}
    1917
    2018PabloAST * OptimizeAnd::operator ()(PabloAST * expr1, PabloAST * expr2, PabloBlock * pb) {
    21     if (isa<Ones>(expr1)) {
     19    if (isa<Zeroes>(expr2) || isa<Ones>(expr1)) {
    2220        return expr2;
    2321    }
    24     else if (isa<Zeroes>(expr1)){
    25         return expr1;       
    26     }
    27     else if (isa<Ones>(expr2)) {
     22    else if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
    2823        return expr1;
    29     }
    30     else if (isa<Zeroes>(expr2)){
    31         return expr2;
    3224    }
    3325    else if (equals(expr1, expr2)) {
    3426        return expr1;
    3527    }
    36     else if (Not * pe_not_e1 = dyn_cast<Not>(expr1)) {
    37         if (Not * pe_not_e2 = dyn_cast<Not>(expr2)) {
    38             return pb->createNot(pb->createOr(pe_not_e1->getExpr(), pe_not_e2->getExpr()));
     28    else if (Not * not1 = dyn_cast<Not>(expr1)) {
     29        if (Not * not2 = dyn_cast<Not>(expr2)) {
     30            return pb->createNot(pb->createOr(not1->getExpr(), not2->getExpr()));
    3931        }
    40         else if (equals(pe_not_e1->getExpr(), expr2)) {
     32        else if (equals(not1->getExpr(), expr2)) {
    4133            return pb->createZeroes();
    4234        }
    4335    }
    44     else if (Not * pe_not_e2 = dyn_cast<Not>(expr2)) {
    45         if (equals(expr1, pe_not_e2->getExpr())) {
     36    else if (Not * not2 = dyn_cast<Not>(expr2)) {
     37        if (equals(expr1, not2->getExpr())) {
    4638            return pb->createZeroes();
    4739        }
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.h

    r4410 r4414  
    2727    virtual ~And() {
    2828    }
    29     virtual PabloAST * getOperand(const unsigned index) const {
    30         assert (index < 2);
    31         return mExprs[index];
    32     }
    33     virtual unsigned getNumOperands() const {
    34         return 2;
    35     }
    36     virtual void setOperand(const unsigned index, PabloAST * value) {
    37         assert (index < 2);
    38         mExprs[index] = value;
    39     }
    4029    PabloAST * getExpr1() const {
    41         return mExprs[0];
     30        return mOperand[0];
    4231    }
    4332    PabloAST * getExpr2() const {
    44         return mExprs[1];
     33        return mOperand[1];
    4534    }
    4635protected:
    4736    And(PabloAST * expr1, PabloAST * expr2, PabloBlock * parent);
    48 private:
    49     std::array<PabloAST*, 2> mExprs;
    5037};
    5138
  • icGREP/icgrep-devel/icgrep/pablo/pe_call.h

    r4410 r4414  
    1919    virtual ~Call() {
    2020    }
    21     virtual PabloAST * getOperand(const unsigned index) const {
    22         assert (index == 0);
    23         return mCallee;
    24     }
    25     virtual unsigned getNumOperands() const {
    26         return 1;
    27     }
    28     virtual void setOperand(const unsigned index, PabloAST * value) {
    29         assert (index == 0);
    30         assert (isa<String>(value));
    31         mCallee = cast<String>(value);
    32     }
    3321    inline const String * getCallee() const {
    34         return mCallee;
     22        return cast<String>(mOperand[0]);
    3523    }
    3624protected:
    3725    Call(PabloAST * callee, PabloBlock * parent)
    38     : Statement(ClassTypeId::Call, cast<String>(callee), parent)
    39     , mCallee(cast<String>(callee)) {
     26    : Statement(ClassTypeId::Call, {callee}, cast<String>(callee), parent) {
    4027
    4128    }
    42 private:
    43     String * mCallee;
    4429};
    4530}
  • icGREP/icgrep-devel/icgrep/pablo/pe_matchstar.h

    r4410 r4414  
    2525    virtual ~MatchStar() {
    2626    }
    27     virtual PabloAST * getOperand(const unsigned index) const {
    28         assert (index < 2);
    29         return mExprs[index];
    30     }
    31     virtual unsigned getNumOperands() const {
    32         return 2;
    33     }
    34     virtual void setOperand(const unsigned index, PabloAST * value) {
    35         assert (index < 2);
    36         mExprs[index] = value;
    37     }
    3827    inline PabloAST * getMarker() const {
    39         return mExprs[0];
     28        return mOperand[0];
    4029    }
    4130    inline PabloAST * getCharClass() const  {
    42         return mExprs[1];
     31        return mOperand[1];
    4332    }
    4433protected:
    4534    MatchStar(PabloAST * marker, PabloAST * cc, SymbolGenerator * sg, PabloBlock * parent)
    46     : Statement(ClassTypeId::MatchStar, sg->make("matchstar"), parent)
    47     , mExprs({{marker, cc}})
     35    : Statement(ClassTypeId::MatchStar, {{marker, cc}}, sg->make("matchstar"), parent)
    4836    {
    49         marker->addUser(this);
    50         cc->addUser(this);
     37
    5138    }
    52 private:
    53     std::array<PabloAST*, 2> mExprs;
    5439};
    5540
  • icGREP/icgrep-devel/icgrep/pablo/pe_next.h

    r4410 r4414  
    2020        return false;
    2121    }
    22     virtual PabloAST * getOperand(const unsigned index) const {
    23         assert (index < 2);
    24         return mExprs[index];
    25     }
    26     virtual unsigned getNumOperands() const {
    27         return 2;
    28     }
    29     virtual void setOperand(const unsigned index, PabloAST * value) {
    30         assert (index < 2);
    31         assert (index == 0 || isa<Assign>(value));
    32         mExprs[index] = value;
    33     }
    3422    inline const Assign * getInitial() const {
    35         return cast<const Assign>(mExprs[0]);
    36     }
    37     inline const String * getName() const {
    38         return getInitial()->getName();
     23        return cast<const Assign>(mOperand[0]);
    3924    }
    4025    inline PabloAST * getExpr() const {
    41         return mExprs[1];
     26        return mOperand[1];
    4227    }
    4328protected:
    4429    Next(PabloAST * initial, PabloAST * expr, PabloBlock * parent)
    45     : Statement(ClassTypeId::Next, cast<Assign>(initial)->getName(), parent)
    46     , mExprs({{cast<Assign>(initial), expr}}) {
    47         initial->addUser(this);
    48         expr->addUser(this);
     30    : Statement(ClassTypeId::Next, {{cast<Assign>(initial), expr}}, cast<Assign>(initial)->getName(), parent)
     31    {
     32
    4933    }
    50 private:
    51     std::array<PabloAST*, 2>  mExprs;
    5234};
    5335
  • icGREP/icgrep-devel/icgrep/pablo/pe_not.cpp

    r4410 r4414  
    1212
    1313Not::Not(PabloAST * expr, PabloBlock * parent)
    14 : Statement(ClassTypeId::Not, parent->makeName("not"), parent)
    15 , mExpr(expr) {
    16     expr->addUser(this);
     14: Statement(ClassTypeId::Not, {expr}, parent->makeName("not"), parent)
     15{
     16
    1717}
    1818
    1919PabloAST * OptimizeNot::operator ()(PabloAST * expr, PabloBlock * pb) {
    2020    if (isa<Ones>(expr)) {
    21     return pb->createZeroes();
     21        return pb->createZeroes();
    2222    }
    2323    else if (isa<Zeroes>(expr)){
    2424        return pb->createOnes();
    2525    }
    26     else if (Not * pe_not = dyn_cast<Not>(expr)) {
    27         return pe_not->getExpr();
     26    else if (Not * not1 = dyn_cast<Not>(expr)) {
     27        return not1->getExpr();
    2828    }
    2929    return pb->createNotImm(expr);
  • icGREP/icgrep-devel/icgrep/pablo/pe_not.h

    r4410 r4414  
    2424        return false;
    2525    }
    26     virtual PabloAST * getOperand(const unsigned index) const {
    27         assert (index == 0);
    28         return mExpr;
    29     }
    30     virtual unsigned getNumOperands() const {
    31         return 1;
    32     }
    33     virtual void setOperand(const unsigned index, PabloAST * value) {
    34         assert (index == 0);
    35         mExpr = value;
    36     }
    3726    virtual ~Not() {
    3827    }
    3928    PabloAST * getExpr() const {
    40         return mExpr;
     29        return mOperand[0];
    4130    }
    4231protected:
    4332    Not(PabloAST * expr, PabloBlock * parent);
    44 private:
    45     PabloAST * mExpr;
    4633};
    4734
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.cpp

    r4410 r4414  
    1111
    1212Or::Or(PabloAST * expr1, PabloAST * expr2, PabloBlock * parent)
    13 : Statement(ClassTypeId::Or, parent->makeName("or"), parent)
    14 , mExprs({{expr1, expr2}})
     13: Statement(ClassTypeId::Or, {{expr1, expr2}}, parent->makeName("or"), parent)
    1514{
    16     expr1->addUser(this);
    17     expr2->addUser(this);
     15
    1816}
    1917
    2018PabloAST * OptimizeOr::operator ()(PabloAST * expr1, PabloAST * expr2, PabloBlock * pb) {
    21     if (isa<Ones>(expr1)) {
    22         return expr1;
     19    if (isa<Zeroes>(expr2) || isa<Ones>(expr1)) {
     20        return expr1;
    2321    }
    24     else if (isa<Zeroes>(expr1)){
    25         return expr2;       
    26     }
    27     else if (isa<Ones>(expr2)) {
    28         return expr2;
    29     }
    30     else if (isa<Zeroes>(expr2)){
    31         return expr1;
     22    else if (isa<Zeroes>(expr1) || isa<Ones>(expr2)){
     23        return expr2;
    3224    }
    3325    else if (equals(expr1, expr2)) {
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.h

    r4410 r4414  
    2727    virtual ~Or() {
    2828    }
    29     virtual PabloAST * getOperand(const unsigned index) const {
    30         assert (index < 2);
    31         return mExprs[index];
    32     }
    33     virtual unsigned getNumOperands() const {
    34         return 2;
    35     }
    36     virtual void setOperand(const unsigned index, PabloAST * value) {
    37         assert (index < 2);
    38         mExprs[index] = value;
    39     }
    4029    PabloAST * getExpr1() const {
    41         return mExprs[0];
     30        return mOperand[0];
    4231    }
    4332    PabloAST * getExpr2() const {
    44         return mExprs[1];
     33        return mOperand[1];
    4534    }
    4635protected:
    4736    Or(PabloAST * expr1, PabloAST * expr2, PabloBlock * parent);
    48 private:
    49     std::array<PabloAST*, 2> mExprs;
    5037};
    5138
  • icGREP/icgrep-devel/icgrep/pablo/pe_scanthru.h

    r4410 r4414  
    2525    virtual ~ScanThru() {
    2626    }
    27     virtual PabloAST * getOperand(const unsigned index) const {
    28         assert (index < 2);
    29         return mExprs[index];
    30     }
    31     virtual unsigned getNumOperands() const {
    32         return 2;
    33     }
    34     virtual void setOperand(const unsigned index, PabloAST * value) {
    35         assert (index < 2);
    36         mExprs[index] = value;
    37     }
    3827    PabloAST * getScanFrom() const {
    39         return mExprs[0];
     28        return mOperand[0];
    4029    }
    4130    PabloAST * getScanThru() const {
    42         return mExprs[1];
     31        return mOperand[1];
    4332    }
    4433    ScanThru(PabloAST * from, PabloAST * thru, SymbolGenerator * sg, PabloBlock * parent)
    45     : Statement(ClassTypeId::ScanThru, sg->make("scanthru"), parent)
    46     , mExprs({{from, thru}})
     34    : Statement(ClassTypeId::ScanThru, {{from, thru}}, sg->make("scanthru"), parent)
    4735    {
    48         from->addUser(this);
    49         thru->addUser(this);
     36
    5037    }
    51 private:
    52     std::array<PabloAST*, 2> mExprs;
    5338};
    5439
  • icGREP/icgrep-devel/icgrep/pablo/pe_sel.cpp

    r4410 r4414  
    1111
    1212Sel::Sel(PabloAST* if_expr, PabloAST* t_expr, PabloAST* f_expr, PabloBlock * parent)
    13 : Statement(ClassTypeId::Sel, parent->makeName("sel"), parent)
    14 , mExprs({{if_expr, t_expr, f_expr}})
     13: Statement(ClassTypeId::Sel, {{if_expr, t_expr, f_expr}}, parent->makeName("sel"), parent)
    1514{
    16     if_expr->addUser(this);
    17     t_expr->addUser(this);
    18     f_expr->addUser(this);
     15
    1916}
    2017
    2118PabloAST * OptimizeSel::operator()(PabloAST * if_expr, PabloAST * t_expr, PabloAST * f_expr, PabloBlock * pb) {
    2219    if (isa<Ones>(if_expr)) {
    23         return t_expr;
     20        return t_expr;
    2421    }
    2522    else if (isa<Zeroes>(if_expr)){
    26         return f_expr;       
     23        return f_expr;
    2724    }
    2825    else if (isa<Ones>(t_expr)) {
    29     return pb->createOr(if_expr, f_expr);
     26        return pb->createOr(if_expr, f_expr);
    3027    }
    3128    else if (isa<Zeroes>(t_expr)){
     
    3330    }
    3431    else if (isa<Ones>(f_expr)) {
    35     return pb->createOr(pb->createNot(if_expr), t_expr);
     32        return pb->createOr(pb->createNot(if_expr), t_expr);
    3633    }
    3734    else if (isa<Zeroes>(f_expr)){
  • icGREP/icgrep-devel/icgrep/pablo/pe_sel.h

    r4410 r4414  
    2727    virtual ~Sel() {
    2828    }
    29     virtual PabloAST * getOperand(const unsigned index) const {
    30         assert (index < 3);
    31         return mExprs[index];
    32     }
    33     virtual unsigned getNumOperands() const {
    34         return 3;
    35     }
    36     virtual void setOperand(const unsigned index, PabloAST * value) {
    37         assert (index < 3);
    38         mExprs[index] = value;
    39     }
    4029    inline PabloAST * getCondition() const {
    41         return mExprs[0];
     30        return mOperand[0];
    4231    }
    4332    inline PabloAST * getTrueExpr() const {
    44         return mExprs[1];
     33        return mOperand[1];
    4534    }
    4635    inline PabloAST * getFalseExpr() const {
    47         return mExprs[2];
     36        return mOperand[2];
    4837    }
    4938protected:
    5039    Sel(PabloAST* if_expr, PabloAST* t_expr, PabloAST* f_expr, PabloBlock * parent);
    51 private:
    52     std::array<PabloAST*, 3> mExprs;
    5340};
    5441
  • icGREP/icgrep-devel/icgrep/pablo/pe_var.h

    r4410 r4414  
    3939    virtual ~Var(){
    4040    }
    41 //    virtual PabloAST * getOperand(const unsigned index) const {
    42 //        assert (index == 0);
    43 //        return mVar;
    44 //    }
    45 //    virtual unsigned getNumOperands() const {
    46 //        return 1;
    47 //    }
    48 //    virtual void setOperand(const unsigned index, PabloAST * value) {
    49 //        assert (index == 0);
    50 //        mVar = value;
    51 //        mName = getNameOf(value);
    52 //    }
    5341    inline const String * getName() const {
    5442        return mName;
    5543    }
    56 //    inline PabloAST * getVar() {
    57 //        return mVar;
    58 //    }
    59 //    inline const PabloAST * getVar() const {
    60 //        return mVar;
    61 //    }
    62 //    inline bool isInternal() const {
    63 //        return mVar != mName;
    64 //    }
    65 //    inline bool isExternal() const {
    66 //        return mVar == mName;
    67 //    }
    6844protected:
    6945    Var(PabloAST * var, PabloBlock *)
    7046    : PabloAST(ClassTypeId::Var)
    71     //, mVar(var)
    72     , mName(cast<String>(var)) // getNameOf(var))
     47    , mName(cast<String>(var))
    7348    {
    7449        var->addUser(this);
    7550    }
    7651private:
    77 //    static inline const String * getNameOf(const PabloAST * var) {
    78 //        if (isa<String>(var)) {
    79 //            return cast<String>(var);
    80 //        }
    81 //        if (isa<Assign>(var)) {
    82 //            return cast<Assign>(var)->getName();
    83 //        }
    84 //        if (isa<Next>(var)) {
    85 //            return cast<Next>(var)->getName();
    86 //        }
    87 //        throw std::runtime_error("Pablo Var only accepts String, Assign and Next nodes.");
    88 //    }
    89 private:
    90     //PabloAST *         mVar;
    9152    const String *     mName;
    9253};
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.cpp

    r4410 r4414  
    1111
    1212Xor::Xor(PabloAST * expr1, PabloAST * expr2, PabloBlock * parent)
    13 : Statement(ClassTypeId::Xor, parent->makeName("xor"), parent)
    14 , mExprs({{expr1, expr2}})
     13: Statement(ClassTypeId::Xor, {{expr1, expr2}}, parent->makeName("xor"), parent)
    1514{
    16     expr1->addUser(this);
    17     expr2->addUser(this);
     15
    1816}
    1917
     
    2321    }
    2422    else if (isa<Zeroes>(expr1)){
    25         return expr2;       
     23        return expr2;
    2624    }
    2725    else if (isa<Ones>(expr2)) {
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.h

    r4410 r4414  
    2727    virtual ~Xor() {
    2828    }
    29     virtual PabloAST * getOperand(const unsigned index) const {
    30         assert (index < 2);
    31         return mExprs[index];
    32     }
    33     virtual unsigned getNumOperands() const {
    34         return 2;
    35     }
    36     virtual void setOperand(const unsigned index, PabloAST * value) {
    37         assert (index < 2);
    38         mExprs[index] = value;
    39     }
    4029    PabloAST * getExpr1() const {
    41         return mExprs[0];
     30        return mOperand[0];
    4231    }
    4332    PabloAST * getExpr2() const {
    44         return mExprs[1];
     33        return mOperand[1];
    4534    }
    4635protected:
    4736    Xor(PabloAST * expr1, PabloAST * expr2, PabloBlock * parent);
    48 private:
    49     std::array<PabloAST*, 2> mExprs;
    5037};
    5138
  • icGREP/icgrep-devel/icgrep/pablo/ps_assign.h

    r4410 r4414  
    2727    virtual ~Assign() {
    2828    }
    29     virtual PabloAST * getOperand(const unsigned index) const {
    30         assert (index == 0);
    31         return mExpr;
    32     }
    33     virtual unsigned getNumOperands() const {
    34         return 1;
    35     }
    36     virtual void setOperand(const unsigned index, PabloAST * value) {
    37         assert (index == 0);
    38         mExpr = value;
    39     }
    4029    inline PabloAST * getExpr() const {
    41         return mExpr;
     30        return mOperand[0];
    4231    }
    4332    inline bool isOutputAssignment() const {
     
    4938protected:
    5039    explicit Assign(PabloAST * expr, int outputIndex, String * name, PabloBlock * parent)
    51     : Statement(ClassTypeId::Assign, name, parent)
    52     , mExpr(expr)
     40    : Statement(ClassTypeId::Assign, {expr}, name, parent)
    5341    , mOutputIndex(outputIndex)
    5442    {
    55         expr->addUser(this);
     43
    5644    }
    5745private:
    58     PabloAST *          mExpr;
    5946    const int           mOutputIndex;
    6047};
  • icGREP/icgrep-devel/icgrep/pablo/ps_if.cpp

    r4410 r4414  
    55
    66If::If(PabloAST * expr, DefinedVars && definedVars, PabloBlock & body, PabloBlock * parent)
    7 : Statement(ClassTypeId::If, nullptr, parent)
    8 , mExpr(expr)
     7: Statement(ClassTypeId::If, {expr}, nullptr, parent)
    98, mBody(body)
    109, mDefined(std::move(definedVars))
     
    1211, mAdvanceCount(0)
    1312{
    14     expr->addUser(this);
    15     for (Statement * s : body) {
    16         addUser(s);
    17     }
     13
    1814}
    1915
  • icGREP/icgrep-devel/icgrep/pablo/ps_if.h

    r4404 r4414  
    2828    virtual ~If() {
    2929    }
    30     virtual PabloAST * getOperand(const unsigned index) const {
    31         assert (index == 0);
    32         return mExpr;
    33     }
    34     virtual unsigned getNumOperands() const {
    35         return 1;
    36     }
    37     virtual void setOperand(const unsigned index, PabloAST * value) {
    38         assert (index == 0);
    39         mExpr = value;
    40     }
    4130    inline PabloAST * getCondition() const {
    42         return mExpr;
     31        return mOperand[0];
    4332    }
    4433    inline PabloBlock & getBody() {
     
    6655    If(PabloAST * expr, DefinedVars && definedVars, PabloBlock & body, PabloBlock * parent);
    6756private:
    68     PabloAST *      mExpr;
    6957    PabloBlock &    mBody;
    7058    DefinedVars     mDefined;
  • icGREP/icgrep-devel/icgrep/pablo/ps_while.cpp

    r4410 r4414  
    55
    66While::While(PabloAST * expr, PabloBlock & body, PabloBlock * parent)
    7 : Statement(ClassTypeId::While, nullptr, parent)
    8 , mExpr(expr)
     7: Statement(ClassTypeId::While, {expr}, nullptr, parent)
    98, mBody(body)
    109, mCarryCount(0)
    1110, mAdvanceCount(0)
    1211{
    13     expr->addUser(this);
    14     for (Statement * s : body) {
    15         addUser(s);
    16     }
     12
    1713}
    1814
  • icGREP/icgrep-devel/icgrep/pablo/ps_while.h

    r4404 r4414  
    2323    virtual ~While() {
    2424    }
    25     virtual PabloAST * getOperand(const unsigned index) const {
    26         assert (index == 0);
    27         return mExpr;
    28     }
    29     virtual unsigned getNumOperands() const {
    30         return 1;
    31     }
    32     virtual void setOperand(const unsigned index, PabloAST * value) {
    33         assert (index == 0);
    34         mExpr = value;
    35     }
    3625    inline PabloAST * getCondition() const {
    37         return mExpr;
     26        return mOperand[0];
    3827    }
    3928    inline PabloBlock & getBody() {
     
    5847    While(PabloAST * expr, PabloBlock &body, PabloBlock * parent);
    5948private:
    60     PabloAST *          mExpr;
    6149    PabloBlock &        mBody;
    6250    unsigned            mCarryCount;
Note: See TracChangeset for help on using the changeset viewer.