source: icGREP/icgrep-devel/icgrep/IDISA/idisa_builder.h @ 5230

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

Multi-threading support for PabloAST / PabloCompiler?. Requires unique LLVM Context / Module for each thread.

File size: 8.4 KB
Line 
1#ifndef IDISA_BUILDER_H
2#define IDISA_BUILDER_H
3
4/*
5 *  Copyright (c) 2015 International Characters.
6 *  This software is licensed to the public under the Open Software License 3.0.
7 *  icgrep is a trademark of International Characters.
8 */
9#include <llvm/IR/Module.h>
10#include <llvm/IR/Constant.h>
11#include <llvm/IR/Type.h>
12#include <llvm/IR/Value.h>
13#include <llvm/IR/IRBuilder.h>
14#include <llvm/Support/Host.h>
15#include <llvm/ADT/Triple.h>
16#include <IDISA/types/streamtype.h>
17#include <boost/container/flat_map.hpp>
18
19using namespace llvm;
20
21namespace IDISA {
22
23class IDISA_Builder : public IRBuilder<> {
24
25    using StreamTypes = boost::container::flat_map<unsigned, StreamType *>;
26
27public:
28
29    IDISA_Builder(Module * m, unsigned archBitWidth, unsigned bitBlockWidth, unsigned stride, unsigned CacheAlignment=64)
30    : IRBuilder<>(m->getContext())
31    , mMod(m)
32    , mCacheLineAlignment(CacheAlignment)
33    , mBitBlockWidth(bitBlockWidth)
34    , mStride(stride)
35    , mSizeType(getIntNTy(archBitWidth))
36    , mBitBlockType(VectorType::get(IntegerType::get(getContext(), 64), bitBlockWidth / 64))
37    , mZeroInitializer(Constant::getNullValue(mBitBlockType))
38    , mOneInitializer(Constant::getAllOnesValue(mBitBlockType))
39    , mPrintRegisterFunction(nullptr) {
40
41    }
42
43    virtual ~IDISA_Builder() {}
44   
45    std::string getBitBlockTypeName() const;  // A short string such as v4i64 or i256.
46
47    Value * bitCast(Value * a) {
48        return (a->getType() == mBitBlockType) ? a : CreateBitCast(a, mBitBlockType);
49    }
50
51    unsigned getBitBlockWidth() const {
52        return mBitBlockWidth;
53    }
54
55    unsigned getStride() const {
56        return mStride;
57    }
58
59    Module * getModule() const {
60        return mMod;
61    }
62   
63    void setModule(Module * m)  {
64        mMod = m;
65    }
66   
67    Constant * allZeroes() const {
68        return mZeroInitializer;
69    }
70
71    Constant * allOnes() const {
72        return mOneInitializer;
73    }
74   
75
76    LoadInst * CreateBlockAlignedLoad(Value * const ptr);
77    LoadInst * CreateBlockAlignedLoad(Value * const ptr, Value * const index);
78    LoadInst * CreateBlockAlignedLoad(Value * const ptr, std::initializer_list<Value *> indices);
79
80    void CreateBlockAlignedStore(Value * const value, Value * const ptr);
81    void CreateBlockAlignedStore(Value * const value, Value * const ptr, Value * const index);
82    void CreateBlockAlignedStore(Value * const value, Value * const ptr, std::initializer_list<Value *> indices);
83
84    Value * CreateMalloc(Type * type, Value * size);
85    Value * CreateAlignedMalloc(Type *type, Value * size, const unsigned alignment);
86    void CreateFree(Value * ptr);
87    void CreateAlignedFree(Value * ptr);
88    Value * CreateRealloc(Value * ptr, Value * size);
89    Value * CreateAlignedRealloc(Value * ptr, Value * size, const unsigned alignment);
90    void CreateMemZero(Value * ptr, Value * size, const unsigned alignment = 1);
91
92    void CallPrintRegister(const std::string & regName, Value * const value);
93    void CallPrintInt(const std::string & name, Value * const value);
94
95    VectorType * fwVectorType(unsigned fw);
96
97    Constant * simd_himask(unsigned fw);
98    Constant * simd_lomask(unsigned fw);
99   
100    virtual Value * simd_fill(unsigned fw, Value * a);
101
102    virtual Value * simd_add(unsigned fw, Value * a, Value * b);
103    virtual Value * simd_sub(unsigned fw, Value * a, Value * b);
104    virtual Value * simd_mult(unsigned fw, Value * a, Value * b);
105    virtual Value * simd_eq(unsigned fw, Value * a, Value * b);
106    virtual Value * simd_gt(unsigned fw, Value * a, Value * b);
107    virtual Value * simd_ugt(unsigned fw, Value * a, Value * b);
108    virtual Value * simd_lt(unsigned fw, Value * a, Value * b);
109    virtual Value * simd_ult(unsigned fw, Value * a, Value * b);
110    virtual Value * simd_max(unsigned fw, Value * a, Value * b);
111    virtual Value * simd_umax(unsigned fw, Value * a, Value * b);
112    virtual Value * simd_min(unsigned fw, Value * a, Value * b);
113    virtual Value * simd_umin(unsigned fw, Value * a, Value * b);
114    virtual Value * simd_if(unsigned fw, Value * cond, Value * a, Value * b);
115   
116    virtual Value * simd_slli(unsigned fw, Value * a, unsigned shift);
117    virtual Value * simd_srli(unsigned fw, Value * a, unsigned shift);
118    virtual Value * simd_srai(unsigned fw, Value * a, unsigned shift);
119   
120    virtual Value * simd_cttz(unsigned fw, Value * a);
121    virtual Value * simd_popcount(unsigned fw, Value * a);
122   
123    virtual Value * esimd_mergeh(unsigned fw, Value * a, Value * b);
124    virtual Value * esimd_mergel(unsigned fw, Value * a, Value * b);
125    virtual Value * esimd_bitspread(unsigned fw, Value * bitmask);
126   
127    virtual Value * hsimd_packh(unsigned fw, Value * a, Value * b);
128    virtual Value * hsimd_packl(unsigned fw, Value * a, Value * b);
129    virtual Value * hsimd_packh_in_lanes(unsigned lanes, unsigned fw, Value * a, Value * b);
130    virtual Value * hsimd_packl_in_lanes(unsigned lanes, unsigned fw, Value * a, Value * b);
131
132    virtual Value * hsimd_signmask(unsigned fw, Value * a);
133   
134    virtual Value * mvmd_extract(unsigned fw, Value * a, unsigned fieldIndex);
135    virtual Value * mvmd_insert(unsigned fw, Value * blk, Value * elt, unsigned fieldIndex);
136    virtual Value * mvmd_slli(unsigned fw, Value * a, unsigned shift);
137    virtual Value * mvmd_srli(unsigned fw, Value * a, unsigned shift);
138    virtual Value * mvmd_dslli(unsigned fw, Value * a, Value * b, unsigned shift);
139   
140   
141    virtual Value * bitblock_any(Value * a);
142    // full add producing {carryout, sum}
143    virtual std::pair<Value *, Value *> bitblock_add_with_carry(Value * a, Value * b, Value * carryin);
144    // full shift producing {shiftout, shifted}
145    virtual std::pair<Value *, Value *> bitblock_advance(Value * a, Value * shiftin, unsigned shift);
146    virtual Value * bitblock_mask_from(Value * pos);
147    virtual Value * bitblock_set_bit(Value * pos);
148   
149    Value * simd_and(Value * a, Value * b);
150    Value * simd_or(Value * a, Value * b);
151    Value * simd_xor(Value * a, Value * b);
152    Value * simd_not(Value * a);
153    Value * fwCast(unsigned fw, Value * a);
154   
155    inline llvm::IntegerType * getSizeTy() const {
156        return mSizeType;
157    }
158
159    inline llvm::ConstantInt * getSize(const size_t value) const {
160        return ConstantInt::get(getSizeTy(), value);
161    }
162
163    PointerType * getVoidPtrTy() const;
164
165    inline VectorType * getBitBlockType() const {
166        return mBitBlockType;
167    }
168
169    inline unsigned getCacheAlignment() const {
170        return mCacheLineAlignment;
171    }
172
173    inline Type * getStreamSetTy(const uint64_t NumElements = 1, const uint64_t FieldWidth = 1) {
174        return ArrayType::get(getStreamTy(FieldWidth), NumElements);
175    }
176   
177    Type * getStreamTy(const uint64_t FieldWidth = 1);
178
179    inline llvm::AllocaInst * CreateCacheAlignedAlloca(llvm::Type * Ty, llvm::Value * ArraySize = nullptr) {
180        llvm::AllocaInst * instr = CreateAlloca(Ty, ArraySize);
181        instr->setAlignment(mCacheLineAlignment);
182        return instr;
183    }
184   
185    virtual llvm::LoadInst* CreateAtomicLoadAcquire(Value * ptr);
186    virtual llvm::StoreInst *  CreateAtomicStoreRelease(Value * val, Value * ptr); 
187   
188protected:
189    Module *            mMod;
190    unsigned            mCacheLineAlignment;
191    unsigned            mBitBlockWidth;
192    unsigned            mStride;
193    IntegerType *       mSizeType;
194    VectorType *        mBitBlockType;
195
196    Constant *          mZeroInitializer;
197    Constant *          mOneInitializer;
198    Constant *          mPrintRegisterFunction;
199   
200    StreamTypes         mStreamTypes;
201};
202
203inline LoadInst * IDISA_Builder::CreateBlockAlignedLoad(Value * const ptr) {
204    return CreateAlignedLoad(ptr, mBitBlockWidth / 8);
205}
206
207inline LoadInst * IDISA_Builder::CreateBlockAlignedLoad(Value * const ptr, Value * const index) {
208    return CreateBlockAlignedLoad(CreateGEP(ptr, index));
209}
210
211inline LoadInst * IDISA_Builder::CreateBlockAlignedLoad(Value * const ptr, std::initializer_list<Value *> indicies) {
212    return CreateBlockAlignedLoad(CreateGEP(ptr, indicies));
213}
214
215inline void IDISA_Builder::CreateBlockAlignedStore(Value * const value, Value * const ptr) {
216    CreateAlignedStore(value, ptr, mBitBlockWidth / 8);
217}
218
219inline void IDISA_Builder::CreateBlockAlignedStore(Value * const value, Value * const ptr, Value * const index) {
220    CreateBlockAlignedStore(value, CreateGEP(ptr, index));
221}
222
223inline void IDISA_Builder::CreateBlockAlignedStore(Value * const value, Value * const ptr, std::initializer_list<Value *> indicies) {
224    CreateBlockAlignedStore(value, CreateGEP(ptr, indicies));
225}
226   
227
228   
229}
230#endif // IDISA_BUILDER_H
Note: See TracBrowser for help on using the repository browser.