Upgrade SPIRV translator from LLVM 3.6 to LLVM 3.8

Change-Id: I97247b6472ff75ea83e12a485e06809ad2d2061c

15 files changed, 230 insertions, 114 deletions

diff --git a/lib/SPIRV/Mangler/Mangler.cpp b/lib/SPIRV/Mangler/Mangler.cpp
index aa2c333..5b891c8 100644
--- a/lib/SPIRV/Mangler/Mangler.cpp
+++ b/lib/SPIRV/Mangler/Mangler.cpp
@@ -84,8 +84,25 @@ public:
 // Visit methods
 //
   MangleError visit(const PrimitiveType* t) {
+    MangleError me = MANGLE_SUCCESS;
+#if defined(SPIRV_SPIR20_MANGLING_REQUIREMENTS)
     m_stream << mangledPrimitiveString(t->getPrimitive());
-    return MANGLE_SUCCESS;
+#else
+    std::string mangledPrimitive = std::string(mangledPrimitiveString(t->getPrimitive()));
+    // out of all enums it makes sense to substitute only memory_scope/memory_order
+    // since only they appear several times in the builtin declaration.
+    if (mangledPrimitive.compare("12memory_scope") == 0 ||
+        mangledPrimitive.compare("12memory_order") == 0) {
+      if (!mangleSubstitution(t, mangledPrimitiveString(t->getPrimitive()))) {
+        size_t index = m_stream.str().size();
+        m_stream << mangledPrimitiveString(t->getPrimitive());
+        substitutions[m_stream.str().substr(index)] = seqId++;
+      }
+    } else {
+      m_stream << mangledPrimitive;
+    }
+#endif
+    return me;
   }
 
   MangleError visit(const PointerType* p) {
@@ -133,8 +150,15 @@ public:
   }
 
   MangleError visit(const AtomicType* p) {
-    m_stream << "U" << "7_Atomic";
-    return p->getBaseType()->accept(this);
+    MangleError me = MANGLE_SUCCESS;
+    size_t index = m_stream.str().size();
+    const char* typeStr = "U7_Atomic";
+    if (!mangleSubstitution(p, typeStr)) {
+      m_stream << typeStr;
+      me = p->getBaseType()->accept(this);
+      substitutions[m_stream.str().substr(index)] = seqId++;
+    }
+    return me;
   }
 
   MangleError visit(const BlockType* p) {
diff --git a/lib/SPIRV/Mangler/ManglingUtils.cpp b/lib/SPIRV/Mangler/ManglingUtils.cpp
index 645d31a..4ee3fc2 100644
--- a/lib/SPIRV/Mangler/ManglingUtils.cpp
+++ b/lib/SPIRV/Mangler/ManglingUtils.cpp
@@ -51,6 +51,8 @@ namespace SPIR {
     "sampler_t",
     "kernel_enqueue_flags_t",
     "clk_profiling_info",
+    "memory_order",
+    "memory_scope"
   };
 
   const char* mangledTypes[PRIMITIVE_NUM] = {
@@ -87,12 +89,14 @@ namespace SPIR {
     "9ndrange_t",                    //PRIMITIVE_NDRANGE_T
     "12ocl_clkevent",                //PRIMITIVE_CLK_EVENT_T
     "11ocl_sampler",                 //PRIMITIVE_SAMPLER_T
-#if defined(SPIRV_SPIR20_MANGLING_REQUIREMENTS)
     "i",                             //PRIMITIVE_KERNEL_ENQUEUE_FLAGS_T
     "i",                             //PRIMITIVE_CLK_PROFILING_INFO
+#if defined(SPIRV_SPIR20_MANGLING_REQUIREMENTS)
+    "i",                             //PRIMITIVE_MEMORY_ORDER
+    "i",                             //PRIMITIVE_MEMORY_SCOPE
 #else
-    "22kernel_enqueue_flags_t",      //PRIMITIVE_KERNEL_ENQUEUE_FLAGS_T
-    "18clk_profiling_info",          //PRIMITIVE_CLK_PROFILING_INFO
+    "12memory_order",                //PRIMITIVE_MEMORY_ORDER
+    "12memory_scope"                 //PRIMITIVE_MEMORY_SCOPE
 #endif
   };
 
@@ -192,4 +196,24 @@ namespace SPIR {
     }
   }
 
+  bool isPipeBuiltin(std::string unmangledName) {
+    return
+      unmangledName == "write_pipe" ||
+      unmangledName == "read_pipe" ||
+      unmangledName == "reserve_write_pipe" ||
+      unmangledName == "reserve_read_pipe" ||
+      unmangledName == "commit_write_pipe" ||
+      unmangledName == "commit_read_pipe" ||
+      unmangledName == "work_group_reserve_write_pipe" ||
+      unmangledName == "work_group_reserve_read_pipe" ||
+      unmangledName == "work_group_commit_write_pipe" ||
+      unmangledName == "work_group_commit_read_pipe" ||
+      unmangledName == "get_pipe_num_packets" ||
+      unmangledName == "get_pipe_max_packets" ||
+      unmangledName == "sub_group_reserve_write_pipe" ||
+      unmangledName == "sub_group_reserve_read_pipe" ||
+      unmangledName == "sub_group_commit_write_pipe" ||
+      unmangledName == "sub_group_commit_read_pipe";
+  }
+
 } // End SPIR namespace
