Ignore:
Timestamp:
Jan 7, 2015, 3:40:23 PM (5 years ago)
Author:
nmedfort
Message:

Changes to support 3-operand form for all instructions. CSE disabled but partially redundant now.

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

Legend:

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

    r4404 r4410  
    1616
    1717void UseAnalysis::cse(PabloBlock & block) {
    18     VertexIterator vi, vi_end;
    19     const auto nodeOf = get(vertex_name, mUseDefGraph);
    20     for (std::tie(vi, vi_end) = vertices(mUseDefGraph); vi != vi_end; ++vi) {
    21         const Vertex u = *vi;
    22         const auto count = out_degree(u, mUseDefGraph);
    23         if (count > 1) {
    24             PabloAST * expr = nodeOf[u];
    25             if (isa<Statement>(expr) || isa<Var>(expr)) {
    26                 continue;
    27             }
    28             // create the new nodes
    29             Assign * assign = block.createAssign("cse", expr);
    30             Var * var = block.createVar(assign);
    31             if (expr == var) {
    32                 continue;
    33             }
    34             const Vertex s = find(assign);
    35             const Vertex v = find(var);
    36             // update the program and graph
    37             OutEdgeIterator ei, ei_end;
    38             for (std::tie(ei, ei_end) = out_edges(u, mUseDefGraph); ei != ei_end; ++ei) {
    39                 const Vertex t = target(*ei, mUseDefGraph);
    40                 add_edge(v, t, mUseDefGraph);
    41                 PabloAST * user = nodeOf[t];
    42                 user->replaceUsesOfWith(expr, var);
    43             }
    44             clear_out_edges(u, mUseDefGraph);
    45             add_edge(u, s, mUseDefGraph);
    46             add_edge(s, v, mUseDefGraph);
    47             Statement * ip = findInsertionPointFor(u, block);
    48             if (ip == nullptr) {
    49                 assign->insertBefore(block.statements().front());
    50             }
    51             else {
    52                 assign->insertAfter(ip);
    53             }
    54         }
    55     }
     18//    VertexIterator vi, vi_end;
     19//    const auto nodeOf = get(vertex_name, mUseDefGraph);
     20//    for (std::tie(vi, vi_end) = vertices(mUseDefGraph); vi != vi_end; ++vi) {
     21//        const Vertex u = *vi;
     22//        const auto count = out_degree(u, mUseDefGraph);
     23//        if (count > 1) {
     24//            PabloAST * expr = nodeOf[u];
     25//            if (isa<Statement>(expr) || isa<Var>(expr)) {
     26//                continue;
     27//            }
     28//            // create the new nodes
     29//            Assign * assign = block.createAssign("cse", expr);
     30//            Var * var = block.createVar(assign);
     31//            if (expr == var) {
     32//                continue;
     33//            }
     34//            const Vertex s = find(assign);
     35//            const Vertex v = find(var);
     36//            // update the program and graph
     37//            OutEdgeIterator ei, ei_end;
     38//            for (std::tie(ei, ei_end) = out_edges(u, mUseDefGraph); ei != ei_end; ++ei) {
     39//                const Vertex t = target(*ei, mUseDefGraph);
     40//                add_edge(v, t, mUseDefGraph);
     41//                PabloAST * user = nodeOf[t];
     42//                user->replaceUsesOfWith(expr, var);
     43//            }
     44//            clear_out_edges(u, mUseDefGraph);
     45//            add_edge(u, s, mUseDefGraph);
     46//            add_edge(s, v, mUseDefGraph);
     47//            Statement * ip = findInsertionPointFor(u, block);
     48//            if (ip == nullptr) {
     49//                assign->insertBefore(block.statements().front());
     50//            }
     51//            else {
     52//                assign->insertAfter(ip);
     53//            }
     54//        }
     55//    }
    5656}
    5757
    5858inline Statement * UseAnalysis::findInsertionPointFor(const Vertex v, PabloBlock & block) {
    59     // We want to find a predecessor of v that is the last statement in the AST.
    60     const auto nodeOf = get(vertex_name, mUseDefGraph);
    61     PredecessorSet predecessors;
    62     std::queue<Vertex> Q;
    63     InEdgeIterator ei, ei_end;
    64     for (std::tie(ei, ei_end) = in_edges(v, mUseDefGraph); ei != ei_end; ++ei) {
    65         const Vertex u = source(*ei, mUseDefGraph);
    66         PabloAST * n = nodeOf[u];
    67         if (isa<Statement>(n)) {
    68             predecessors.insert(cast<Statement>(n));
    69         }
    70         else {
    71             Q.push(u);
    72         }
    73     }
    74 
    75     while (!Q.empty()) {
    76         const Vertex u = Q.front();
    77         Q.pop();
    78         PabloAST * n = nodeOf[u];
    79 
    80         if (isa<Statement>(n)) {
    81             predecessors.insert(cast<Statement>(n));
    82         }
    83         else {
    84             InEdgeIterator ei, ei_end;
    85             for (std::tie(ei, ei_end) = in_edges(u, mUseDefGraph); ei != ei_end; ++ei) {
    86                 Q.push(source(*ei, mUseDefGraph));
    87             }
    88         }
    89     }
    90     if (predecessors.empty()) {
    91         return nullptr;
    92     }
    93     return findLastStatement(predecessors, block.statements());
     59//    // We want to find a predecessor of v that is the last statement in the AST.
     60//    const auto nodeOf = get(vertex_name, mUseDefGraph);
     61//    PredecessorSet predecessors;
     62//    std::queue<Vertex> Q;
     63//    InEdgeIterator ei, ei_end;
     64//    for (std::tie(ei, ei_end) = in_edges(v, mUseDefGraph); ei != ei_end; ++ei) {
     65//        const Vertex u = source(*ei, mUseDefGraph);
     66//        PabloAST * n = nodeOf[u];
     67//        if (isa<Statement>(n)) {
     68//            predecessors.insert(cast<Statement>(n));
     69//        }
     70//        else {
     71//            Q.push(u);
     72//        }
     73//    }
     74
     75//    while (!Q.empty()) {
     76//        const Vertex u = Q.front();
     77//        Q.pop();
     78//        PabloAST * n = nodeOf[u];
     79
     80//        if (isa<Statement>(n)) {
     81//            predecessors.insert(cast<Statement>(n));
     82//        }
     83//        else {
     84//            InEdgeIterator ei, ei_end;
     85//            for (std::tie(ei, ei_end) = in_edges(u, mUseDefGraph); ei != ei_end; ++ei) {
     86//                Q.push(source(*ei, mUseDefGraph));
     87//            }
     88//        }
     89//    }
     90//    if (predecessors.empty()) {
     91//        return nullptr;
     92//    }
     93//    return findLastStatement(predecessors, block.statements());
    9494}
    9595
    9696Statement * UseAnalysis::findLastStatement(const PredecessorSet & predecessors, StatementList & statements) {
    97     for (auto ri = statements.rbegin(); ri != statements.rend(); ++ri) {
    98         Statement * stmt = *ri;
    99         if (predecessors.count(stmt)) {
    100             return stmt;
    101         }
    102         else if (isa<If>(stmt)) {
    103             Statement * innerstmt = findLastStatement(predecessors, cast<If>(stmt)->getBody());
    104             if (innerstmt) {
    105                 return stmt;
    106             }
    107         }
    108         else if (isa<While>(stmt)) {
    109             stmt = findLastStatement(predecessors, cast<While>(stmt)->getBody());
    110             if (stmt) {
    111                 return stmt;
    112             }
    113         }
    114     }
    115     return nullptr;
     97//    for (auto ri = statements.rbegin(); ri != statements.rend(); ++ri) {
     98//        Statement * stmt = *ri;
     99//        if (predecessors.count(stmt)) {
     100//            return stmt;
     101//        }
     102//        else if (isa<If>(stmt)) {
     103//            Statement * innerstmt = findLastStatement(predecessors, cast<If>(stmt)->getBody());
     104//            if (innerstmt) {
     105//                return stmt;
     106//            }
     107//        }
     108//        else if (isa<While>(stmt)) {
     109//            stmt = findLastStatement(predecessors, cast<While>(stmt)->getBody());
     110//            if (stmt) {
     111//                return stmt;
     112//            }
     113//        }
     114//    }
     115//    return nullptr;
    116116}
    117117
    118118void UseAnalysis::dce() {
    119     const auto nodeOf = get(vertex_name, mUseDefGraph);
    120     std::queue<Vertex> Q;
    121     // gather up all of the nodes that aren't output assignments and have no users
    122     VertexIterator vi, vi_end;
    123     for (std::tie(vi, vi_end) = vertices(mUseDefGraph); vi != vi_end; ++vi) {
    124         const Vertex v = *vi;
    125         if (out_degree(v, mUseDefGraph) == 0) {
    126             PabloAST * n = nodeOf[v];
    127             if (!isa<Assign>(n) || (cast<Assign>(n)->isOutputAssignment())) {
    128                 continue;
    129             }
    130             Q.push(v);
    131         }
    132     }
    133     while (!Q.empty()) {
    134         const Vertex v = Q.front();
    135         Q.pop();
    136         PabloAST * n = nodeOf[v];
    137         if (isa<Assign>(n)) {
    138             cast<Assign>(n)->removeFromParent();
    139         }
    140         InEdgeIterator ei, ei_end;
    141         for (std::tie(ei, ei_end) = in_edges(v, mUseDefGraph); ei != ei_end; ++ei) {
    142             const Vertex u = source(*ei, mUseDefGraph);
    143             if (out_degree(u, mUseDefGraph) == 1) {
    144                 Q.push(u);
    145             }
    146         }
    147         clear_in_edges(v, mUseDefGraph);
    148     }
     119//    const auto nodeOf = get(vertex_name, mUseDefGraph);
     120//    std::queue<Vertex> Q;
     121//    // gather up all of the nodes that aren't output assignments and have no users
     122//    VertexIterator vi, vi_end;
     123//    for (std::tie(vi, vi_end) = vertices(mUseDefGraph); vi != vi_end; ++vi) {
     124//        const Vertex v = *vi;
     125//        if (out_degree(v, mUseDefGraph) == 0) {
     126//            PabloAST * n = nodeOf[v];
     127//            if (!isa<Assign>(n) || (cast<Assign>(n)->isOutputAssignment())) {
     128//                continue;
     129//            }
     130//            Q.push(v);
     131//        }
     132//    }
     133//    while (!Q.empty()) {
     134//        const Vertex v = Q.front();
     135//        Q.pop();
     136//        PabloAST * n = nodeOf[v];
     137//        if (isa<Assign>(n)) {
     138//            cast<Assign>(n)->removeFromParent();
     139//        }
     140//        InEdgeIterator ei, ei_end;
     141//        for (std::tie(ei, ei_end) = in_edges(v, mUseDefGraph); ei != ei_end; ++ei) {
     142//            const Vertex u = source(*ei, mUseDefGraph);
     143//            if (out_degree(u, mUseDefGraph) == 1) {
     144//                Q.push(u);
     145//            }
     146//        }
     147//        clear_in_edges(v, mUseDefGraph);
     148//    }
    149149}
    150150
     
    192192
    193193void UseAnalysis::gatherUseDefInformation(const Vertex v, const PabloAST * expr) {
    194     if (isa<Var>(expr) && cast<Var>(expr)->isExternal()) {
    195         return;
    196     }
     194//    if (isa<Var>(expr) && cast<Var>(expr)->isExternal()) {
     195//        return;
     196//    }
    197197    const Vertex u = find(expr);
    198198    add_edge(u, v, mUseDefGraph);
    199199    if (const Var * var = dyn_cast<Var>(expr)) {
    200         gatherUseDefInformation(u, var->getVar());
     200//        gatherUseDefInformation(u, var->getVar());
    201201    }
    202202    else if (const And * pablo_and = dyn_cast<const And>(expr)) {
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.cpp

    r4404 r4410  
    1616        return expr;
    1717    }
    18     return mUnaryWithInt.findOrMake<Advance>(PabloAST::ClassTypeId::Advance, expr, shiftAmount).first;
    19 }
    20 
    21 PabloAST * PabloBlock::createCall(const std::string name) {
    22     return mUnary.findOrMake<Call>(PabloAST::ClassTypeId::Call, mSymbolGenerator->get(name)).first;
     18    return appendIfNew(mUnaryWithInt.findOrMake<Advance>(PabloAST::ClassTypeId::Advance, expr, shiftAmount, mSymbolGenerator, this));
     19}
     20
     21Call * PabloBlock::createCall(const std::string name) {
     22    return appendIfNew(mUnary.findOrMake<Call>(PabloAST::ClassTypeId::Call, mSymbolGenerator->get(name), this));
    2323}
    2424
    2525PabloAST * PabloBlock::createNot(PabloAST * expr) {
    26     return mUnary.findOrCall<OptimizeNot>(PabloAST::ClassTypeId::Not, expr).first;
    27 }
     26    return mUnary.findOrCall<OptimizeNot>(PabloAST::ClassTypeId::Not, expr, this);
     27}
     28
     29Not * PabloBlock::createNotImm(PabloAST * expr) {
     30    return appendIfNew(mUnary.findOrMake<Not>(PabloAST::ClassTypeId::Not, expr, this));
     31}
     32
    2833
    2934Var * PabloBlock::createVar(const std::string name) {
    30     return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, mSymbolGenerator->get(name)).first;
    31 }
    32 
    33 Var * PabloBlock::createVar(Assign * assign) {
    34     return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, assign).first;
    35 }
    36 
    37 Var * PabloBlock::createVar(Next * next) {
    38     return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, next).first;
     35    return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, mSymbolGenerator->get(name), this).first;
    3936}
    4037
     
    4239
    4340Next * PabloBlock::createNext(Assign * assign, PabloAST * expr) {
    44     Next * next;
    45     bool added;
    46     std::tie(next, added) = mBinary.findOrMake<Next>(PabloAST::ClassTypeId::Next, assign, expr, this);
    47     if (LLVM_LIKELY(added)) {
    48         push_back(next);
    49     }
    50     return next;
     41    return appendIfNew(mBinary.findOrMake<Next>(PabloAST::ClassTypeId::Next, assign, expr, this));
    5142}
    5243
     
    5546        return marker;
    5647    }
    57     return mBinary.findOrMake<MatchStar>(PabloAST::ClassTypeId::MatchStar, marker, charclass).first;
     48    return appendIfNew(mBinary.findOrMake<MatchStar>(PabloAST::ClassTypeId::MatchStar, marker, charclass, mSymbolGenerator, this));
    5849}
    5950
     
    6253        return from;
    6354    }
    64     return mBinary.findOrMake<ScanThru>(PabloAST::ClassTypeId::ScanThru, from, thru).first;
     55    return appendIfNew(mBinary.findOrMake<ScanThru>(PabloAST::ClassTypeId::ScanThru, from, thru, mSymbolGenerator, this));
    6556}
    6657
     
    6960        std::swap(expr1, expr2);
    7061    }
    71     return mBinary.findOrCall<OptimizeAnd>(PabloAST::ClassTypeId::And, expr1, expr2).first;
     62    return mBinary.findOrCall<OptimizeAnd>(PabloAST::ClassTypeId::And, expr1, expr2, this);
     63}
     64
     65And * PabloBlock::createAndImm(PabloAST * expr1, PabloAST * expr2) {
     66    return appendIfNew(mBinary.findOrMake<And>(PabloAST::ClassTypeId::And, expr1, expr2, this));
    7267}
    7368
     
    7671        std::swap(expr1, expr2);
    7772    }
    78     return mBinary.findOrCall<OptimizeOr>(PabloAST::ClassTypeId::Or, expr1, expr2).first;
     73    return mBinary.findOrCall<OptimizeOr>(PabloAST::ClassTypeId::Or, expr1, expr2, this);
     74}
     75
     76Or * PabloBlock::createOrImm(PabloAST * expr1, PabloAST * expr2) {
     77    return appendIfNew(mBinary.findOrMake<Or>(PabloAST::ClassTypeId::Or, expr1, expr2, this));
    7978}
    8079
     
    8382        std::swap(expr1, expr2);
    8483    }
    85     return mBinary.findOrCall<OptimizeXor>(PabloAST::ClassTypeId::Xor, expr1, expr2).first;
     84    return mBinary.findOrCall<OptimizeXor>(PabloAST::ClassTypeId::Xor, expr1, expr2, this);
     85}
     86
     87Xor * PabloBlock::createXorImm(PabloAST * expr1, PabloAST * expr2) {
     88    return appendIfNew(mBinary.findOrMake<Xor>(PabloAST::ClassTypeId::Xor, expr1, expr2,  this));
    8689}
    8790
     
    8992
    9093PabloAST * PabloBlock::createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
    91     return mTernary.findOrCall<OptimizeSel>(PabloAST::ClassTypeId::Sel, condition, trueExpr, falseExpr).first;
    92 }
     94    return mTernary.findOrCall<OptimizeSel>(PabloAST::ClassTypeId::Sel, condition, trueExpr, falseExpr, this);
     95}
     96
     97Sel * PabloBlock::createSelImm(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
     98    return appendIfNew(mTernary.findOrMake<Sel>(PabloAST::ClassTypeId::Sel, condition, trueExpr, falseExpr, this));
     99}
     100
    93101
    94102//PabloAST * PabloBlock::replaceUsesOfWith(PabloAST * inst, PabloAST * from, PabloAST * to) {
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.h

    r4404 r4410  
    3333#include <array>
    3434#include <tuple>
     35#include <pablo/printer_pablos.h>
    3536
    3637namespace pablo {
     
    5859    }
    5960
    60     PabloAST * createCall(const std::string name);
     61    Call * createCall(const std::string name);
    6162
    6263    Assign * createAssign(const std::string prefix, PabloAST * expr, const int outputIndex = -1)  {
     
    6465        // unique until we prove it has no Next node associated with it. But the Assign node must be created
    6566        // before the Next node. Should we create a "Constant" flag for this?
    66         Assign * assign = new Assign(mSymbolGenerator->get_ssa(prefix), expr, outputIndex, this);
     67        Assign * assign = new Assign(expr, outputIndex, mSymbolGenerator->make(prefix), this);
    6768        push_back(assign);
    6869        return assign;
    6970    }
    7071
    71     Var * createVar(const std::string name);
    72 
    73     Var * createVar(Assign * assign);
    74 
    75     Var * createVar(Next * next);
    76 
    77     inline PabloAST * createVar(PabloAST * const input) {
    78         switch (input->getClassTypeId()) {
    79             case PabloAST::ClassTypeId::Assign:
    80                 return createVar(cast<Assign>(input));
    81             case PabloAST::ClassTypeId::Next:
    82                 return createVar(cast<Next>(input));
    83             default:
    84                 return input;
    85         }
     72    Var * createVar(const std::string);
     73
     74    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.");
    8676    }
    8777
     
    10191
    10292    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr);
     93
     94    And * createAndImm(PabloAST * expr1, PabloAST * expr2);
     95
     96    Not * createNotImm(PabloAST * expr);
     97
     98    Or * createOrImm(PabloAST * expr1, PabloAST * expr2);
     99
     100    Xor * createXorImm(PabloAST * expr1, PabloAST * expr2);
     101
     102    Sel * createSelImm(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr);
    103103
    104104    inline If * createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBlock & body) {
     
    120120        typedef std::tuple<PabloAST::ClassTypeId, Args...> Key;
    121121
    122         inline ExpressionMap(MapType * predecessor, PabloBlock * parent)
     122        inline ExpressionMap(MapType * predecessor)
    123123        : mPredecessor(predecessor)
    124         , mCurrentBlock(*parent)
    125124        {
    126125
     
    134133                return std::make_pair(cast<Type>(f), false);
    135134            }
    136             Type * const expr = new Type(std::forward<Args>(args)..., std::forward<Params>(params)...);
     135            PabloAST * const expr = new Type(std::forward<Args>(args)..., std::forward<Params>(params)...);
    137136            insert(std::move(key), expr);
    138             return std::make_pair(expr, true);
    139         }
    140 
     137            return std::make_pair(cast<Type>(expr), isa<Statement>(expr));
     138        }
    141139
    142140        template <class Functor, typename... Params>
    143         inline std::pair<PabloAST *, bool> findOrCall(const PabloAST::ClassTypeId type, Args... args, Params... params) {
     141        inline PabloAST * findOrCall(const PabloAST::ClassTypeId type, Args... args, Params... params) {
    144142            Key key = std::make_tuple(type, args...);
    145143            PabloAST * const f = find(key);
    146144            if (f) {
    147                 return std::make_pair(f, false);
    148             }
    149             Functor mf(mCurrentBlock);
     145                return f;
     146            }
     147            Functor mf;
    150148            PabloAST * const expr = mf(std::forward<Args>(args)..., std::forward<Params>(params)...);
    151149            insert(std::move(key), expr);
    152             return std::make_pair(expr, true);
     150            return expr;
    153151        }
    154152
     
    178176    private:
    179177        MapType * const             mPredecessor;
    180         PabloBlock &                mCurrentBlock;
    181178        std::map<Key, PabloAST *>   mMap;
    182179    };
     
    188185    inline const StatementList & statements() const {
    189186        return *this;
     187    }
     188    inline String * getName(const std::string name) const {
     189        return mSymbolGenerator->get(name);
     190    }
     191    inline String * makeName(const std::string prefix) const {
     192        return mSymbolGenerator->make(prefix);
    190193    }
    191194protected:
     
    194197    , mOnes(new Ones())
    195198    , mSymbolGenerator(new SymbolGenerator())
    196     , mUnary(nullptr, this)
    197     , mUnaryWithInt(nullptr, this)
    198     , mBinary(nullptr, this)
    199     , mTernary(nullptr, this)
     199    , mUnary(nullptr)
     200    , mUnaryWithInt(nullptr)
     201    , mBinary(nullptr)
     202    , mTernary(nullptr)
    200203    {
    201204
     
    206209    , mOnes(predecessor->mOnes) // inherit the original "Ones" variable for simplicity
    207210    , mSymbolGenerator(predecessor->mSymbolGenerator)
    208     , mUnary(&(predecessor->mUnary), this)
    209     , mUnaryWithInt(&(predecessor->mUnaryWithInt), this)
    210     , mBinary(&(predecessor->mBinary), this)
    211     , mTernary(&(predecessor->mTernary), this)
     211    , mUnary(&(predecessor->mUnary))
     212    , mUnaryWithInt(&(predecessor->mUnaryWithInt))
     213    , mBinary(&(predecessor->mBinary))
     214    , mTernary(&(predecessor->mTernary))
    212215    {
    213216
     
    217220        return PabloAST::mAllocator.allocate(size);
    218221    }
     222
     223    template<typename Type>
     224    inline Type appendIfNew(std::pair<Type, bool> retVal) {
     225        if (std::get<1>(retVal)) {
     226            push_back(cast<Statement>(std::get<0>(retVal)));
     227        }
     228        return std::get<0>(retVal);
     229    }
     230
    219231private:       
    220232    Zeroes * const                                      mZeroes;
  • icGREP/icgrep-devel/icgrep/pablo/pabloAST.h

    r4404 r4410  
    7070    }
    7171
    72     inline void replaceUsesOfWith(PabloAST * from, PabloAST * to) {
    73         if (from == to) {
    74             return;
    75         }
    76         for (unsigned i = 0, operands = getNumOperands(); i != operands; ++i) {
    77             if (getOperand(i) == from) {
    78                 setOperand(i, to);
    79             }
    80         }
    81     }
    82 
    83     virtual PabloAST * getOperand(const unsigned index) const = 0;
    84 
    85     virtual unsigned getNumOperands() const = 0;
    86 
    87     virtual void setOperand(const unsigned index, PabloAST * value) = 0;
    88 
    8972    void setMetadata(const std::string & name, PMDNode * node);
    9073
     
    122105
    123106class StatementList;
     107
     108class String;
    124109
    125110class Statement : public PabloAST {
     
    131116    static inline bool classof(const PabloAST * e) {
    132117        switch (e->getClassTypeId()) {
    133             case PabloAST::ClassTypeId::Assign:
    134             case PabloAST::ClassTypeId::Next:
    135             case PabloAST::ClassTypeId::If:
    136             case PabloAST::ClassTypeId::While:
     118            case PabloAST::ClassTypeId::String:
     119                return false;
     120            default:
    137121                return true;
    138             default:
    139                 return false;
    140122        }
    141123    }
     
    146128        return false;
    147129    }
     130
     131    inline void replaceUsesOfWith(PabloAST * from, PabloAST * to) {
     132        if (from == to) {
     133            return;
     134        }
     135        for (unsigned i = 0, operands = getNumOperands(); i != operands; ++i) {
     136            if (getOperand(i) == from) {
     137                setOperand(i, to);
     138            }
     139        }
     140    }
     141
     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;
    148147
    149148    void insertBefore(Statement * const statement);
     
    152151    void replaceWith(Statement * const statement);
    153152
     153    inline const String * getName() const {
     154        return mName;
     155    }
    154156    inline Statement * getNextNode() const {
    155157        return mNext;
     
    162164    }
    163165protected:
    164     Statement(const ClassTypeId id, PabloBlock * parent)
     166    Statement(const ClassTypeId id, const String * name, PabloBlock * parent)
    165167    : PabloAST(id)
     168    , mName(name)
    166169    , mNext(nullptr)
    167170    , mPrev(nullptr)
     
    172175    virtual ~Statement() = 0;
    173176protected:
     177    const String * mName;
    174178    Statement * mNext;
    175179    Statement * mPrev;
  • icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.cpp

    r4403 r4410  
    159159        IRBuilder<> b(mBasicBlock);
    160160        Value* indices[] = {b.getInt64(0), b.getInt32(i)};
    161         const String * const name = mBasisBits[i]->getName();
    162161        Value * gep = b.CreateGEP(mBasisBitsAddr, indices);
    163         LoadInst * basisBit = b.CreateAlignedLoad(gep, BLOCK_SIZE/8, false, name->str());
    164         mMarkerMap.insert(std::make_pair(name, basisBit));
     162        LoadInst * basisBit = b.CreateAlignedLoad(gep, BLOCK_SIZE/8, false, mBasisBits[i]->getName()->str());
     163        mMarkerMap.insert(std::make_pair(mBasisBits[i], basisBit));
    165164    }
    166165
     
    169168
    170169    assert (mCarryQueueIdx == mCarryQueueSize);
    171     assert (mAdvanceQueueIdx == mAdvanceQueueSize);
     170    assert (mAdvanceQueueIdx <= mAdvanceQueueSize);
    172171    assert (mNestingDepth == 0);
    173172    //Terminate the block
     
    492491
    493492void PabloCompiler::compileStatements(const StatementList & stmts) {
    494     for (const PabloAST * statement : stmts) {
     493    for (const Statement * statement : stmts) {
    495494        compileStatement(statement);
    496495    }
    497496}
    498497
    499 void PabloCompiler::compileStatement(const PabloAST * stmt)
     498void PabloCompiler::compileStatement(const Statement * stmt)
    500499{
    501     if (const Assign * assign = dyn_cast<const Assign>(stmt))
    502     {
    503         Value* expr = compileExpression(assign->getExpr());
    504         mMarkerMap[assign->getName()] = expr;
     500    IRBuilder<> b(mBasicBlock);
     501    if (const Assign * assign = dyn_cast<const Assign>(stmt)) {
     502        Value * expr = compileExpression(assign->getExpr());
     503        mMarkerMap[assign] = expr;
    505504        if (LLVM_UNLIKELY(assign->isOutputAssignment())) {
    506505            SetOutputValue(expr, assign->getOutputIndex());
    507506        }
    508507    }
    509     if (const Next * next = dyn_cast<const Next>(stmt))
    510     {
    511         Value* expr = compileExpression(next->getExpr());
    512         mMarkerMap[next->getName()] = expr;
     508    else if (const Next * next = dyn_cast<const Next>(stmt)) {
     509        Value * expr = compileExpression(next->getExpr());
     510        mMarkerMap[next->getInitial()] = expr;
    513511    }
    514512    else if (const If * ifStatement = dyn_cast<const If>(stmt))
    515     //
    516     //  The If-ElseZero stmt:
    517     //  if <predicate:expr> then <body:stmt>* elsezero <defined:var>* endif
    518     //  If the value of the predicate is nonzero, then determine the values of variables
    519     //  <var>* by executing the given statements.  Otherwise, the value of the
    520     //  variables are all zero.  Requirements: (a) no variable that is defined within
    521     //  the body of the if may be accessed outside unless it is explicitly 
    522     //  listed in the variable list, (b) every variable in the defined list receives
    523     //  a value within the body, and (c) the logical consequence of executing
    524     //  the statements in the event that the predicate is zero is that the
    525     //  values of all defined variables indeed work out to be 0.
    526     //
    527     //  Simple Implementation with Phi nodes:  a phi node in the if exit block
    528     //  is inserted for each variable in the defined variable list.  It receives
    529     //  a zero value from the ifentry block and the defined value from the if
    530     //  body.
    531     //
    532     {
     513    {
     514        //
     515        //  The If-ElseZero stmt:
     516        //  if <predicate:expr> then <body:stmt>* elsezero <defined:var>* endif
     517        //  If the value of the predicate is nonzero, then determine the values of variables
     518        //  <var>* by executing the given statements.  Otherwise, the value of the
     519        //  variables are all zero.  Requirements: (a) no variable that is defined within
     520        //  the body of the if may be accessed outside unless it is explicitly
     521        //  listed in the variable list, (b) every variable in the defined list receives
     522        //  a value within the body, and (c) the logical consequence of executing
     523        //  the statements in the event that the predicate is zero is that the
     524        //  values of all defined variables indeed work out to be 0.
     525        //
     526        //  Simple Implementation with Phi nodes:  a phi node in the if exit block
     527        //  is inserted for each variable in the defined variable list.  It receives
     528        //  a zero value from the ifentry block and the defined value from the if
     529        //  body.
     530        //
     531
    533532        BasicBlock * ifEntryBlock = mBasicBlock;  // The block we are in.
    534533        BasicBlock * ifBodyBlock = BasicBlock::Create(mMod->getContext(), "if.body", mFunction, 0);
     
    572571
    573572        // Entry processing is complete, now handle the body of the if.
    574        
    575573        mBasicBlock = ifBodyBlock;
    576        
    577574        compileStatements(ifStatement->getBody());
    578575
     
    587584
    588585            Value * carry_summary = mZeroInitializer;
    589             for (int c = baseCarryQueueIdx; c < baseCarryQueueIdx + ifCarryCount; c++)
    590             {
     586            for (int c = baseCarryQueueIdx; c < baseCarryQueueIdx + ifCarryCount; c++) {
    591587                int s = mCarryQueueSummaryIdx[c];
    592588                if (s == -1) {
    593589                    Value* carryq_value = mCarryQueueVector[c];
    594                     carry_summary = bIfBody.CreateOr(carry_summary, carryq_value);
     590                    if (carry_summary == mZeroInitializer) {
     591                        carry_summary = carryq_value;
     592                    }
     593                    else {
     594                        carry_summary = bIfBody.CreateOr(carry_summary, carryq_value);
     595                    }
    595596                    mCarryQueueSummaryIdx[c] = mAdvanceQueueIdx;
    596597                }
    597                
    598 
    599598            }
    600599            // Note that the limit in the following uses -1, because
    601600            // last entry of the advance queue is for the summary variable.
    602             for (int c = baseAdvanceQueueIdx; c < baseAdvanceQueueIdx + ifAdvanceCount - 1; c++)
    603             {
     601            for (int c = baseAdvanceQueueIdx; c < baseAdvanceQueueIdx + ifAdvanceCount - 1; c++) {
    604602                int s = mAdvanceQueueSummaryIdx[c];
    605603                if (s == -1 ) {
    606604                    Value* advance_q_value = mAdvanceQueueVector[c];
    607                     carry_summary = bIfBody.CreateOr(advance_q_value, carry_summary);
     605                    if (carry_summary == mZeroInitializer) {
     606                        carry_summary = advance_q_value;
     607                    }
     608                    else {
     609                        carry_summary = bIfBody.CreateOr(carry_summary, advance_q_value);
     610                    }
    608611                    mAdvanceQueueSummaryIdx[c] = mAdvanceQueueIdx;
    609612                }
    610613            }
    611             genAdvanceOutStore(carry_summary, mAdvanceQueueIdx++); //baseAdvanceQueueIdx + ifAdvanceCount - 1);
     614            genAdvanceOutStore(carry_summary, mAdvanceQueueIdx++);
    612615        }
    613616        bIfBody.CreateBr(ifEndBlock);
     
    616619        for (const Assign * a : ifStatement->getDefined()) {
    617620            PHINode * phi = bEnd.CreatePHI(mBitBlockType, 2, a->getName()->str());
    618             auto f = mMarkerMap.find(a->getName());
     621            auto f = mMarkerMap.find(a);
    619622            assert (f != mMarkerMap.end());
    620623            phi->addIncoming(mZeroInitializer, ifEntryBlock);
    621624            phi->addIncoming(f->second, mBasicBlock);
    622             mMarkerMap[a->getName()] = phi;
     625            mMarkerMap[a] = phi;
    623626        }
    624627        // Create the phi Node for the summary variable.
    625628        if (ifAdvanceCount >= 1) {
    626           // final AdvanceQ entry is summary variable.
    627           PHINode * summary_phi = bEnd.CreatePHI(mBitBlockType, 2, "summary");
    628           summary_phi->addIncoming(mZeroInitializer, ifEntryBlock);
    629           summary_phi->addIncoming(mAdvanceQueueVector[mAdvanceQueueIdx-1], mBasicBlock);
    630           mAdvanceQueueVector[mAdvanceQueueIdx-1] = summary_phi;
     629            // final AdvanceQ entry is summary variable.
     630            PHINode * summary_phi = bEnd.CreatePHI(mBitBlockType, 2, "summary");
     631            summary_phi->addIncoming(mZeroInitializer, ifEntryBlock);
     632            summary_phi->addIncoming(mAdvanceQueueVector[mAdvanceQueueIdx-1], mBasicBlock);
     633            mAdvanceQueueVector[mAdvanceQueueIdx-1] = summary_phi;
    631634        }
    632635        else if (ifCarryCount == 1) {
    633           PHINode * summary_phi = bEnd.CreatePHI(mBitBlockType, 2, "summary");
    634           summary_phi->addIncoming(mZeroInitializer, ifEntryBlock);
    635           summary_phi->addIncoming(mCarryQueueVector[baseCarryQueueIdx], mBasicBlock);
    636           mCarryQueueVector[baseCarryQueueIdx] = summary_phi;
     636            PHINode * summary_phi = bEnd.CreatePHI(mBitBlockType, 2, "summary");
     637            summary_phi->addIncoming(mZeroInitializer, ifEntryBlock);
     638            summary_phi->addIncoming(mCarryQueueVector[baseCarryQueueIdx], mBasicBlock);
     639            mCarryQueueVector[baseCarryQueueIdx] = summary_phi;
    637640        }
    638641       
     
    706709        for (const Next * n : nextNodes) {
    707710            PHINode * phi = bCond.CreatePHI(mBitBlockType, 2, n->getName()->str());
    708             auto f = mMarkerMap.find(n->getName());
     711            auto f = mMarkerMap.find(n->getInitial());
    709712            assert (f != mMarkerMap.end());
    710713            phi->addIncoming(f->second, mBasicBlock);
    711             mMarkerMap[n->getName()] = phi;
     714            mMarkerMap[n->getInitial()] = phi;
    712715            phiNodes[index++] = phi;
    713716        }
     
    735738        // and for any Next nodes in the loop body
    736739        for (const Next * n : nextNodes) {
    737             auto f = mMarkerMap.find(n->getName());
     740            auto f = mMarkerMap.find(n->getInitial());
    738741            assert (f != mMarkerMap.end());
    739742            PHINode * phi = phiNodes[index++];
    740743            phi->addIncoming(f->second, mBasicBlock);
    741             mMarkerMap[n->getName()] = phi;
     744            mMarkerMap[n->getInitial()] = phi;
    742745        }
    743746
     
    755758        }
    756759    }
    757 }
    758 
    759 Value * PabloCompiler::compileExpression(const PabloAST * expr)
    760 {
    761     IRBuilder<> b(mBasicBlock);
    762     if (isa<Ones>(expr)) {
    763         return mOneInitializer;
    764     }
    765     else if (isa<Zeroes>(expr)) {
    766         return mZeroInitializer;
    767     }
    768     else if (const Call* call = dyn_cast<Call>(expr)) {
     760    else if (const Call* call = dyn_cast<Call>(stmt)) {
    769761        //Call the callee once and store the result in the marker map.
    770         auto mi = mMarkerMap.find(call->getCallee());
     762        auto mi = mMarkerMap.find(call);
    771763        if (mi == mMarkerMap.end()) {
    772764            auto ci = mCalleeMap.find(call->getCallee());
     
    774766                throw std::runtime_error("Unexpected error locating static function for \"" + call->getCallee()->str() + "\"");
    775767            }
    776             mi = mMarkerMap.insert(std::make_pair(call->getCallee(), b.CreateCall(ci->second, mBasisBitsAddr))).first;
    777         }
    778         return mi->second;
    779     }
    780     else if (const Var * var = dyn_cast<Var>(expr))
    781     {
    782         auto f = mMarkerMap.find(var->getName());
    783         if (LLVM_UNLIKELY(f == mMarkerMap.end())) {
    784             throw std::runtime_error((var->getName()->str()) + " used before creation.");
    785         }
    786         return f->second;
    787     }
    788     else if (const And * pablo_and = dyn_cast<And>(expr))
    789     {
    790         return b.CreateAnd(compileExpression(pablo_and->getExpr1()), compileExpression(pablo_and->getExpr2()), "and");
    791     }
    792     else if (const Or * pablo_or = dyn_cast<Or>(expr))
    793     {
    794         return b.CreateOr(compileExpression(pablo_or->getExpr1()), compileExpression(pablo_or->getExpr2()), "or");
    795     }
    796     else if (const Xor * pablo_xor = dyn_cast<Xor>(expr))
    797     {
    798         return b.CreateXor(compileExpression(pablo_xor->getExpr1()), compileExpression(pablo_xor->getExpr2()), "xor");
    799     }
    800     else if (const Sel * sel = dyn_cast<Sel>(expr))
    801     {
     768            mi = mMarkerMap.insert(std::make_pair(call, b.CreateCall(ci->second, mBasisBitsAddr))).first;
     769        }
     770        // return mi->second;
     771    }
     772    else if (const And * pablo_and = dyn_cast<And>(stmt)) {
     773        Value * expr = b.CreateAnd(compileExpression(pablo_and->getExpr1()), compileExpression(pablo_and->getExpr2()), "and");
     774        mMarkerMap[pablo_and] = expr;
     775        // return expr;
     776    }
     777    else if (const Or * pablo_or = dyn_cast<Or>(stmt)) {
     778        Value * expr = b.CreateOr(compileExpression(pablo_or->getExpr1()), compileExpression(pablo_or->getExpr2()), "or");
     779        mMarkerMap[pablo_or] = expr;
     780        // return expr;
     781    }
     782    else if (const Xor * pablo_xor = dyn_cast<Xor>(stmt)) {
     783        Value * expr = b.CreateXor(compileExpression(pablo_xor->getExpr1()), compileExpression(pablo_xor->getExpr2()), "xor");
     784        mMarkerMap[pablo_xor] = expr;
     785        // return expr;
     786    }
     787    else if (const Sel * sel = dyn_cast<Sel>(stmt)) {
    802788        Value* ifMask = compileExpression(sel->getCondition());
    803789        Value* ifTrue = b.CreateAnd(ifMask, compileExpression(sel->getTrueExpr()));
    804790        Value* ifFalse = b.CreateAnd(genNot(ifMask), compileExpression(sel->getFalseExpr()));
    805         return b.CreateOr(ifTrue, ifFalse);
    806     }
    807     else if (const Not * pablo_not = dyn_cast<Not>(expr))
    808     {
    809         return genNot(compileExpression(pablo_not->getExpr()));
    810     }
    811     else if (const Advance * adv = dyn_cast<Advance>(expr))
    812     {
     791        Value * expr = b.CreateOr(ifTrue, ifFalse);
     792        mMarkerMap[sel] = expr;
     793        // return expr;
     794    }
     795    else if (const Not * pablo_not = dyn_cast<Not>(stmt)) {
     796        Value * expr = genNot(compileExpression(pablo_not->getExpr()));
     797        mMarkerMap[pablo_not] = expr;
     798        // return expr;
     799    }
     800    else if (const Advance * adv = dyn_cast<Advance>(stmt)) {
    813801        Value* strm_value = compileExpression(adv->getExpr());
    814802        int shift = adv->getAdvanceAmount();
    815         return genAdvanceWithCarry(strm_value, shift);
    816     }
    817     else if (const MatchStar * mstar = dyn_cast<MatchStar>(expr))
    818     {
    819         Value* marker = compileExpression(mstar->getMarker());
    820         Value* cc = compileExpression(mstar->getCharClass());
    821         Value* marker_and_cc = b.CreateAnd(marker, cc);
    822         return b.CreateOr(b.CreateXor(genAddWithCarry(marker_and_cc, cc), cc), marker, "matchstar");
    823     }
    824     else if (const ScanThru * sthru = dyn_cast<ScanThru>(expr))
    825     {
    826         Value* marker_expr = compileExpression(sthru->getScanFrom());
    827         Value* cc_expr = compileExpression(sthru->getScanThru());
    828         return b.CreateAnd(genAddWithCarry(marker_expr, cc_expr), genNot(cc_expr), "scanthru");
     803        Value * expr = genAdvanceWithCarry(strm_value, shift);
     804        mMarkerMap[adv] = expr;
     805        // return expr;
     806    }
     807    else if (const MatchStar * mstar = dyn_cast<MatchStar>(stmt))
     808    {
     809        Value * marker = compileExpression(mstar->getMarker());
     810        Value * cc = compileExpression(mstar->getCharClass());
     811        Value * marker_and_cc = b.CreateAnd(marker, cc);
     812        Value * expr = b.CreateOr(b.CreateXor(genAddWithCarry(marker_and_cc, cc), cc), marker, "matchstar");
     813        mMarkerMap[mstar] = expr;
     814        // return expr;
     815    }
     816    else if (const ScanThru * sthru = dyn_cast<ScanThru>(stmt))
     817    {
     818        Value * marker_expr = compileExpression(sthru->getScanFrom());
     819        Value * cc_expr = compileExpression(sthru->getScanThru());
     820        Value * expr = b.CreateAnd(genAddWithCarry(marker_expr, cc_expr), genNot(cc_expr), "scanthru");
     821        mMarkerMap[sthru] = expr;
     822        // return expr;
    829823    }
    830824    else {
     825        PabloPrinter::print(stmt, std::cerr);
     826        throw std::runtime_error("Unrecognized Pablo Statement! can't compile.");
     827    }
     828}
     829
     830Value * PabloCompiler::compileExpression(const PabloAST * expr) {
     831    if (isa<Ones>(expr)) {
     832        return mOneInitializer;
     833    }
     834    else if (isa<Zeroes>(expr)) {
     835        return mZeroInitializer;
     836    }
     837    else if (const Next * next = dyn_cast<Next>(expr)) {
     838        expr = next->getInitial();
     839    }
     840    auto f = mMarkerMap.find(expr);
     841    if (f == mMarkerMap.end()) {
    831842        throw std::runtime_error("Unrecognized Pablo expression type; can't compile.");
    832843    }
    833 
     844    return f->second;
    834845}
    835846
  • icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.h

    r4401 r4410  
    5757    #endif
    5858
    59     typedef std::unordered_map<const pablo::String *, Value*>   StringToValueMap;
    60     typedef std::vector<Value*>                                 CarryQueueVector;
     59    typedef std::unordered_map<const pablo::PabloAST *, Value*>    ASTToValueMap;
     60    typedef std::unordered_map<const pablo::String *, Value*>      StringToValueMap;
     61    typedef std::vector<Value*>                                    CarryQueueVector;
    6162
    6263public:
     
    7475
    7576    void compileStatements(const StatementList & stmts);
    76     void compileStatement(const PabloAST * stmt);
     77    void compileStatement(const Statement * stmt);
    7778    Value* compileExpression(const PabloAST * expr);
    7879    Value* genCarryInLoad(const unsigned index);
     
    9899
    99100
    100     StringToValueMap                    mMarkerMap;
     101    ASTToValueMap                 mMarkerMap;
    101102    CarryQueueVector                    mCarryQueueVector;
    102103    std::vector<int>                    mCarryQueueSummaryIdx;
  • icGREP/icgrep-devel/icgrep/pablo/pe_advance.h

    r4404 r4410  
    99
    1010#include "pabloAST.h"
     11#include <pablo/symbol_generator.h>
    1112
    1213namespace pablo {
    1314
    14 class Advance : public PabloAST {
     15class Advance : public Statement {
    1516    friend class PabloBlock;
    1617public:
     
    4142    }
    4243protected:
    43     Advance(PabloAST * expr, int shiftAmount)
    44     : PabloAST(ClassTypeId::Advance)
     44    Advance(PabloAST * expr, int shiftAmount, SymbolGenerator * sg, PabloBlock * parent)
     45    : Statement(ClassTypeId::Advance, sg->make("advance"), parent)
    4546    , mExpr(expr)
    4647        , mShiftAmount(shiftAmount) {
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.cpp

    r4404 r4410  
    1010namespace pablo {
    1111
    12 PabloAST * OptimizeAnd::operator ()(PabloAST * expr1, PabloAST * expr2) {
     12And::And(PabloAST * expr1, PabloAST * expr2, PabloBlock * parent)
     13: Statement(ClassTypeId::And, parent->makeName("and"), parent)
     14, mExprs({{expr1, expr2}})
     15{
     16    expr1->addUser(this);
     17    expr2->addUser(this);
     18}
     19
     20PabloAST * OptimizeAnd::operator ()(PabloAST * expr1, PabloAST * expr2, PabloBlock * pb) {
    1321    if (isa<Ones>(expr1)) {
    1422        return expr2;
     
    2836    else if (Not * pe_not_e1 = dyn_cast<Not>(expr1)) {
    2937        if (Not * pe_not_e2 = dyn_cast<Not>(expr2)) {
    30             return cg.createNot(cg.createOr(pe_not_e1->getExpr(), pe_not_e2->getExpr()));
     38            return pb->createNot(pb->createOr(pe_not_e1->getExpr(), pe_not_e2->getExpr()));
    3139        }
    3240        else if (equals(pe_not_e1->getExpr(), expr2)) {
    33             return cg.createZeroes();
     41            return pb->createZeroes();
    3442        }
    3543    }
    3644    else if (Not * pe_not_e2 = dyn_cast<Not>(expr2)) {
    3745        if (equals(expr1, pe_not_e2->getExpr())) {
    38             return cg.createZeroes();
     46            return pb->createZeroes();
    3947        }
    4048    }
     
    4250        std::swap(expr1, expr2);
    4351    }
    44     return new And(expr1, expr2);
     52    return pb->createAndImm(expr1, expr2);
    4553}
    4654
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.h

    r4404 r4410  
    99
    1010#include <pablo/pabloAST.h>
    11 #include <pablo/pe_var.h>
    1211#include <array>
    1312
     
    1615class PabloBlock;
    1716
    18 class And : public PabloAST {
     17class And : public Statement {
    1918    friend struct OptimizeAnd;
    2019    friend class PabloBlock;
     
    4645    }
    4746protected:
    48     And(PabloAST * expr1, PabloAST * expr2)
    49     : PabloAST(ClassTypeId::And)
    50     , mExprs({{expr1, expr2}})
    51     {
    52         expr1->addUser(this);
    53         expr2->addUser(this);
    54     }
     47    And(PabloAST * expr1, PabloAST * expr2, PabloBlock * parent);
    5548private:
    5649    std::array<PabloAST*, 2> mExprs;
     
    5851
    5952struct OptimizeAnd {
    60     inline OptimizeAnd(PabloBlock & cg) : cg(cg) {}
    61     PabloAST * operator()(PabloAST * expr1, PabloAST * expr2);
    62 private:
    63     PabloBlock & cg;
     53    PabloAST * operator()(PabloAST * expr1, PabloAST * expr2, PabloBlock * pb);
    6454};
    6555
  • icGREP/icgrep-devel/icgrep/pablo/pe_call.h

    r4284 r4410  
    88namespace pablo {
    99
    10 class Call : public PabloAST {
     10class Call : public Statement {
    1111    friend class PabloBlock;
    1212public:
     
    3535    }
    3636protected:
    37     Call(PabloAST * callee)
    38     : PabloAST(ClassTypeId::Call)
     37    Call(PabloAST * callee, PabloBlock * parent)
     38    : Statement(ClassTypeId::Call, cast<String>(callee), parent)
    3939    , mCallee(cast<String>(callee)) {
    4040
  • icGREP/icgrep-devel/icgrep/pablo/pe_matchstar.h

    r4404 r4410  
    99
    1010#include "pabloAST.h"
     11#include <pablo/symbol_generator.h>
    1112#include <array>
    1213
    1314namespace pablo {
    1415
    15 class MatchStar : public PabloAST {
     16class MatchStar : public Statement {
    1617    friend class PabloBlock;
    1718public:
     
    4243    }
    4344protected:
    44     MatchStar(PabloAST * marker, PabloAST * cc)
    45     : PabloAST(ClassTypeId::MatchStar)
     45    MatchStar(PabloAST * marker, PabloAST * cc, SymbolGenerator * sg, PabloBlock * parent)
     46    : Statement(ClassTypeId::MatchStar, sg->make("matchstar"), parent)
    4647    , mExprs({{marker, cc}})
    4748    {
  • icGREP/icgrep-devel/icgrep/pablo/pe_next.h

    r4404 r4410  
    44#include <pablo/pabloAST.h>
    55#include <pablo/ps_assign.h>
     6#include <pablo/symbol_generator.h>
    67#include <array>
    78
     
    4243protected:
    4344    Next(PabloAST * initial, PabloAST * expr, PabloBlock * parent)
    44     : Statement(ClassTypeId::Next, parent)
     45    : Statement(ClassTypeId::Next, cast<Assign>(initial)->getName(), parent)
    4546    , mExprs({{cast<Assign>(initial), expr}}) {
    4647        initial->addUser(this);
  • icGREP/icgrep-devel/icgrep/pablo/pe_not.cpp

    r4247 r4410  
    1111namespace pablo {
    1212
    13 PabloAST * OptimizeNot::operator ()(PabloAST * expr) {
     13Not::Not(PabloAST * expr, PabloBlock * parent)
     14: Statement(ClassTypeId::Not, parent->makeName("not"), parent)
     15, mExpr(expr) {
     16    expr->addUser(this);
     17}
     18
     19PabloAST * OptimizeNot::operator ()(PabloAST * expr, PabloBlock * pb) {
    1420    if (isa<Ones>(expr)) {
    15         return cg.createZeroes();
     21    return pb->createZeroes();
    1622    }
    1723    else if (isa<Zeroes>(expr)){
    18         return cg.createOnes();       
     24        return pb->createOnes();
    1925    }
    2026    else if (Not * pe_not = dyn_cast<Not>(expr)) {
    2127        return pe_not->getExpr();
    2228    }
    23     return new Not(expr);
     29    return pb->createNotImm(expr);
    2430}
    2531
  • icGREP/icgrep-devel/icgrep/pablo/pe_not.h

    r4404 r4410  
    99
    1010#include <pablo/pabloAST.h>
    11 #include <pablo/pe_var.h>
    1211
    1312namespace pablo {
     
    1514class PabloBlock;
    1615
    17 class Not : public PabloAST {
     16class Not : public Statement {
    1817    friend struct OptimizeNot;
    1918    friend class PabloBlock;
     
    4241    }
    4342protected:
    44     Not(PabloAST * expr)
    45     : PabloAST(ClassTypeId::Not)
    46     , mExpr(expr) {
    47         expr->addUser(this);
    48     }
     43    Not(PabloAST * expr, PabloBlock * parent);
    4944private:
    5045    PabloAST * mExpr;
     
    5247
    5348struct OptimizeNot {
    54     inline OptimizeNot(PabloBlock & cg) : cg(cg) {}
    55     PabloAST * operator()(PabloAST * expr);
    56 private:
    57     PabloBlock & cg;
    58 
     49    PabloAST * operator()(PabloAST * expr, PabloBlock * pb);
    5950};
    6051
  • icGREP/icgrep-devel/icgrep/pablo/pe_ones.h

    r4404 r4410  
    2424    virtual ~Ones() {
    2525    }
    26     virtual PabloAST * getOperand(const unsigned) const {
    27         assert (false);
    28         return nullptr;
    29     }
    30     virtual unsigned getNumOperands() const {
    31         return 0;
    32     }
    33     virtual void setOperand(const unsigned, PabloAST *) {
    34         assert (false);
    35     }
     26//    virtual PabloAST * getOperand(const unsigned) const {
     27//        assert (false);
     28//        return nullptr;
     29//    }
     30//    virtual unsigned getNumOperands() const {
     31//        return 0;
     32//    }
     33//    virtual void setOperand(const unsigned, PabloAST *) {
     34//        assert (false);
     35//    }
    3636    inline bool operator==(const Ones & other) const {
    3737        return true;
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.cpp

    r4247 r4410  
    1010namespace pablo {
    1111
    12 PabloAST * OptimizeOr::operator ()(PabloAST * expr1, PabloAST * expr2) {
     12Or::Or(PabloAST * expr1, PabloAST * expr2, PabloBlock * parent)
     13: Statement(ClassTypeId::Or, parent->makeName("or"), parent)
     14, mExprs({{expr1, expr2}})
     15{
     16    expr1->addUser(this);
     17    expr2->addUser(this);
     18}
     19
     20PabloAST * OptimizeOr::operator ()(PabloAST * expr1, PabloAST * expr2, PabloBlock * pb) {
    1321    if (isa<Ones>(expr1)) {
    1422        return expr1;
     
    2836    else if (Not * not1 = dyn_cast<Not>(expr1)) {
    2937        // ¬a√b = ¬¬(¬a√b) = ¬(a ∧ ¬b)
    30         return cg.createNot(cg.createAnd(not1->getExpr(), cg.createNot(expr2)));
     38        return pb->createNot(pb->createAnd(not1->getExpr(), pb->createNot(expr2)));
    3139    }
    3240    else if (Not * not2 = dyn_cast<Not>(expr2)) {
    3341        // a√¬b = ¬¬(¬b√a) = ¬(b ∧ ¬a)
    34         return cg.createNot(cg.createAnd(not2->getExpr(), cg.createNot(expr1)));
     42        return pb->createNot(pb->createAnd(not2->getExpr(), pb->createNot(expr1)));
    3543    }
    3644    else if (equals(expr1, expr2)) {
     
    4654            //(e.g., union of [a-z] and [A-Z].
    4755            if (equals(expr1a, expr2a)) {
    48                 return cg.createAnd(expr1a, cg.createOr(expr1b, expr2b));
     56                return pb->createAnd(expr1a, pb->createOr(expr1b, expr2b));
    4957            }
    5058            else if (equals(expr1b, expr2b)) {
    51                 return cg.createAnd(expr1b, cg.createOr(expr1a, expr2a));
     59                return pb->createAnd(expr1b, pb->createOr(expr1a, expr2a));
    5260            }
    5361            else if (equals(expr1a, expr2b)) {
    54                 return cg.createAnd(expr1a, cg.createOr(expr1b, expr2a));
     62                return pb->createAnd(expr1a, pb->createOr(expr1b, expr2a));
    5563            }
    5664            else if (equals(expr1b, expr2a)) {
    57                 return cg.createAnd(expr1b, cg.createOr(expr1a, expr2b));
     65                return pb->createAnd(expr1b, pb->createOr(expr1a, expr2b));
    5866            }
    5967        }
    6068    }
    61     return new Or(expr1, expr2);
     69    return pb->createOrImm(expr1, expr2);
    6270}
    6371
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.h

    r4404 r4410  
    99
    1010#include <pablo/pabloAST.h>
    11 #include <pablo/pe_var.h>
    1211#include <array>
    1312
     
    1615class PabloBlock;
    1716
    18 class Or : public PabloAST {
     17class Or : public Statement {
    1918    friend struct OptimizeOr;
    2019    friend class PabloBlock;
     
    4645    }
    4746protected:
    48     Or(PabloAST * expr1, PabloAST * expr2)
    49     : PabloAST(ClassTypeId::Or)
    50     , mExprs({{expr1, expr2}})
    51     {
    52         expr1->addUser(this);
    53         expr2->addUser(this);
    54     }
     47    Or(PabloAST * expr1, PabloAST * expr2, PabloBlock * parent);
    5548private:
    5649    std::array<PabloAST*, 2> mExprs;
     
    5851
    5952struct OptimizeOr {
    60     inline OptimizeOr(PabloBlock & cg) : cg(cg) {}
    61     PabloAST * operator()(PabloAST * expr1, PabloAST * expr2);
    62 private:
    63     PabloBlock & cg;
     53    PabloAST * operator()(PabloAST * expr1, PabloAST * expr2, PabloBlock * pb);
    6454};
    6555
  • icGREP/icgrep-devel/icgrep/pablo/pe_scanthru.h

    r4404 r4410  
    99
    1010#include <pablo/pabloAST.h>
     11#include <pablo/symbol_generator.h>
    1112#include <array>
    1213
    1314namespace pablo {
    1415
    15 class ScanThru : public  PabloAST {
     16class ScanThru : public Statement {
    1617    friend class PabloBlock;
    1718public:
     
    4142        return mExprs[1];
    4243    }
    43     ScanThru(PabloAST * from, PabloAST * thru)
    44     : PabloAST(ClassTypeId::ScanThru)
     44    ScanThru(PabloAST * from, PabloAST * thru, SymbolGenerator * sg, PabloBlock * parent)
     45    : Statement(ClassTypeId::ScanThru, sg->make("scanthru"), parent)
    4546    , mExprs({{from, thru}})
    4647    {
  • icGREP/icgrep-devel/icgrep/pablo/pe_sel.cpp

    r4359 r4410  
    1010namespace pablo {
    1111
    12 PabloAST * OptimizeSel::operator()(PabloAST * if_expr, PabloAST * t_expr, PabloAST * f_expr) {
     12Sel::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}})
     15{
     16    if_expr->addUser(this);
     17    t_expr->addUser(this);
     18    f_expr->addUser(this);
     19}
     20
     21PabloAST * OptimizeSel::operator()(PabloAST * if_expr, PabloAST * t_expr, PabloAST * f_expr, PabloBlock * pb) {
    1322    if (isa<Ones>(if_expr)) {
    1423        return t_expr;
     
    1827    }
    1928    else if (isa<Ones>(t_expr)) {
    20         return cg.createOr(if_expr, f_expr);
     29    return pb->createOr(if_expr, f_expr);
    2130    }
    2231    else if (isa<Zeroes>(t_expr)){
    23         return cg.createAnd(cg.createNot(if_expr), f_expr);   
     32        return pb->createAnd(pb->createNot(if_expr), f_expr);
    2433    }
    2534    else if (isa<Ones>(f_expr)) {
    26         return cg.createOr(cg.createNot(if_expr), t_expr);
     35    return pb->createOr(pb->createNot(if_expr), t_expr);
    2736    }
    2837    else if (isa<Zeroes>(f_expr)){
    29         return cg.createAnd(if_expr, t_expr);       
     38        return pb->createAnd(if_expr, t_expr);
    3039    }
    3140    else if (equals(t_expr, f_expr)) {
     
    3342    }
    3443    else if (isa<Not>(t_expr) && equals(cast<Not>(t_expr)->getExpr(), f_expr)) {
    35         return cg.createXor(if_expr, f_expr);
     44        return pb->createXor(if_expr, f_expr);
    3645    }
    3746    else if (isa<Not>(f_expr) && equals(t_expr, cast<Not>(f_expr)->getExpr())){
    38         return cg.createXor(if_expr, f_expr);
     47        return pb->createXor(if_expr, f_expr);
    3948    }
    40     return new Sel(if_expr, t_expr, f_expr);
     49    return pb->createSelImm(if_expr, t_expr, f_expr);
    4150}
    4251
  • icGREP/icgrep-devel/icgrep/pablo/pe_sel.h

    r4404 r4410  
    99
    1010#include <pablo/pabloAST.h>
    11 #include <pablo/pe_var.h>
    1211#include <array>
    1312
     
    1615class PabloBlock;
    1716
    18 class Sel : public PabloAST {
     17class Sel : public Statement {
    1918    friend struct OptimizeSel;
    2019    friend class PabloBlock;
     
    4948    }
    5049protected:
    51     Sel(PabloAST* if_expr, PabloAST* t_expr, PabloAST* f_expr)
    52     : PabloAST(ClassTypeId::Sel)
    53     , mExprs({{if_expr, t_expr, f_expr}})
    54     {
    55         if_expr->addUser(this);
    56         t_expr->addUser(this);
    57         f_expr->addUser(this);
    58     }
     50    Sel(PabloAST* if_expr, PabloAST* t_expr, PabloAST* f_expr, PabloBlock * parent);
    5951private:
    6052    std::array<PabloAST*, 3> mExprs;
     
    6254
    6355struct OptimizeSel {
    64     inline OptimizeSel(PabloBlock & cg) : cg(cg) {}
    65     PabloAST * operator()(PabloAST * if_expr, PabloAST * t_expr, PabloAST * f_expr);
    66 private:
    67     PabloBlock & cg;
     56    PabloAST * operator()(PabloAST * if_expr, PabloAST * t_expr, PabloAST * f_expr, PabloBlock * pb);
    6857};
    6958
  • icGREP/icgrep-devel/icgrep/pablo/pe_string.h

    r4280 r4410  
    1818    virtual ~String(){
    1919
    20     }
    21     virtual PabloAST * getOperand(const unsigned) const {
    22         assert (false);
    23         return nullptr;
    24     }
    25     virtual unsigned getNumOperands() const {
    26         return 0;
    27     }
    28     virtual void setOperand(const unsigned, PabloAST *) {
    29         assert (false);
    3020    }
    3121    inline const std::string & str() const {
  • icGREP/icgrep-devel/icgrep/pablo/pe_var.h

    r4404 r4410  
    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     }
     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//    }
    5353    inline const String * getName() const {
    5454        return mName;
    5555    }
    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     }
     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//    }
    6868protected:
    69     Var(PabloAST * var)
     69    Var(PabloAST * var, PabloBlock *)
    7070    : PabloAST(ClassTypeId::Var)
    71     , mVar(var)
    72     , mName(getNameOf(var))
     71    //, mVar(var)
     72    , mName(cast<String>(var)) // getNameOf(var))
    7373    {
    7474        var->addUser(this);
    7575    }
    7676private:
    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     }
     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//    }
    8989private:
    90     PabloAST *         mVar;
     90    //PabloAST *         mVar;
    9191    const String *     mName;
    9292};
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.cpp

    r4247 r4410  
    1010namespace pablo {
    1111
    12 PabloAST * OptimizeXor::operator()(PabloAST * expr1, PabloAST * expr2) {
     12Xor::Xor(PabloAST * expr1, PabloAST * expr2, PabloBlock * parent)
     13: Statement(ClassTypeId::Xor, parent->makeName("xor"), parent)
     14, mExprs({{expr1, expr2}})
     15{
     16    expr1->addUser(this);
     17    expr2->addUser(this);
     18}
     19
     20PabloAST * OptimizeXor::operator()(PabloAST * expr1, PabloAST * expr2, PabloBlock * pb) {
    1321    if (isa<Ones>(expr1)) {
    14         return cg.createNot(expr2);
     22        return pb->createNot(expr2);
    1523    }
    1624    else if (isa<Zeroes>(expr1)){
     
    1826    }
    1927    else if (isa<Ones>(expr2)) {
    20         return cg.createNot(expr1);
     28        return pb->createNot(expr1);
    2129    }
    2230    else if (isa<Zeroes>(expr2)){
     
    2533    else if (Not * not1 = dyn_cast<Not>(expr1)) {
    2634        if (Not * not2 = dyn_cast<Not>(expr2)) {
    27             return cg.createXor(not1->getExpr(), not2->getExpr());
     35            return pb->createXor(not1->getExpr(), not2->getExpr());
    2836        }
    2937    }
    30     return new Xor(expr1, expr2);
     38    return pb->createXorImm(expr1, expr2);
    3139}
    3240
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.h

    r4404 r4410  
    99
    1010#include <pablo/pabloAST.h>
    11 #include <pablo/pe_var.h>
    1211#include <array>
    1312
     
    1615class PabloBlock;
    1716
    18 class Xor : public PabloAST {
     17class Xor : public Statement {
    1918    friend struct OptimizeXor;
    2019    friend class PabloBlock;
     
    4645    }
    4746protected:
    48     Xor(PabloAST * expr1, PabloAST * expr2)
    49     : PabloAST(ClassTypeId::Xor)
    50     , mExprs({{expr1, expr2}})
    51     {
    52         expr1->addUser(this);
    53         expr2->addUser(this);
    54     }
     47    Xor(PabloAST * expr1, PabloAST * expr2, PabloBlock * parent);
    5548private:
    5649    std::array<PabloAST*, 2> mExprs;
     
    5851
    5952struct OptimizeXor {
    60     inline OptimizeXor(PabloBlock & cg) : cg(cg) {}
    61     PabloAST * operator()(PabloAST * expr1, PabloAST * expr2);
    62 private:
    63     PabloBlock & cg;
     53    PabloAST * operator()(PabloAST * expr1, PabloAST * expr2, PabloBlock * pb);
    6454};
    6555
  • icGREP/icgrep-devel/icgrep/pablo/pe_zeroes.h

    r4404 r4410  
    2525
    2626    }
    27     virtual PabloAST * getOperand(const unsigned) const {
    28         assert (false);
    29         return nullptr;
    30     }
    31     virtual unsigned getNumOperands() const {
    32         return 0;
    33     }
    34     virtual void setOperand(const unsigned, PabloAST *) {
    35         assert (false);
    36     }
     27//    virtual PabloAST * getOperand(const unsigned) const {
     28//        assert (false);
     29//        return nullptr;
     30//    }
     31//    virtual unsigned getNumOperands() const {
     32//        return 0;
     33//    }
     34//    virtual void setOperand(const unsigned, PabloAST *) {
     35//        assert (false);
     36//    }
    3737    inline bool operator==(const Zeroes & other) const {
    3838        return true;
  • icGREP/icgrep-devel/icgrep/pablo/printer_pablos.cpp

    r4359 r4410  
    5555
    5656void PabloPrinter::print(const Statement * stmt, std::string indent, std::ostream & strm) {
     57    strm << indent;
    5758    if (stmt == nullptr) {
    5859        strm << "<null-stmt>" << std::endl;
    5960    }
    6061    else if (const Assign * an = dyn_cast<const Assign>(stmt)) {
    61         strm << indent;
    6262        if (an->isOutputAssignment()) {
    6363            strm << "Output[" << std::to_string(an->getOutputIndex()) << "].";
     
    6767        strm << std::endl;
    6868    }
    69     else if (const Next * next = dyn_cast<const Next>(stmt)) {
    70         strm << indent << "Next(" << next->getName()->str() << ") = ";
     69    else if (const Next * next = dyn_cast<const Next>(stmt)) {       
     70        strm << "Next(" << next->getName()->str() << ") = ";
    7171        print(next->getExpr(), strm);
    7272        strm << std::endl;
    7373    }
    7474    else if (const If * ifstmt = dyn_cast<const If>(stmt)) {
    75         strm << indent << "if ";
     75        strm << "if ";
    7676        print(ifstmt->getCondition(), strm);
    7777        strm << ":\n";
     
    7979    }
    8080    else if (const While * whl = dyn_cast<const While>(stmt)) {
    81         strm << indent << "while";
     81        strm << "while";
    8282        print(whl->getCondition(), strm);
    8383        strm << ":\n";
    8484        print(whl->getBody(), indent + "  ", strm);
     85    }
     86    else if (const Call * pablo_call = dyn_cast<const Call>(stmt)) {
     87        print(pablo_call, strm);
     88        strm << " = " << pablo_call->getCallee()->str() << "()" << std::endl;;
     89    }
     90    else if (const And * pablo_and = dyn_cast<const And>(stmt)) {
     91        print(pablo_and, strm);
     92        strm << " = (";
     93        print(pablo_and->getExpr1(), strm);
     94        strm << " & ";
     95        print(pablo_and->getExpr2(), strm);
     96        strm << ")" << std::endl;;
     97    }
     98    else if (const Or * pablo_or = dyn_cast<const Or>(stmt)) {
     99        print(pablo_or, strm);
     100        strm << " = (";
     101        print(pablo_or->getExpr1(), strm);
     102        strm << " | ";
     103        print(pablo_or->getExpr2(), strm);
     104        strm << ")" << std::endl;;
     105    }
     106    else if (const Xor * pablo_xor = dyn_cast<const Xor>(stmt)) {
     107        print(pablo_xor, strm);
     108        strm << " = (";
     109        print(pablo_xor->getExpr1(), strm);
     110        strm << " ^ ";
     111        print(pablo_xor->getExpr2(), strm);
     112        strm << ")" << std::endl;;
     113    }
     114    else if (const Sel * pablo_sel = dyn_cast<const Sel>(stmt)) {
     115        print(pablo_sel, strm);
     116        strm << " = (";
     117        print(pablo_sel->getCondition(), strm);
     118        strm << " ? ";
     119        print(pablo_sel->getTrueExpr(), strm);
     120        strm << " : ";
     121        print(pablo_sel->getFalseExpr(), strm);
     122        strm << ")" << std::endl;;
     123    }
     124    else if (const Not * pablo_not = dyn_cast<const Not>(stmt)) {
     125        print(pablo_not, strm);
     126        strm << " = (~";
     127        print(pablo_not->getExpr(), strm);
     128        strm << ")" << std::endl;;
     129    }
     130    else if (const Advance * adv = dyn_cast<const Advance>(stmt)) {
     131        print(adv, strm);
     132        strm << " = pablo.Advance(";
     133        print(adv->getExpr(), strm);
     134        strm << ", " << std::to_string(adv->getAdvanceAmount()) << ")" << std::endl;;
     135    }
     136    else if (const MatchStar * mstar = dyn_cast<const MatchStar>(stmt)) {
     137        print(mstar, strm);
     138        strm << " = pablo.MatchStar(";
     139        print(mstar->getMarker(), strm);
     140        strm << ", ";
     141        print(mstar->getCharClass(), strm);
     142        strm << ")" << std::endl;;
     143    }
     144    else if (const ScanThru * sthru = dyn_cast<const ScanThru>(stmt)) {
     145        print(sthru, strm);
     146        strm << " = pablo.ScanThru(";
     147        print(sthru->getScanFrom(), strm);
     148        strm << ", ";
     149        print(sthru->getScanThru(), strm);
     150        strm << ")" << std::endl;;
    85151    }
    86152    else {
     
    99165        strm << "1";
    100166    }
    101     else if (const Call * pablo_call = dyn_cast<const Call>(expr)) {
    102         strm << pablo_call->getCallee()->str() << "()";
    103     }
    104167    else if (const Var * pablo_var = dyn_cast<const Var>(expr)) {
    105168        strm << pablo_var->getName()->str();
    106169    }
    107     else if (const And * pablo_and = dyn_cast<const And>(expr)) {
    108         strm << "(";
    109         print(pablo_and->getExpr1(), strm);
    110         strm << " & ";
    111         print(pablo_and->getExpr2(), strm);
    112         strm << ")";
    113     }
    114     else if (const Or * pablo_or = dyn_cast<const Or>(expr)) {
    115         strm << "(";
    116         print(pablo_or->getExpr1(), strm);
    117         strm << " | ";
    118         print(pablo_or->getExpr2(), strm);
    119         strm << ")";
    120     }
    121     else if (const Xor * pablo_xor = dyn_cast<const Xor>(expr)) {
    122         strm << "(";
    123         print(pablo_xor->getExpr1(), strm);
    124         strm << " ^ ";
    125         print(pablo_xor->getExpr2(), strm);
    126         strm << ")";
    127     }
    128     else if (const Sel * pablo_sel = dyn_cast<const Sel>(expr)) {
    129         strm << "(";
    130         print(pablo_sel->getCondition(), strm);
    131         strm << " ? ";
    132         print(pablo_sel->getTrueExpr(), strm);
    133         strm << " : ";
    134         print(pablo_sel->getFalseExpr(), strm);
    135         strm << ")";
    136     }
    137     else if (const Not * pablo_not = dyn_cast<const Not>(expr)) {
    138         strm << "(~";
    139         print(pablo_not->getExpr(), strm);
    140         strm << ")";
    141     }
    142     else if (const Advance * adv = dyn_cast<const Advance>(expr)) {
    143         strm << "pablo.Advance(";
    144         print(adv->getExpr(), strm);
    145         strm << ", " << std::to_string(adv->getAdvanceAmount()) << ")";
    146     }
    147     else if (const MatchStar * mstar = dyn_cast<const MatchStar>(expr)) {
    148         strm << "pablo.MatchStar(";
    149         print(mstar->getMarker(), strm);
    150         strm << ", ";
    151         print(mstar->getCharClass(), strm);
    152         strm << ")";
    153     }
    154     else if (const ScanThru * sthru = dyn_cast<const ScanThru>(expr)) {
    155         strm << "pablo.ScanThru(";
    156         print(sthru->getScanFrom(), strm);
    157         strm << ", ";
    158         print(sthru->getScanThru(), strm);
    159         strm << ")";
    160     }
    161170    else if (isa<Statement>(expr)) {
    162         print(cast<Statement>(expr), strm);
     171        strm << cast<Statement>(expr)->getName()->str();
    163172    }
    164173    else {
  • icGREP/icgrep-devel/icgrep/pablo/ps_assign.h

    r4404 r4410  
    2828    }
    2929    virtual PabloAST * getOperand(const unsigned index) const {
    30         assert (index < 2);
    31         return mExprs[index];
     30        assert (index == 0);
     31        return mExpr;
    3232    }
    3333    virtual unsigned getNumOperands() const {
    34         return 2;
     34        return 1;
    3535    }
    3636    virtual void setOperand(const unsigned index, PabloAST * value) {
    37         assert (index < 2);
    38         mExprs[index] = value;
    39     }
    40     inline const String * getName() const {
    41         return cast<String>(mExprs[0]);
     37        assert (index == 0);
     38        mExpr = value;
    4239    }
    4340    inline PabloAST * getExpr() const {
    44         return mExprs[1];
     41        return mExpr;
    4542    }
    4643    inline bool isOutputAssignment() const {
     
    5148    }
    5249protected:
    53     explicit Assign(PabloAST * name, PabloAST * expr, int outputIndex, PabloBlock * parent)
    54     : Statement(ClassTypeId::Assign, parent)
    55     , mExprs({{name, expr}})
     50    explicit Assign(PabloAST * expr, int outputIndex, String * name, PabloBlock * parent)
     51    : Statement(ClassTypeId::Assign, name, parent)
     52    , mExpr(expr)
    5653    , mOutputIndex(outputIndex)
    5754    {
     
    5956    }
    6057private:
    61     std::array<PabloAST *,2>    mExprs;
    62     const int                   mOutputIndex;
     58    PabloAST *          mExpr;
     59    const int           mOutputIndex;
    6360};
    6461
  • icGREP/icgrep-devel/icgrep/pablo/ps_if.cpp

    r4404 r4410  
    55
    66If::If(PabloAST * expr, DefinedVars && definedVars, PabloBlock & body, PabloBlock * parent)
    7 : Statement(ClassTypeId::If, parent)
     7: Statement(ClassTypeId::If, nullptr, parent)
    88, mExpr(expr)
    99, mBody(body)
  • icGREP/icgrep-devel/icgrep/pablo/ps_while.cpp

    r4404 r4410  
    55
    66While::While(PabloAST * expr, PabloBlock & body, PabloBlock * parent)
    7 : Statement(ClassTypeId::While, parent)
     7: Statement(ClassTypeId::While, nullptr, parent)
    88, mExpr(expr)
    99, mBody(body)
  • icGREP/icgrep-devel/icgrep/pablo/symbol_generator.cpp

    r4257 r4410  
    2929}
    3030
    31 String * SymbolGenerator::get_ssa(const std::string prefix) {
     31String * SymbolGenerator::make(const std::string prefix) {
    3232    auto f = mPrefixMap.find(prefix);
    3333    unsigned count = 0;
  • icGREP/icgrep-devel/icgrep/pablo/symbol_generator.h

    r4404 r4410  
    2020public:
    2121    String * get(const std::string name);
    22     String * get_ssa(const std::string prefix);
     22    String * make(const std::string prefix);
    2323protected:
    2424    SymbolGenerator();
Note: See TracChangeset for help on using the changeset viewer.