1 /*========================== begin_copyright_notice ============================
2 
3 Copyright (C) 2018-2021 Intel Corporation
4 
5 SPDX-License-Identifier: MIT
6 
7 ============================= end_copyright_notice ===========================*/
8 
9 #include "PacketBuilder.h"
10 #include <cstdarg>
11 #include "Probe/Assertion.h"
12 
13 namespace pktz
14 {
AssertMemoryUsageParams(Value * ptr,JIT_MEM_CLIENT usage)15     void PacketBuilder::AssertMemoryUsageParams(Value* ptr, JIT_MEM_CLIENT usage)
16     {
17         IGC_ASSERT_MESSAGE(ptr->getType() != mInt64Ty,
18             "Address appears to be GFX access.  Requires translation through BuilderGfxMem.");
19     }
20 
GEP(Value * Ptr,Value * Idx,Type * Ty,const Twine & Name)21     Value* PacketBuilder::GEP(Value* Ptr, Value* Idx, Type* Ty, const Twine& Name)
22     {
23         return IRB()->CreateGEP(Ptr, Idx, Name);
24     }
25 
GEP(Type * Ty,Value * Ptr,Value * Idx,const Twine & Name)26     Value* PacketBuilder::GEP(Type* Ty, Value* Ptr, Value* Idx, const Twine& Name)
27     {
28         return IRB()->CreateGEP(Ty, Ptr, Idx, Name);
29     }
30 
GEP(Value * ptr,const std::initializer_list<Value * > & indexList,Type * Ty)31     Value* PacketBuilder::GEP(Value* ptr, const std::initializer_list<Value*>& indexList, Type* Ty)
32     {
33         std::vector<Value*> indices;
34         for (auto i : indexList)
35             indices.push_back(i);
36         return GEPA(ptr, indices);
37     }
38 
GEP(Value * ptr,const std::initializer_list<uint32_t> & indexList,Type * Ty)39     Value* PacketBuilder::GEP(Value* ptr, const std::initializer_list<uint32_t>& indexList, Type* Ty)
40     {
41         std::vector<Value*> indices;
42         for (auto i : indexList)
43             indices.push_back(C(i));
44         return GEPA(ptr, indices);
45     }
46 
GEPA(Value * Ptr,ArrayRef<Value * > IdxList,const Twine & Name)47     Value* PacketBuilder::GEPA(Value* Ptr, ArrayRef<Value*> IdxList, const Twine& Name)
48     {
49         return IRB()->CreateGEP(Ptr, IdxList, Name);
50     }
51 
GEPA(Type * Ty,Value * Ptr,ArrayRef<Value * > IdxList,const Twine & Name)52     Value* PacketBuilder::GEPA(Type* Ty, Value* Ptr, ArrayRef<Value*> IdxList, const Twine& Name)
53     {
54         return IRB()->CreateGEP(Ty, Ptr, IdxList, Name);
55     }
56 
IN_BOUNDS_GEP(Value * ptr,const std::initializer_list<Value * > & indexList)57     Value* PacketBuilder::IN_BOUNDS_GEP(Value* ptr, const std::initializer_list<Value*>& indexList)
58     {
59         std::vector<Value*> indices;
60         for (auto i : indexList)
61             indices.push_back(i);
62         return IN_BOUNDS_GEP(ptr, indices);
63     }
64 
IN_BOUNDS_GEP(Value * ptr,const std::initializer_list<uint32_t> & indexList)65     Value* PacketBuilder::IN_BOUNDS_GEP(Value* ptr, const std::initializer_list<uint32_t>& indexList)
66     {
67         std::vector<Value*> indices;
68         for (auto i : indexList)
69             indices.push_back(C(i));
70         return IN_BOUNDS_GEP(ptr, indices);
71     }
72 
LOAD(Value * Ptr,const char * Name,Type * Ty,JIT_MEM_CLIENT usage)73     LoadInst* PacketBuilder::LOAD(Value* Ptr, const char* Name, Type* Ty, JIT_MEM_CLIENT usage)
74     {
75         AssertMemoryUsageParams(Ptr, usage);
76         return IRB()->CreateLoad(Ptr, Name);
77     }
78 
LOAD(Value * Ptr,const Twine & Name,Type * Ty,JIT_MEM_CLIENT usage)79     LoadInst* PacketBuilder::LOAD(Value* Ptr, const Twine& Name, Type* Ty, JIT_MEM_CLIENT usage)
80     {
81         AssertMemoryUsageParams(Ptr, usage);
82         return IRB()->CreateLoad(Ptr, Name);
83     }
84 
LOAD(Type * Ty,Value * Ptr,const Twine & Name,JIT_MEM_CLIENT usage)85     LoadInst* PacketBuilder::LOAD(Type* Ty, Value* Ptr, const Twine& Name, JIT_MEM_CLIENT usage)
86     {
87         AssertMemoryUsageParams(Ptr, usage);
88         return IRB()->CreateLoad(Ty, Ptr, Name);
89     }
90 
91     LoadInst*
LOAD(Value * Ptr,bool isVolatile,const Twine & Name,Type * Ty,JIT_MEM_CLIENT usage)92     PacketBuilder::LOAD(Value* Ptr, bool isVolatile, const Twine& Name, Type* Ty, JIT_MEM_CLIENT usage)
93     {
94         AssertMemoryUsageParams(Ptr, usage);
95         return IRB()->CreateLoad(Ptr, isVolatile, Name);
96     }
97 
LOAD(Value * basePtr,const std::initializer_list<uint32_t> & indices,const llvm::Twine & name,Type * Ty,JIT_MEM_CLIENT usage)98     LoadInst* PacketBuilder::LOAD(Value*                                 basePtr,
99                             const std::initializer_list<uint32_t>& indices,
100                             const llvm::Twine&                     name,
101                             Type*                                  Ty,
102                             JIT_MEM_CLIENT                         usage)
103     {
104         std::vector<Value*> valIndices;
105         for (auto i : indices)
106             valIndices.push_back(C(i));
107         return PacketBuilder::LOAD(GEPA(basePtr, valIndices), name);
108     }
109 
LOADV(Value * basePtr,const std::initializer_list<Value * > & indices,const llvm::Twine & name)110     LoadInst* PacketBuilder::LOADV(Value*                               basePtr,
111                              const std::initializer_list<Value*>& indices,
112                              const llvm::Twine&                   name)
113     {
114         std::vector<Value*> valIndices;
115         for (auto i : indices)
116             valIndices.push_back(i);
117         return LOAD(GEPA(basePtr, valIndices), name);
118     }
119 
120     StoreInst*
STORE(Value * val,Value * basePtr,const std::initializer_list<uint32_t> & indices)121     PacketBuilder::STORE(Value* val, Value* basePtr, const std::initializer_list<uint32_t>& indices)
122     {
123         std::vector<Value*> valIndices;
124         for (auto i : indices)
125             valIndices.push_back(C(i));
126         return STORE(val, GEPA(basePtr, valIndices));
127     }
128 
129     StoreInst*
STOREV(Value * val,Value * basePtr,const std::initializer_list<Value * > & indices)130     PacketBuilder::STOREV(Value* val, Value* basePtr, const std::initializer_list<Value*>& indices)
131     {
132         std::vector<Value*> valIndices;
133         for (auto i : indices)
134             valIndices.push_back(i);
135         return STORE(val, GEPA(basePtr, valIndices));
136     }
137 
OFFSET_TO_NEXT_COMPONENT(Value * base,Constant * offset)138     Value* PacketBuilder::OFFSET_TO_NEXT_COMPONENT(Value* base, Constant* offset)
139     {
140         return GEP(base, offset);
141     }
142 
MEM_ADD(Value * i32Incr,Value * basePtr,const std::initializer_list<uint32_t> & indices,const llvm::Twine & name)143     Value* PacketBuilder::MEM_ADD(Value*                                 i32Incr,
144                             Value*                                 basePtr,
145                             const std::initializer_list<uint32_t>& indices,
146                             const llvm::Twine&                     name)
147     {
148         Value* i32Value  = LOAD(GEP(basePtr, indices), name);
149         Value* i32Result = ADD(i32Value, i32Incr);
150         return STORE(i32Result, GEP(basePtr, indices));
151     }
152 
153 }
154