diff --git a/lib/SPIRV/Mangler/ManglingUtils.h b/lib/SPIRV/Mangler/ManglingUtils.h
index 6fc5572..943ceac 100644
--- a/lib/SPIRV/Mangler/ManglingUtils.h
+++ b/lib/SPIRV/Mangler/ManglingUtils.h
@@ -27,6 +27,8 @@ namespace SPIR {
   const char* getSPIRVersionAsString(SPIRversion version);
 
   const char* mangledPrimitiveStringfromName(std::string type);
+
+  bool isPipeBuiltin(std::string unmangledName);
 } // End SPIR namespace
 
 #endif //__MANGLING_UTILS_H__
diff --git a/lib/SPIRV/Mangler/ParameterType.h b/lib/SPIRV/Mangler/ParameterType.h
index 8089e8e..41c46bb 100644
--- a/lib/SPIRV/Mangler/ParameterType.h
+++ b/lib/SPIRV/Mangler/ParameterType.h
@@ -73,7 +73,9 @@ namespace SPIR {
     PRIMITIVE_SAMPLER_T,
     PRIMITIVE_KERNEL_ENQUEUE_FLAGS_T,
     PRIMITIVE_CLK_PROFILING_INFO,
-    PRIMITIVE_LAST = PRIMITIVE_CLK_PROFILING_INFO,
+    PRIMITIVE_MEMORY_ORDER,
+    PRIMITIVE_MEMORY_SCOPE,
+    PRIMITIVE_LAST = PRIMITIVE_MEMORY_SCOPE,
     PRIMITIVE_NONE,
     // Keep this at the end.
     PRIMITIVE_NUM = PRIMITIVE_NONE
diff --git a/lib/SPIRV/OCL20ToSPIRV.cpp b/lib/SPIRV/OCL20ToSPIRV.cpp
index 32aaed8..d786d73 100644
--- a/lib/SPIRV/OCL20ToSPIRV.cpp
+++ b/lib/SPIRV/OCL20ToSPIRV.cpp
@@ -1191,9 +1191,9 @@ OCL20ToSPIRV::visitCallBuiltinSimple(CallInst* CI,
 void OCL20ToSPIRV::transWorkItemBuiltinsToVariables() {

   DEBUG(dbgs() << "Enter transWorkItemBuiltinsToVariables\n");

   std::vector<Function *> WorkList;

-  for (auto I = M->begin(), E = M->end(); I != E; ++I) {

+  for (auto &I:*M) {

     std::string DemangledName;

-    if (!oclIsBuiltin(I->getName(), &DemangledName))

+    if (!oclIsBuiltin(I.getName(), &DemangledName))

       continue;

     DEBUG(dbgs() << "Function demangled name: " << DemangledName << '\n');

     std::string BuiltinVarName;

@@ -1203,9 +1203,9 @@ void OCL20ToSPIRV::transWorkItemBuiltinsToVariables() {
     BuiltinVarName = std::string(kSPIRVName::Prefix) +

         SPIRVBuiltInNameMap::map(BVKind);

     DEBUG(dbgs() << "builtin variable name: " << BuiltinVarName << '\n');

-    bool IsVec = I->getFunctionType()->getNumParams() > 0;

-    Type *GVType = IsVec ? VectorType::get(I->getReturnType(),3) :

-        I->getReturnType();

+    bool IsVec = I.getFunctionType()->getNumParams() > 0;

+    Type *GVType = IsVec ? VectorType::get(I.getReturnType(),3) :

+        I.getReturnType();

     auto BV = new GlobalVariable(*M, GVType,

         true,

         GlobalValue::ExternalLinkage,

@@ -1214,7 +1214,7 @@ void OCL20ToSPIRV::transWorkItemBuiltinsToVariables() {
         GlobalVariable::NotThreadLocal,

         SPIRAS_Constant);

     std::vector<Instruction *> InstList;

-    for (auto UI = I->user_begin(), UE = I->user_end(); UI != UE; ++UI) {

+    for (auto UI = I.user_begin(), UE = I.user_end(); UI != UE; ++UI) {

       auto CI = dyn_cast<CallInst>(*UI);

       assert(CI && "invalid instruction");

       Value * NewValue = new LoadInst(BV, "", CI);

@@ -1232,7 +1232,7 @@ void OCL20ToSPIRV::transWorkItemBuiltinsToVariables() {
     for (auto &Inst:InstList) {

       Inst->eraseFromParent();

     }

-    WorkList.push_back(I);

+    WorkList.push_back(&I);

   }

   for (auto &I:WorkList) {

     I->eraseFromParent();

diff --git a/lib/SPIRV/OCLTypeToSPIRV.cpp b/lib/SPIRV/OCLTypeToSPIRV.cpp
index f088620..5ebff5d 100644
--- a/lib/SPIRV/OCLTypeToSPIRV.cpp
+++ b/lib/SPIRV/OCLTypeToSPIRV.cpp
@@ -128,7 +128,7 @@ static unsigned
 getArgIndex(Function *F, Value *V) {
   auto A = F->arg_begin(), E = F->arg_end();
   for (unsigned I = 0; A != E; ++I, ++A) {
-    if (A == V)
+    if (&(*A) == V)
       return I;
   }
   llvm_unreachable("Not argument of function");
@@ -139,7 +139,7 @@ static Argument*
 getArg(Function *F, unsigned I) {
   auto AI = F->arg_begin();
   std::advance(AI, I);
-  return AI;
+  return &(*AI);
 }
 
 /// Create a new function type if \param F has arguments in AdaptedTy, and
@@ -323,7 +323,7 @@ OCLTypeToSPIRV::adaptArgumentsByMetadata(Function* F) {
     auto OCLTyStr = getMDOperandAsString(TypeMD, I);
     auto NewTy = *PI;
     if (OCLTyStr == OCL_TYPE_NAME_SAMPLER_T && !NewTy->isStructTy()) {
-      addAdaptedType(Arg, getSamplerType(M));
+      addAdaptedType(&(*Arg), getSamplerType(M));
       Changed = true;
     } else if (isPointerToOpaqueStructType(NewTy)) {
       auto STName = NewTy->getPointerElementType()->getStructName();
@@ -333,7 +333,7 @@ OCLTypeToSPIRV::adaptArgumentsByMetadata(Function* F) {
         auto AccMD = getArgAccessQualifierMetadata(F);
         assert(AccMD && "Invalid access qualifier metadata");
         auto AccStr = getMDOperandAsString(AccMD, I);
-        addAdaptedType(Arg, getOrCreateOpaquePtrType(M,
+        addAdaptedType(&(*Arg), getOrCreateOpaquePtrType(M,
             mapOCLTypeNameToSPIRV(Ty, AccStr)));
         Changed = true;
       }
diff --git a/lib/SPIRV/OCLUtil.cpp b/lib/SPIRV/OCLUtil.cpp
index 33f59f2..10a660c 100644
--- a/lib/SPIRV/OCLUtil.cpp
+++ b/lib/SPIRV/OCLUtil.cpp
@@ -363,9 +363,9 @@ getOCLOpaqueTypeAddrSpace(SPIR::TypePrimitiveEnum prim) {
 // Fetch type of invoke function passed to device execution built-ins
 static FunctionType *
 getBlockInvokeTy(Function * F, unsigned blockIdx) {
-    auto params = F->getFunctionType()->params();
-    PointerType * funcPtr = cast<PointerType>(params[blockIdx]);
-    return cast<FunctionType>(funcPtr->getElementType());
+  auto params = F->getFunctionType()->params();
+  PointerType * funcPtr = cast<PointerType>(params[blockIdx]);
+  return cast<FunctionType>(funcPtr->getElementType());
 }
 
 class OCLBuiltinFuncMangleInfo : public SPIRV::BuiltinFuncMangleInfo {
@@ -406,9 +406,9 @@ public:
   } else if (UnmangledName.find("get_") == 0 ||
       UnmangledName == "nan" ||
       UnmangledName == "mem_fence" ||
-      UnmangledName.find("shuffle") == 0){
+      UnmangledName.find("shuffle") == 0) {
     addUnsignedArg(-1);
-    if (UnmangledName.find(kOCLBuiltinName::GetFence) == 0){
+    if (UnmangledName.find(kOCLBuiltinName::GetFence) == 0) {
       setArgAttr(0, SPIR::ATTR_CONST);
       addVoidPtrArg(0);
     }
@@ -418,10 +418,12 @@ public:
     addUnsignedArg(0);
   } else if (UnmangledName.find("atomic_work_item_fence") == 0) {
     addUnsignedArg(0);
+    setEnumArg(1, SPIR::PRIMITIVE_MEMORY_ORDER);
+    setEnumArg(2, SPIR::PRIMITIVE_MEMORY_SCOPE);
   } else if (UnmangledName.find("atomic") == 0) {
     setArgAttr(0, SPIR::ATTR_VOLATILE);
     if (UnmangledName.find("atomic_umax") == 0 ||
-        UnmangledName.find("atomic_umin") == 0) {
+      UnmangledName.find("atomic_umin") == 0) {
       addUnsignedArg(0);
       addUnsignedArg(1);
       UnmangledName.erase(7, 1);
@@ -431,6 +433,21 @@ public:
       addUnsignedArg(1);
       UnmangledName.erase(13, 1);
     }
+    if (UnmangledName.find("store_explicit") != std::string::npos ||
+        UnmangledName.find("exchange_explicit") != std::string::npos ||
+        (UnmangledName.find("atomic_fetch") == 0 && UnmangledName.find("explicit") != std::string::npos)) {
+      setEnumArg(2, SPIR::PRIMITIVE_MEMORY_ORDER);
+      setEnumArg(3, SPIR::PRIMITIVE_MEMORY_SCOPE);
+    } else if (UnmangledName.find("load_explicit") != std::string::npos ||
+              (UnmangledName.find("atomic_flag") == 0 && UnmangledName.find("explicit") != std::string::npos)) {
+      setEnumArg(1, SPIR::PRIMITIVE_MEMORY_ORDER);
+      setEnumArg(2, SPIR::PRIMITIVE_MEMORY_SCOPE);
+    } else if (UnmangledName.find("compare_exchange_strong_explicit") != std::string::npos ||
+               UnmangledName.find("compare_exchange_weak_explicit") != std::string::npos) {
+      setEnumArg(3, SPIR::PRIMITIVE_MEMORY_ORDER);
+      setEnumArg(4, SPIR::PRIMITIVE_MEMORY_ORDER);
+      setEnumArg(5, SPIR::PRIMITIVE_MEMORY_SCOPE);
+    }
     // Don't set atomic property to the first argument of 1.2 atomic built-ins.
     if(UnmangledName.find("atomic_add")  != 0 && UnmangledName.find("atomic_sub") != 0 &&
        UnmangledName.find("atomic_xchg") != 0 && UnmangledName.find("atomic_inc") != 0 &&
diff --git a/lib/SPIRV/SPIRVInternal.h b/lib/SPIRV/SPIRVInternal.h
index 45954ff..1bc7fe4 100644
--- a/lib/SPIRV/SPIRVInternal.h
+++ b/lib/SPIRV/SPIRVInternal.h
@@ -407,7 +407,7 @@ public:
       init(UniqName);

   }

   virtual ~BuiltinFuncMangleInfo(){}

-  const std::string &getUnmangledName() const { return UnmangledName;}

+  const std::string &getUnmangledName() const { return UnmangledName; }

   void addUnsignedArg(int Ndx) { UnsignedArgs.insert(Ndx);}

   void addVoidPtrArg(int Ndx) { VoidPtrArgs.insert(Ndx);}

   void addSamplerArg(int Ndx) { SamplerArgs.insert(Ndx);}

diff --git a/lib/SPIRV/SPIRVLowerConstExpr.cpp b/lib/SPIRV/SPIRVLowerConstExpr.cpp
index e27b479..9ed1fa9 100644
--- a/lib/SPIRV/SPIRVLowerConstExpr.cpp
+++ b/lib/SPIRV/SPIRVLowerConstExpr.cpp
@@ -118,9 +118,9 @@ SPIRVLowerConstExpr::visit(Module *M) {
       std::map<ConstantExpr*, Instruction *> CMap;
       std::list<Instruction *> WorkList;
       auto FBegin = I->begin();
-      for (auto BI = FBegin, BE = I->end(); BI != BE; ++BI) {
-        for (auto II = BI->begin(), IE = BI->end(); II != IE; ++II) {
-          WorkList.push_back(II);
+      for (auto &BI:*I) {
+        for (auto &II:BI) {
+          WorkList.push_back(&II);
         }
       }
       while (!WorkList.empty()) {
diff --git a/lib/SPIRV/SPIRVLowerOCLBlocks.cpp b/lib/SPIRV/SPIRVLowerOCLBlocks.cpp
index bdb4563..b4106a6 100644
--- a/lib/SPIRV/SPIRVLowerOCLBlocks.cpp
+++ b/lib/SPIRV/SPIRVLowerOCLBlocks.cpp
@@ -103,7 +103,7 @@ public:
 

   virtual void getAnalysisUsage(AnalysisUsage &AU) const {

     AU.addRequired<CallGraphWrapperPass>();

-    AU.addRequired<AliasAnalysis>();

+    AU.addRequired<AAResultsWrapperPass>();

     AU.addRequired<AssumptionCacheTracker>();

   }

 

@@ -146,7 +146,7 @@ private:
   eraseUselessFunctions() {

     bool changed = false;

     for (auto I = M->begin(), E = M->end(); I != E;) {

-      Function *F = I++;

+      Function *F = &(*I++);

       if (!GlobalValue::isInternalLinkage(F->getLinkage()) &&

           !F->isDeclaration())

         continue;

@@ -161,10 +161,20 @@ private:
           }

         }

       }

-      if (F->use_empty()) {

-        erase(F);

-        changed = true;

+

+      if (!F->use_empty()) {

+        continue;

+      }

+

+      auto &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();

+      CallGraphNode* CGN = CG[F];

+

+      if (CGN->getNumReferences() != 0) {

+        continue;

       }

+

+      erase(F);

+      changed = true;

     }

     return changed;

   }

@@ -342,8 +352,7 @@ private:
       DEBUG(dbgs() << "[lowerReturnBlock] inline " << F->getName() << '\n');

       auto CG = &getAnalysis<CallGraphWrapperPass>().getCallGraph();

       auto ACT = &getAnalysis<AssumptionCacheTracker>();

-      auto AA = &getAnalysis<AliasAnalysis>();

-      InlineFunctionInfo IFI(CG, M->getDataLayout(), AA, ACT);

+      InlineFunctionInfo IFI(CG, ACT);

       InlineFunction(CI, IFI);

       Inlined = true;

     }

@@ -567,9 +576,18 @@ private:
       dumpUsers(F);

       return;

     }

+

     F->dropAllReferences();

+

     auto &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();

-    CG.removeFunctionFromModule(new CallGraphNode(F));

+    CallGraphNode* CGN = CG[F];

+

+    if (CGN->getNumReferences() != 0) {

+      return;

+    }

+

+    CGN->removeAllCalledFunctions();

+    delete CG.removeFunctionFromModule(CGN);

   }

 

   llvm::PointerType* getOCLClkEventType() {

@@ -605,7 +623,7 @@ INITIALIZE_PASS_BEGIN(SPIRVLowerOCLBlocks, "spvblocks",
     "SPIR-V lower OCL blocks", false, false)

 INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)

 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)

-INITIALIZE_AG_DEPENDENCY(AliasAnalysis)

+INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)

 INITIALIZE_PASS_END(SPIRVLowerOCLBlocks, "spvblocks",

     "SPIR-V lower OCL blocks", false, false)

 

diff --git a/lib/SPIRV/SPIRVReader.cpp b/lib/SPIRV/SPIRVReader.cpp
index 8842294..efc8952 100644
--- a/lib/SPIRV/SPIRVReader.cpp
+++ b/lib/SPIRV/SPIRVReader.cpp
@@ -60,7 +60,7 @@
 #include "llvm/IR/Module.h"

 #include "llvm/IR/Operator.h"

 #include "llvm/IR/Type.h"

-#include "llvm/PassManager.h"

+#include "llvm/IR/LegacyPassManager.h"

 #include "llvm/Support/Casting.h"

 #include "llvm/Support/Debug.h"

 #include "llvm/Support/Dwarf.h"

@@ -206,28 +206,27 @@ public:
         DEBUG_METADATA_VERSION);

   }

 

-  DIFile getDIFile(const std::string &FileName){

-    return getOrInsert(FileMap, FileName, [=](){

+  DIFile* getDIFile(const std::string &FileName){

+    return getOrInsert(FileMap, FileName, [=]() -> DIFile* {

       std::string BaseName;

       std::string Path;

       splitFileName(FileName, BaseName, Path);

       if (!BaseName.empty())

         return Builder.createFile(BaseName, Path);

       else

-        return DIFile();

+        return nullptr;

     });

   }

 

-  DISubprogram getDISubprogram(SPIRVFunction *SF, Function *F){

+  DISubprogram* getDISubprogram(SPIRVFunction *SF, Function *F){

     return getOrInsert(FuncMap, F, [=](){

       auto DF = getDIFile(SpDbg.getFunctionFileStr(SF));

       auto FN = F->getName();

       auto LN = SpDbg.getFunctionLineNo(SF);

-      Metadata *Args[] = {DIType()};

       return Builder.createFunction(DF, FN, FN, DF, LN,

-        Builder.createSubroutineType(DF, Builder.getOrCreateTypeArray(Args)),

+        Builder.createSubroutineType(Builder.getOrCreateTypeArray(None)),

         Function::isInternalLinkage(F->getLinkage()),

-        true, LN, 0, 0, NULL, NULL, NULL);

+        true, LN);

     });

   }

 

@@ -259,8 +258,8 @@ private:
   SPIRVDbgInfo SpDbg;

   DIBuilder Builder;

   bool Enable;

-  std::unordered_map<std::string, DIFile> FileMap;

-  std::unordered_map<Function *, DISubprogram> FuncMap;

+  std::unordered_map<std::string, DIFile *> FileMap;

+  std::unordered_map<Function *, DISubprogram *> FuncMap;

 

   void splitFileName(const std::string &FileName,

       std::string &BaseName,

@@ -558,11 +557,11 @@ SPIRVToLLVM::transOCLBuiltinsFromVariables(){
   std::vector<GlobalVariable *> WorkList;

   for (auto I = M->global_begin(), E = M->global_end(); I != E; ++I) {

     SPIRVBuiltinVariableKind Kind;

-    if (!isSPIRVBuiltinVariable(I, &Kind))

+    if (!isSPIRVBuiltinVariable(&(*I), &Kind))

       continue;

-    if (!transOCLBuiltinFromVariable(I, Kind))

+    if (!transOCLBuiltinFromVariable(&(*I), Kind))

       return false;

-    WorkList.push_back(I);

+    WorkList.push_back(&(*I));

   }

   for (auto &I:WorkList) {

     I->eraseFromParent();

@@ -1053,7 +1052,7 @@ SPIRVToLLVM::postProcessOCL() {
       DEBUG(dbgs() << "[postProcessOCL sret] " << *F << '\n');

       if (F->getReturnType()->isStructTy() &&

           oclIsBuiltin(F->getName(), &DemangledName, isCPP)) {

-        if (!postProcessOCLBuiltinReturnStruct(F))

+        if (!postProcessOCLBuiltinReturnStruct(&(*F)))

           return false;

       }

     }

@@ -1063,8 +1062,8 @@ SPIRVToLLVM::postProcessOCL() {
     if (F->hasName() && F->isDeclaration()) {

       DEBUG(dbgs() << "[postProcessOCL func ptr] " << *F << '\n');

       auto AI = F->arg_begin();

-      if (hasFunctionPointerArg(F, AI) && isDecoratedSPIRVFunc(F))

-        if (!postProcessOCLBuiltinWithFuncPointer(F, AI))

+      if (hasFunctionPointerArg(&(*F), AI) && isDecoratedSPIRVFunc(&(*F)))

+        if (!postProcessOCLBuiltinWithFuncPointer(&(*F), AI))

           return false;

     }

   }

@@ -1072,8 +1071,8 @@ SPIRVToLLVM::postProcessOCL() {
     auto F = I++;

     if (F->hasName() && F->isDeclaration()) {

       DEBUG(dbgs() << "[postProcessOCL array arg] " << *F << '\n');

-      if (hasArrayArg(F) && oclIsBuiltin(F->getName(), &DemangledName, isCPP))

-        if (!postProcessOCLBuiltinWithArrayArguments(F, DemangledName))

+      if (hasArrayArg(&(*F)) && oclIsBuiltin(F->getName(), &DemangledName, isCPP))

+        if (!postProcessOCLBuiltinWithArrayArguments(&(*F), DemangledName))

           return false;

     }

   }

@@ -1153,7 +1152,7 @@ SPIRVToLLVM::postProcessOCLBuiltinWithArrayArguments(Function* F,
       auto T = I->getType();

       if (!T->isArrayTy())

         continue;

-      auto Alloca = new AllocaInst(T, "", FBegin);

+      auto Alloca = new AllocaInst(T, "", &(*FBegin));

       auto Store = new StoreInst(I, Alloca, false, CI);

       auto Zero = ConstantInt::getNullValue(Type::getInt32Ty(T->getContext()));

       Value *Index[] = {Zero, Zero};

@@ -1509,7 +1508,7 @@ SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F,
     for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;

         ++I, ++ArgNo) {

       if (ArgNo == BA->getArgNo())

-        return mapValue(BV, I);

+        return mapValue(BV, &(*I));

     }

     llvm_unreachable("Invalid argument");

     return nullptr;

@@ -1777,11 +1776,11 @@ SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F,
     auto IsInbound = AC->isInBounds();

     Value *V = nullptr;

     if (BB) {

-      auto GEP = GetElementPtrInst::Create(Base, Index, BV->getName(), BB);

+      auto GEP = GetElementPtrInst::Create(nullptr, Base, Index, BV->getName(), BB);

       GEP->setIsInBounds(IsInbound);

       V = GEP;

     } else {

-      V = ConstantExpr::getGetElementPtr(dyn_cast<Constant>(Base), Index,

+      V = ConstantExpr::getGetElementPtr(nullptr, dyn_cast<Constant>(Base), Index,

                                          IsInbound);

     }

     return mapValue(BV, V);

@@ -2028,8 +2027,8 @@ SPIRVToLLVM::transFunction(SPIRVFunction *BF) {
   for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;

       ++I) {

     auto BA = BF->getArgument(I->getArgNo());

-    mapValue(BA, I);

-    setName(I, BA);

+    mapValue(BA, &(*I));

+    setName(&(*I), BA);

     BA->foreachAttr([&](SPIRVFuncParamAttrKind Kind){

       if (Kind == FunctionParameterAttributeNoWrite)

         return;

@@ -2944,7 +2943,7 @@ llvm::ReadSPIRV(LLVMContext &C, std::istream &IS, Module *&M,
     BM->getError(ErrMsg);

     Succeed = false;

   }

-  PassManager PassMgr;

+  llvm::legacy::PassManager PassMgr;

   PassMgr.add(createSPIRVToOCL20());

   PassMgr.add(createOCL20To12());

   PassMgr.run(*M);

diff --git a/lib/SPIRV/SPIRVRegularizeLLVM.cpp b/lib/SPIRV/SPIRVRegularizeLLVM.cpp
index 1631b61..a028543 100644
--- a/lib/SPIRV/SPIRVRegularizeLLVM.cpp
+++ b/lib/SPIRV/SPIRVRegularizeLLVM.cpp
@@ -116,7 +116,7 @@ SPIRVRegularizeLLVM::regularize() {
   //lowerConstantExpressions();
 
   for (auto I = M->begin(), E = M->end(); I != E;) {
-    Function *F = I++;
+    Function *F = &(*I++);
     if (F->isDeclaration() && F->use_empty()) {
       F->eraseFromParent();
       continue;
@@ -192,13 +192,12 @@ void SPIRVRegularizeLLVM::lowerFuncPtr(Function* F, Op OC) {
 void
 SPIRVRegularizeLLVM::lowerFuncPtr(Module* M) {
   std::vector<std::pair<Function *, Op>> Work;
-  for (auto I = M->begin(), E = M->end(); I != E;) {
-    Function *F = I++;
-    auto AI = F->arg_begin();
-    if (hasFunctionPointerArg(F, AI)) {
-      auto OC = getSPIRVFuncOC(F->getName());
+  for (auto &F:*M) {
+    auto AI = F.arg_begin();
+    if (hasFunctionPointerArg(&F, AI)) {
+      auto OC = getSPIRVFuncOC(F.getName());
       assert(OC != OpNop && "Invalid function pointer usage");
-      Work.push_back(std::make_pair(F, OC));
+      Work.push_back(std::make_pair(&F, OC));
     }
   }
   for (auto &I:Work)
diff --git a/lib/SPIRV/SPIRVToOCL20.cpp b/lib/SPIRV/SPIRVToOCL20.cpp
index d994490..9fe3632 100644
--- a/lib/SPIRV/SPIRVToOCL20.cpp
+++ b/lib/SPIRV/SPIRVToOCL20.cpp
@@ -308,7 +308,7 @@ void SPIRVToOCL20::visitCallSPRIVImageQuerySize(CallInst *CI) {
   if (imgArray) {
     assert((imgDim == 1 || imgDim == 2) && "invalid image array type");
     // Insert get_image_array_size to the last position of the resulting vector.
-    Type * sizeTy = Type::getIntNTy(*Ctx, M->getDataLayout()->getPointerSizeInBits(0));
+    Type * sizeTy = Type::getIntNTy(*Ctx, M->getDataLayout().getPointerSizeInBits(0));
     Instruction * getImageArraySize =
       addCallInst(M, kOCLBuiltinName::GetImageArraySize, sizeTy,
                   CI->getArgOperand(0), &attributes,
@@ -370,7 +370,7 @@ void SPIRVToOCL20::visitCallSPIRVAtomicBuiltin(CallInst* CI, Op OC) {
       // value by pointer passed as 2nd argument (aka expected) while SPIR-V
       // instructions returns this new/original value as a resulting value.
       AllocaInst *pExpected = new AllocaInst(CI->getType(), "expected",
-        pInsertBefore->getParent()->getParent()->getEntryBlock().getFirstInsertionPt());
+        &(*pInsertBefore->getParent()->getParent()->getEntryBlock().getFirstInsertionPt()));
       pExpected->setAlignment(CI->getType()->getScalarSizeInBits() / 8);
       new StoreInst(Args[1], pExpected, pInsertBefore);
       Args[1] = pExpected;
diff --git a/lib/SPIRV/SPIRVUtil.cpp b/lib/SPIRV/SPIRVUtil.cpp
index 0c75e11..d420044 100644
--- a/lib/SPIRV/SPIRVUtil.cpp
+++ b/lib/SPIRV/SPIRVUtil.cpp
@@ -41,6 +41,10 @@
 #include "SPIRVInternal.h"
 #include "libSPIRV/SPIRVDecorate.h"
 #include "libSPIRV/SPIRVValue.h"
+#include "NameMangleAPI.h"
+#include "ManglingUtils.h"
+#include "ParameterType.h"
+#include "FunctionDescriptor.h"
 #include "SPIRVMDWalker.h"
 #include "OCLUtil.h"
 
@@ -819,7 +823,7 @@ addBlockBind(Module *M, Function *InvokeFunc, Value *BlkCtx, Value *CtxLen,
 
 IntegerType* getSizetType(Module *M) {
   return IntegerType::getIntNTy(M->getContext(),
-    M->getDataLayout()->getPointerSizeInBits(0));
+    M->getDataLayout().getPointerSizeInBits(0));
 }
 
 Type *
@@ -1370,19 +1374,37 @@ bool
 eraseUselessFunctions(Module *M) {
   bool changed = false;
   for (auto I = M->begin(), E = M->end(); I != E;)
-    changed |= eraseIfNoUse(I++);
+    changed |= eraseIfNoUse(&(*I++));
   return changed;
 }
 
+// The mangling algorithm follows OpenCL pipe built-ins clang 3.8 CodeGen rules.
+static SPIR::MangleError
+manglePipeBuiltin(const SPIR::FunctionDescriptor &fd, std::string &mangledName) {
+  assert(SPIR::isPipeBuiltin(fd.name) &&
+    "Method is expected to be called only for pipe builtins!");
+  if (fd.isNull()) {
+    mangledName.assign(SPIR::FunctionDescriptor::nullString());
+    return SPIR::MANGLE_NULL_FUNC_DESCRIPTOR;
+  }
+  mangledName.assign("__" + fd.name);
+  if (fd.name.compare("write_pipe") == 0 || fd.name.compare("read_pipe") == 0) {
+    // add "_2" or "_4" postfix reflecting the number of explicit args.
+    mangledName.append("_");
+    // subtruct 2 in order to not count size and alignment of packet.
+    mangledName.append(std::to_string(fd.parameters.size() - 2));
+  }
+  return SPIR::MANGLE_SUCCESS;
+}
+
 std::string
 mangleBuiltin(const std::string &UniqName,
-    ArrayRef<Type*> ArgTypes, BuiltinFuncMangleInfo* BtnInfo) {
+  ArrayRef<Type*> ArgTypes, BuiltinFuncMangleInfo* BtnInfo) {
   if (!BtnInfo)
     return UniqName;
   BtnInfo->init(UniqName);
   std::string MangledName;
   DEBUG(dbgs() << "[mangle] " << UniqName << " => ");
-  SPIR::NameMangler Mangler(SPIR::SPIR20);
   SPIR::FunctionDescriptor FD;
   FD.name = BtnInfo->getUnmangledName();
   bool BIVarArgNegative = BtnInfo->getVarArg() < 0;
@@ -1390,26 +1412,38 @@ mangleBuiltin(const std::string &UniqName,
   if (ArgTypes.empty()) {
     // Function signature cannot be ()(void, ...) so if there is an ellipsis
     // it must be ()(...)
-    if(BIVarArgNegative) {
+    if (BIVarArgNegative) {
       FD.parameters.emplace_back(SPIR::RefParamType(new SPIR::PrimitiveType(
         SPIR::PRIMITIVE_VOID)));
     }
   } else {
-    for (unsigned I = 0, 
-         E = BIVarArgNegative ? ArgTypes.size() : (unsigned)BtnInfo->getVarArg();
-         I != E; ++I) {
+    for (unsigned I = 0,
+      E = BIVarArgNegative ? ArgTypes.size() : (unsigned)BtnInfo->getVarArg();
+      I != E; ++I) {
       auto T = ArgTypes[I];
       FD.parameters.emplace_back(transTypeDesc(T, BtnInfo->getTypeMangleInfo(I)));
     }
   }
   // Ellipsis must be the last argument of any function
-  if(!BIVarArgNegative) {
+  if (!BIVarArgNegative) {
     assert((unsigned)BtnInfo->getVarArg() <= ArgTypes.size()
-           && "invalid index of an ellipsis");
+      && "invalid index of an ellipsis");
     FD.parameters.emplace_back(SPIR::RefParamType(new SPIR::PrimitiveType(
-        SPIR::PRIMITIVE_VAR_ARG)));
+      SPIR::PRIMITIVE_VAR_ARG)));
   }
+
+#if defined(SPIRV_SPIR20_MANGLING_REQUIREMENTS)
+  SPIR::NameMangler Mangler(SPIR::SPIR20);
   Mangler.mangle(FD, MangledName);
+#else
+  if (SPIR::isPipeBuiltin(BtnInfo->getUnmangledName())) {
+    manglePipeBuiltin(FD, MangledName);
+  } else {
+    SPIR::NameMangler Mangler(SPIR::SPIR20);
+    Mangler.mangle(FD, MangledName);
+  }
+#endif
+
   DEBUG(dbgs() << MangledName << '\n');
   return MangledName;
 }
diff --git a/lib/SPIRV/SPIRVWriter.cpp b/lib/SPIRV/SPIRVWriter.cpp
index e62bca6..127262d 100644
--- a/lib/SPIRV/SPIRVWriter.cpp
+++ b/lib/SPIRV/SPIRVWriter.cpp
@@ -68,9 +68,9 @@
 #include "llvm/IR/Module.h"

 #include "llvm/IR/Operator.h"

 #include "llvm/IR/Verifier.h"

+#include "llvm/IR/LegacyPassManager.h"

 #include "llvm/Pass.h"

 #include "llvm/PassSupport.h"

-#include "llvm/PassManager.h"

 #include "llvm/Support/Casting.h"

 #include "llvm/Support/CommandLine.h"

 #include "llvm/Support/Debug.h"

@@ -135,15 +135,14 @@ public:
   void transDbgInfo(Value *V, SPIRVValue *BV) {

     if (auto I = dyn_cast<Instruction>(V)) {

       auto DL = I->getDebugLoc();

-      if (!DL.isUnknown()) {

-        DILocation DIL(DL.getAsMDNode());

-        auto File = BM->getString(DIL.getFilename().str());

-        BM->addLine(BV, File->getId(), DIL.getLineNumber(), DIL.getColumnNumber());

+      if (DL) {

+        auto File = BM->getString(DL->getFilename().str());

+        BM->addLine(BV, File, DL->getLine(), DL->getColumn());

       }

     } else if (auto F = dyn_cast<Function>(V)) {

       if (auto DIS = getDISubprogram(F)) {

-        auto File = BM->getString(DIS.getFilename().str());

-        BM->addLine(BV, File->getId(), DIS.getLineNumber(), 0);

+        auto File = BM->getString(DIS->getFilename().str());

+        BM->addLine(BV, File->getId(), DIS->getLine(), 0);

       }

     }

   }

@@ -1437,7 +1436,7 @@ bool
 LLVMToSPIRV::transGlobalVariables() {

   for (auto I = M->global_begin(),

             E = M->global_end(); I != E; ++I) {

-    if (!transValue(I, nullptr))

+    if (!transValue(&(*I), nullptr))

       return false;

   }

   return true;

@@ -1470,14 +1469,13 @@ void
 LLVMToSPIRV::transFunction(Function *I) {

   transFunctionDecl(I);

   // Creating all basic blocks before creating any instruction.

-  for (Function::iterator FI = I->begin(), FE = I->end(); FI != FE; ++FI) {

-    transValue(FI, nullptr);

-  }

-  for (Function::iterator FI = I->begin(), FE = I->end(); FI != FE; ++FI) {

-    SPIRVBasicBlock* BB = static_cast<SPIRVBasicBlock*>(transValue(FI, nullptr));

-    for (BasicBlock::iterator BI = FI->begin(), BE = FI->end(); BI != BE;

-        ++BI) {

-      transValue(BI, BB, false);

+  for (auto &FI:*I) {

+    transValue(&FI, nullptr);

+  }

+  for (auto &FI:*I) {

+    SPIRVBasicBlock* BB = static_cast<SPIRVBasicBlock*>(transValue(&FI, nullptr));

+    for (auto &BI:FI) {

+      transValue(&BI, BB, false);

     }

   }

 }

@@ -1497,26 +1495,25 @@ LLVMToSPIRV::translate() {
   if (!transGlobalVariables())

     return false;

 

-  for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) {

-    Function *F = I;

-    auto FT = F->getFunctionType();

+  for (auto &F:*M) {

+    auto FT = F.getFunctionType();

     std::map<unsigned, Type *> ChangedType;

-    oclGetMutatedArgumentTypesByBuiltin(FT, ChangedType, F);

-    mutateFuncArgType(ChangedType, F);

+    oclGetMutatedArgumentTypesByBuiltin(FT, ChangedType, &F);

+    mutateFuncArgType(ChangedType, &F);

   }

 

   // SPIR-V logical layout requires all function declarations go before

   // function definitions.

   std::vector<Function *> Decls, Defs;

-  for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) {

-    if (isBuiltinTransToInst(I) || isBuiltinTransToExtInst(I)

-        || I->getName().startswith(SPCV_CAST) ||

-        I->getName().startswith(LLVM_MEMCPY))

+  for (auto &F:*M) {

+    if (isBuiltinTransToInst(&F) || isBuiltinTransToExtInst(&F)

+        || F.getName().startswith(SPCV_CAST) ||

+        F.getName().startswith(LLVM_MEMCPY))

       continue;

-    if (I->isDeclaration())

-      Decls.push_back(I);

+    if (F.isDeclaration())

+      Decls.push_back(&F);

     else

-      Defs.push_back(I);

+      Defs.push_back(&F);

   }

   for (auto I:Decls)

     transFunctionDecl(I);

@@ -1536,7 +1533,7 @@ LLVMToSPIRV::translate() {
 

 llvm::IntegerType* LLVMToSPIRV::getSizetType() {

   return IntegerType::getIntNTy(M->getContext(),

-    M->getDataLayout()->getPointerSizeInBits());

+    M->getDataLayout().getPointerSizeInBits());

 }

 

 void

@@ -1829,7 +1826,7 @@ ModulePass *llvm::createLLVMToSPIRV(SPIRVModule *SMod) {
 }

 

 void

-addPassesForSPIRV(PassManager &PassMgr) {

+addPassesForSPIRV(legacy::PassManager &PassMgr) {

   if (SPIRVMemToReg)

     PassMgr.add(createPromoteMemoryToRegisterPass());

   PassMgr.add(createTransOCLMD());

@@ -1846,7 +1843,7 @@ addPassesForSPIRV(PassManager &PassMgr) {
 bool

 llvm::WriteSPIRV(Module *M, llvm::raw_ostream &OS, std::string &ErrMsg) {

   std::unique_ptr<SPIRVModule> BM(SPIRVModule::createSPIRVModule());

-  PassManager PassMgr;

+  legacy::PassManager PassMgr;

   addPassesForSPIRV(PassMgr);

   PassMgr.add(createLLVMToSPIRV(BM.get()));

   PassMgr.run(*M);

@@ -1860,7 +1857,7 @@ llvm::WriteSPIRV(Module *M, llvm::raw_ostream &OS, std::string &ErrMsg) {
 bool

 llvm::RegularizeLLVMForSPIRV(Module *M, std::string &ErrMsg) {

   std::unique_ptr<SPIRVModule> BM(SPIRVModule::createSPIRVModule());

-  PassManager PassMgr;

+  legacy::PassManager PassMgr;

   addPassesForSPIRV(PassMgr);

   PassMgr.run(*M);

   return true;