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

Last change on this file since 5217 was 5217, checked in by nmedfort, 2 years ago

Merged PabloFunction? and PabloKernel? classes. Updated projects where necessary.

File size: 7.5 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
18using namespace llvm;
19
20namespace IDISA {
21
22class IDISA_Builder : public IRBuilder<> {
23public:
24
25    IDISA_Builder(Module * m, unsigned archBitWidth, unsigned bitBlockWidth, unsigned stride, unsigned CacheAlignment=64)
26    : IRBuilder<>(m->getContext())
27    , mMod(m)
28    , mCacheLineAlignment(CacheAlignment)
29    , mBitBlockWidth(bitBlockWidth)
30    , mStride(stride)
31    , mSizeType(getIntNTy(archBitWidth))
32    , mBitBlockType(VectorType::get(IntegerType::get(getContext(), 64), bitBlockWidth / 64))
33    , mZeroInitializer(Constant::getNullValue(mBitBlockType))
34    , mOneInitializer(Constant::getAllOnesValue(mBitBlockType))
35    , mPrintRegisterFunction(nullptr) {
36
37    }
38
39    virtual ~IDISA_Builder() {}
40   
41    std::string getBitBlockTypeName() const;  // A short string such as v4i64 or i256.
42
43    Value * bitCast(Value * a) {
44        return (a->getType() == mBitBlockType) ? a : CreateBitCast(a, mBitBlockType);
45    }
46
47    unsigned getBitBlockWidth() const {
48        return mBitBlockWidth;
49    }
50
51    unsigned getStride() const {
52        return mStride;
53    }
54
55    Module * getModule() const {
56        return mMod;
57    }
58   
59    void setModule(Module * m)  {
60        mMod = m;
61    }
62   
63    Constant * allZeroes() const {
64        return mZeroInitializer;
65    }
66
67    Constant * allOnes() const {
68        return mOneInitializer;
69    }
70   
71
72    LoadInst * CreateBlockAlignedLoad(Value * const ptr);
73    LoadInst * CreateBlockAlignedLoad(Value * const ptr, Value * const index);
74    LoadInst * CreateBlockAlignedLoad(Value * const ptr, std::initializer_list<Value *> indices);
75
76    void CreateBlockAlignedStore(Value * const value, Value * const ptr);
77    void CreateBlockAlignedStore(Value * const value, Value * const ptr, Value * const index);
78    void CreateBlockAlignedStore(Value * const value, Value * const ptr, std::initializer_list<Value *> indices);
79
80    void CallPrintRegister(const std::string & regName, Value * const value);
81    void CallPrintInt(const std::string & name, Value * const value);
82
83    Constant * simd_himask(unsigned fw);
84    Constant * simd_lomask(unsigned fw);
85   
86    virtual Value * simd_fill(unsigned fw, Value * a);
87
88    virtual Value * simd_add(unsigned fw, Value * a, Value * b);
89    virtual Value * simd_sub(unsigned fw, Value * a, Value * b);
90    virtual Value * simd_mult(unsigned fw, Value * a, Value * b);
91    virtual Value * simd_eq(unsigned fw, Value * a, Value * b);
92    virtual Value * simd_gt(unsigned fw, Value * a, Value * b);
93    virtual Value * simd_ugt(unsigned fw, Value * a, Value * b);
94    virtual Value * simd_lt(unsigned fw, Value * a, Value * b);
95    virtual Value * simd_ult(unsigned fw, Value * a, Value * b);
96    virtual Value * simd_max(unsigned fw, Value * a, Value * b);
97    virtual Value * simd_umax(unsigned fw, Value * a, Value * b);
98    virtual Value * simd_min(unsigned fw, Value * a, Value * b);
99    virtual Value * simd_umin(unsigned fw, Value * a, Value * b);
100    virtual Value * simd_if(unsigned fw, Value * cond, Value * a, Value * b);
101   
102    virtual Value * simd_slli(unsigned fw, Value * a, unsigned shift);
103    virtual Value * simd_srli(unsigned fw, Value * a, unsigned shift);
104    virtual Value * simd_srai(unsigned fw, Value * a, unsigned shift);
105   
106    virtual Value * simd_cttz(unsigned fw, Value * a);
107    virtual Value * simd_popcount(unsigned fw, Value * a);
108   
109    virtual Value * esimd_mergeh(unsigned fw, Value * a, Value * b);
110    virtual Value * esimd_mergel(unsigned fw, Value * a, Value * b);
111    virtual Value * esimd_bitspread(unsigned fw, Value * bitmask);
112   
113    virtual Value * hsimd_packh(unsigned fw, Value * a, Value * b);
114    virtual Value * hsimd_packl(unsigned fw, Value * a, Value * b);
115    virtual Value * hsimd_packh_in_lanes(unsigned lanes, unsigned fw, Value * a, Value * b);
116    virtual Value * hsimd_packl_in_lanes(unsigned lanes, unsigned fw, Value * a, Value * b);
117
118    virtual Value * hsimd_signmask(unsigned fw, Value * a);
119   
120    virtual Value * mvmd_extract(unsigned fw, Value * a, unsigned fieldIndex);
121    virtual Value * mvmd_insert(unsigned fw, Value * blk, Value * elt, unsigned fieldIndex);
122    virtual Value * mvmd_slli(unsigned fw, Value * a, unsigned shift);
123    virtual Value * mvmd_srli(unsigned fw, Value * a, unsigned shift);
124    virtual Value * mvmd_dslli(unsigned fw, Value * a, Value * b, unsigned shift);
125   
126   
127    virtual Value * bitblock_any(Value * a);
128    // full add producing {carryout, sum}
129    virtual std::pair<Value *, Value *> bitblock_add_with_carry(Value * a, Value * b, Value * carryin);
130    // full shift producing {shiftout, shifted}
131    virtual std::pair<Value *, Value *> bitblock_advance(Value * a, Value * shiftin, unsigned shift);
132    virtual Value * bitblock_mask_from(Value * pos);
133    virtual Value * bitblock_set_bit(Value * pos);
134   
135    Value * simd_and(Value * a, Value * b);
136    Value * simd_or(Value * a, Value * b);
137    Value * simd_xor(Value * a, Value * b);
138    Value * simd_not(Value * a);
139    Value * fwCast(unsigned fw, Value * a);
140   
141    inline llvm::IntegerType * getSizeTy() const {
142        return mSizeType;
143    }
144
145    inline VectorType * getBitBlockType() const {
146        return mBitBlockType;
147    }
148
149    inline Type * getStreamSetTy(const uint64_t NumElements = 1, const uint64_t FieldWidth = 1) {
150        return StreamType::get(getContext(), NumElements, FieldWidth);
151    }
152   
153    inline llvm::AllocaInst * CreateCacheAlignedAlloca(llvm::Type * Ty, llvm::Value * ArraySize = nullptr) {
154        llvm::AllocaInst * instr = CreateAlloca(Ty, ArraySize);
155        instr->setAlignment(mCacheLineAlignment);
156        return instr;
157    }
158   
159    virtual llvm::LoadInst* CreateAtomicLoadAcquire(Value * ptr);
160    virtual llvm::StoreInst *  CreateAtomicStoreRelease(Value * val, Value * ptr); 
161   
162protected:
163    Module *            mMod;
164    unsigned            mCacheLineAlignment;
165    unsigned            mBitBlockWidth;
166    unsigned            mStride;
167    IntegerType *       mSizeType;
168    VectorType *        mBitBlockType;
169
170    Constant *          mZeroInitializer;
171    Constant *          mOneInitializer;
172    Constant *          mPrintRegisterFunction;
173   
174    VectorType * fwVectorType(unsigned fw);
175};
176
177inline LoadInst * IDISA_Builder::CreateBlockAlignedLoad(Value * const ptr) {
178    return CreateAlignedLoad(ptr, mBitBlockWidth / 8);
179}
180
181inline LoadInst * IDISA_Builder::CreateBlockAlignedLoad(Value * const ptr, Value * const index) {
182    return CreateBlockAlignedLoad(CreateGEP(ptr, index));
183}
184
185inline LoadInst * IDISA_Builder::CreateBlockAlignedLoad(Value * const ptr, std::initializer_list<Value *> indicies) {
186    return CreateBlockAlignedLoad(CreateGEP(ptr, indicies));
187}
188
189inline void IDISA_Builder::CreateBlockAlignedStore(Value * const value, Value * const ptr) {
190    CreateAlignedStore(value, ptr, mBitBlockWidth / 8);
191}
192
193inline void IDISA_Builder::CreateBlockAlignedStore(Value * const value, Value * const ptr, Value * const index) {
194    CreateBlockAlignedStore(value, CreateGEP(ptr, index));
195}
196
197inline void IDISA_Builder::CreateBlockAlignedStore(Value * const value, Value * const ptr, std::initializer_list<Value *> indicies) {
198    CreateBlockAlignedStore(value, CreateGEP(ptr, indicies));
199}
200   
201
202   
203}
204#endif // IDISA_BUILDER_H
Note: See TracBrowser for help on using the repository browser.