beignet-llvm11-support.patch

   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