]> git.pld-linux.org Git - packages/beignet.git/blame - beignet-llvm11-support.patch
projects / packages / beignet.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- added dirty llvm11-support patch, now at least builds with llvm 11
[packages/beignet.git] / beignet-llvm11-support.patch
CommitLineData
960d1c98
JB		 1--- Beignet-1.3.2-Source/backend/src/llvm/llvm_includes.hpp.orig 2021-05-16 18:47:43.370592614 +0200
2+++ Beignet-1.3.2-Source/backend/src/llvm/llvm_includes.hpp 2021-05-16 20:13:29.672712703 +0200
3@@ -103,7 +103,11 @@
4
5 #if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 35
6 #include "llvm/IR/Mangler.h"
7+#if LLVM_VERSION_MAJOR >= 11
8+#include "llvm/IR/AbstractCallSite.h"
9+#else
10 #include "llvm/IR/CallSite.h"
11+#endif
12 #include "llvm/IR/CFG.h"
13 #include "llvm/IR/InstVisitor.h"
14 #include "llvm/IR/IRPrintingPasses.h"
15--- Beignet-1.3.2-Source/backend/src/llvm/llvm_sampler_fix.cpp.orig 2021-05-16 20:31:12.343622387 +0200
16+++ Beignet-1.3.2-Source/backend/src/llvm/llvm_sampler_fix.cpp 2021-05-16 20:31:16.373600555 +0200
17@@ -45,8 +45,12 @@
18 bool visitCallInst(CallInst *I) {
19 if(!I)
20 return false;
21+#if LLVM_VERSION_MAJOR >= 11
22+ Value *Callee = I->getCalledOperand();
23+#else
24 Value *Callee = I->getCalledValue();
25- const std::string fnName = Callee->getName();
26+#endif
27+ auto fnName = Callee->getName();
28 bool changed = false;
29 Type *boolTy = IntegerType::get(I->getContext(), 1);
30 Type *i32Ty = IntegerType::get(I->getContext(), 32);
31@@ -59,7 +63,11 @@
32 Value *needFixVal;
33 #if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 40
34 CallInst *init = dyn_cast<CallInst>(I->getOperand(0));
35+#if LLVM_VERSION_MAJOR >= 11
36+ if (init && init->getCalledOperand()->getName().compare("__translate_sampler_initializer"))
37+#else
38 if (init && init->getCalledValue()->getName().compare("__translate_sampler_initializer"))
39+#endif
40 {
41 const ConstantInt *ci = dyn_cast<ConstantInt>(init->getOperand(0));
42 uint32_t samplerInt = ci->getZExtValue();
43@@ -113,7 +121,11 @@
44 Value *needFixVal;
45 #if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 40
46 CallInst *init = dyn_cast<CallInst>(I->getOperand(0));
47+#if LLVM_VERSION_MAJOR >= 11
48+ if (init && init->getCalledOperand()->getName().compare("__translate_sampler_initializer"))
49+#else
50 if (init && init->getCalledValue()->getName().compare("__translate_sampler_initializer"))
51+#endif
52 {
53 const ConstantInt *ci = dyn_cast<ConstantInt>(init->getOperand(0));
54 uint32_t samplerInt = ci->getZExtValue();
55--- Beignet-1.3.2-Source/backend/src/llvm/llvm_bitcode_link.cpp.orig 2021-05-16 18:47:43.370592614 +0200
56+++ Beignet-1.3.2-Source/backend/src/llvm/llvm_bitcode_link.cpp 2021-05-16 20:35:03.445703733 +0200
57@@ -97,8 +97,11 @@
58
59 if (callFunc && callFunc->getIntrinsicID() != 0)
60 continue;
61-
62+#if LLVM_VERSION_MAJOR >= 11
63+ std::string fnName = call->getCalledOperand()->stripPointerCasts()->getName().str();
64+#else
65 std::string fnName = call->getCalledValue()->stripPointerCasts()->getName();
66+#endif
67
68 if (!MFS.insert(fnName).second) {
69 continue;
70--- Beignet-1.3.2-Source/backend/src/llvm/llvm_gen_backend.cpp.orig 2021-05-16 18:47:43.443925550 +0200
71+++ Beignet-1.3.2-Source/backend/src/llvm/llvm_gen_backend.cpp 2021-05-17 16:41:07.490340725 +0200
72@@ -376,7 +376,12 @@
73 GBE_ASSERT(index == 0);
74 return this->_newScalar(value, key, type, index, uniform);
75 break;
76+#if LLVM_VERSION_MAJOR >= 11
77+ case Type::FixedVectorTyID:
78+ case Type::ScalableVectorTyID:
79+#else
80 case Type::VectorTyID:
81+#endif
82 {
83 auto vectorType = cast<VectorType>(type);
84 auto elementType = vectorType->getElementType();
85@@ -743,20 +748,20 @@
86 #undef DECL_VISIT_FN
87
88 // Emit rounding instructions from gen native function
89- void emitRoundingCallInst(CallInst &I, CallSite &CS, ir::Opcode opcode);
90+ void emitRoundingCallInst(CallInst &I, CallBase &CB, ir::Opcode opcode);
91 // Emit unary instructions from gen native function
92- void emitUnaryCallInst(CallInst &I, CallSite &CS, ir::Opcode opcode, ir::Type = ir::TYPE_FLOAT);
93+ void emitUnaryCallInst(CallInst &I, CallBase &CB, ir::Opcode opcode, ir::Type = ir::TYPE_FLOAT);
94 // Emit unary instructions from gen native function
95- void emitAtomicInst(CallInst &I, CallSite &CS, ir::AtomicOps opcode);
96+ void emitAtomicInst(CallInst &I, CallBase &CB, ir::AtomicOps opcode);
97 // Emit workgroup instructions
98- void emitWorkGroupInst(CallInst &I, CallSite &CS, ir::WorkGroupOps opcode);
99+ void emitWorkGroupInst(CallInst &I, CallBase &CB, ir::WorkGroupOps opcode);
100 // Emit subgroup instructions
101- void emitSubGroupInst(CallInst &I, CallSite &CS, ir::WorkGroupOps opcode);
102+ void emitSubGroupInst(CallInst &I, CallBase &CB, ir::WorkGroupOps opcode);
103 // Emit subgroup instructions
104- void emitBlockReadWriteMemInst(CallInst &I, CallSite &CS, bool isWrite, uint8_t vec_size, ir::Type = ir::TYPE_U32);
105- void emitBlockReadWriteImageInst(CallInst &I, CallSite &CS, bool isWrite, uint8_t vec_size, ir::Type = ir::TYPE_U32);
106+ void emitBlockReadWriteMemInst(CallInst &I, CallBase &CB, bool isWrite, uint8_t vec_size, ir::Type = ir::TYPE_U32);
107+ void emitBlockReadWriteImageInst(CallInst &I, CallBase &CB, bool isWrite, uint8_t vec_size, ir::Type = ir::TYPE_U32);
108
109- uint8_t appendSampler(CallSite::arg_iterator AI);
110+ uint8_t appendSampler(User::op_iterator AI);
111 uint8_t getImageID(CallInst &I);
112
113 // These instructions are not supported at all
114@@ -1320,13 +1325,13 @@
115 #endif
116
117 if(typeNameNode) {
118- llvmInfo.typeName= (cast<MDString>(typeNameNode->getOperand(opID)))->getString();
119+ llvmInfo.typeName= (cast<MDString>(typeNameNode->getOperand(opID)))->getString().str();
120 }
121 if(typeBaseNameNode) {
122- llvmInfo.typeBaseName= (cast<MDString>(typeBaseNameNode->getOperand(opID)))->getString();
123+ llvmInfo.typeBaseName= (cast<MDString>(typeBaseNameNode->getOperand(opID)))->getString().str();
124 }
125- llvmInfo.typeName= (cast<MDString>(typeNameNode->getOperand(opID)))->getString();
126- llvmInfo.typeQual = (cast<MDString>(typeQualNode->getOperand(opID)))->getString();
127+ llvmInfo.typeName= (cast<MDString>(typeNameNode->getOperand(opID)))->getString().str();
128+ llvmInfo.typeQual = (cast<MDString>(typeQualNode->getOperand(opID)))->getString().str();
129 bool isImage = llvmInfo.isImageType();
130 bool isPipe = llvmInfo.isPipeType();
131 if (I->getType()->isPointerTy() || isImage || isPipe) {
132@@ -1531,7 +1536,7 @@
133 EltTy = getEltType(EltTy, TypeIndex);
134 }
135
136- ir::Constant cc = unit.getConstantSet().getConstant(pointer->getName());
137+ ir::Constant cc = unit.getConstantSet().getConstant(pointer->getName().str());
138 unsigned int defOffset = cc.getOffset();
139 relocs.push_back(ir::RelocEntry(offset, defOffset + constantOffset));
140
141@@ -1546,7 +1551,7 @@
142 return;
143 }
144 if (isa<GlobalVariable>(c)) {
145- ir::Constant cc = unit.getConstantSet().getConstant(c->getName());
146+ ir::Constant cc = unit.getConstantSet().getConstant(c->getName().str());
147 unsigned int defOffset = cc.getOffset();
148
149 relocs.push_back(ir::RelocEntry(offset, defOffset));
150@@ -1609,7 +1614,12 @@
151 }
152 break;
153 }
154+#if LLVM_VERSION_MAJOR >= 11
155+ case Type::TypeID::FixedVectorTyID:
156+ case Type::TypeID::ScalableVectorTyID:
157+#else
158 case Type::TypeID::VectorTyID:
159+#endif
160 {
161 const ConstantDataSequential *cds = dyn_cast<ConstantDataSequential>(c);
162 const VectorType *vecTy = cast<VectorType>(type);
163@@ -1936,7 +1946,12 @@
164 case Type::PointerTyID:
165 regTranslator.newScalar(value, key, 0, uniform);
166 break;
167+#if LLVM_VERSION_MAJOR >= 11
168+ case Type::TypeID::FixedVectorTyID:
169+ case Type::TypeID::ScalableVectorTyID:
170+#else
171 case Type::VectorTyID:
172+#endif
173 {
174 auto vectorType = cast<VectorType>(type);
175 const uint32_t elemNum = vectorType->getNumElements();
176@@ -2395,7 +2410,7 @@
177 #endif
178 }
179 if(typeNameNode) {
180- llvmInfo.typeName = (cast<MDString>(typeNameNode->getOperand(opID)))->getString();
181+ llvmInfo.typeName = (cast<MDString>(typeNameNode->getOperand(opID)))->getString().str();
182 //LLVM 3.9 image's type name include access qual, don't match OpenCL spec, erase them.
183 std::vector<std::string> filters = {"__read_only ", "__write_only "};
184 for (uint32_t i = 0; i < filters.size(); i++) {
185@@ -2406,16 +2421,16 @@
186 }
187 }
188 if(typeBaseNameNode){
189- llvmInfo.typeBaseName = (cast<MDString>(typeBaseNameNode->getOperand(opID)))->getString();
190+ llvmInfo.typeBaseName = (cast<MDString>(typeBaseNameNode->getOperand(opID)))->getString().str();
191 }
192 if(accessQualNode) {
193- llvmInfo.accessQual = (cast<MDString>(accessQualNode->getOperand(opID)))->getString();
194+ llvmInfo.accessQual = (cast<MDString>(accessQualNode->getOperand(opID)))->getString().str();
195 }
196 if(typeQualNode) {
197- llvmInfo.typeQual = (cast<MDString>(typeQualNode->getOperand(opID)))->getString();
198+ llvmInfo.typeQual = (cast<MDString>(typeQualNode->getOperand(opID)))->getString().str();
199 }
200 if(argNameNode){
201- llvmInfo.argName = (cast<MDString>(argNameNode->getOperand(opID)))->getString();
202+ llvmInfo.argName = (cast<MDString>(argNameNode->getOperand(opID)))->getString().str();
203 }
204
205 // function arguments are uniform values.
206@@ -3010,7 +3025,7 @@
207 } else {
208 this->newRegister(const_cast<GlobalVariable*>(&v));
209 ir::Register reg = regTranslator.getScalar(const_cast<GlobalVariable*>(&v), 0);
210- ir::Constant &con = unit.getConstantSet().getConstant(v.getName());
211+ ir::Constant &con = unit.getConstantSet().getConstant(v.getName().str());
212 if (!legacyMode) {
213 ir::Register regload = ctx.reg(getFamily(getType(ctx, v.getType())));
214 ctx.LOADI(getType(ctx, v.getType()), regload, ctx.newIntegerImmediate(con.getOffset(), getType(ctx, v.getType())));
215@@ -3212,7 +3227,7 @@
216 GBE_ASSERTM(false, "Unsupported calling convention");
217 }
218
219- ctx.startFunction(F.getName());
220+ ctx.startFunction(F.getName().str());
221
222 ir::Function &fn = ctx.getFunction();
223 this->regTranslator.clear();
224@@ -3810,9 +3825,14 @@
225
226 void GenWriter::regAllocateCallInst(CallInst &I) {
227 Value *dst = &I;
228+#if LLVM_VERSION_MAJOR >= 11
229+ Value *Callee = I.getCalledOperand();
230+ GBE_ASSERT(isa<InlineAsm>(I.getCalledOperand()) == false);
231+#else
232 Value *Callee = I.getCalledValue();
233- GBE_ASSERT(ctx.getFunction().getProfile() == ir::PROFILE_OCL);
234 GBE_ASSERT(isa<InlineAsm>(I.getCalledValue()) == false);
235+#endif
236+ GBE_ASSERT(ctx.getFunction().getProfile() == ir::PROFILE_OCL);
237 if(I.getNumArgOperands()) GBE_ASSERT(I.hasStructRetAttr() == false);
238
239 // We only support a small number of intrinsics right now
240@@ -3870,7 +3890,7 @@
241 }
242 }
243 // Get the name of the called function and handle it
244- const std::string fnName = Callee->stripPointerCasts()->getName();
245+ const std::string fnName = Callee->stripPointerCasts()->getName().str();
246 auto genIntrinsicID = intrinsicMap.find(fnName);
247 switch (genIntrinsicID) {
248 case GEN_OCL_GET_GROUP_ID0:
249@@ -4166,7 +4186,7 @@
250 };
251 }
252
253- void GenWriter::emitRoundingCallInst(CallInst &I, CallSite &CS, ir::Opcode opcode) {
254+ void GenWriter::emitRoundingCallInst(CallInst &I, CallBase &CB, ir::Opcode opcode) {
255 if (I.getType()->isHalfTy()) {
256 const ir::Register src = this->getRegister(I.getOperand(0));
257 const ir::Register srcFloat = ctx.reg(ir::FAMILY_DWORD);
258@@ -4177,14 +4197,14 @@
259 ctx.F32TO16(ir::TYPE_U16, ir::TYPE_FLOAT, dst, dstFloat);
260 } else {
261 GBE_ASSERT(I.getType()->isFloatTy());
262- this->emitUnaryCallInst(I,CS,opcode);
263+ this->emitUnaryCallInst(I,CB,opcode);
264 }
265 }
266
267- void GenWriter::emitUnaryCallInst(CallInst &I, CallSite &CS, ir::Opcode opcode, ir::Type type) {
268- CallSite::arg_iterator AI = CS.arg_begin();
269+ void GenWriter::emitUnaryCallInst(CallInst &I, CallBase &CB, ir::Opcode opcode, ir::Type type) {
270+ auto AI = CB.arg_begin();
271 #if GBE_DEBUG
272- CallSite::arg_iterator AE = CS.arg_end();
273+ auto AE = CB.arg_end();
274 #endif /* GBE_DEBUG */
275 GBE_ASSERT(AI != AE);
276 const ir::Register src = this->getRegister(*AI);
277@@ -4293,9 +4313,9 @@
278 this->emitAtomicInstHelper(opcode, type, dst, llvmPtr, payloadTuple);
279 }
280
281- void GenWriter::emitAtomicInst(CallInst &I, CallSite &CS, ir::AtomicOps opcode) {
282- CallSite::arg_iterator AI = CS.arg_begin();
283- CallSite::arg_iterator AE = CS.arg_end();
284+ void GenWriter::emitAtomicInst(CallInst &I, CallBase &CB, ir::AtomicOps opcode) {
285+ auto AI = CB.arg_begin();
286+ auto AE = CB.arg_end();
287 GBE_ASSERT(AI != AE);
288 Value *llvmPtr = *AI;
289 ir::AddressSpace addrSpace = addressSpaceLLVMToGen(llvmPtr->getType()->getPointerAddressSpace());
290@@ -4348,7 +4368,7 @@
291 }
292 }
293
294- void GenWriter::emitWorkGroupInst(CallInst &I, CallSite &CS, ir::WorkGroupOps opcode) {
295+ void GenWriter::emitWorkGroupInst(CallInst &I, CallBase &CB, ir::WorkGroupOps opcode) {
296 ir::Function &f = ctx.getFunction();
297
298 if (f.getwgBroadcastSLM() < 0 && opcode == ir::WORKGROUP_OP_BROADCAST) {
299@@ -4378,8 +4398,8 @@
300 GBE_ASSERT(f.gettidMapSLM() >= 0);
301 }
302
303- CallSite::arg_iterator AI = CS.arg_begin();
304- CallSite::arg_iterator AE = CS.arg_end();
305+ auto AI = CB.arg_begin();
306+ auto AE = CB.arg_end();
307 GBE_ASSERT(AI != AE);
308
309 if (opcode == ir::WORKGROUP_OP_ALL || opcode == ir::WORKGROUP_OP_ANY) {
310@@ -4391,14 +4411,14 @@
311 const ir::Tuple srcTuple = ctx.arrayTuple(&src[0], 3);
312 ctx.WORKGROUP(opcode, (uint32_t)f.gettidMapSLM(), getRegister(&I), srcTuple, 3, ir::TYPE_S32);
313 } else if (opcode == ir::WORKGROUP_OP_BROADCAST) {
314- int argNum = CS.arg_size();
315+ int argNum = CB.arg_size();
316 std::vector<ir::Register> src(argNum);
317 for (int i = 0; i < argNum; i++) {
318 src[i] = this->getRegister(*(AI++));
319 }
320 const ir::Tuple srcTuple = ctx.arrayTuple(&src[0], argNum);
321 ctx.WORKGROUP(ir::WORKGROUP_OP_BROADCAST, (uint32_t)f.getwgBroadcastSLM(), getRegister(&I), srcTuple, argNum,
322- getType(ctx, (*CS.arg_begin())->getType()));
323+ getType(ctx, (*CB.arg_begin())->getType()));
324 } else {
325 ConstantInt *sign = dyn_cast<ConstantInt>(AI);
326 GBE_ASSERT(sign);
327@@ -4423,9 +4443,9 @@
328 GBE_ASSERT(AI == AE);
329 }
330
331- void GenWriter::emitSubGroupInst(CallInst &I, CallSite &CS, ir::WorkGroupOps opcode) {
332- CallSite::arg_iterator AI = CS.arg_begin();
333- CallSite::arg_iterator AE = CS.arg_end();
334+ void GenWriter::emitSubGroupInst(CallInst &I, CallBase &CB, ir::WorkGroupOps opcode) {
335+ auto AI = CB.arg_begin();
336+ auto AE = CB.arg_end();
337 GBE_ASSERT(AI != AE);
338
339 if (opcode == ir::WORKGROUP_OP_ALL || opcode == ir::WORKGROUP_OP_ANY) {
340@@ -4435,7 +4455,7 @@
341 const ir::Tuple srcTuple = ctx.arrayTuple(&src[0], 1);
342 ctx.SUBGROUP(opcode, getRegister(&I), srcTuple, 1, ir::TYPE_S32);
343 } else if (opcode == ir::WORKGROUP_OP_BROADCAST) {
344- int argNum = CS.arg_size();
345+ int argNum = CB.arg_size();
346 GBE_ASSERT(argNum == 2);
347 std::vector<ir::Register> src(argNum);
348 for (int i = 0; i < argNum; i++) {
349@@ -4443,7 +4463,7 @@
350 }
351 const ir::Tuple srcTuple = ctx.arrayTuple(&src[0], argNum);
352 ctx.SUBGROUP(ir::WORKGROUP_OP_BROADCAST, getRegister(&I), srcTuple, argNum,
353- getType(ctx, (*CS.arg_begin())->getType()));
354+ getType(ctx, (*CB.arg_begin())->getType()));
355 } else {
356 ConstantInt *sign = dyn_cast<ConstantInt>(AI);
357 GBE_ASSERT(sign);
358@@ -4466,9 +4486,9 @@
359 GBE_ASSERT(AI == AE);
360 }
361
362- void GenWriter::emitBlockReadWriteMemInst(CallInst &I, CallSite &CS, bool isWrite, uint8_t vec_size, ir::Type type) {
363- CallSite::arg_iterator AI = CS.arg_begin();
364- CallSite::arg_iterator AE = CS.arg_end();
365+ void GenWriter::emitBlockReadWriteMemInst(CallInst &I, CallBase &CB, bool isWrite, uint8_t vec_size, ir::Type type) {
366+ auto AI = CB.arg_begin();
367+ auto AE = CB.arg_end();
368 GBE_ASSERT(AI != AE);
369
370 Value *llvmPtr = *(AI++);
371@@ -4522,9 +4542,9 @@
372 GBE_ASSERT(AI == AE);
373 }
374
375- void GenWriter::emitBlockReadWriteImageInst(CallInst &I, CallSite &CS, bool isWrite, uint8_t vec_size, ir::Type type) {
376- CallSite::arg_iterator AI = CS.arg_begin();
377- CallSite::arg_iterator AE = CS.arg_end();
378+ void GenWriter::emitBlockReadWriteImageInst(CallInst &I, CallBase &CB, bool isWrite, uint8_t vec_size, ir::Type type) {
379+ auto AI = CB.arg_begin();
380+ auto AE = CB.arg_end();
381 GBE_ASSERT(AI != AE);
382
383 const uint8_t imageID = getImageID(I);
384@@ -4557,7 +4577,7 @@
385
386 /* append a new sampler. should be called before any reference to
387 * a sampler_t value. */
388- uint8_t GenWriter::appendSampler(CallSite::arg_iterator AI) {
389+ uint8_t GenWriter::appendSampler(User::op_iterator AI) {
390 #if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 40
391 CallInst *TC = dyn_cast<CallInst>(*AI);
392 Constant *CPV = TC ? dyn_cast<Constant>(TC->getOperand(0)) : NULL;
393@@ -4595,10 +4615,10 @@
394 const ir::Function &fn = ctx.getFunction();
395
396 // Get the function arguments
397- CallSite CS(&I);
398- CallSite::arg_iterator AI = CS.arg_begin();
399+ CallBase &CB(I);
400+ auto AI = CB.arg_begin();
401 #if GBE_DEBUG
402- CallSite::arg_iterator AE = CS.arg_end();
403+ auto AE = CB.arg_end();
404 #endif /* GBE_DEBUG */
405 switch (F->getIntrinsicID()) {
406 case Intrinsic::stacksave:
407@@ -4764,17 +4784,17 @@
408 ctx.MAD(srcType, dst, src0, src1, src2);
409 }
410 break;
411- case Intrinsic::sqrt: this->emitUnaryCallInst(I,CS,ir::OP_SQR); break;
412- case Intrinsic::ceil: this->emitRoundingCallInst(I,CS,ir::OP_RNDU); break;
413- case Intrinsic::trunc: this->emitRoundingCallInst(I,CS,ir::OP_RNDZ); break;
414- case Intrinsic::rint: this->emitRoundingCallInst(I,CS,ir::OP_RNDE); break;
415- case Intrinsic::floor: this->emitRoundingCallInst(I,CS,ir::OP_RNDD); break;
416- case Intrinsic::sin: this->emitUnaryCallInst(I,CS,ir::OP_SIN); break;
417- case Intrinsic::cos: this->emitUnaryCallInst(I,CS,ir::OP_COS); break;
418- case Intrinsic::log2: this->emitUnaryCallInst(I,CS,ir::OP_LOG); break;
419- case Intrinsic::exp2: this->emitUnaryCallInst(I,CS,ir::OP_EXP); break;
420+ case Intrinsic::sqrt: this->emitUnaryCallInst(I,CB,ir::OP_SQR); break;
421+ case Intrinsic::ceil: this->emitRoundingCallInst(I,CB,ir::OP_RNDU); break;
422+ case Intrinsic::trunc: this->emitRoundingCallInst(I,CB,ir::OP_RNDZ); break;
423+ case Intrinsic::rint: this->emitRoundingCallInst(I,CB,ir::OP_RNDE); break;
424+ case Intrinsic::floor: this->emitRoundingCallInst(I,CB,ir::OP_RNDD); break;
425+ case Intrinsic::sin: this->emitUnaryCallInst(I,CB,ir::OP_SIN); break;
426+ case Intrinsic::cos: this->emitUnaryCallInst(I,CB,ir::OP_COS); break;
427+ case Intrinsic::log2: this->emitUnaryCallInst(I,CB,ir::OP_LOG); break;
428+ case Intrinsic::exp2: this->emitUnaryCallInst(I,CB,ir::OP_EXP); break;
429 case Intrinsic::bswap:
430- this->emitUnaryCallInst(I,CS,ir::OP_BSWAP, getUnsignedType(ctx, I.getType())); break;
431+ this->emitUnaryCallInst(I,CB,ir::OP_BSWAP, getUnsignedType(ctx, I.getType())); break;
432 case Intrinsic::pow:
433 {
434 const ir::Register src0 = this->getRegister(*AI); ++AI;
435@@ -4794,21 +4814,26 @@
436 }
437 } else {
438 // Get the name of the called function and handle it
439+#if LLVM_VERSION_MAJOR >= 11
440+ Value *Callee = I.getCalledOperand();
441+ const std::string fnName = Callee->stripPointerCasts()->getName().str();
442+#else
443 Value *Callee = I.getCalledValue();
444 const std::string fnName = Callee->stripPointerCasts()->getName();
445+#endif
446 auto genIntrinsicID = intrinsicMap.find(fnName);
447
448 // Get the function arguments
449- CallSite CS(&I);
450- CallSite::arg_iterator AI = CS.arg_begin();
451+ CallBase &CB(I);
452+ auto AI = CB.arg_begin();
453 #if GBE_DEBUG
454- CallSite::arg_iterator AE = CS.arg_end();
455+ auto AE = CB.arg_end();
456 #endif /* GBE_DEBUG */
457
458 switch (genIntrinsicID) {
459- case GEN_OCL_FBH: this->emitUnaryCallInst(I,CS,ir::OP_FBH, ir::TYPE_U32); break;
460- case GEN_OCL_FBL: this->emitUnaryCallInst(I,CS,ir::OP_FBL, ir::TYPE_U32); break;
461- case GEN_OCL_CBIT: this->emitUnaryCallInst(I,CS,ir::OP_CBIT, getUnsignedType(ctx, (*AI)->getType())); break;
462+ case GEN_OCL_FBH: this->emitUnaryCallInst(I,CB,ir::OP_FBH, ir::TYPE_U32); break;
463+ case GEN_OCL_FBL: this->emitUnaryCallInst(I,CB,ir::OP_FBL, ir::TYPE_U32); break;
464+ case GEN_OCL_CBIT: this->emitUnaryCallInst(I,CB,ir::OP_CBIT, getUnsignedType(ctx, (*AI)->getType())); break;
465 case GEN_OCL_ABS:
466 {
467 const ir::Register src = this->getRegister(*AI);
468@@ -4915,8 +4940,8 @@
469 ctx.REGION(dst, src, x.getIntegerValue());
470 break;
471 }
472- case GEN_OCL_RSQ: this->emitUnaryCallInst(I,CS,ir::OP_RSQ); break;
473- case GEN_OCL_RCP: this->emitUnaryCallInst(I,CS,ir::OP_RCP); break;
474+ case GEN_OCL_RSQ: this->emitUnaryCallInst(I,CB,ir::OP_RSQ); break;
475+ case GEN_OCL_RCP: this->emitUnaryCallInst(I,CB,ir::OP_RCP); break;
476 case GEN_OCL_FORCE_SIMD8: ctx.setSimdWidth(8); break;
477 case GEN_OCL_FORCE_SIMD16: ctx.setSimdWidth(16); break;
478 case GEN_OCL_LBARRIER: ctx.SYNC(ir::syncLocalBarrier); break;
479@@ -4947,31 +4972,31 @@
480 break;
481 }
482 case GEN_OCL_ATOMIC_ADD0:
483- case GEN_OCL_ATOMIC_ADD1: this->emitAtomicInst(I,CS,ir::ATOMIC_OP_ADD); break;
484+ case GEN_OCL_ATOMIC_ADD1: this->emitAtomicInst(I,CB,ir::ATOMIC_OP_ADD); break;
485 case GEN_OCL_ATOMIC_SUB0:
486- case GEN_OCL_ATOMIC_SUB1: this->emitAtomicInst(I,CS,ir::ATOMIC_OP_SUB); break;
487+ case GEN_OCL_ATOMIC_SUB1: this->emitAtomicInst(I,CB,ir::ATOMIC_OP_SUB); break;
488 case GEN_OCL_ATOMIC_AND0:
489- case GEN_OCL_ATOMIC_AND1: this->emitAtomicInst(I,CS,ir::ATOMIC_OP_AND); break;
490+ case GEN_OCL_ATOMIC_AND1: this->emitAtomicInst(I,CB,ir::ATOMIC_OP_AND); break;
491 case GEN_OCL_ATOMIC_OR0:
492- case GEN_OCL_ATOMIC_OR1: this->emitAtomicInst(I,CS,ir::ATOMIC_OP_OR); break;
493+ case GEN_OCL_ATOMIC_OR1: this->emitAtomicInst(I,CB,ir::ATOMIC_OP_OR); break;
494 case GEN_OCL_ATOMIC_XOR0:
495- case GEN_OCL_ATOMIC_XOR1: this->emitAtomicInst(I,CS,ir::ATOMIC_OP_XOR); break;
496+ case GEN_OCL_ATOMIC_XOR1: this->emitAtomicInst(I,CB,ir::ATOMIC_OP_XOR); break;
497 case GEN_OCL_ATOMIC_XCHG0:
498- case GEN_OCL_ATOMIC_XCHG1: this->emitAtomicInst(I,CS,ir::ATOMIC_OP_XCHG); break;
499+ case GEN_OCL_ATOMIC_XCHG1: this->emitAtomicInst(I,CB,ir::ATOMIC_OP_XCHG); break;
500 case GEN_OCL_ATOMIC_INC0:
501- case GEN_OCL_ATOMIC_INC1: this->emitAtomicInst(I,CS,ir::ATOMIC_OP_INC); break;
502+ case GEN_OCL_ATOMIC_INC1: this->emitAtomicInst(I,CB,ir::ATOMIC_OP_INC); break;
503 case GEN_OCL_ATOMIC_DEC0:
504- case GEN_OCL_ATOMIC_DEC1: this->emitAtomicInst(I,CS,ir::ATOMIC_OP_DEC); break;
505+ case GEN_OCL_ATOMIC_DEC1: this->emitAtomicInst(I,CB,ir::ATOMIC_OP_DEC); break;
506 case GEN_OCL_ATOMIC_UMIN0:
507- case GEN_OCL_ATOMIC_UMIN1: this->emitAtomicInst(I,CS,ir::ATOMIC_OP_UMIN); break;
508+ case GEN_OCL_ATOMIC_UMIN1: this->emitAtomicInst(I,CB,ir::ATOMIC_OP_UMIN); break;
509 case GEN_OCL_ATOMIC_UMAX0:
510- case GEN_OCL_ATOMIC_UMAX1: this->emitAtomicInst(I,CS,ir::ATOMIC_OP_UMAX); break;
511+ case GEN_OCL_ATOMIC_UMAX1: this->emitAtomicInst(I,CB,ir::ATOMIC_OP_UMAX); break;
512 case GEN_OCL_ATOMIC_IMIN0:
513- case GEN_OCL_ATOMIC_IMIN1: this->emitAtomicInst(I,CS,ir::ATOMIC_OP_IMIN); break;
514+ case GEN_OCL_ATOMIC_IMIN1: this->emitAtomicInst(I,CB,ir::ATOMIC_OP_IMIN); break;
515 case GEN_OCL_ATOMIC_IMAX0:
516- case GEN_OCL_ATOMIC_IMAX1: this->emitAtomicInst(I,CS,ir::ATOMIC_OP_IMAX); break;
517+ case GEN_OCL_ATOMIC_IMAX1: this->emitAtomicInst(I,CB,ir::ATOMIC_OP_IMAX); break;
518 case GEN_OCL_ATOMIC_CMPXCHG0:
519- case GEN_OCL_ATOMIC_CMPXCHG1: this->emitAtomicInst(I,CS,ir::ATOMIC_OP_CMPXCHG); break;
520+ case GEN_OCL_ATOMIC_CMPXCHG1: this->emitAtomicInst(I,CB,ir::ATOMIC_OP_CMPXCHG); break;
521 case GEN_OCL_GET_IMAGE_WIDTH:
522 case GEN_OCL_GET_IMAGE_HEIGHT:
523 case GEN_OCL_GET_IMAGE_DEPTH:
524@@ -5429,48 +5454,48 @@
525 ctx.WAIT();
526 break;
527 }
528- case GEN_OCL_WORK_GROUP_ALL: this->emitWorkGroupInst(I, CS, ir::WORKGROUP_OP_ALL); break;
529- case GEN_OCL_WORK_GROUP_ANY: this->emitWorkGroupInst(I, CS, ir::WORKGROUP_OP_ANY); break;
530+ case GEN_OCL_WORK_GROUP_ALL: this->emitWorkGroupInst(I, CB, ir::WORKGROUP_OP_ALL); break;
531+ case GEN_OCL_WORK_GROUP_ANY: this->emitWorkGroupInst(I, CB, ir::WORKGROUP_OP_ANY); break;
532 case GEN_OCL_WORK_GROUP_BROADCAST:
533- this->emitWorkGroupInst(I, CS, ir::WORKGROUP_OP_BROADCAST); break;
534+ this->emitWorkGroupInst(I, CB, ir::WORKGROUP_OP_BROADCAST); break;
535 case GEN_OCL_WORK_GROUP_REDUCE_ADD:
536- this->emitWorkGroupInst(I, CS, ir::WORKGROUP_OP_REDUCE_ADD); break;
537+ this->emitWorkGroupInst(I, CB, ir::WORKGROUP_OP_REDUCE_ADD); break;
538 case GEN_OCL_WORK_GROUP_REDUCE_MAX:
539- this->emitWorkGroupInst(I, CS, ir::WORKGROUP_OP_REDUCE_MAX); break;
540+ this->emitWorkGroupInst(I, CB, ir::WORKGROUP_OP_REDUCE_MAX); break;
541 case GEN_OCL_WORK_GROUP_REDUCE_MIN:
542- this->emitWorkGroupInst(I, CS, ir::WORKGROUP_OP_REDUCE_MIN); break;
543+ this->emitWorkGroupInst(I, CB, ir::WORKGROUP_OP_REDUCE_MIN); break;
544 case GEN_OCL_WORK_GROUP_SCAN_EXCLUSIVE_ADD:
545- this->emitWorkGroupInst(I, CS, ir::WORKGROUP_OP_EXCLUSIVE_ADD); break;
546+ this->emitWorkGroupInst(I, CB, ir::WORKGROUP_OP_EXCLUSIVE_ADD); break;
547 case GEN_OCL_WORK_GROUP_SCAN_EXCLUSIVE_MAX:
548- this->emitWorkGroupInst(I, CS, ir::WORKGROUP_OP_EXCLUSIVE_MAX); break;
549+ this->emitWorkGroupInst(I, CB, ir::WORKGROUP_OP_EXCLUSIVE_MAX); break;
550 case GEN_OCL_WORK_GROUP_SCAN_EXCLUSIVE_MIN:
551- this->emitWorkGroupInst(I, CS, ir::WORKGROUP_OP_EXCLUSIVE_MIN); break;
552+ this->emitWorkGroupInst(I, CB, ir::WORKGROUP_OP_EXCLUSIVE_MIN); break;
553 case GEN_OCL_WORK_GROUP_SCAN_INCLUSIVE_ADD:
554- this->emitWorkGroupInst(I, CS, ir::WORKGROUP_OP_INCLUSIVE_ADD); break;
555+ this->emitWorkGroupInst(I, CB, ir::WORKGROUP_OP_INCLUSIVE_ADD); break;
556 case GEN_OCL_WORK_GROUP_SCAN_INCLUSIVE_MAX:
557- this->emitWorkGroupInst(I, CS, ir::WORKGROUP_OP_INCLUSIVE_MAX); break;
558+ this->emitWorkGroupInst(I, CB, ir::WORKGROUP_OP_INCLUSIVE_MAX); break;
559 case GEN_OCL_WORK_GROUP_SCAN_INCLUSIVE_MIN:
560- this->emitWorkGroupInst(I, CS, ir::WORKGROUP_OP_INCLUSIVE_MIN); break;
561+ this->emitWorkGroupInst(I, CB, ir::WORKGROUP_OP_INCLUSIVE_MIN); break;
562 case GEN_OCL_SUB_GROUP_BROADCAST:
563- this->emitSubGroupInst(I, CS, ir::WORKGROUP_OP_BROADCAST); break;
564+ this->emitSubGroupInst(I, CB, ir::WORKGROUP_OP_BROADCAST); break;
565 case GEN_OCL_SUB_GROUP_REDUCE_ADD:
566- this->emitSubGroupInst(I, CS, ir::WORKGROUP_OP_REDUCE_ADD); break;
567+ this->emitSubGroupInst(I, CB, ir::WORKGROUP_OP_REDUCE_ADD); break;
568 case GEN_OCL_SUB_GROUP_REDUCE_MAX:
569- this->emitSubGroupInst(I, CS, ir::WORKGROUP_OP_REDUCE_MAX); break;
570+ this->emitSubGroupInst(I, CB, ir::WORKGROUP_OP_REDUCE_MAX); break;
571 case GEN_OCL_SUB_GROUP_REDUCE_MIN:
572- this->emitSubGroupInst(I, CS, ir::WORKGROUP_OP_REDUCE_MIN); break;
573+ this->emitSubGroupInst(I, CB, ir::WORKGROUP_OP_REDUCE_MIN); break;
574 case GEN_OCL_SUB_GROUP_SCAN_EXCLUSIVE_ADD:
575- this->emitSubGroupInst(I, CS, ir::WORKGROUP_OP_EXCLUSIVE_ADD); break;
576+ this->emitSubGroupInst(I, CB, ir::WORKGROUP_OP_EXCLUSIVE_ADD); break;
577 case GEN_OCL_SUB_GROUP_SCAN_EXCLUSIVE_MAX:
578- this->emitSubGroupInst(I, CS, ir::WORKGROUP_OP_EXCLUSIVE_MAX); break;
579+ this->emitSubGroupInst(I, CB, ir::WORKGROUP_OP_EXCLUSIVE_MAX); break;
580 case GEN_OCL_SUB_GROUP_SCAN_EXCLUSIVE_MIN:
581- this->emitSubGroupInst(I, CS, ir::WORKGROUP_OP_EXCLUSIVE_MIN); break;
582+ this->emitSubGroupInst(I, CB, ir::WORKGROUP_OP_EXCLUSIVE_MIN); break;
583 case GEN_OCL_SUB_GROUP_SCAN_INCLUSIVE_ADD:
584- this->emitSubGroupInst(I, CS, ir::WORKGROUP_OP_INCLUSIVE_ADD); break;
585+ this->emitSubGroupInst(I, CB, ir::WORKGROUP_OP_INCLUSIVE_ADD); break;
586 case GEN_OCL_SUB_GROUP_SCAN_INCLUSIVE_MAX:
587- this->emitSubGroupInst(I, CS, ir::WORKGROUP_OP_INCLUSIVE_MAX); break;
588+ this->emitSubGroupInst(I, CB, ir::WORKGROUP_OP_INCLUSIVE_MAX); break;
589 case GEN_OCL_SUB_GROUP_SCAN_INCLUSIVE_MIN:
590- this->emitSubGroupInst(I, CS, ir::WORKGROUP_OP_INCLUSIVE_MIN); break;
591+ this->emitSubGroupInst(I, CB, ir::WORKGROUP_OP_INCLUSIVE_MIN); break;
592 case GEN_OCL_LRP:
593 {
594 const ir::Register dst = this->getRegister(&I);
595@@ -5484,69 +5509,69 @@
596 break;
597 }
598 case GEN_OCL_SUB_GROUP_BLOCK_READ_UI_MEM:
599- this->emitBlockReadWriteMemInst(I, CS, false, 1); break;
600+ this->emitBlockReadWriteMemInst(I, CB, false, 1); break;
601 case GEN_OCL_SUB_GROUP_BLOCK_READ_UI_MEM2:
602- this->emitBlockReadWriteMemInst(I, CS, false, 2); break;
603+ this->emitBlockReadWriteMemInst(I, CB, false, 2); break;
604 case GEN_OCL_SUB_GROUP_BLOCK_READ_UI_MEM4:
605- this->emitBlockReadWriteMemInst(I, CS, false, 4); break;
606+ this->emitBlockReadWriteMemInst(I, CB, false, 4); break;
607 case GEN_OCL_SUB_GROUP_BLOCK_READ_UI_MEM8:
608- this->emitBlockReadWriteMemInst(I, CS, false, 8); break;
609+ this->emitBlockReadWriteMemInst(I, CB, false, 8); break;
610 case GEN_OCL_SUB_GROUP_BLOCK_WRITE_UI_MEM:
611- this->emitBlockReadWriteMemInst(I, CS, true, 1); break;
612+ this->emitBlockReadWriteMemInst(I, CB, true, 1); break;
613 case GEN_OCL_SUB_GROUP_BLOCK_WRITE_UI_MEM2:
614- this->emitBlockReadWriteMemInst(I, CS, true, 2); break;
615+ this->emitBlockReadWriteMemInst(I, CB, true, 2); break;
616 case GEN_OCL_SUB_GROUP_BLOCK_WRITE_UI_MEM4:
617- this->emitBlockReadWriteMemInst(I, CS, true, 4); break;
618+ this->emitBlockReadWriteMemInst(I, CB, true, 4); break;
619 case GEN_OCL_SUB_GROUP_BLOCK_WRITE_UI_MEM8:
620- this->emitBlockReadWriteMemInst(I, CS, true, 8); break;
621+ this->emitBlockReadWriteMemInst(I, CB, true, 8); break;
622 case GEN_OCL_SUB_GROUP_BLOCK_READ_UI_IMAGE:
623- this->emitBlockReadWriteImageInst(I, CS, false, 1); break;
624+ this->emitBlockReadWriteImageInst(I, CB, false, 1); break;
625 case GEN_OCL_SUB_GROUP_BLOCK_READ_UI_IMAGE2:
626- this->emitBlockReadWriteImageInst(I, CS, false, 2); break;
627+ this->emitBlockReadWriteImageInst(I, CB, false, 2); break;
628 case GEN_OCL_SUB_GROUP_BLOCK_READ_UI_IMAGE4:
629- this->emitBlockReadWriteImageInst(I, CS, false, 4); break;
630+ this->emitBlockReadWriteImageInst(I, CB, false, 4); break;
631 case GEN_OCL_SUB_GROUP_BLOCK_READ_UI_IMAGE8:
632- this->emitBlockReadWriteImageInst(I, CS, false, 8); break;
633+ this->emitBlockReadWriteImageInst(I, CB, false, 8); break;
634 case GEN_OCL_SUB_GROUP_BLOCK_WRITE_UI_IMAGE:
635- this->emitBlockReadWriteImageInst(I, CS, true, 1); break;
636+ this->emitBlockReadWriteImageInst(I, CB, true, 1); break;
637 case GEN_OCL_SUB_GROUP_BLOCK_WRITE_UI_IMAGE2:
638- this->emitBlockReadWriteImageInst(I, CS, true, 2); break;
639+ this->emitBlockReadWriteImageInst(I, CB, true, 2); break;
640 case GEN_OCL_SUB_GROUP_BLOCK_WRITE_UI_IMAGE4:
641- this->emitBlockReadWriteImageInst(I, CS, true, 4); break;
642+ this->emitBlockReadWriteImageInst(I, CB, true, 4); break;
643 case GEN_OCL_SUB_GROUP_BLOCK_WRITE_UI_IMAGE8:
644- this->emitBlockReadWriteImageInst(I, CS, true, 8); break;
645+ this->emitBlockReadWriteImageInst(I, CB, true, 8); break;
646 case GEN_OCL_SUB_GROUP_BLOCK_READ_US_MEM:
647- this->emitBlockReadWriteMemInst(I, CS, false, 1, ir::TYPE_U16); break;
648+ this->emitBlockReadWriteMemInst(I, CB, false, 1, ir::TYPE_U16); break;
649 case GEN_OCL_SUB_GROUP_BLOCK_READ_US_MEM2:
650- this->emitBlockReadWriteMemInst(I, CS, false, 2, ir::TYPE_U16); break;
651+ this->emitBlockReadWriteMemInst(I, CB, false, 2, ir::TYPE_U16); break;
652 case GEN_OCL_SUB_GROUP_BLOCK_READ_US_MEM4:
653- this->emitBlockReadWriteMemInst(I, CS, false, 4, ir::TYPE_U16); break;
654+ this->emitBlockReadWriteMemInst(I, CB, false, 4, ir::TYPE_U16); break;
655 case GEN_OCL_SUB_GROUP_BLOCK_READ_US_MEM8:
656- this->emitBlockReadWriteMemInst(I, CS, false, 8, ir::TYPE_U16); break;
657+ this->emitBlockReadWriteMemInst(I, CB, false, 8, ir::TYPE_U16); break;
658 case GEN_OCL_SUB_GROUP_BLOCK_WRITE_US_MEM:
659- this->emitBlockReadWriteMemInst(I, CS, true, 1, ir::TYPE_U16); break;
660+ this->emitBlockReadWriteMemInst(I, CB, true, 1, ir::TYPE_U16); break;
661 case GEN_OCL_SUB_GROUP_BLOCK_WRITE_US_MEM2:
662- this->emitBlockReadWriteMemInst(I, CS, true, 2, ir::TYPE_U16); break;
663+ this->emitBlockReadWriteMemInst(I, CB, true, 2, ir::TYPE_U16); break;
664 case GEN_OCL_SUB_GROUP_BLOCK_WRITE_US_MEM4:
665- this->emitBlockReadWriteMemInst(I, CS, true, 4, ir::TYPE_U16); break;
666+ this->emitBlockReadWriteMemInst(I, CB, true, 4, ir::TYPE_U16); break;
667 case GEN_OCL_SUB_GROUP_BLOCK_WRITE_US_MEM8:
668- this->emitBlockReadWriteMemInst(I, CS, true, 8, ir::TYPE_U16); break;
669+ this->emitBlockReadWriteMemInst(I, CB, true, 8, ir::TYPE_U16); break;
670 case GEN_OCL_SUB_GROUP_BLOCK_READ_US_IMAGE:
671- this->emitBlockReadWriteImageInst(I, CS, false, 1, ir::TYPE_U16); break;
672+ this->emitBlockReadWriteImageInst(I, CB, false, 1, ir::TYPE_U16); break;
673 case GEN_OCL_SUB_GROUP_BLOCK_READ_US_IMAGE2:
674- this->emitBlockReadWriteImageInst(I, CS, false, 2, ir::TYPE_U16); break;
675+ this->emitBlockReadWriteImageInst(I, CB, false, 2, ir::TYPE_U16); break;
676 case GEN_OCL_SUB_GROUP_BLOCK_READ_US_IMAGE4:
677- this->emitBlockReadWriteImageInst(I, CS, false, 4, ir::TYPE_U16); break;
678+ this->emitBlockReadWriteImageInst(I, CB, false, 4, ir::TYPE_U16); break;
679 case GEN_OCL_SUB_GROUP_BLOCK_READ_US_IMAGE8:
680- this->emitBlockReadWriteImageInst(I, CS, false, 8, ir::TYPE_U16); break;
681+ this->emitBlockReadWriteImageInst(I, CB, false, 8, ir::TYPE_U16); break;
682 case GEN_OCL_SUB_GROUP_BLOCK_WRITE_US_IMAGE:
683- this->emitBlockReadWriteImageInst(I, CS, true, 1, ir::TYPE_U16); break;
684+ this->emitBlockReadWriteImageInst(I, CB, true, 1, ir::TYPE_U16); break;
685 case GEN_OCL_SUB_GROUP_BLOCK_WRITE_US_IMAGE2:
686- this->emitBlockReadWriteImageInst(I, CS, true, 2, ir::TYPE_U16); break;
687+ this->emitBlockReadWriteImageInst(I, CB, true, 2, ir::TYPE_U16); break;
688 case GEN_OCL_SUB_GROUP_BLOCK_WRITE_US_IMAGE4:
689- this->emitBlockReadWriteImageInst(I, CS, true, 4, ir::TYPE_U16); break;
690+ this->emitBlockReadWriteImageInst(I, CB, true, 4, ir::TYPE_U16); break;
691 case GEN_OCL_SUB_GROUP_BLOCK_WRITE_US_IMAGE8:
692- this->emitBlockReadWriteImageInst(I, CS, true, 8, ir::TYPE_U16); break;
693+ this->emitBlockReadWriteImageInst(I, CB, true, 8, ir::TYPE_U16); break;
694 case GEN_OCL_GET_PIPE:
695 case GEN_OCL_MAKE_RID:
696 case GEN_OCL_GET_RID:
697--- Beignet-1.3.2-Source/backend/src/llvm/llvm_passes.cpp.orig 2021-05-16 18:47:43.440592235 +0200
698+++ Beignet-1.3.2-Source/backend/src/llvm/llvm_passes.cpp 2021-05-17 17:21:48.197118282 +0200
699@@ -94,7 +94,12 @@
700 {
701 switch (Ty->getTypeID()) {
702 case Type::VoidTyID: NOT_SUPPORTED;
703+#if LLVM_VERSION_MAJOR >= 11
704+ case Type::FixedVectorTyID:
705+ case Type::ScalableVectorTyID:
706+#else
707 case Type::VectorTyID:
708+#endif
709 {
710 const VectorType* VecTy = cast<VectorType>(Ty);
711 uint32_t elemNum = VecTy->getNumElements();
712@@ -138,7 +143,12 @@
713 case Type::HalfTyID: return 16;
714 case Type::FloatTyID: return 32;
715 case Type::DoubleTyID: return 64;
716+#if LLVM_VERSION_MAJOR >= 11
717+ case Type::FixedVectorTyID:
718+ case Type::ScalableVectorTyID:
719+#else
720 case Type::VectorTyID:
721+#endif
722 {
723 const VectorType* VecTy = cast<VectorType>(Ty);
724 uint32_t numElem = VecTy->getNumElements();
725@@ -184,10 +194,19 @@
726 Type *elementType = NULL;
727 if (PointerType* ptrType = dyn_cast<PointerType>(eltTy))
728 elementType = ptrType->getElementType();
729+#if LLVM_VERSION_MAJOR >= 11
730+ else if(ArrayType * arrType = dyn_cast<ArrayType>(eltTy))
731+ elementType = arrType->getElementType();
732+ else if(VectorType * vecType = dyn_cast<VectorType>(eltTy))
733+ elementType = vecType->getElementType();
734+ else if(StructType *strType = dyn_cast<StructType>(eltTy))
735+ elementType = strType->getElementType(index);
736+#else
737 else if(SequentialType * seqType = dyn_cast<SequentialType>(eltTy))
738 elementType = seqType->getElementType();
739 else if(CompositeType * compTy= dyn_cast<CompositeType>(eltTy))
740 elementType = compTy->getTypeAtIndex(index);
741+#endif
742 GBE_ASSERT(elementType);
743 return elementType;
744 }
745--- Beignet-1.3.2-Source/backend/src/llvm/llvm_scalarize.cpp.orig 2021-05-16 18:47:43.443925550 +0200
746+++ Beignet-1.3.2-Source/backend/src/llvm/llvm_scalarize.cpp 2021-05-18 18:27:01.084518052 +0200
747@@ -178,7 +178,12 @@
748 if(!type)
749 return type;
750 switch(type->getTypeID()) {
751+#if LLVM_VERSION_MAJOR >= 11
752+ case Type::FixedVectorTyID:
753+ case Type::ScalableVectorTyID:
754+#else
755 case Type::VectorTyID:
756+#endif
757 case Type::ArrayTyID:
758 return GetBasicType(type->getContainedType(0));
759 default:
760@@ -188,8 +193,13 @@
761 }
762
763 int GetComponentCount(const Type* type) {
764+#if LLVM_VERSION_MAJOR >= 11
765+ if (type && (type->getTypeID() == Type::FixedVectorTyID || type->getTypeID() == Type::ScalableVectorTyID))
766+ return llvm::dyn_cast<VectorType>(type)->getNumElements();
767+#else
768 if (type && type->getTypeID() == Type::VectorTyID)
769 return llvm::dyn_cast<VectorType>(type)->getNumElements();
770+#endif
771 else
772 return 1;
773 }
774@@ -652,13 +662,18 @@
775 break;
776 }
777 } else {
778+#if LLVM_VERSION_MAJOR >= 11
779+ Value *Callee = call->getCalledOperand();
780+ const std::string fnName = Callee->getName().str();
781+#else
782 Value *Callee = call->getCalledValue();
783 const std::string fnName = Callee->getName();
784+#endif
785 auto genIntrinsicID = intrinsicMap.find(fnName);
786
787 // Get the function arguments
788- CallSite CS(call);
789- CallSite::arg_iterator CI = CS.arg_begin() + 1;
790+ CallBase &CB(*call);
791+ auto CI = CB.arg_begin() + 1;
792
793 switch (genIntrinsicID) {
794 case GEN_OCL_NOT_FOUND:
795@@ -729,7 +744,7 @@
796 extractFromVector(call);
797 break;
798 case GEN_OCL_PRINTF:
799- for (; CI != CS.arg_end(); ++CI)
800+ for (; CI != CB.arg_end(); ++CI)
801 if ((*CI)->getType()->isVectorTy())
802 *CI = InsertToVector(call, *CI);
803 break;
804--- Beignet-1.3.2-Source/backend/src/llvm/llvm_printf_parser.cpp.orig 2017-10-24 08:04:48.000000000 +0200
805+++ Beignet-1.3.2-Source/backend/src/llvm/llvm_printf_parser.cpp 2021-05-18 19:37:42.918204733 +0200
806@@ -323,8 +323,8 @@
807
808 bool PrintfParser::parseOnePrintfInstruction(CallInst * call)
809 {
810- CallSite CS(call);
811- CallSite::arg_iterator CI_FMT = CS.arg_begin();
812+ CallBase &CB(*call);
813+ auto CI_FMT = CB.arg_begin();
814 int param_num = 0;
815
816 llvm::Constant* arg0 = dyn_cast<llvm::ConstantExpr>(*CI_FMT);
817@@ -341,7 +341,7 @@
818 return false;
819 }
820
821- std::string fmt = fmt_arg->getAsCString();
822+ std::string fmt = fmt_arg->getAsCString().str();
823 if (fmt.size() == 0)
824 return false;
825
826@@ -437,8 +437,13 @@
827 if ( callFunc->getIntrinsicID() != 0)
828 continue;
829
830+#if LLVM_VERSION_MAJOR >= 11
831+ Value *Callee = call->getCalledOperand();
832+ const std::string fnName = Callee->getName().str();
833+#else
834 Value *Callee = call->getCalledValue();
835 const std::string fnName = Callee->getName();
836+#endif
837
838 if (fnName != "__gen_ocl_printf_stub" && fnName != "__gen_ocl_puts_stub")
839 continue;
840@@ -582,7 +587,7 @@
841 if (!fmt_arg || !fmt_arg->isCString()) {
842 return false;
843 }
844- slot.state.str = fmt_arg->getAsCString();
845+ slot.state.str = fmt_arg->getAsCString().str();
846 return true;
847 }
848 case PRINTF_CONVERSION_P: {
849@@ -595,10 +600,18 @@
850
851 break;
852
853+#if LLVM_VERSION_MAJOR >= 11
854+ case Type::FixedVectorTyID:
855+ case Type::ScalableVectorTyID: {
856+ Type* vect_type = arg->getType();
857+ Type* elt_type = cast<VectorType>(vect_type)->getElementType();
858+ int vec_num = cast<VectorType>(vect_type)->getNumElements();
859+#else
860 case Type::VectorTyID: {
861 Type* vect_type = arg->getType();
862 Type* elt_type = vect_type->getVectorElementType();
863 int vec_num = vect_type->getVectorNumElements();
864+#endif
865 bool sign = false;
866
867 if (vec_num != slot.state.vector_n) {
868--- Beignet-1.3.2-Source/backend/src/llvm/llvm_profiling.cpp.orig 2021-05-16 18:47:43.413925712 +0200
869+++ Beignet-1.3.2-Source/backend/src/llvm/llvm_profiling.cpp 2021-05-18 19:43:54.136193672 +0200
870@@ -35,7 +35,11 @@
871 #include "llvm/IR/IRBuilder.h"
872
873 #if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 35
874+#if LLVM_VERSION_MAJOR >= 11
875+#include "llvm/IR/AbstractCallSite.h"
876+#else
877 #include "llvm/IR/CallSite.h"
878+#endif
879 #include "llvm/IR/CFG.h"
880 #else
881 #include "llvm/Support/CallSite.h"
882--- Beignet-1.3.2-Source/backend/src/llvm/llvm_device_enqueue.cpp.orig 2021-05-18 19:47:35.171662887 +0200
883+++ Beignet-1.3.2-Source/backend/src/llvm/llvm_device_enqueue.cpp 2021-05-18 20:01:28.610481095 +0200
884@@ -45,7 +45,7 @@
885 return NULL;
886
887 /* This is a fake, to check the function bitcast is for block or not */
888- std::string fnName = Fn->getName();
889+ std::string fnName = Fn->getName().str();
890 if(fnName.find("_invoke") == std::string::npos)
891 return NULL;
892
893@@ -124,7 +124,7 @@
894
895 Function::arg_iterator NewFnArgIt = NewFn->arg_begin();
896 for (Function::arg_iterator I = Fn->arg_begin(), E = Fn->arg_end(); I != E; ++I) {
897- std::string ArgName = I->getName();
898+ std::string ArgName = I->getName().str();
899 NewFnArgIt->setName(ArgName);
900 VMap[&*I] = &(*NewFnArgIt++);
901 }
902@@ -198,7 +198,7 @@
903 * invoke pointer to store the index in the unit's block functions index.*/
904 Function *Fn = dyn_cast<Function>(bt->getOperand(0));
905
906- std::string fnName = Fn->getName();
907+ std::string fnName = Fn->getName().str();
908 int index = -1;
909 for(size_t i=0; i<unit.blockFuncs.size(); i++) {
910 if(unit.blockFuncs[i] == fnName) {
911@@ -241,7 +241,11 @@
912 //unnamed call function, parse the use to find the define of called function
913 SmallVector<Value*, 16> args(CI->op_begin(), CI->op_end()-1);
914
915+#if LLVM_VERSION_MAJOR >= 11
916+ Value *v = CI->getCalledOperand();
917+#else
918 Value *v = CI->getCalledValue();
919+#endif
920 BitCastInst* bt = dyn_cast<BitCastInst>(v);
921 if(bt == NULL)
922 continue;
923@@ -316,7 +320,7 @@
924 ConstantExpr *expr = dyn_cast<ConstantExpr>(c->getOperand(3));
925 BitCastInst *bt = dyn_cast<BitCastInst>(expr->getAsInstruction());
926 Function* f = dyn_cast<Function>(bt->getOperand(0));
927- blocks[v] = f->getName();
928+ blocks[v] = f->getName().str();
929 }
930 }
931
932@@ -361,7 +365,7 @@
933 ConstantExpr *expr = dyn_cast<ConstantExpr>(c->getOperand(3));
934 BitCastInst *bt = dyn_cast<BitCastInst>(expr->getAsInstruction());
935 Function* f = dyn_cast<Function>(bt->getOperand(0));
936- blocks[v] = f->getName();
937+ blocks[v] = f->getName().str();
938 }
939 }
940 } else if(isa<AllocaInst>(block)) {
941--- Beignet-1.3.2-Source/backend/src/llvm/StripAttributes.cpp.orig 2017-10-24 08:04:48.000000000 +0200
942+++ Beignet-1.3.2-Source/backend/src/llvm/StripAttributes.cpp 2021-05-18 20:52:53.147104059 +0200
943@@ -107,9 +107,9 @@
944 BB != E; ++BB) {
945 for (BasicBlock::iterator Inst = BB->begin(), E = BB->end();
946 Inst != E; ++Inst) {
947- CallSite Call(&*Inst);
948+ auto *Call = dyn_cast<CallBase>(&*Inst);
949 if (Call)
950- Call.setCallingConv(CallingConv::C);
951+ Call->setCallingConv(CallingConv::C);
952 }
953 }
954
955--- Beignet-1.3.2-Source/backend/src/llvm/llvm_loadstore_optimization.cpp.orig 2021-05-16 18:47:43.440592235 +0200
956+++ Beignet-1.3.2-Source/backend/src/llvm/llvm_loadstore_optimization.cpp 2021-05-18 21:34:07.053701756 +0200
957@@ -154,8 +154,10 @@
958 LoadInst *ld = cast<LoadInst>(merged[0]);
959 #if LLVM_VERSION_MAJOR < 10
960 unsigned align = ld->getAlignment();
961-#else
962+#elif LLVM_VERSION_MAJOR < 11
963 MaybeAlign align = ld->getAlign();
964+#else
965+ Align align = ld->getAlign();
966 #endif
967 unsigned addrSpace = ld->getPointerAddressSpace();
968 // insert before first load
969@@ -241,8 +243,10 @@
970
971 #if LLVM_VERSION_MAJOR < 10
972 unsigned align = st->getAlignment();
973-#else
974+#elif LLVM_VERSION_MAJOR < 11
975 MaybeAlign align = st->getAlign();
976+#else
977+ Align align = st->getAlign();
978 #endif
979 // insert before the last store
980 Builder.SetInsertPoint(merged[size-1]);
981--- Beignet-1.3.2-Source/CMake/FindLLVM.cmake.orig 2021-05-16 18:47:43.403925767 +0200
982+++ Beignet-1.3.2-Source/CMake/FindLLVM.cmake 2021-05-19 06:34:06.278180089 +0200
983@@ -109,6 +109,8 @@
984 )
985 if (LLVM_SYSTEM_LIBS_ORIG)
986 string(REGEX REPLACE " *\n" "" LLVM_SYSTEM_LIBS ${LLVM_SYSTEM_LIBS_ORIG})
987+else (LLVM_SYSTEM_LIBS_ORIG)
988+set(LLVM_SYSTEM_LIBS tinfo z)
989 endif (LLVM_SYSTEM_LIBS_ORIG)
990 endif (LLVM_VERSION_NODOT VERSION_GREATER 34)
991
Open source implementation of the OpenCL specification for Intel GPUs
This page took 0.14036 seconds and 4 git commands to generate.