Ignore:
Timestamp:
Sep 23, 2016, 4:12:41 PM (3 years ago)
Author:
nmedfort
Message:

Initial work for incorporating Types into Pablo AST.

File:
1 edited

Legend:

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

    r5061 r5160  
    5757    }
    5858
    59     inline static PabloBlock * Create(PabloFunction & function) noexcept {
    60         return new PabloBlock(function.mSymbolTable);
    61     }
    62 
    63     inline static PabloBlock * Create(PabloBlock * const block) noexcept {
    64         return new PabloBlock(block->mSymbolGenerator);
     59    inline static PabloBlock * Create(PabloFunction & parent) noexcept {
     60        return new PabloBlock(&parent, nullptr);
     61    }
     62
     63    inline static PabloBlock * Create(PabloBlock * const predecessor) noexcept {
     64        return new PabloBlock(predecessor->mParent, predecessor);
    6565    }
    6666
     
    8181    PabloAST * createLookahead(PabloAST * expr, PabloAST * shiftAmount, const std::string prefix);
    8282
    83     static inline Zeroes * createZeroes() {
    84         return &mZeroes;
    85     }
    86 
    87     static inline Ones * createOnes() {
    88         return &mOnes;
     83    inline Zeroes * createZeroes(const PabloType * const type = nullptr) {
     84        return mParent->getNullValue(type);
     85    }
     86
     87    inline Ones * createOnes(const PabloType * const type = nullptr) {
     88        return mParent->getAllOnesValue(type);
    8989    }
    9090
     
    105105    Assign * createAssign(const std::string && prefix, PabloAST * const expr);
    106106
    107     inline Var * createVar(const std::string name) {
    108         return createVar(getName(name, false));
    109     }
    110 
    111     inline Var * createVar(String * name) {
    112         return createVar(cast<PabloAST>(name));
     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) {
     112        return createVar(cast<PabloAST>(name), type);
    113113    }
    114114
     
    119119    PabloAST * createAnd(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
    120120
    121     And * createAnd(const unsigned reserved);
    122 
    123     And * createAnd(const unsigned reserved, const std::string prefix);
    124 
    125     And * createAnd(std::vector<PabloAST *>::iterator begin, std::vector<PabloAST *>::iterator end) {
    126         return insertAtInsertionPoint(new And(begin, end, makeName("and_")));
    127     }
    128 
    129     And * createAnd(Variadic::iterator begin, Variadic::iterator end) {
    130         return insertAtInsertionPoint(new And(begin, end, makeName("and_")));
    131     }
     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);
    132128
    133129    PabloAST * createNot(PabloAST * expr);
     
    139135    PabloAST * createOr(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
    140136
    141     Or * createOr(std::vector<PabloAST *>::iterator begin, std::vector<PabloAST *>::iterator end) {
    142         return insertAtInsertionPoint(new Or(begin, end, makeName("or_")));
    143     }
    144 
    145     Or * createOr(Variadic::iterator begin, Variadic::iterator end) {
    146         return insertAtInsertionPoint(new Or(begin, end, makeName("or_")));
    147     }
    148 
    149     Or * createOr(const unsigned reserved);
    150 
    151     Or * createOr(const unsigned reserved, const std::string prefix);
     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);
    152144
    153145    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2);
     
    155147    PabloAST * createXor(PabloAST * expr1, PabloAST * expr2, const std::string prefix);
    156148
    157     Xor * createXor(std::vector<PabloAST *>::iterator begin, std::vector<PabloAST *>::iterator end) {
    158         return insertAtInsertionPoint(new Xor(begin, end, makeName("xor_")));
    159     }
    160 
    161     Xor * createXor(Variadic::iterator begin, Variadic::iterator end) {
    162         return insertAtInsertionPoint(new Xor(begin, end, makeName("xor_")));
    163     }
    164 
    165     Xor * createXor(const unsigned reserved);
    166 
    167     Xor * createXor(const unsigned reserved, const std::string prefix);
     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);
    168156
    169157    PabloAST * createMatchStar(PabloAST * marker, PabloAST * charclass);
     
    210198
    211199    inline String * getName(const std::string name, const bool generated = true) const {
    212         return mSymbolGenerator->get(name, generated);
     200        return getSymbolTable()->get(name, generated);
    213201    }
    214202
    215203    inline String * makeName(const std::string prefix, const bool generated = true) const {
    216         return mSymbolGenerator->make(prefix, generated);
     204        return getSymbolTable()->make(prefix, generated);
    217205    }
    218206
    219207    inline Integer * getInteger(Integer::Type value) {
    220         return mSymbolGenerator->getInteger(value);
    221     }
    222 
    223     inline PabloBlock * getParent() const {
     208        return getSymbolTable()->getInteger(value);
     209    }
     210
     211    inline PabloBlock * getPredecessor() const {
     212        return mPredecessor;
     213    }
     214   
     215    void setPredecessor(PabloBlock * const predecessor) {
     216        mPredecessor = predecessor;
     217    }
     218
     219    inline PabloFunction * getParent() const {
    224220        return mParent;
    225221    }
    226    
    227     void setParent(PabloBlock * parent) {
     222
     223    void setParent(PabloFunction * const parent) {
    228224        mParent = parent;
    229         // Add test to assert this block is in the same function.
    230225    }
    231226
     
    244239    }
    245240
     241    SymbolGenerator * getSymbolTable() const {
     242        return mParent->getSymbolTable();
     243    }
     244
    246245    virtual ~PabloBlock();
    247246
    248247protected:
    249248
    250     explicit PabloBlock(SymbolGenerator * symbolGenerator) noexcept;
     249    explicit PabloBlock(PabloFunction * parent, PabloBlock * predecessor) noexcept;
    251250
    252251    PabloAST * renameNonNamedNode(PabloAST * expr, const std::string && prefix);
     
    257256            if (LLVM_UNLIKELY(isa<If>(expr) || isa<While>(expr))) {
    258257                PabloBlock * const body = isa<If>(expr) ? cast<If>(expr)->getBody() : cast<While>(expr)->getBody();
    259                 body->setParent(this);
     258                body->setPredecessor (this);
    260259                addUser(body);
    261260            }
     
    273272    Call * createCall(PabloAST * prototype, const std::vector<PabloAST *> &);
    274273
    275     Var * createVar(PabloAST * name);
     274    Var * createVar(PabloAST * name, const PabloType * const type);
    276275
    277276private:       
    278     static Zeroes                                       mZeroes;
    279     static Ones                                         mOnes;
    280     SymbolGenerator *                                   mSymbolGenerator; // TODO: need a better way of passing a symbol generator around
    281     PabloBlock *                                        mParent;
     277    PabloFunction *                                     mParent;
     278    PabloBlock *                                        mPredecessor;
    282279    Statement *                                         mBranch; // What statement branches into this scope block?
    283280    unsigned                                            mScopeIndex;
Note: See TracChangeset for help on using the changeset viewer.