Changeset 4404


Ignore:
Timestamp:
Jan 6, 2015, 3:29:34 PM (4 years ago)
Author:
nmedfort
Message:

Some work towards maintaining UseDef? information. Use PabloBlock::Create() instead of the PabloBlock? constructors.

Location:
icGREP/icgrep-devel/icgrep
Files:
2 added
25 edited

Legend:

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

    r4393 r4404  
    5353find_package(Boost COMPONENTS system REQUIRED)
    5454
    55 add_library(PabloADT pablo/pe_and.cpp pablo/pe_not.cpp pablo/pe_or.cpp  pablo/pabloAST.cpp  pablo/pe_sel.cpp  pablo/pe_xor.cpp pablo/codegenstate.cpp pablo/symbol_generator.cpp pablo/analysis/useanalysis.cpp pablo/printer_pablos.cpp pablo/pablo_compiler.cpp)
     55add_library(PabloADT pablo/pe_and.cpp pablo/pe_not.cpp pablo/pe_or.cpp pablo/pabloAST.cpp pablo/pe_sel.cpp pablo/pe_xor.cpp pablo/ps_if.cpp pablo/ps_while.cpp pablo/codegenstate.cpp pablo/symbol_generator.cpp pablo/analysis/useanalysis.cpp pablo/printer_pablos.cpp pablo/pablo_compiler.cpp)
    5656add_library(RegExpADT re/re_re.cpp re/re_cc.cpp re/re_parser.cpp re/re_rep.cpp re/parsefailure.cpp re/re_nullable.cpp re/re_simplifier.cpp re/re_compiler.cpp re/printer_re.cpp re/re_diff.cpp re/re_intersect.cpp re/re_analysis.cpp)
    5757add_library(CCADT cc/cc_namemap.cpp cc/cc_compiler.cpp utf_encoding.cpp utf8_encoder.cpp UCD/CaseFolding_txt.cpp)
  • icGREP/icgrep-devel/icgrep/compiler.cpp

    r4392 r4404  
    118118    }
    119119
    120     SymbolGenerator symgen;
    121     PabloBlock main(symgen);
     120    PabloBlock & main = PabloBlock::Create();
    122121
    123122    CC_Compiler cc_compiler(main, encoding, enable_multiplexing);
  • icGREP/icgrep-devel/icgrep/pablo/analysis/useanalysis.cpp

    r4351 r4404  
    2929            Assign * assign = block.createAssign("cse", expr);
    3030            Var * var = block.createVar(assign);
     31            if (expr == var) {
     32                continue;
     33            }
    3134            const Vertex s = find(assign);
    3235            const Vertex v = find(var);
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.cpp

    r4280 r4404  
    1313
    1414PabloAST * PabloBlock::createAdvance(PabloAST * expr, const int shiftAmount) {
    15     if (isa<Zeroes>(expr)) {
     15    if (isa<Zeroes>(expr) || shiftAmount == 0) {
    1616        return expr;
    1717    }
    18     return mUnaryWithInt.findOrMake<Advance>(PabloAST::ClassTypeId::Advance, expr, shiftAmount);
    19 }
    20 
    21 Call * PabloBlock::createCall(const std::string name) {
    22     return mUnary.findOrMake<Call>(PabloAST::ClassTypeId::Call, mSymbolGenerator.get(name));
     18    return mUnaryWithInt.findOrMake<Advance>(PabloAST::ClassTypeId::Advance, expr, shiftAmount).first;
     19}
     20
     21PabloAST * PabloBlock::createCall(const std::string name) {
     22    return mUnary.findOrMake<Call>(PabloAST::ClassTypeId::Call, mSymbolGenerator->get(name)).first;
    2323}
    2424
    2525PabloAST * PabloBlock::createNot(PabloAST * expr) {
    26     return mUnary.findOrCall<OptimizeNot>(PabloAST::ClassTypeId::Not, expr);
     26    return mUnary.findOrCall<OptimizeNot>(PabloAST::ClassTypeId::Not, expr).first;
    2727}
    2828
    2929Var * PabloBlock::createVar(const std::string name) {
    30     return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, mSymbolGenerator.get(name));
     30    return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, mSymbolGenerator->get(name)).first;
    3131}
    3232
    3333Var * PabloBlock::createVar(Assign * assign) {
    34     return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, assign);
     34    return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, assign).first;
    3535}
    3636
    3737Var * PabloBlock::createVar(Next * next) {
    38     return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, next);
     38    return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, next).first;
    3939}
    4040
     
    4242
    4343Next * PabloBlock::createNext(Assign * assign, PabloAST * expr) {
    44     Next * next = mBinary.findOrMake<Next>(PabloAST::ClassTypeId::Next, assign, expr, &mStatements);
    45     mStatements.push_back(next);
     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    }
    4650    return next;
    4751}
     
    5155        return marker;
    5256    }
    53     return mBinary.findOrMake<MatchStar>(PabloAST::ClassTypeId::MatchStar, marker, charclass);
     57    return mBinary.findOrMake<MatchStar>(PabloAST::ClassTypeId::MatchStar, marker, charclass).first;
    5458}
    5559
     
    5862        return from;
    5963    }
    60     return mBinary.findOrMake<ScanThru>(PabloAST::ClassTypeId::ScanThru, from, thru);
     64    return mBinary.findOrMake<ScanThru>(PabloAST::ClassTypeId::ScanThru, from, thru).first;
    6165}
    6266
     
    6569        std::swap(expr1, expr2);
    6670    }
    67     return mBinary.findOrCall<OptimizeAnd>(PabloAST::ClassTypeId::And, expr1, expr2);
     71    return mBinary.findOrCall<OptimizeAnd>(PabloAST::ClassTypeId::And, expr1, expr2).first;
    6872}
    6973
     
    7276        std::swap(expr1, expr2);
    7377    }
    74     return mBinary.findOrCall<OptimizeOr>(PabloAST::ClassTypeId::Or, expr1, expr2);
     78    return mBinary.findOrCall<OptimizeOr>(PabloAST::ClassTypeId::Or, expr1, expr2).first;
    7579}
    7680
     
    7983        std::swap(expr1, expr2);
    8084    }
    81     return mBinary.findOrCall<OptimizeXor>(PabloAST::ClassTypeId::Xor, expr1, expr2);
     85    return mBinary.findOrCall<OptimizeXor>(PabloAST::ClassTypeId::Xor, expr1, expr2).first;
    8286}
    8387
    8488/// TERNARY CREATE FUNCTION
    8589
    86 PabloAST *PabloBlock::createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
    87     return mTernary.findOrCall<OptimizeSel>(PabloAST::ClassTypeId::Sel, condition, trueExpr, falseExpr);
    88 }
    89 
    90 }
     90PabloAST * PabloBlock::createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
     91    return mTernary.findOrCall<OptimizeSel>(PabloAST::ClassTypeId::Sel, condition, trueExpr, falseExpr).first;
     92}
     93
     94//PabloAST * PabloBlock::replaceUsesOfWith(PabloAST * inst, PabloAST * from, PabloAST * to) {
     95//    if (from == to) {
     96//        return inst;
     97//    }
     98//    switch (inst->getClassTypeId()) {
     99//        case PabloAST::ClassTypeId::Advance:
     100//            {
     101//                Advance * n = cast<Advance>(inst);
     102//                if (n->getExpr() == from) {
     103//                    return createAdvance(to, n->getAdvanceAmount());
     104//                }
     105//                return inst;
     106//            }
     107//        case PabloAST::ClassTypeId::Assign:
     108//            {
     109//                Assign * n = cast<Assign>(inst);
     110//                if (n->getExpr() == from) {
     111//                    Assign * assign = createAssign(to);
     112//                    n->replaceWith(assign);
     113//                    return assign;
     114//                }
     115//                return inst;
     116//            }
     117//        case PabloAST::ClassTypeId::Var:
     118//            {
     119//                Var * n = cast<Var>(inst);
     120//                if (n->getVar() == from) {
     121//                    return createVar(to);
     122//                }
     123//                return inst;
     124//            }
     125//        case PabloAST::ClassTypeId::Next:
     126//            {
     127//                Next * n = cast<Next>(inst);
     128//                if (n->getInitial() == from || n->getExpr() == from) {
     129//                    return createNext(n->getInitial() == from ? to : n->getInitial(),
     130//                                      n->getExpr() == from ? to : n->getExpr());
     131//                }
     132//                return inst;
     133//            }
     134////        case PabloAST::ClassTypeId::Call:
     135////            {
     136////                Call * n = cast<Call>(node);
     137////                if (n->getCallee() == from) {
     138////                    return createCall(to, n->getExpr());
     139////                }
     140////                return node;
     141////            }
     142//        case PabloAST::ClassTypeId::Not:
     143//            {
     144//                Not * n = cast<Not>(inst);
     145//                if (n->getExpr() == from) {
     146//                    return createNot(to);
     147//                }
     148//                return inst;
     149//            }
     150//        case PabloAST::ClassTypeId::And:
     151//            {
     152//                And * n = cast<And>(inst);
     153//                if (n->getExpr1() == from || n->getExpr2() == from) {
     154//                    return createAnd(n->getExpr1() == from ? to : n->getExpr1(),
     155//                                     n->getExpr2() == from ? to : n->getExpr2());
     156//                }
     157//                return inst;
     158//            }
     159//        case PabloAST::ClassTypeId::Or:
     160//            {
     161//                Or * n = cast<Or>(inst);
     162//                if (n->getExpr1() == from || n->getExpr2() == from) {
     163//                    return createOr(n->getExpr1() == from ? to : n->getExpr1(),
     164//                                    n->getExpr2() == from ? to : n->getExpr2());
     165//                }
     166//                return inst;
     167//            }
     168//        case PabloAST::ClassTypeId::Xor:
     169//            {
     170//                Xor * n = cast<Xor>(inst);
     171//                if (n->getExpr1() == from || n->getExpr2() == from) {
     172//                    return createXor(n->getExpr1() == from ? to : n->getExpr1(),
     173//                                     n->getExpr2() == from ? to : n->getExpr2());
     174//                }
     175//                return inst;
     176//            }
     177//        case PabloAST::ClassTypeId::ScanThru:
     178//            {
     179//                ScanThru * n = cast<ScanThru>(inst);
     180//                if (n->getScanFrom() == from || n->getScanThru() == from) {
     181//                    return createScanThru(n->getScanFrom() == from ? to : n->getScanFrom(),
     182//                                          n->getScanThru() == from ? to : n->getScanThru());
     183//                }
     184//                return inst;
     185//            }
     186//        case PabloAST::ClassTypeId::MatchStar:
     187//            {
     188//                MatchStar * n = cast<MatchStar>(inst);
     189//                if (n->getMarker() == from || n->getScanThru() == from) {
     190//                    return createMatchStar(n->getMarker() == from ? to : n->getMarker(),
     191//                                           n->getScanThru() == from ? to : n->getScanThru());
     192//                }
     193//                return inst;
     194//            }
     195//        case PabloAST::ClassTypeId::Ones:
     196//        case PabloAST::ClassTypeId::Zeroes:
     197//        case PabloAST::ClassTypeId::If:
     198//        case PabloAST::ClassTypeId::While:
     199//            return inst;
     200//        default:
     201//            throw std::runtime_error("Unhandled node type (" + std::to_string(inst->getClassTypeId()) +
     202//                                     ") given to PabloBlock::replaceUsesOfWith(...)")
     203//    }
     204
     205//}
     206
     207
     208}
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.h

    r4344 r4404  
    3636namespace pablo {
    3737
    38 class PabloBlock {
     38class PabloBlock : public StatementList {
     39    friend class pablo::PabloAST;
    3940public:
    4041
    41     PabloBlock(SymbolGenerator & symgen)
    42     : mZeroes(new Zeroes())
    43     , mOnes(new Ones())
    44     , mSymbolGenerator(symgen)
    45     , mUnary(nullptr, this)
    46     , mUnaryWithInt(nullptr, this)
    47     , mBinary(nullptr, this)
    48     , mTernary(nullptr, this)
    49     {
    50 
    51     }
    52 
    53     PabloBlock(PabloBlock & cg)
    54     : mZeroes(cg.mZeroes) // inherit the original "Zeroes" variable for simplicity
    55     , mOnes(cg.mOnes) // inherit the original "Ones" variable for simplicity
    56     , mSymbolGenerator(cg.mSymbolGenerator)
    57     , mUnary(&(cg.mUnary), this)
    58     , mUnaryWithInt(&(cg.mUnaryWithInt), this)
    59     , mBinary(&(cg.mBinary), this)
    60     , mTernary(&(cg.mTernary), this)
    61     {
    62 
     42    inline static PabloBlock & Create() {
     43        return *(new PabloBlock());
     44    }
     45
     46    inline static PabloBlock & Create(PabloBlock & predecessor) {
     47        return *(new PabloBlock(&predecessor));
    6348    }
    6449
     
    7358    }
    7459
    75     Call * createCall(const std::string name);
    76 
    77     inline Assign * createAssign(const std::string prefix, PabloAST * expr, const int outputIndex = -1) {
    78         // TODO: should this test whether we've somehow created a var for this prior to
    79         // making the assignment?
    80         Assign * assign = new Assign(mSymbolGenerator.get_ssa(prefix), expr, outputIndex, &mStatements);
    81         mStatements.push_back(assign);
     60    PabloAST * createCall(const std::string name);
     61
     62    Assign * createAssign(const std::string prefix, PabloAST * expr, const int outputIndex = -1)  {
     63        // Note: we cannot just use the findOrMake method to obtain this; an Assign node cannot be considered
     64        // unique until we prove it has no Next node associated with it. But the Assign node must be created
     65        // 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        push_back(assign);
    8268        return assign;
    8369    }
     
    116102    PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr);
    117103
    118     inline If * createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBlock && body) {
    119         If * statement = new If(condition, std::move(definedVars), std::move(body.statements()), &mStatements);
    120         mStatements.push_back(statement);
     104    inline If * createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBlock & body) {
     105        If * statement = new If(condition, std::move(definedVars), body, this);
     106        push_back(statement);
    121107        return statement;
    122108    }
    123109
    124     inline While * createWhile(PabloAST * cond, PabloBlock && body) {
    125         While * statement = new While(cond, std::move(body.statements()), &mStatements);
    126         mStatements.push_back(statement);
     110    inline While * createWhile(PabloAST * cond, PabloBlock & body) {
     111        While * statement = new While(cond, body, this);
     112        push_back(statement);
    127113        return statement;
    128114    }
     
    142128
    143129        template <class Type, typename... Params>
    144         inline Type * findOrMake(const PabloAST::ClassTypeId type, Args... args, Params... params) {
     130        inline std::pair<Type *, bool> findOrMake(const PabloAST::ClassTypeId type, Args... args, Params... params) {
    145131            Key key = std::make_tuple(type, args...);
    146132            PabloAST * const f = find(key);
    147133            if (f) {
    148                 return cast<Type>(f);
     134                return std::make_pair(cast<Type>(f), false);
    149135            }
    150136            Type * const expr = new Type(std::forward<Args>(args)..., std::forward<Params>(params)...);
    151137            insert(std::move(key), expr);
    152             return expr;
     138            return std::make_pair(expr, true);
    153139        }
    154140
    155141
    156142        template <class Functor, typename... Params>
    157         inline PabloAST * findOrCall(const PabloAST::ClassTypeId type, Args... args, Params... params) {
     143        inline std::pair<PabloAST *, bool> findOrCall(const PabloAST::ClassTypeId type, Args... args, Params... params) {
    158144            Key key = std::make_tuple(type, args...);
    159145            PabloAST * const f = find(key);
    160146            if (f) {
    161                 return f;
     147                return std::make_pair(f, false);
    162148            }
    163149            Functor mf(mCurrentBlock);
    164150            PabloAST * const expr = mf(std::forward<Args>(args)..., std::forward<Params>(params)...);
    165151            insert(std::move(key), expr);
    166             return expr;
     152            return std::make_pair(expr, true);
    167153        }
    168154
     
    196182    };
    197183
    198 
    199184    inline StatementList & statements() {
    200         return mStatements;
     185        return *this;
    201186    }
    202187
    203188    inline const StatementList & statements() const {
    204         return mStatements;
    205     }
    206 
     189        return *this;
     190    }
     191protected:
     192    PabloBlock()
     193    : mZeroes(new Zeroes())
     194    , mOnes(new Ones())
     195    , mSymbolGenerator(new SymbolGenerator())
     196    , mUnary(nullptr, this)
     197    , mUnaryWithInt(nullptr, this)
     198    , mBinary(nullptr, this)
     199    , mTernary(nullptr, this)
     200    {
     201
     202    }
     203
     204    PabloBlock(PabloBlock * predecessor)
     205    : mZeroes(predecessor->mZeroes) // inherit the original "Zeroes" variable for simplicity
     206    , mOnes(predecessor->mOnes) // inherit the original "Ones" variable for simplicity
     207    , mSymbolGenerator(predecessor->mSymbolGenerator)
     208    , mUnary(&(predecessor->mUnary), this)
     209    , mUnaryWithInt(&(predecessor->mUnaryWithInt), this)
     210    , mBinary(&(predecessor->mBinary), this)
     211    , mTernary(&(predecessor->mTernary), this)
     212    {
     213
     214    }
     215
     216    void* operator new (std::size_t size) noexcept {
     217        return PabloAST::mAllocator.allocate(size);
     218    }
    207219private:       
    208220    Zeroes * const                                      mZeroes;
    209221    Ones * const                                        mOnes;
    210     SymbolGenerator &                                   mSymbolGenerator;
     222    SymbolGenerator * const                             mSymbolGenerator;
    211223    ExpressionMap<PabloAST *>                           mUnary;
    212224    ExpressionMap<PabloAST *, int>                      mUnaryWithInt;
    213225    ExpressionMap<PabloAST *, PabloAST *>               mBinary;
    214226    ExpressionMap<PabloAST *, PabloAST *, PabloAST *>   mTernary;
    215     StatementList                                       mStatements;
    216227};
    217228
  • icGREP/icgrep-devel/icgrep/pablo/pabloAST.cpp

    r4284 r4404  
    1919#include "pe_zeroes.h"
    2020#include "pe_ones.h"
     21#include <pablo/codegenstate.h>
    2122#include <llvm/Support/Compiler.h>
    2223
     
    9293}
    9394
    94 
    9595void PabloAST::setMetadata(const std::string & name, PMDNode * node) {
    9696    if (LLVM_UNLIKELY(mMetadataMap == nullptr)) {
     
    111111}
    112112
     113
     114void Statement::insertBefore(Statement * const statement) {
     115    assert (statement);
     116    assert (statement != this);
     117    assert (statement->mParent);
     118    removeFromParent();
     119    mParent = statement->mParent;
     120    if (LLVM_UNLIKELY(mParent->mFirst == statement)) {
     121        mParent->mFirst = this;
     122    }
     123    mNext = statement;
     124    mPrev = statement->mPrev;
     125    statement->mPrev = this;
     126    if (LLVM_LIKELY(mPrev != nullptr)) {
     127        mPrev->mNext = this;
     128    }
     129}
     130
     131void Statement::insertAfter(Statement * const statement) {
     132    assert (statement);
     133    assert (statement != this);
     134    assert (statement->mParent);
     135    removeFromParent();
     136    mParent = statement->mParent;
     137    if (LLVM_UNLIKELY(mParent->mLast == statement)) {
     138        mParent->mLast = this;
     139    }
     140    mPrev = statement;
     141    mNext = statement->mNext;
     142    statement->mNext = this;
     143    if (LLVM_LIKELY(mNext != nullptr)) {
     144        mNext->mPrev = this;
     145    }
     146}
     147
     148void Statement::removeFromParent() {
     149    if (LLVM_LIKELY(mParent != nullptr)) {
     150        if (LLVM_UNLIKELY(mParent->mFirst == this)) {
     151            mParent->mFirst = mNext;
     152        }
     153        if (LLVM_UNLIKELY(mParent->mLast == this)) {
     154            mParent->mLast = mPrev;
     155        }
     156        if (LLVM_LIKELY(mPrev != nullptr)) {
     157            mPrev->mNext = mNext;
     158        }
     159        if (LLVM_LIKELY(mNext != nullptr)) {
     160            mNext->mPrev = mPrev;
     161        }
     162    }
     163    mPrev = nullptr;
     164    mNext = nullptr;
     165    mParent = nullptr;
     166}
     167
     168void Statement::replaceWith(Statement * const statement) {
     169    if (LLVM_UNLIKELY(mParent != nullptr)) {
     170        statement->removeFromParent();
     171    }
     172    statement->mParent = mParent;
     173    statement->mNext = mNext;
     174    statement->mPrev = mPrev;
     175    if (LLVM_LIKELY(mPrev != nullptr)) {
     176        mPrev->mNext = statement;
     177    }
     178    if (LLVM_LIKELY(mNext != nullptr)) {
     179        mNext->mPrev = statement;
     180    }
     181    mParent=nullptr;
     182    mNext=nullptr;
     183    mPrev=nullptr;
     184}
     185
    113186Statement::~Statement() {
    114187
  • icGREP/icgrep-devel/icgrep/pablo/pabloAST.h

    r4358 r4404  
    1010#include <llvm/Support/Casting.h>
    1111#include <llvm/Support/Compiler.h>
     12#include <llvm/ADT/SetVector.h>
    1213#include <slab_allocator.h>
    1314#include <iterator>
     
    2425class PabloAST {
    2526    friend class PMDNode;
     27    friend class Advance;
     28    friend class And;
     29    friend class Assign;
     30    friend class Call;
     31    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;
     41    friend class While;
     42    friend class Xor;
     43    friend class Zeroes;
     44    friend class PabloBlock;
     45    friend class SymbolGenerator;
    2646    typedef std::unordered_map<std::string, PMDNode *> PMDNodeMap;
    2747public:
    28     typedef SlabAllocator<1024> Allocator;
     48    typedef SlabAllocator<4096> Allocator;
    2949    enum class ClassTypeId : unsigned {
    3050        Advance
     
    85105
    86106    }
    87     static Allocator    mAllocator;
     107    inline void addUser(PabloAST * user) {
     108        mUsers.insert(user);
     109    }
     110    inline void removeUser(PabloAST * user) {
     111        mUsers.remove(user);
     112    }
     113    // virtual void removeUsageFromDefs() = 0;
     114    static Allocator        mAllocator;
    88115private:
    89     const ClassTypeId   mClassTypeId;
    90     PMDNodeMap *        mMetadataMap;
     116    const ClassTypeId       mClassTypeId;
     117    SetVector<PabloAST *>   mUsers;
     118    PMDNodeMap *            mMetadataMap;
    91119};
    92120
     
    99127    friend class If;
    100128    friend class While;
     129    friend class PabloBlock;
    101130public:
    102131    static inline bool classof(const PabloAST * e) {
     
    118147    }
    119148
    120     inline void insertBefore(Statement * const statement);
    121     inline void insertAfter(Statement * const statement);
    122     inline void removeFromParent();
     149    void insertBefore(Statement * const statement);
     150    void insertAfter(Statement * const statement);
     151    void removeFromParent();
     152    void replaceWith(Statement * const statement);
     153
    123154    inline Statement * getNextNode() const {
    124155        return mNext;
     
    127158        return mPrev;
    128159    }
    129     inline StatementList * getParent() const {
     160    inline PabloBlock * getParent() const {
    130161        return mParent;
    131162    }
    132163protected:
    133     Statement(const ClassTypeId id, StatementList * parent)
     164    Statement(const ClassTypeId id, PabloBlock * parent)
    134165    : PabloAST(id)
    135166    , mNext(nullptr)
     
    143174    Statement * mNext;
    144175    Statement * mPrev;
    145     StatementList * mParent;
     176    PabloBlock * mParent;
    146177};
    147178
     
    373404
    374405private:
    375     Statement * mFirst;
    376     Statement * mLast;
     406    Statement   * mFirst;
     407    Statement   * mLast;
    377408};
    378409
    379 inline void Statement::insertBefore(Statement * const statement) {
    380     assert (statement);
    381     assert (statement != this);
    382     assert (statement->mParent);
    383     removeFromParent();
    384     mParent = statement->mParent;
    385     if (LLVM_UNLIKELY(mParent->mFirst == statement)) {
    386         mParent->mFirst = this;
    387     }
    388     mNext = statement;
    389     mPrev = statement->mPrev;
    390     statement->mPrev = this;
    391     if (LLVM_LIKELY(mPrev != nullptr)) {
    392         mPrev->mNext = this;
    393     }
    394410}
    395 inline void Statement::insertAfter(Statement * const statement) {
    396     assert (statement);
    397     assert (statement != this);
    398     assert (statement->mParent);
    399     removeFromParent();
    400     mParent = statement->mParent;
    401     if (LLVM_UNLIKELY(mParent->mLast == statement)) {
    402         mParent->mLast = this;
    403     }
    404     mPrev = statement;
    405     mNext = statement->mNext;
    406     statement->mNext = this;
    407     if (LLVM_LIKELY(mNext != nullptr)) {
    408         mNext->mPrev = this;
    409     }
    410 }
    411 inline void Statement::removeFromParent() {
    412     if (LLVM_LIKELY(mParent != nullptr)) {
    413         if (LLVM_UNLIKELY(mParent->mFirst == this)) {
    414             mParent->mFirst = mNext;
    415         }
    416         if (LLVM_UNLIKELY(mParent->mLast == this)) {
    417             mParent->mLast = mPrev;
    418         }
    419         if (LLVM_LIKELY(mPrev != nullptr)) {
    420             mPrev->mNext = mNext;
    421         }
    422         if (LLVM_LIKELY(mNext != nullptr)) {
    423             mNext->mPrev = mPrev;
    424         }
    425     }
    426     mPrev = nullptr;
    427     mNext = nullptr;
    428     mParent = nullptr;
    429 }
    430 
    431 }
    432411
    433412#endif // PE_PabloAST_H
  • icGREP/icgrep-devel/icgrep/pablo/pe_advance.h

    r4284 r4404  
    4545    , mExpr(expr)
    4646        , mShiftAmount(shiftAmount) {
    47 
     47        expr->addUser(this);
    4848    }
    4949private:
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.cpp

    r4247 r4404  
    1212PabloAST * OptimizeAnd::operator ()(PabloAST * expr1, PabloAST * expr2) {
    1313    if (isa<Ones>(expr1)) {
    14         return expr2;
     14        return expr2;
    1515    }
    1616    else if (isa<Zeroes>(expr1)){
     
    1818    }
    1919    else if (isa<Ones>(expr2)) {
    20         return expr1;
     20        return expr1;
    2121    }
    2222    else if (isa<Zeroes>(expr2)){
     
    3939        }
    4040    }
     41    if (isa<Not>(expr1)) {
     42        std::swap(expr1, expr2);
     43    }
    4144    return new And(expr1, expr2);
    4245}
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.h

    r4358 r4404  
    99
    1010#include <pablo/pabloAST.h>
     11#include <pablo/pe_var.h>
    1112#include <array>
    1213
     
    4950    , mExprs({{expr1, expr2}})
    5051    {
    51 
     52        expr1->addUser(this);
     53        expr2->addUser(this);
    5254    }
    5355private:
  • icGREP/icgrep-devel/icgrep/pablo/pe_matchstar.h

    r4358 r4404  
    4646    , mExprs({{marker, cc}})
    4747    {
    48 
     48        marker->addUser(this);
     49        cc->addUser(this);
    4950    }
    5051private:
  • icGREP/icgrep-devel/icgrep/pablo/pe_next.h

    r4358 r4404  
    4141    }
    4242protected:
    43     Next(PabloAST * initial, PabloAST * expr, StatementList * parent)
     43    Next(PabloAST * initial, PabloAST * expr, PabloBlock * parent)
    4444    : Statement(ClassTypeId::Next, parent)
    45     , mExprs({{cast<Assign>(initial), expr}})
    46     {
    47 
     45    , mExprs({{cast<Assign>(initial), expr}}) {
     46        initial->addUser(this);
     47        expr->addUser(this);
    4848    }
    4949private:
  • icGREP/icgrep-devel/icgrep/pablo/pe_not.h

    r4284 r4404  
    99
    1010#include <pablo/pabloAST.h>
     11#include <pablo/pe_var.h>
    1112
    1213namespace pablo {
     
    4445    : PabloAST(ClassTypeId::Not)
    4546    , mExpr(expr) {
    46 
     47        expr->addUser(this);
    4748    }
    4849private:
  • icGREP/icgrep-devel/icgrep/pablo/pe_ones.h

    r4284 r4404  
    99
    1010#include "pabloAST.h"
     11#include <pablo/pe_var.h>
    1112
    1213namespace pablo {
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.h

    r4358 r4404  
    99
    1010#include <pablo/pabloAST.h>
     11#include <pablo/pe_var.h>
    1112#include <array>
    1213
     
    4950    , mExprs({{expr1, expr2}})
    5051    {
    51 
     52        expr1->addUser(this);
     53        expr2->addUser(this);
    5254    }
    5355private:
  • icGREP/icgrep-devel/icgrep/pablo/pe_scanthru.h

    r4358 r4404  
    4545    , mExprs({{from, thru}})
    4646    {
    47 
     47        from->addUser(this);
     48        thru->addUser(this);
    4849    }
    4950private:
  • icGREP/icgrep-devel/icgrep/pablo/pe_sel.h

    r4358 r4404  
    99
    1010#include <pablo/pabloAST.h>
     11#include <pablo/pe_var.h>
    1112#include <array>
    1213
     
    5253    , mExprs({{if_expr, t_expr, f_expr}})
    5354    {
    54 
     55        if_expr->addUser(this);
     56        t_expr->addUser(this);
     57        f_expr->addUser(this);
    5558    }
    5659private:
  • icGREP/icgrep-devel/icgrep/pablo/pe_var.h

    r4284 r4404  
    2323class Var : public PabloAST {
    2424    friend class PabloBlock;
     25    friend class And;
     26    friend class Or;
     27    friend class Not;
     28    friend class Sel;
     29    friend class Xor;
     30    friend class Zeroes;
     31    friend class Ones;
    2532public:
    2633    static inline bool classof(const PabloAST * e) {
     
    6572    , mName(getNameOf(var))
    6673    {
    67 
     74        var->addUser(this);
    6875    }
    6976private:
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.h

    r4358 r4404  
    99
    1010#include <pablo/pabloAST.h>
     11#include <pablo/pe_var.h>
    1112#include <array>
    1213
     
    4950    , mExprs({{expr1, expr2}})
    5051    {
    51 
     52        expr1->addUser(this);
     53        expr2->addUser(this);
    5254    }
    5355private:
  • icGREP/icgrep-devel/icgrep/pablo/pe_zeroes.h

    r4284 r4404  
    99
    1010#include "pabloAST.h"
     11#include <pablo/pe_var.h>
    1112
    1213namespace pablo {
  • icGREP/icgrep-devel/icgrep/pablo/ps_assign.h

    r4358 r4404  
    99
    1010#include <pablo/pe_string.h>
     11#include <pablo/symbol_generator.h>
    1112#include <array>
    1213
     
    1617    friend class PabloBlock;
    1718    friend class Next;
     19    friend class Var;
    1820public:
    1921    static inline bool classof(const PabloAST * e) {
     
    4951    }
    5052protected:
    51     Assign(PabloAST * name, PabloAST * expr, const int outputIndex, StatementList * parent)
     53    explicit Assign(PabloAST * name, PabloAST * expr, int outputIndex, PabloBlock * parent)
    5254    : Statement(ClassTypeId::Assign, parent)
    5355    , mExprs({{name, expr}})
    5456    , mOutputIndex(outputIndex)
    5557    {
    56 
     58        expr->addUser(this);
    5759    }
    5860private:
  • icGREP/icgrep-devel/icgrep/pablo/ps_if.h

    r4345 r4404  
    1313namespace pablo {
    1414
     15class Assign;
     16
    1517class If : public Statement {
    1618    friend class PabloBlock;
    1719public:
     20    using DefinedVars = std::vector<Assign *>;
     21
    1822    static inline bool classof(const PabloAST * e) {
    1923        return e->getClassTypeId() == ClassTypeId::If;
     
    3842        return mExpr;
    3943    }
    40     inline StatementList & getBody() {
     44    inline PabloBlock & getBody() {
    4145        return mBody;
    4246    }
    43     inline const StatementList & getBody() const {
     47    inline const PabloBlock & getBody() const {
    4448        return mBody;
    4549    }
    46     inline const std::vector<Assign *> & getDefined() const {
     50    inline const DefinedVars & getDefined() const {
    4751        return mDefined;
    4852    }
     
    6064    }
    6165protected:
    62     If(PabloAST * expr, std::vector<Assign *> && definedVars, StatementList && body, StatementList * parent)
    63     : Statement(ClassTypeId::If, parent)
    64     , mExpr(expr)
    65     , mBody(std::move(body))
    66     , mDefined(std::move(definedVars))
    67     , mCarryCount(0)
    68     , mAdvanceCount(0)
    69     {
    70         for (Statement * s : mBody) {
    71             s->mParent = &mBody;
    72         }
    73     }
     66    If(PabloAST * expr, DefinedVars && definedVars, PabloBlock & body, PabloBlock * parent);
    7467private:
    75     PabloAST *          mExpr;
    76     StatementList       mBody;
    77     std::vector<Assign *>    mDefined;
    78     unsigned            mCarryCount;
    79     unsigned            mAdvanceCount;
     68    PabloAST *      mExpr;
     69    PabloBlock &    mBody;
     70    DefinedVars     mDefined;
     71    unsigned        mCarryCount;
     72    unsigned        mAdvanceCount;
    8073};
    8174
  • icGREP/icgrep-devel/icgrep/pablo/ps_while.h

    r4288 r4404  
    3737        return mExpr;
    3838    }
    39     inline StatementList & getBody() {
     39    inline PabloBlock & getBody() {
    4040        return mBody;
    4141    }
    42     inline const StatementList & getBody() const {
     42    inline const PabloBlock & getBody() const {
    4343        return mBody;
    4444    }
     
    5656    }
    5757protected:
    58     While(PabloAST * expr, StatementList && body, StatementList * parent)
    59     : Statement(ClassTypeId::While, parent)
    60     , mExpr(expr)
    61     , mBody(std::move(body))
    62     , mCarryCount(0)
    63     , mAdvanceCount(0)
    64     {
    65         for (Statement * s : mBody) {
    66             s->mParent = &mBody;
    67         }
    68     }
     58    While(PabloAST * expr, PabloBlock &body, PabloBlock * parent);
    6959private:
    7060    PabloAST *          mExpr;
    71     StatementList       mBody;
     61    PabloBlock &        mBody;
    7262    unsigned            mCarryCount;
    7363    unsigned            mAdvanceCount;
  • icGREP/icgrep-devel/icgrep/pablo/symbol_generator.h

    r4252 r4404  
    88#define SYMBOL_GENERATOR_H
    99
     10#include <pablo/pabloAST.h>
    1011#include <string>
    1112#include <unordered_map>
     
    1516class String;
    1617
    17 class SymbolGenerator
    18 {
     18class SymbolGenerator {
     19    friend class PabloBlock;
    1920public:
     21    String * get(const std::string name);
     22    String * get_ssa(const std::string prefix);
     23protected:
    2024    SymbolGenerator();
    21 
    22     String * get(const std::string name);
    23 
    24     String * get_ssa(const std::string prefix);
    25 
     25    void* operator new (std::size_t size) noexcept {
     26        return PabloAST::mAllocator.allocate(size);
     27    }
    2628private:
    2729    std::unordered_map<std::string, unsigned>   mPrefixMap;
  • icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

    r4393 r4404  
    8484    mCRLF = mCG.createAnd(mCG.createAdvance(CR, 1), mLineFeed);
    8585#else
    86     PabloBlock crb(mCG);
     86    PabloBlock & crb = PabloBlock::Create(mCG);
    8787    Assign * cr1 = crb.createAssign("cr1", crb.createAdvance(CR, 1));
    8888    Assign * acrlf = crb.createAssign("crlf", crb.createAnd(crb.createVar(cr1), crb.createVar(LF)));
    89     mCG.createIf(CR, std::move(std::vector<Assign *>{acrlf}), std::move(crb));
     89    mCG.createIf(CR, std::move(std::vector<Assign *>{acrlf}), crb);
    9090    mCRLF = mCG.createVar(acrlf);
    9191#endif
     
    113113    PabloAST * u8single = ccc.compileCC(makeCC(0x00, 0x7F));
    114114    PabloAST * u8pfx = ccc.compileCC(makeCC(0xC0, 0xFF));
    115     PabloBlock it(mCG);
     115    PabloBlock & it = PabloBlock::Create(mCG);
    116116    PabloAST * u8pfx2 = ccc.compileCC(makeCC(0xC2, 0xDF), it);
    117117    PabloAST * u8pfx3 = ccc.compileCC(makeCC(0xE0, 0xEF), it);
     
    126126    PabloAST * LS_PS = it.createAnd(it.createAdvance(E2_80, 1), ccc.compileCC(makeCC(0xA8,0xA9), it));
    127127    Assign * NEL_LS_PS = it.createAssign("NEL_LS_PS", it.createOr(NEL, LS_PS));
    128     mCG.createIf(u8pfx, std::move(std::vector<Assign *>{valid_pfx, a_nonfinal, NEL_LS_PS}), std::move(it));
     128    mCG.createIf(u8pfx, std::move(std::vector<Assign *>{valid_pfx, a_nonfinal, NEL_LS_PS}), it);
    129129    PabloAST * LB_chars = mCG.createOr(LF_VT_FF_CR, mCG.createVar(NEL_LS_PS));
    130130    mInitial = mCG.createVar(mCG.createAssign(initial, mCG.createOr(u8single, mCG.createVar(valid_pfx))));
     
    378378        Assign * whileAccum = pb.createAssign("accum", base);
    379379
    380         PabloBlock wb(pb);
     380        PabloBlock & wb = PabloBlock::Create(pb);
    381381
    382382        Var * loopComputation = postPositionVar(process(repeated, wrapPostPositionMarker(whileTest), wb), wb);
     
    388388        wb.createNext(whileAccum, wb.createOr(loopComputation, whileAccumVar));
    389389
    390         pb.createWhile(wb.createVar(nextWhileTest), std::move(wb));
     390        pb.createWhile(wb.createVar(nextWhileTest), wb);
    391391
    392392        return makePostPositionMarker("unbounded", whileAccumVar, pb);
Note: See TracChangeset for help on using the changeset viewer.