Ignore:
Timestamp:
Nov 6, 2016, 8:37:11 PM (3 years ago)
Author:
nmedfort
Message:

Initial work on adding types to PabloAST and mutable Var objects.

File:
1 edited

Legend:

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

    r5160 r5202  
    1515#include <pablo/pe_call.h>
    1616#include <pablo/pe_matchstar.h>
    17 #include <pablo/pe_next.h>
    1817#include <pablo/pe_not.h>
    1918#include <pablo/pe_ones.h>
     
    2928#include <pablo/pe_count.h>
    3029#include <pablo/ps_assign.h>
    31 #include <pablo/ps_if.h>
    32 #include <pablo/ps_while.h>
     30#include <pablo/branch.h>
    3331#include <pablo/function.h>
    3432#include <llvm/ADT/ArrayRef.h>
     
    3937class PabloBlock : public PabloAST, public StatementList {
    4038    friend class PabloAST;
    41     friend class If;
    42     friend class While;
     39    friend class Branch;
    4340    friend class PabloBuilder;
    4441public:
     
    5855
    5956    inline static PabloBlock * Create(PabloFunction & parent) noexcept {
    60         return new PabloBlock(&parent, nullptr);
     57        return new PabloBlock(&parent);
    6158    }
    6259
    6360    inline static PabloBlock * Create(PabloBlock * const predecessor) noexcept {
    64         return new PabloBlock(predecessor->mParent, predecessor);
    65     }
    66 
    67     PabloAST * createAdvance(PabloAST * expr, const Integer::Type shiftAmount);
    68 
    69     PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount);
    70 
    71     PabloAST * createAdvance(PabloAST * expr, const Integer::Type shiftAmount, const std::string prefix);
    72 
    73     PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix);
    74 
    75     PabloAST * createLookahead(PabloAST * expr, const Integer::Type shiftAmount);
    76 
    77     PabloAST * createLookahead(PabloAST * expr, PabloAST * shiftAmount);
    78 
    79     PabloAST * createLookahead(PabloAST * expr, const Integer::Type shiftAmount, const std::string prefix);
    80 
    81     PabloAST * createLookahead(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix);
    82 
    83     inline Zeroes * createZeroes(const PabloType * const type = nullptr) {
     61        return new PabloBlock(predecessor->mParent);
     62    }
     63
     64    Advance * createAdvance(PabloAST * expr, PabloAST * shiftAmount) {
     65        return createAdvance(expr, shiftAmount, nullptr);
     66    }
     67
     68    Advance * createAdvance(PabloAST * expr, PabloAST * shiftAmount, const std::string & prefix) {
     69        return createAdvance(expr, shiftAmount, makeName(prefix));
     70    }
     71
     72    Advance * createAdvance(PabloAST * expr, PabloAST * shiftAmount, String * const name);
     73
     74    Lookahead * createLookahead(PabloAST * expr, PabloAST * shiftAmount) {
     75        return createLookahead(expr, shiftAmount, nullptr);
     76    }
     77
     78    Lookahead * createLookahead(PabloAST * expr, PabloAST * shiftAmount, const std::string & prefix) {
     79        return createLookahead(expr, shiftAmount, makeName(prefix));
     80    }
     81
     82    Lookahead * createLookahead(PabloAST * expr, PabloAST * shiftAmount, String * const name);
     83
     84    inline Zeroes * createZeroes(Type * const type = nullptr) {
    8485        return mParent->getNullValue(type);
    8586    }
    8687
    87     inline Ones * createOnes(const PabloType * const type = nullptr) {
     88    inline Ones * createOnes(Type * const type = nullptr) {
    8889        return mParent->getAllOnesValue(type);
    8990    }
     
    103104    }
    104105
    105     Assign * createAssign(const std::string && prefix, PabloAST * const expr);
    106 
    107     inline Var * createVar(const std::string name, const PabloType * const type) {
    108         return createVar(getName(name, false), type);
    109     }
    110 
    111     inline Var * createVar(String * name, const PabloType * const type) {
     106    Not * createNot(PabloAST * expr) {
     107        return createNot(expr, nullptr);
     108    }
     109
     110    Not * createNot(PabloAST * expr, const std::string & prefix) {
     111        return createNot(expr, makeName(prefix));
     112    }
     113
     114    Not * createNot(PabloAST * expr, String * const name);
     115
     116    inline Var * createVar(const std::string & name, Type * const type = nullptr) {
     117        return createVar(makeName(name), type);
     118    }
     119
     120    inline Var * createVar(String * name, Type * const type = nullptr) {
    112121        return createVar(cast<PabloAST>(name), type);
    113122    }
    114123
    115     Next * createNext(Assign * assign, PabloAST * expr);
    116 
    117     PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2);
    118 
    119     PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
    120 
    121     And * createAnd(const PabloType * const type, const unsigned reserved);
    122 
    123     And * createAnd(const PabloType * const type, const unsigned reserved, const std::string prefix);
    124 
    125     And * createAnd(const PabloType * const type, std::vector<PabloAST *>::iterator begin, std::vector<PabloAST *>::iterator end);
    126 
    127     And * createAnd(const PabloType * const type, Variadic::iterator begin, Variadic::iterator end);
    128 
    129     PabloAST * createNot(PabloAST * expr);
    130 
    131     PabloAST * createNot(PabloAST * expr, const std::string prefix);
    132 
    133     PabloAST * createOr(PabloAST * expr1, PabloAST * expr2);
    134 
    135     PabloAST * createOr(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
    136 
    137     Or * createOr(const PabloType * const type, std::vector<PabloAST *>::iterator begin, std::vector<PabloAST *>::iterator end);
    138 
    139     Or * createOr(const PabloType * const type, Variadic::iterator begin, Variadic::iterator end);
    140 
    141     Or * createOr(const PabloType * const type, const unsigned reserved);
    142 
    143     Or * createOr(const PabloType * const type, const unsigned reserved, const std::string prefix);
    144 
    145     PabloAST * createXor(PabloAST * expr1, PabloAST * expr2);
    146 
    147     PabloAST * createXor(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
    148 
    149     Xor * createXor(const PabloType * const type, std::vector<PabloAST *>::iterator begin, std::vector<PabloAST *>::iterator end);
    150 
    151     Xor * createXor(const PabloType * const type, Variadic::iterator begin, Variadic::iterator end);
    152 
    153     Xor * createXor(const PabloType * const type, const unsigned reserved);
    154 
    155     Xor * createXor(const PabloType * const type, const unsigned reserved, const std::string prefix);
    156 
    157     PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass);
    158 
    159     PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass, const std::string prefix);
    160 
    161     PabloAST * createScanThru(PabloAST * from, PabloAST * thru);
    162 
    163     PabloAST * createScanThru(PabloAST * from, PabloAST * thru, const std::string prefix);
    164 
    165     PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr);
    166 
    167     PabloAST * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const std::string prefix);
    168 
    169     Count * createCount(const std::string counter, PabloAST * const expr);
     124    Count * createCount(PabloAST * expr);
     125
     126    Count * createCount(PabloAST * expr, const std::string & prefix);
     127
     128    InFile * createInFile(PabloAST * expr) {
     129        return createInFile(expr, nullptr);
     130    }
     131
     132    InFile * createInFile(PabloAST * expr, const std::string & prefix) {
     133        return createInFile(expr, makeName(prefix));
     134    }
     135
     136    InFile * createInFile(PabloAST * expr, String * const name);
     137
     138    AtEOF * createAtEOF(PabloAST * expr) {
     139        return createAtEOF(expr, nullptr);
     140    }
     141
     142    AtEOF * createAtEOF(PabloAST * expr, const std::string & prefix) {
     143        return createAtEOF(expr, makeName(prefix));
     144    }
     145
     146    AtEOF * createAtEOF(PabloAST * expr, String * const name);
     147
     148    Extract * createExtract(PabloAST * array, const Integer::Type index) {
     149        return createExtract(array, getInteger(index), nullptr);
     150    }
     151
     152    inline Extract * createExtract(PabloAST * array, PabloAST * index) {
     153        return createExtract(array, index, nullptr);
     154    }
     155
     156    Extract * createExtract(PabloAST * array, PabloAST * index, const std::string & prefix) {
     157        return createExtract(array, index, makeName(prefix));
     158    }
     159
     160    Extract * createExtract(PabloAST * array, const Integer::Type index, const std::string & prefix) {
     161        return createExtract(array, getInteger(index), makeName(prefix));
     162    }
     163
     164    Extract * createExtract(PabloAST * array, PabloAST * index, String * const name);
     165
     166    Assign * createAssign(PabloAST * const var, PabloAST * const value);
     167
     168    And * createAnd(PabloAST * expr1, PabloAST * expr2) {
     169        return createAnd(expr1, expr2, nullptr);
     170    }
     171
     172    And * createAnd(PabloAST * expr1, PabloAST * expr2, const std::string & prefix) {
     173        return createAnd(expr1, expr2, nullptr);
     174    }
     175
     176    And * createAnd(PabloAST * expr1, PabloAST * expr2, String * const name);
     177
     178    And * createAnd(Type * const type, const unsigned reserved) {
     179        return createAnd(type, reserved, nullptr);
     180    }
     181
     182    And * createAnd(Type * const type, const unsigned reserved, String * const name);
     183
     184    Or * createOr(PabloAST * expr1, PabloAST * expr2) {
     185        return createOr(expr1, expr2, nullptr);
     186    }
     187
     188    Or * createOr(PabloAST * expr1, PabloAST * expr2, const std::string & prefix) {
     189        return createOr(expr1, expr2, makeName(prefix));
     190    }
     191
     192    Or * createOr(PabloAST * expr1, PabloAST * expr2, String * const name);
     193
     194    Or * createOr(Type * const type, const unsigned reserved) {
     195        return createOr(type, reserved, nullptr);
     196    }
     197
     198    Or * createOr(Type * const type, const unsigned reserved, String * const name);
     199
     200    Xor * createXor(PabloAST * expr1, PabloAST * expr2) {
     201        return createXor(expr1, expr2, nullptr);
     202    }
     203
     204    Xor * createXor(PabloAST * expr1, PabloAST * expr2, const std::string & prefix) {
     205        return createXor(expr1, expr2, makeName(prefix));
     206    }
     207
     208    Xor * createXor(PabloAST * expr1, PabloAST * expr2, String * const name);
     209
     210    Xor * createXor(Type * const type, const unsigned reserved) {
     211        return createXor(type, reserved, nullptr);
     212    }
     213
     214    Xor * createXor(Type * const type, const unsigned reserved, String * const name);
     215
     216    MatchStar * createMatchStar(PabloAST * marker, PabloAST * charclass) {
     217        return createMatchStar(marker, charclass, nullptr);
     218    }
     219
     220    MatchStar * createMatchStar(PabloAST * marker, PabloAST * charclass, const std::string & prefix) {
     221        return createMatchStar(marker, charclass, makeName(prefix));
     222    }
     223
     224    MatchStar * createMatchStar(PabloAST * marker, PabloAST * charclass, String * const name);
     225
     226    ScanThru * createScanThru(PabloAST * from, PabloAST * thru) {
     227        return createScanThru(from, thru, nullptr);
     228    }
     229
     230    ScanThru * createScanThru(PabloAST * from, PabloAST * thru, const std::string & prefix) {
     231        return createScanThru(from, thru, makeName(prefix));
     232    }
     233
     234    ScanThru * createScanThru(PabloAST * from, PabloAST * thru, String * const name);
     235
     236    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
     237        return createSel(condition, trueExpr, falseExpr, nullptr);
     238    }
     239
     240    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const std::string & prefix) {
     241        return createSel(condition, trueExpr, falseExpr, makeName(prefix));
     242    }
     243
     244    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, String * const name);
    170245   
    171     PabloAST * createInFile(PabloAST * expr);
    172    
    173     PabloAST * createInFile(PabloAST * expr, const std::string prefix);
    174    
    175     PabloAST * createAtEOF(PabloAST * expr);
    176    
    177     PabloAST * createAtEOF(PabloAST * expr, const std::string prefix);
    178    
    179     If * createIf(PabloAST * condition, const std::initializer_list<Assign *> definedVars, PabloBlock * body);
    180 
    181     If * createIf(PabloAST * condition, const std::vector<Assign *> & definedVars, PabloBlock * body);
    182 
    183     If * createIf(PabloAST * condition, std::vector<Assign *> && definedVars, PabloBlock * body);
    184 
    185     While * createWhile(PabloAST * condition, const std::initializer_list<Next *> nextVars, PabloBlock * body);
    186 
    187     While * createWhile(PabloAST * condition, const std::vector<Next *> & nextVars, PabloBlock * body);
    188 
    189     While * createWhile(PabloAST * condition, std::vector<Next *> && nextVars, PabloBlock * body);
    190 
    191     inline StatementList & statements() {
    192         return *this;
    193     }
    194 
    195     inline const StatementList & statements() const {
    196         return *this;
    197     }
    198 
    199     inline String * getName(const std::string name, const bool generated = true) const {
    200         return getSymbolTable()->get(name, generated);
    201     }
    202 
    203     inline String * makeName(const std::string prefix, const bool generated = true) const {
    204         return getSymbolTable()->make(prefix, generated);
    205     }
    206 
    207     inline Integer * getInteger(Integer::Type value) {
    208         return getSymbolTable()->getInteger(value);
    209     }
     246    If * createIf(PabloAST * condition, PabloBlock * body);
     247
     248    While * createWhile(PabloAST * condition, PabloBlock * body);
    210249
    211250    inline PabloBlock * getPredecessor() const {
    212         return mPredecessor;
    213     }
    214    
    215     void setPredecessor(PabloBlock * const predecessor) {
    216         mPredecessor = predecessor;
     251        return getBranch() ? getBranch()->getParent() : nullptr;
    217252    }
    218253
     
    235270    void eraseFromParent(const bool recursively = false);
    236271
    237     inline Statement * getBranch() const {
     272    inline Branch * getBranch() const {
    238273        return mBranch;
     274    }
     275
     276    inline void setBranch(Branch * const branch) {
     277        mBranch = branch;
     278    }
     279
     280    inline String * getName(const std::string name) const {
     281        return getSymbolTable()->get(name);
     282    }
     283
     284    inline String * makeName(const std::string & prefix) const {
     285        return getSymbolTable()->make(prefix);
     286    }
     287
     288    inline Integer * getInteger(Integer::Type value) const {
     289        return getSymbolTable()->getInteger(value);
    239290    }
    240291
     
    247298protected:
    248299
    249     explicit PabloBlock(PabloFunction * parent, PabloBlock * predecessor) noexcept;
    250 
    251     PabloAST * renameNonNamedNode(PabloAST * expr, const std::string && prefix);
     300    explicit PabloBlock(PabloFunction * parent) noexcept;
    252301
    253302    template<typename Type>
    254303    inline Type * insertAtInsertionPoint(Type * expr) {
    255304        if (isa<Statement>(expr)) {
    256             if (LLVM_UNLIKELY(isa<If>(expr) || isa<While>(expr))) {
    257                 PabloBlock * const body = isa<If>(expr) ? cast<If>(expr)->getBody() : cast<While>(expr)->getBody();
    258                 body->setPredecessor (this);
    259                 addUser(body);
    260             }
    261305            insert(cast<Statement>(expr));
    262306        }
     
    264308    }
    265309
    266     inline void setBranch(Statement * const branch) {
    267         mBranch = branch;
    268     }
    269 
    270 private:
    271 
    272310    Call * createCall(PabloAST * prototype, const std::vector<PabloAST *> &);
    273311
    274     Var * createVar(PabloAST * name, const PabloType * const type);
     312    Var * createVar(PabloAST * name, Type * const type);
    275313
    276314private:       
    277315    PabloFunction *                                     mParent;
    278     PabloBlock *                                        mPredecessor;
    279     Statement *                                         mBranch; // What statement branches into this scope block?
     316    Branch *                                            mBranch;
    280317    unsigned                                            mScopeIndex;
    281318};
Note: See TracChangeset for help on using the changeset viewer.