source: icGREP/icgrep-devel/icgrep/pablo/function.h @ 5160

Last change on this file since 5160 was 5160, checked in by nmedfort, 3 years ago

Initial work for incorporating Types into Pablo AST.

File size: 5.3 KB
Line 
1#ifndef FUNCTION_H
2#define FUNCTION_H
3
4#include <pablo/pabloAST.h>
5#include <pablo/symbol_generator.h>
6#include <pablo/pe_var.h>
7#include <pablo/ps_assign.h>
8#include <pablo/pe_count.h>
9#include <pablo/pe_zeroes.h>
10#include <pablo/pe_ones.h>
11
12namespace pablo {
13
14class Prototype : public PabloAST {
15    friend class PabloBlock;
16public:
17
18    static inline bool classof(const PabloAST * e) {
19        return e->getClassTypeId() == ClassTypeId::Prototype;
20    }
21
22    static inline bool classof(void *) {
23        return false;
24    }
25
26    static Prototype * Create(std::string name, const unsigned numOfParameters, const unsigned numOfResults, void * functionPtr = nullptr);
27
28    const String * getName() const {
29        return mName;
30    }
31
32    unsigned getNumOfParameters() const {
33        return mNumOfParameters;
34    }
35
36    unsigned getNumOfResults() const {
37        return mNumOfResults;
38    }
39
40    void * getFunctionPtr() const {
41        return mFunctionPtr;
42    }
43protected:
44    Prototype(const PabloAST::ClassTypeId type, std::string && name, const unsigned numOfParameters, const unsigned numOfResults, void * functionPtr);
45protected:
46    const String * const    mName;
47    const unsigned          mNumOfParameters;
48    const unsigned          mNumOfResults;
49    void *                  mFunctionPtr;
50};
51
52inline Prototype * Prototype::Create(std::string name, const unsigned numOfParameters, const unsigned numOfResults, void * functionPtr) {
53    return new Prototype(PabloAST::ClassTypeId::Prototype, std::move(name), numOfParameters, numOfResults, functionPtr);
54}
55
56class PabloFunction : public Prototype {
57    friend class PabloBlock;
58    using Allocator = SlabAllocator<PabloAST *>;
59public:
60
61    static inline bool classof(const PabloAST * e) {
62        switch (e->getClassTypeId()) {
63            case ClassTypeId::Function:
64            case ClassTypeId::Prototype:
65                return true;
66            default:
67                return false;
68        }       
69    }
70
71    static inline bool classof(void *) {
72        return false;
73    }
74
75    static PabloFunction * Create(std::string name, const unsigned numOfParameters, const unsigned numOfResults);
76   
77    virtual bool operator==(const PabloAST & other) const {
78        return &other == this;
79    }
80
81    PabloBlock * getEntryBlock() {
82        return mEntryBlock;
83    }
84
85    const PabloBlock * getEntryBlock() const {
86        return mEntryBlock;
87    }
88
89    PabloBlock * setEntryBlock(PabloBlock * entryBlock) {
90        assert (entryBlock);
91        std::swap(mEntryBlock, entryBlock);
92        return entryBlock;
93    }
94
95    Var * getParameter(const unsigned index) {
96        if (LLVM_LIKELY(index < getNumOfParameters()))
97            return cast<Var>(mParameters[index]);
98        else throwInvalidParameterIndex(index);
99    }
100
101    const Var * getParameter(const unsigned index) const {
102        if (LLVM_LIKELY(index < getNumOfParameters()))
103            return cast<Var>(mParameters[index]);
104        else throwInvalidParameterIndex(index);
105    }
106
107    void setParameter(const unsigned index, Var * value) {
108        if (LLVM_LIKELY(index < getNumOfParameters()))
109            mParameters[index] = value;
110        else throwInvalidParameterIndex(index);
111    }
112
113    Assign * getResult(const unsigned index) {
114        if (LLVM_LIKELY(index < getNumOfResults()))
115            return cast<Assign>(mResults[index]);
116        else throwInvalidResultIndex(index);
117    }
118
119    const Assign * getResult(const unsigned index) const {
120        if (LLVM_LIKELY(index < getNumOfResults()))
121            return cast<Assign>(mResults[index]);
122        else throwInvalidResultIndex(index);
123    }
124
125    void setResult(const unsigned index, Assign * value) {       
126        if (LLVM_LIKELY(index < getNumOfResults())) {
127            if (LLVM_LIKELY(mResults[index] != value)) {
128                if (LLVM_UNLIKELY(mResults[index] != nullptr)) {
129                    mResults[index]->removeUser(this);
130                }
131                mResults[index] = value;
132                value->addUser(this);
133            }
134        }
135        else throwInvalidResultIndex(index);
136    }
137
138    void setResultCount(Count * value) {
139        value->addUser(this);
140    }
141   
142    void setFunctionPtr(void * functionPtr) {
143        mFunctionPtr = functionPtr;
144    }
145
146    Zeroes * getNullValue(const PabloType * const type);
147
148    Ones * getAllOnesValue(const PabloType * const type);
149
150    void operator delete (void*);
151
152    virtual ~PabloFunction() { }
153
154    inline SymbolGenerator * getSymbolTable() const {
155        return mSymbolTable;
156    }
157
158protected:
159
160    __attribute__((noreturn)) void throwInvalidParameterIndex(const unsigned index) const;
161
162    __attribute__((noreturn)) void throwInvalidResultIndex(const unsigned index) const;
163
164    PabloFunction(std::string && name, const unsigned numOfParameters, const unsigned numOfResults);
165private:
166    SymbolGenerator *                           mSymbolTable;
167    const PabloType *                           mBitStreamType;
168    PabloBlock *                                mEntryBlock;
169    std::vector<PabloAST *, Allocator>          mParameters;
170    std::vector<PabloAST *, Allocator>          mResults;
171    std::vector<PabloAST *, Allocator>          mConstants;
172};
173
174inline PabloFunction * PabloFunction::Create(std::string name, const unsigned numOfParameters, const unsigned numOfResults) {
175    return new PabloFunction(std::move(name), numOfParameters, numOfResults);
176}
177   
178}
179
180#endif // FUNCTION_H
Note: See TracBrowser for help on using the repository browser.