[V2,2/2] GBE: enable llvm5.0 support.

Submitted by Song, Ruiling on Sept. 20, 2017, 8:44 a.m.

Details

Message ID 148B1B7A67D1C24B9EF0BE42EA49770684E16106@SHSMSX103.ccr.corp.intel.com
State New
Headers show

Patch hide | download patch | download mbox

diff --git a/backend/src/llvm/PromoteIntegers.cpp b/backend/src/llvm/PromoteIntegers.cpp
index a500311..d433771 100644
--- a/backend/src/llvm/PromoteIntegers.cpp
+++ b/backend/src/llvm/PromoteIntegers.cpp
@@ -605,8 +605,13 @@  static void convertInstruction(Instruction *Inst, ConversionState &State) {
     for (SwitchInst::CaseIt I = Switch->case_begin(),
              E = Switch->case_end();
          I != E; ++I) {
+#if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 50
+      NewInst->addCase(cast<ConstantInt>(convertConstant(I->getCaseValue())),
+                       I->getCaseSuccessor());
+#else
       NewInst->addCase(cast<ConstantInt>(convertConstant(I.getCaseValue())),
                        I.getCaseSuccessor());
+#endif
     }
     Switch->eraseFromParent();
   } else {
diff --git a/backend/src/llvm/llvm_barrier_nodup.cpp b/backend/src/llvm/llvm_barrier_nodup.cpp
index a7d0d1a..b8ffdf4 100644
--- a/backend/src/llvm/llvm_barrier_nodup.cpp
+++ b/backend/src/llvm/llvm_barrier_nodup.cpp
@@ -74,7 +74,11 @@  namespace gbe {
               if (F.hasFnAttribute(Attribute::NoDuplicate)) {
                 auto attrs = F.getAttributes();
                 F.setAttributes(attrs.removeAttribute(M.getContext(),
+#if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 50
+                                AttributeList::FunctionIndex,
+#else
                                 AttributeSet::FunctionIndex,
+#endif
                                 Attribute::NoDuplicate));
                 changed = true;
               }
diff --git a/backend/src/llvm/llvm_device_enqueue.cpp b/backend/src/llvm/llvm_device_enqueue.cpp
index 9a0fb46..58aa681 100644
--- a/backend/src/llvm/llvm_device_enqueue.cpp
+++ b/backend/src/llvm/llvm_device_enqueue.cpp
@@ -29,6 +29,7 @@  namespace gbe {
     BitCastInst* bt = dyn_cast<BitCastInst>(I);
     if (bt == NULL)
       return NULL;
+//bt->dump();
 
     Type* type = bt->getOperand(0)->getType();
     if(!type->isPointerTy())
@@ -112,7 +113,8 @@  namespace gbe {
     ValueToValueMapTy VMap;
     for (Function::arg_iterator I = Fn->arg_begin(), E = Fn->arg_end(); I != E; ++I) {
       PointerType *ty = dyn_cast<PointerType>(I->getType());
-      if(ty && ty->getAddressSpace() == 0) //Foce set the address space to global
+      //Foce set the address space to global
+      if(ty && (ty->getAddressSpace() == 0 || ty->getAddressSpace() == 4))
         ty = PointerType::get(ty->getPointerElementType(), 1);
       ParamTys.push_back(ty);
     }
@@ -252,12 +254,13 @@  namespace gbe {
             if(gep == NULL)
               continue;
 
-            BitCastInst* fnPointer = dyn_cast<BitCastInst>(gep->getOperand(0));
-            if(fnPointer == NULL)
+            Value *fnPointer = gep->getOperand(0)->stripPointerCasts();
+
+            if(fnPointer == gep->getOperand(0))
               continue;
 
-            if(BitCastInst* bt = dyn_cast<BitCastInst>(fnPointer->getOperand(0))) {
-              std::string fnName = blocks[bt->getOperand(0)];
+            if(blocks.find(fnPointer) != blocks.end()) {
+              std::string fnName = blocks[fnPointer];
               Function* f = mod->getFunction(fnName);
               CallInst *newCI = builder.CreateCall(f, args);
               CI->replaceAllUsesWith(newCI);
@@ -266,7 +269,7 @@  namespace gbe {
             }
 
             //the function is global variable
-            if(GlobalVariable* gv = dyn_cast<GlobalVariable>(fnPointer->getOperand(0))) {
+            if(GlobalVariable* gv = dyn_cast<GlobalVariable>(fnPointer)) {
               Constant *c = gv->getInitializer();
               ConstantExpr *expr = dyn_cast<ConstantExpr>(c->getOperand(3));
               BitCastInst *bt = dyn_cast<BitCastInst>(expr->getAsInstruction());
@@ -277,7 +280,7 @@  namespace gbe {
               continue;
             }
 
-            ld = dyn_cast<LoadInst>(fnPointer->getOperand(0));
+            ld = dyn_cast<LoadInst>(fnPointer);
             if(ld == NULL)
               continue;
 
@@ -304,9 +307,7 @@  namespace gbe {
                 User *theUser = iter->getUser();
 #endif
                 if(StoreInst *st = dyn_cast<StoreInst>(theUser)) {
-                  bt = dyn_cast<BitCastInst>(st->getValueOperand());
-                  if(bt)
-                    v = bt->getOperand(0);
+                  v = st->getValueOperand()->stripPointerCasts();
                 }
               }
               if(blocks.find(v) == blocks.end()) {
@@ -339,9 +340,7 @@  namespace gbe {
             Type *type = CI->getArgOperand(block_index)->getType();
             if(type->isIntegerTy())
                 block_index = 6;
-            Value *block = CI->getArgOperand(block_index);
-            while(isa<BitCastInst>(block))
-               block = dyn_cast<BitCastInst>(block)->getOperand(0);
+            Value *block = CI->getArgOperand(block_index)->stripPointerCasts();
             LoadInst *ld = dyn_cast<LoadInst>(block);
             Value *v = NULL;
             if(ld) {
@@ -353,9 +352,7 @@  namespace gbe {
                 User *theUser = iter->getUser();
 #endif
                 if(StoreInst *st = dyn_cast<StoreInst>(theUser)) {
-                  BitCastInst *bt = dyn_cast<BitCastInst>(st->getValueOperand());
-                  if(bt)
-                    v = bt->getOperand(0);
+                  v = st->getValueOperand()->stripPointerCasts();
                 }
               }
               if(blocks.find(v) == blocks.end()) {
@@ -378,15 +375,20 @@  namespace gbe {
             if( fn->isVarArg() ) {
               //enqueue function with slm, convert to __gen_enqueue_kernel_slm call
               //store the slm information to a alloca address.
-              int start = block_index + 1;
+              int start = block_index + 1 + 1;  //the first is count, skip
               int count = CI->getNumArgOperands() - start;
               Type *intTy = IntegerType::get(mod->getContext(), 32);
+              Type *int64Ty = IntegerType::get(mod->getContext(), 64);
 
               AllocaInst *AI = builder.CreateAlloca(intTy, ConstantInt::get(intTy, count));
 
               for(uint32_t i = start; i < CI->getNumArgOperands(); i++) {
                 Value *ptr = builder.CreateGEP(AI, ConstantInt::get(intTy, i-start));
-                builder.CreateStore(CI->getArgOperand(i), ptr);
+                Value *argSize = CI->getArgOperand(i);
+                if (argSize->getType() == int64Ty) {
+                  argSize = builder.CreateTrunc(argSize, intTy);
+                }
+                builder.CreateStore(argSize, ptr);
               }
               SmallVector<Value*, 16> args(CI->op_begin(), CI->op_begin() + 3);
               args.push_back(CI->getArgOperand(block_index));
@@ -394,8 +396,8 @@  namespace gbe {
               args.push_back(AI);
 
               std::vector<Type *> ParamTys;
-              for (Value** I = args.begin(); I != args.end(); ++I)
-                ParamTys.push_back((*I)->getType());
+              for (Value** iter = args.begin(); iter != args.end(); ++iter)
+                ParamTys.push_back((*iter)->getType());
               CallInst* newCI = builder.CreateCall(cast<llvm::Function>(mod->getOrInsertFunction(
                               "__gen_enqueue_kernel_slm", FunctionType::get(intTy, ParamTys, false))), args);
               CI->replaceAllUsesWith(newCI);
diff --git a/backend/src/llvm/llvm_gen_backend.cpp b/backend/src/llvm/llvm_gen_backend.cpp
index a9df652..c552c91 100644
--- a/backend/src/llvm/llvm_gen_backend.cpp
+++ b/backend/src/llvm/llvm_gen_backend.cpp
@@ -740,6 +740,8 @@  namespace gbe
     DECL_VISIT_FN(AtomicCmpXchgInst, AtomicCmpXchgInst);
 #undef DECL_VISIT_FN
 
+    // Emit rounding instructions from gen native function
+    void emitRoundingCallInst(CallInst &I, CallSite &CS, ir::Opcode opcode);
     // Emit unary instructions from gen native function
     void emitUnaryCallInst(CallInst &I, CallSite &CS, ir::Opcode opcode, ir::Type = ir::TYPE_FLOAT);
     // Emit unary instructions from gen native function
@@ -973,7 +975,7 @@  namespace gbe
             CallInst *ci = dyn_cast<CallInst>(theUser);
             pointer = ci ? ci->getArgOperand(0) : NULL;
           } else {
-            theUser->dump();
+            //theUser->dump();
             GBE_ASSERT(0 && "Unknown instruction operating on pointers\n");
           }
 
@@ -1121,7 +1123,7 @@  namespace gbe
           pointerBaseMap.insert(std::make_pair(ptr, basePhi));
           return basePhi;
       } else {
-        ptr->dump();
+        //ptr->dump();
         GBE_ASSERT(0 && "Unhandled instruction in getPointerBase\n");
         return ptr;
       }
@@ -1202,7 +1204,7 @@  namespace gbe
           BtiValueMap.insert(std::make_pair(Val, btiPhi));
           return btiPhi;
         } else {
-          Val->dump();
+          //Val->dump();
           GBE_ASSERT(0 && "Unhandled instruction in getBtiRegister\n");
           return Val;
         }
@@ -1656,7 +1658,7 @@  namespace gbe
         }
       default:
         {
-          c->dump();
+          //c->dump();
           NOT_IMPLEMENTED;
         }
     }
@@ -1908,7 +1910,7 @@  namespace gbe
   ir::ImmediateIndex GenWriter::processConstantImmIndex(Constant *CPV, int32_t index) {
     if (dyn_cast<ConstantExpr>(CPV) == NULL)
       return processConstantImmIndexImpl(CPV, index);
-    CPV->dump();
+    //CPV->dump();
     GBE_ASSERT(0 && "unsupported constant.\n");
     return ctx.newImmediate((uint32_t)0);
   }
@@ -4172,6 +4174,21 @@  namespace gbe
     };
   }
 
+  void GenWriter::emitRoundingCallInst(CallInst &I, CallSite &CS, ir::Opcode opcode) {
+    if (I.getType()->isHalfTy()) {
+      const ir::Register src = this->getRegister(I.getOperand(0));
+      const ir::Register srcFloat = ctx.reg(ir::FAMILY_DWORD);
+      const ir::Register dstFloat = ctx.reg(ir::FAMILY_DWORD);
+      const ir::Register dst = this->getRegister(&I);
+      ctx.F16TO32(ir::TYPE_FLOAT, ir::TYPE_U16, srcFloat, src);
+      ctx.ALU1(opcode, ir::TYPE_FLOAT, dstFloat, srcFloat);
+      ctx.F32TO16(ir::TYPE_U16, ir::TYPE_FLOAT, dst, dstFloat);
+    } else {
+      GBE_ASSERT(I.getType()->isFloatTy());
+      this->emitUnaryCallInst(I,CS,opcode);
+    }
+  }
+
   void GenWriter::emitUnaryCallInst(CallInst &I, CallSite &CS, ir::Opcode opcode, ir::Type type) {
     CallSite::arg_iterator AI = CS.arg_begin();
 #if GBE_DEBUG
@@ -4838,10 +4855,10 @@  namespace gbe
           }
           break;
           case Intrinsic::sqrt: this->emitUnaryCallInst(I,CS,ir::OP_SQR); break;
-          case Intrinsic::ceil: this->emitUnaryCallInst(I,CS,ir::OP_RNDU); break;
-          case Intrinsic::trunc: this->emitUnaryCallInst(I,CS,ir::OP_RNDZ); break;
-          case Intrinsic::rint: this->emitUnaryCallInst(I,CS,ir::OP_RNDE); break;
-          case Intrinsic::floor: this->emitUnaryCallInst(I,CS,ir::OP_RNDD); break;
+          case Intrinsic::ceil: this->emitRoundingCallInst(I,CS,ir::OP_RNDU); break;
+          case Intrinsic::trunc: this->emitRoundingCallInst(I,CS,ir::OP_RNDZ); break;
+          case Intrinsic::rint: this->emitRoundingCallInst(I,CS,ir::OP_RNDE); break;
+          case Intrinsic::floor: this->emitRoundingCallInst(I,CS,ir::OP_RNDD); break;
           case Intrinsic::sin: this->emitUnaryCallInst(I,CS,ir::OP_SIN); break;
           case Intrinsic::cos: this->emitUnaryCallInst(I,CS,ir::OP_COS); break;
           case Intrinsic::log2: this->emitUnaryCallInst(I,CS,ir::OP_LOG); break;
@@ -5698,9 +5715,13 @@  namespace gbe
           case GEN_OCL_ENQUEUE_SET_NDRANGE_INFO:
           {
             GBE_ASSERT(AI != AE);
+            Value *dstValue;
+            if(I.hasStructRetAttr())
+              dstValue = *AI++;
+            else
+              dstValue = &I;
             Value *srcValue = *AI;
             ++AI;
-            Value *dstValue = &I;
             regTranslator.newValueProxy(srcValue, dstValue);
             break;
           }
diff --git a/backend/src/llvm/llvm_profiling.cpp b/backend/src/llvm/llvm_profiling.cpp
index f7e4cc5..2d2ee11 100644
--- a/backend/src/llvm/llvm_profiling.cpp
+++ b/backend/src/llvm/llvm_profiling.cpp
@@ -162,12 +162,19 @@  namespace gbe
       /* Add the timestamp store function call. */
       // __gen_ocl_store_timestamp(int nth, int type);
       Value *Args[2] = {ConstantInt::get(intTy, pointNum++), ConstantInt::get(intTy, profilingType)};
+#if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 50
       builder->CreateCall(cast<llvm::Function>(module->getOrInsertFunction(
               "__gen_ocl_calc_timestamp", Type::getVoidTy(module->getContext()),
               IntegerType::getInt32Ty(module->getContext()),
+              IntegerType::getInt32Ty(module->getContext()))),
+              ArrayRef<Value*>(Args));
+#else
+      builder->CreateCall(cast<llvm::Function>(module->getOrInsertFunction(
+              "__gen_ocl_calc_timestamp", Type::getVoidTy(module->getContext()),
               IntegerType::getInt32Ty(module->getContext()),
-              NULL)),
+              IntegerType::getInt32Ty(module->getContext()), nullptr)),
               ArrayRef<Value*>(Args));
+#endif
     }
     /* We insert one store_profiling at the end of the last block to hold the place. */
     llvm::Function::iterator BE = F.end();
@@ -177,12 +184,19 @@  namespace gbe
     builder->SetInsertPoint(&*retInst);
     Value *Args2[2] = {profilingBuf, ConstantInt::get(intTy, profilingType)};
 
+#if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 50
     builder->CreateCall(cast<llvm::Function>(module->getOrInsertFunction(
             "__gen_ocl_store_profiling", Type::getVoidTy(module->getContext()),
             ptrTy,
-            IntegerType::getInt32Ty(module->getContext()),
-            NULL)),
+            IntegerType::getInt32Ty(module->getContext()))),
             ArrayRef<Value*>(Args2));
+#else
+    builder->CreateCall(cast<llvm::Function>(module->getOrInsertFunction(
+            "__gen_ocl_store_profiling", Type::getVoidTy(module->getContext()),
+            ptrTy,
+            IntegerType::getInt32Ty(module->getContext()), nullptr)),
+            ArrayRef<Value*>(Args2));
+#endif
 
     delete builder;
     return changed;
diff --git a/backend/src/llvm/llvm_sampler_fix.cpp b/backend/src/llvm/llvm_sampler_fix.cpp
index c249755..c9ec817 100644
--- a/backend/src/llvm/llvm_sampler_fix.cpp
+++ b/backend/src/llvm/llvm_sampler_fix.cpp
@@ -81,7 +81,11 @@  namespace gbe {
 
 #if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 40
           Module *M = I->getParent()->getParent()->getParent();
+#if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 50
+          Value* samplerCvt = M->getOrInsertFunction("__gen_ocl_sampler_to_int", i32Ty, I->getOperand(0)->getType());
+#else
           Value* samplerCvt = M->getOrInsertFunction("__gen_ocl_sampler_to_int", i32Ty, I->getOperand(0)->getType(), nullptr);
+#endif
           Value *samplerVal = Builder.CreateCall(samplerCvt, {I->getOperand(0)});
 #else
           Value *samplerVal = I->getOperand(0);
@@ -119,7 +123,11 @@  namespace gbe {
           Builder.SetInsertPoint(I);
 #if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 40
           Module *M = I->getParent()->getParent()->getParent();
+#if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 50
+          Value* samplerCvt = M->getOrInsertFunction("__gen_ocl_sampler_to_int", i32Ty, I->getOperand(0)->getType());
+#else
           Value* samplerCvt = M->getOrInsertFunction("__gen_ocl_sampler_to_int", i32Ty, I->getOperand(0)->getType(), nullptr);
+#endif
           Value *samplerVal = Builder.CreateCall(samplerCvt, {I->getOperand(0)});
 #else
           Value *samplerVal = I->getOperand(0);

Comments

Yang, Rong R Sept. 21, 2017, 7:14 a.m.
Pushed, thanks.

> -----Original Message-----

> From: Song, Ruiling

> Sent: Wednesday, September 20, 2017 4:44 PM

> To: Yang, Rong R <rong.r.yang@intel.com>; beignet@lists.freedesktop.org

> Cc: Yang, Rong R <rong.r.yang@intel.com>

> Subject: RE: [Beignet] [Patch V2 2/2] GBE: enable llvm5.0 support.

> 

> This version looks good!

> 

> Ruiling

> 

> -----Original Message-----

> From: Beignet [mailto:beignet-bounces@lists.freedesktop.org] On Behalf Of

> Yang Rong

> Sent: Wednesday, September 20, 2017 4:18 PM

> To: beignet@lists.freedesktop.org

> Cc: Yang, Rong R <rong.r.yang@intel.com>

> Subject: [Beignet] [Patch V2 2/2] GBE: enable llvm5.0 support.

> 

> 1. getOrInsertFunction without nullptr.

> 2. handle f16 rounding.

> 3. remove llvm value dump.

> 4. handle AddrSpaceCastInst when parsing block info.

> 

> V2: use stripPointerCasts instead of BitCast and AddrSpaceCast.

> Signed-off-by: Yang Rong <rong.r.yang@intel.com>

> ---

>  backend/src/llvm/PromoteIntegers.cpp     |  5 ++++

>  backend/src/llvm/llvm_barrier_nodup.cpp  |  4 +++

> backend/src/llvm/llvm_device_enqueue.cpp | 42 +++++++++++++++++------------

> ---

>  backend/src/llvm/llvm_gen_backend.cpp    | 41 +++++++++++++++++++++++----

> ----

>  backend/src/llvm/llvm_profiling.cpp      | 20 ++++++++++++---

>  backend/src/llvm/llvm_sampler_fix.cpp    |  8 ++++++

>  6 files changed, 87 insertions(+), 33 deletions(-)

> 

> diff --git a/backend/src/llvm/PromoteIntegers.cpp

> b/backend/src/llvm/PromoteIntegers.cpp

> index a500311..d433771 100644

> --- a/backend/src/llvm/PromoteIntegers.cpp

> +++ b/backend/src/llvm/PromoteIntegers.cpp

> @@ -605,8 +605,13 @@ static void convertInstruction(Instruction *Inst,

> ConversionState &State) {

>      for (SwitchInst::CaseIt I = Switch->case_begin(),

>               E = Switch->case_end();

>           I != E; ++I) {

> +#if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 50

> +      NewInst->addCase(cast<ConstantInt>(convertConstant(I->getCaseValue())),

> +                       I->getCaseSuccessor()); #else

>        NewInst->addCase(cast<ConstantInt>(convertConstant(I.getCaseValue())),

>                         I.getCaseSuccessor());

> +#endif

>      }

>      Switch->eraseFromParent();

>    } else {

> diff --git a/backend/src/llvm/llvm_barrier_nodup.cpp

> b/backend/src/llvm/llvm_barrier_nodup.cpp

> index a7d0d1a..b8ffdf4 100644

> --- a/backend/src/llvm/llvm_barrier_nodup.cpp

> +++ b/backend/src/llvm/llvm_barrier_nodup.cpp

> @@ -74,7 +74,11 @@ namespace gbe {

>                if (F.hasFnAttribute(Attribute::NoDuplicate)) {

>                  auto attrs = F.getAttributes();

>                  F.setAttributes(attrs.removeAttribute(M.getContext(),

> +#if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 50

> +                                AttributeList::FunctionIndex, #else

>                                  AttributeSet::FunctionIndex,

> +#endif

>                                  Attribute::NoDuplicate));

>                  changed = true;

>                }

> diff --git a/backend/src/llvm/llvm_device_enqueue.cpp

> b/backend/src/llvm/llvm_device_enqueue.cpp

> index 9a0fb46..58aa681 100644

> --- a/backend/src/llvm/llvm_device_enqueue.cpp

> +++ b/backend/src/llvm/llvm_device_enqueue.cpp

> @@ -29,6 +29,7 @@ namespace gbe {

>      BitCastInst* bt = dyn_cast<BitCastInst>(I);

>      if (bt == NULL)

>        return NULL;

> +//bt->dump();

> 

>      Type* type = bt->getOperand(0)->getType();

>      if(!type->isPointerTy())

> @@ -112,7 +113,8 @@ namespace gbe {

>      ValueToValueMapTy VMap;

>      for (Function::arg_iterator I = Fn->arg_begin(), E = Fn->arg_end(); I != E; ++I) {

>        PointerType *ty = dyn_cast<PointerType>(I->getType());

> -      if(ty && ty->getAddressSpace() == 0) //Foce set the address space to global

> +      //Foce set the address space to global

> +      if(ty && (ty->getAddressSpace() == 0 || ty->getAddressSpace() ==

> + 4))

>          ty = PointerType::get(ty->getPointerElementType(), 1);

>        ParamTys.push_back(ty);

>      }

> @@ -252,12 +254,13 @@ namespace gbe {

>              if(gep == NULL)

>                continue;

> 

> -            BitCastInst* fnPointer = dyn_cast<BitCastInst>(gep->getOperand(0));

> -            if(fnPointer == NULL)

> +            Value *fnPointer = gep->getOperand(0)->stripPointerCasts();

> +

> +            if(fnPointer == gep->getOperand(0))

>                continue;

> 

> -            if(BitCastInst* bt = dyn_cast<BitCastInst>(fnPointer->getOperand(0))) {

> -              std::string fnName = blocks[bt->getOperand(0)];

> +            if(blocks.find(fnPointer) != blocks.end()) {

> +              std::string fnName = blocks[fnPointer];

>                Function* f = mod->getFunction(fnName);

>                CallInst *newCI = builder.CreateCall(f, args);

>                CI->replaceAllUsesWith(newCI); @@ -266,7 +269,7 @@ namespace gbe

> {

>              }

> 

>              //the function is global variable

> -            if(GlobalVariable* gv = dyn_cast<GlobalVariable>(fnPointer-

> >getOperand(0))) {

> +            if(GlobalVariable* gv =

> + dyn_cast<GlobalVariable>(fnPointer)) {

>                Constant *c = gv->getInitializer();

>                ConstantExpr *expr = dyn_cast<ConstantExpr>(c->getOperand(3));

>                BitCastInst *bt = dyn_cast<BitCastInst>(expr->getAsInstruction());

> @@ -277,7 +280,7 @@ namespace gbe {

>                continue;

>              }

> 

> -            ld = dyn_cast<LoadInst>(fnPointer->getOperand(0));

> +            ld = dyn_cast<LoadInst>(fnPointer);

>              if(ld == NULL)

>                continue;

> 

> @@ -304,9 +307,7 @@ namespace gbe {

>                  User *theUser = iter->getUser();  #endif

>                  if(StoreInst *st = dyn_cast<StoreInst>(theUser)) {

> -                  bt = dyn_cast<BitCastInst>(st->getValueOperand());

> -                  if(bt)

> -                    v = bt->getOperand(0);

> +                  v = st->getValueOperand()->stripPointerCasts();

>                  }

>                }

>                if(blocks.find(v) == blocks.end()) { @@ -339,9 +340,7 @@ namespace

> gbe {

>              Type *type = CI->getArgOperand(block_index)->getType();

>              if(type->isIntegerTy())

>                  block_index = 6;

> -            Value *block = CI->getArgOperand(block_index);

> -            while(isa<BitCastInst>(block))

> -               block = dyn_cast<BitCastInst>(block)->getOperand(0);

> +            Value *block =

> + CI->getArgOperand(block_index)->stripPointerCasts();

>              LoadInst *ld = dyn_cast<LoadInst>(block);

>              Value *v = NULL;

>              if(ld) {

> @@ -353,9 +352,7 @@ namespace gbe {

>                  User *theUser = iter->getUser();  #endif

>                  if(StoreInst *st = dyn_cast<StoreInst>(theUser)) {

> -                  BitCastInst *bt = dyn_cast<BitCastInst>(st->getValueOperand());

> -                  if(bt)

> -                    v = bt->getOperand(0);

> +                  v = st->getValueOperand()->stripPointerCasts();

>                  }

>                }

>                if(blocks.find(v) == blocks.end()) { @@ -378,15 +375,20 @@ namespace

> gbe {

>              if( fn->isVarArg() ) {

>                //enqueue function with slm, convert to __gen_enqueue_kernel_slm

> call

>                //store the slm information to a alloca address.

> -              int start = block_index + 1;

> +              int start = block_index + 1 + 1;  //the first is count,

> + skip

>                int count = CI->getNumArgOperands() - start;

>                Type *intTy = IntegerType::get(mod->getContext(), 32);

> +              Type *int64Ty = IntegerType::get(mod->getContext(), 64);

> 

>                AllocaInst *AI = builder.CreateAlloca(intTy, ConstantInt::get(intTy,

> count));

> 

>                for(uint32_t i = start; i < CI->getNumArgOperands(); i++) {

>                  Value *ptr = builder.CreateGEP(AI, ConstantInt::get(intTy, i-start));

> -                builder.CreateStore(CI->getArgOperand(i), ptr);

> +                Value *argSize = CI->getArgOperand(i);

> +                if (argSize->getType() == int64Ty) {

> +                  argSize = builder.CreateTrunc(argSize, intTy);

> +                }

> +                builder.CreateStore(argSize, ptr);

>                }

>                SmallVector<Value*, 16> args(CI->op_begin(), CI->op_begin() + 3);

>                args.push_back(CI->getArgOperand(block_index));

> @@ -394,8 +396,8 @@ namespace gbe {

>                args.push_back(AI);

> 

>                std::vector<Type *> ParamTys;

> -              for (Value** I = args.begin(); I != args.end(); ++I)

> -                ParamTys.push_back((*I)->getType());

> +              for (Value** iter = args.begin(); iter != args.end(); ++iter)

> +                ParamTys.push_back((*iter)->getType());

>                CallInst* newCI = builder.CreateCall(cast<llvm::Function>(mod-

> >getOrInsertFunction(

>                                "__gen_enqueue_kernel_slm", FunctionType::get(intTy,

> ParamTys, false))), args);

>                CI->replaceAllUsesWith(newCI); diff --git

> a/backend/src/llvm/llvm_gen_backend.cpp

> b/backend/src/llvm/llvm_gen_backend.cpp

> index a9df652..c552c91 100644

> --- a/backend/src/llvm/llvm_gen_backend.cpp

> +++ b/backend/src/llvm/llvm_gen_backend.cpp

> @@ -740,6 +740,8 @@ namespace gbe

>      DECL_VISIT_FN(AtomicCmpXchgInst, AtomicCmpXchgInst);  #undef

> DECL_VISIT_FN

> 

> +    // Emit rounding instructions from gen native function

> +    void emitRoundingCallInst(CallInst &I, CallSite &CS, ir::Opcode

> + opcode);

>      // Emit unary instructions from gen native function

>      void emitUnaryCallInst(CallInst &I, CallSite &CS, ir::Opcode opcode, ir::Type =

> ir::TYPE_FLOAT);

>      // Emit unary instructions from gen native function @@ -973,7 +975,7 @@

> namespace gbe

>              CallInst *ci = dyn_cast<CallInst>(theUser);

>              pointer = ci ? ci->getArgOperand(0) : NULL;

>            } else {

> -            theUser->dump();

> +            //theUser->dump();

>              GBE_ASSERT(0 && "Unknown instruction operating on pointers\n");

>            }

> 

> @@ -1121,7 +1123,7 @@ namespace gbe

>            pointerBaseMap.insert(std::make_pair(ptr, basePhi));

>            return basePhi;

>        } else {

> -        ptr->dump();

> +        //ptr->dump();

>          GBE_ASSERT(0 && "Unhandled instruction in getPointerBase\n");

>          return ptr;

>        }

> @@ -1202,7 +1204,7 @@ namespace gbe

>            BtiValueMap.insert(std::make_pair(Val, btiPhi));

>            return btiPhi;

>          } else {

> -          Val->dump();

> +          //Val->dump();

>            GBE_ASSERT(0 && "Unhandled instruction in getBtiRegister\n");

>            return Val;

>          }

> @@ -1656,7 +1658,7 @@ namespace gbe

>          }

>        default:

>          {

> -          c->dump();

> +          //c->dump();

>            NOT_IMPLEMENTED;

>          }

>      }

> @@ -1908,7 +1910,7 @@ namespace gbe

>    ir::ImmediateIndex GenWriter::processConstantImmIndex(Constant *CPV,

> int32_t index) {

>      if (dyn_cast<ConstantExpr>(CPV) == NULL)

>        return processConstantImmIndexImpl(CPV, index);

> -    CPV->dump();

> +    //CPV->dump();

>      GBE_ASSERT(0 && "unsupported constant.\n");

>      return ctx.newImmediate((uint32_t)0);

>    }

> @@ -4172,6 +4174,21 @@ namespace gbe

>      };

>    }

> 

> +  void GenWriter::emitRoundingCallInst(CallInst &I, CallSite &CS, ir::Opcode

> opcode) {

> +    if (I.getType()->isHalfTy()) {

> +      const ir::Register src = this->getRegister(I.getOperand(0));

> +      const ir::Register srcFloat = ctx.reg(ir::FAMILY_DWORD);

> +      const ir::Register dstFloat = ctx.reg(ir::FAMILY_DWORD);

> +      const ir::Register dst = this->getRegister(&I);

> +      ctx.F16TO32(ir::TYPE_FLOAT, ir::TYPE_U16, srcFloat, src);

> +      ctx.ALU1(opcode, ir::TYPE_FLOAT, dstFloat, srcFloat);

> +      ctx.F32TO16(ir::TYPE_U16, ir::TYPE_FLOAT, dst, dstFloat);

> +    } else {

> +      GBE_ASSERT(I.getType()->isFloatTy());

> +      this->emitUnaryCallInst(I,CS,opcode);

> +    }

> +  }

> +

>    void GenWriter::emitUnaryCallInst(CallInst &I, CallSite &CS, ir::Opcode opcode,

> ir::Type type) {

>      CallSite::arg_iterator AI = CS.arg_begin();  #if GBE_DEBUG @@ -4838,10

> +4855,10 @@ namespace gbe

>            }

>            break;

>            case Intrinsic::sqrt: this->emitUnaryCallInst(I,CS,ir::OP_SQR); break;

> -          case Intrinsic::ceil: this->emitUnaryCallInst(I,CS,ir::OP_RNDU); break;

> -          case Intrinsic::trunc: this->emitUnaryCallInst(I,CS,ir::OP_RNDZ); break;

> -          case Intrinsic::rint: this->emitUnaryCallInst(I,CS,ir::OP_RNDE); break;

> -          case Intrinsic::floor: this->emitUnaryCallInst(I,CS,ir::OP_RNDD); break;

> +          case Intrinsic::ceil: this->emitRoundingCallInst(I,CS,ir::OP_RNDU); break;

> +          case Intrinsic::trunc: this->emitRoundingCallInst(I,CS,ir::OP_RNDZ); break;

> +          case Intrinsic::rint: this->emitRoundingCallInst(I,CS,ir::OP_RNDE); break;

> +          case Intrinsic::floor:

> + this->emitRoundingCallInst(I,CS,ir::OP_RNDD); break;

>            case Intrinsic::sin: this->emitUnaryCallInst(I,CS,ir::OP_SIN); break;

>            case Intrinsic::cos: this->emitUnaryCallInst(I,CS,ir::OP_COS); break;

>            case Intrinsic::log2: this->emitUnaryCallInst(I,CS,ir::OP_LOG); break; @@ -

> 5698,9 +5715,13 @@ namespace gbe

>            case GEN_OCL_ENQUEUE_SET_NDRANGE_INFO:

>            {

>              GBE_ASSERT(AI != AE);

> +            Value *dstValue;

> +            if(I.hasStructRetAttr())

> +              dstValue = *AI++;

> +            else

> +              dstValue = &I;

>              Value *srcValue = *AI;

>              ++AI;

> -            Value *dstValue = &I;

>              regTranslator.newValueProxy(srcValue, dstValue);

>              break;

>            }

> diff --git a/backend/src/llvm/llvm_profiling.cpp

> b/backend/src/llvm/llvm_profiling.cpp

> index f7e4cc5..2d2ee11 100644

> --- a/backend/src/llvm/llvm_profiling.cpp

> +++ b/backend/src/llvm/llvm_profiling.cpp

> @@ -162,12 +162,19 @@ namespace gbe

>        /* Add the timestamp store function call. */

>        // __gen_ocl_store_timestamp(int nth, int type);

>        Value *Args[2] = {ConstantInt::get(intTy, pointNum++),

> ConstantInt::get(intTy, profilingType)};

> +#if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 50

>        builder->CreateCall(cast<llvm::Function>(module->getOrInsertFunction(

>                "__gen_ocl_calc_timestamp", Type::getVoidTy(module->getContext()),

>                IntegerType::getInt32Ty(module->getContext()),

> +              IntegerType::getInt32Ty(module->getContext()))),

> +              ArrayRef<Value*>(Args));

> +#else

> +      builder->CreateCall(cast<llvm::Function>(module->getOrInsertFunction(

> +              "__gen_ocl_calc_timestamp",

> +Type::getVoidTy(module->getContext()),

>                IntegerType::getInt32Ty(module->getContext()),

> -              NULL)),

> +              IntegerType::getInt32Ty(module->getContext()), nullptr)),

>                ArrayRef<Value*>(Args));

> +#endif

>      }

>      /* We insert one store_profiling at the end of the last block to hold the place.

> */

>      llvm::Function::iterator BE = F.end(); @@ -177,12 +184,19 @@ namespace

> gbe

>      builder->SetInsertPoint(&*retInst);

>      Value *Args2[2] = {profilingBuf, ConstantInt::get(intTy, profilingType)};

> 

> +#if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 50

>      builder->CreateCall(cast<llvm::Function>(module->getOrInsertFunction(

>              "__gen_ocl_store_profiling", Type::getVoidTy(module->getContext()),

>              ptrTy,

> -            IntegerType::getInt32Ty(module->getContext()),

> -            NULL)),

> +            IntegerType::getInt32Ty(module->getContext()))),

>              ArrayRef<Value*>(Args2));

> +#else

> +    builder->CreateCall(cast<llvm::Function>(module->getOrInsertFunction(

> +            "__gen_ocl_store_profiling", Type::getVoidTy(module->getContext()),

> +            ptrTy,

> +            IntegerType::getInt32Ty(module->getContext()), nullptr)),

> +            ArrayRef<Value*>(Args2));

> +#endif

> 

>      delete builder;

>      return changed;

> diff --git a/backend/src/llvm/llvm_sampler_fix.cpp

> b/backend/src/llvm/llvm_sampler_fix.cpp

> index c249755..c9ec817 100644

> --- a/backend/src/llvm/llvm_sampler_fix.cpp

> +++ b/backend/src/llvm/llvm_sampler_fix.cpp

> @@ -81,7 +81,11 @@ namespace gbe {

> 

>  #if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 40

>            Module *M = I->getParent()->getParent()->getParent();

> +#if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 50

> +          Value* samplerCvt =

> +M->getOrInsertFunction("__gen_ocl_sampler_to_int", i32Ty,

> +I->getOperand(0)->getType()); #else

>            Value* samplerCvt = M-

> >getOrInsertFunction("__gen_ocl_sampler_to_int", i32Ty, I->getOperand(0)-

> >getType(), nullptr);

> +#endif

>            Value *samplerVal = Builder.CreateCall(samplerCvt, {I->getOperand(0)});

> #else

>            Value *samplerVal = I->getOperand(0); @@ -119,7 +123,11 @@

> namespace gbe {

>            Builder.SetInsertPoint(I);

>  #if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 40

>            Module *M = I->getParent()->getParent()->getParent();

> +#if LLVM_VERSION_MAJOR * 10 + LLVM_VERSION_MINOR >= 50

> +          Value* samplerCvt =

> +M->getOrInsertFunction("__gen_ocl_sampler_to_int", i32Ty,

> +I->getOperand(0)->getType()); #else

>            Value* samplerCvt = M-

> >getOrInsertFunction("__gen_ocl_sampler_to_int", i32Ty, I->getOperand(0)-

> >getType(), nullptr);

> +#endif

>            Value *samplerVal = Builder.CreateCall(samplerCvt, {I->getOperand(0)});

> #else

>            Value *samplerVal = I->getOperand(0);

> --

> 2.7.4

> 

> _______________________________________________

> Beignet mailing list

> Beignet@lists.freedesktop.org

> https://lists.freedesktop.org/mailman/listinfo/beignet