Merge remote-tracking branch 'intel_llvm/sycl' into public_vklochkov_reduction_N_vars_perf

Author: v-klochkov

clang/include/clang/Basic/Attr.td

@@ -1846,13 +1846,14 @@ def SYCLIntelFPGAIVDep : Attr {
   let Documentation = [SYCLIntelFPGAIVDepAttrDocs];
 }
 
-def SYCLIntelFPGAII : Attr {
+def SYCLIntelFPGAInitiationInterval : StmtAttr {
   let Spellings = [CXX11<"intelfpga","ii">,
-                   CXX11<"intel","ii">];
+                   CXX11<"intel","ii">,
+                   CXX11<"intel", "initiation_interval">];
   let Args = [ExprArgument<"IntervalExpr">];
   let LangOpts = [SYCLIsDevice, SYCLIsHost];
   let HasCustomTypeTransform = 1;
-  let Documentation = [SYCLIntelFPGAIIAttrDocs];
+  let Documentation = [SYCLIntelFPGAInitiationIntervalAttrDocs];
 }
 
 def SYCLIntelFPGAMaxConcurrency : Attr {

clang/include/clang/Basic/AttrDocs.td

@@ -2749,24 +2749,27 @@ the no-array ivdep's safelen, with the correspondent treatment by the backend.
   }];
 }
 
-def SYCLIntelFPGAIIAttrDocs : Documentation {
+def SYCLIntelFPGAInitiationIntervalAttrDocs : Documentation {
   let Category = DocCatVariable;
-  let Heading = "intel::ii";
+  let Heading = "intel::initiation_interval";
   let Content = [{
 This attribute applies to a loop. Indicates that the loop should be pipelined
 with an initiation interval of N. N must be a positive integer. Cannot be
 applied multiple times to the same loop.
 
+The ``[[intel::ii]]`` attribute spelling is a deprecated synonym for
+``[[intel::initiation_interval]]`` and will be removed in the future.
+
 .. code-block:: c++
 
   void foo() {
     int var = 0;
-    [[intel::ii(4)]] for (int i = 0; i < 10; ++i) var++;
+    [[intel::initiation_interval(4)]] for (int i = 0; i < 10; ++i) var++;
   }
 
   template<int N>
   void bar() {
-    [[intel::ii(N)]] for(;;) { }
+    [[intel::initiation_interval(N)]] for(;;) { }
   }
 
   }];

clang/include/clang/Sema/Sema.h

@@ -12996,7 +12996,11 @@ class Sema final {
   void checkSYCLDeviceVarDecl(VarDecl *Var);
   void ConstructOpenCLKernel(FunctionDecl *KernelCallerFunc, MangleContext &MC);
   void MarkDevice();
-  void MarkSyclSimd();
+
+  /// Emit a diagnostic about the given attribute having a deprecated name, and
+  /// also emit a fixit hint to generate the new attribute name.
+  void DiagnoseDeprecatedAttribute(const ParsedAttr &A, StringRef NewScope,
+                                   StringRef NewName);
 
   /// Diagnoses an attribute in the 'intelfpga' namespace and suggests using
   /// the attribute in the 'intel' namespace instead.
@@ -13252,7 +13256,7 @@ FPGALoopAttrT *Sema::BuildSYCLIntelFPGALoopAttr(const AttributeCommonInfo &A,
 
     int Val = ArgVal->getSExtValue();
 
-    if (A.getParsedKind() == ParsedAttr::AT_SYCLIntelFPGAII ||
+    if (A.getParsedKind() == ParsedAttr::AT_SYCLIntelFPGAInitiationInterval ||
         A.getParsedKind() == ParsedAttr::AT_SYCLIntelFPGALoopCoalesce) {
       if (Val <= 0) {
         Diag(E->getExprLoc(), diag::err_attribute_requires_positive_integer)

clang/lib/Basic/Targets/SPIR.h

@@ -114,6 +114,16 @@ class LLVM_LIBRARY_VISIBILITY SPIRTargetInfo : public TargetInfo {
     return CC_SpirFunction;
   }
 
+  llvm::Optional<LangAS> getConstantAddressSpace() const override {
+    // If we assign "opencl_constant" address space the following code becomes
+    // illegal, because it can't be cast to any other address space:
+    //
+    //   const char *getLiteral() {
+    //     return "AB";
+    //   }
+    return LangAS::opencl_global;
+  }
+
   void setSupportedOpenCLOpts() override {
     // Assume all OpenCL extensions and optional core features are supported
     // for SPIR since it is a generic target.

clang/lib/CodeGen/CGCall.cpp

@@ -4771,17 +4771,6 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
             V->getType()->isIntegerTy())
           V = Builder.CreateZExt(V, ArgInfo.getCoerceToType());
 
-        if (FirstIRArg < IRFuncTy->getNumParams()) {
-          const auto *LHSPtrTy =
-              dyn_cast_or_null<llvm::PointerType>(V->getType());
-          const auto *RHSPtrTy = dyn_cast_or_null<llvm::PointerType>(
-              IRFuncTy->getParamType(FirstIRArg));
-          if (LHSPtrTy && RHSPtrTy &&
-              LHSPtrTy->getAddressSpace() != RHSPtrTy->getAddressSpace())
-            V = Builder.CreateAddrSpaceCast(V,
-                                            IRFuncTy->getParamType(FirstIRArg));
-        }
-
         // If the argument doesn't match, perform a bitcast to coerce it.  This
         // can happen due to trivial type mismatches.
         if (FirstIRArg < IRFuncTy->getNumParams() &&
@@ -5002,20 +4991,6 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
   if (!CallArgs.getCleanupsToDeactivate().empty())
     deactivateArgCleanupsBeforeCall(*this, CallArgs);
 
-  // Addrspace cast to generic if necessary
-  for (unsigned i = 0; i < IRFuncTy->getNumParams(); ++i) {
-    if (auto *PtrTy = dyn_cast<llvm::PointerType>(IRCallArgs[i]->getType())) {
-      auto *ExpectedPtrType =
-          cast<llvm::PointerType>(IRFuncTy->getParamType(i));
-      unsigned ValueAS = PtrTy->getAddressSpace();
-      unsigned ExpectedAS = ExpectedPtrType->getAddressSpace();
-      if (ValueAS != ExpectedAS) {
-        IRCallArgs[i] = Builder.CreatePointerBitCastOrAddrSpaceCast(
-            IRCallArgs[i], ExpectedPtrType);
-      }
-    }
-  }
-
   // Assert that the arguments we computed match up.  The IR verifier
   // will catch this, but this is a common enough source of problems
   // during IRGen changes that it's way better for debugging to catch

clang/lib/CodeGen/CGClass.cpp

@@ -342,7 +342,7 @@ Address CodeGenFunction::GetAddressOfBaseClass(
       EmitTypeCheck(TCK_Upcast, Loc, Value.getPointer(),
                     DerivedTy, DerivedAlign, SkippedChecks);
     }
-    return Builder.CreatePointerBitCastOrAddrSpaceCast(Value, BasePtrTy);
+    return Builder.CreateBitCast(Value, BasePtrTy);
   }
 
   llvm::BasicBlock *origBB = nullptr;

clang/lib/CodeGen/CGDecl.cpp

@@ -1642,8 +1642,12 @@ CodeGenFunction::EmitAutoVarAlloca(const VarDecl &D) {
     CGM.generateIntelFPGAAnnotation(&D, AnnotStr);
     if (!AnnotStr.empty()) {
       llvm::Value *V = address.getPointer();
-      EmitAnnotationCall(CGM.getIntrinsic(llvm::Intrinsic::var_annotation),
-                         Builder.CreateBitCast(V, CGM.Int8PtrTy, V->getName()),
+      llvm::Type *DestPtrTy = llvm::PointerType::getInt8PtrTy(
+          CGM.getLLVMContext(), address.getAddressSpace());
+      llvm::Value *Arg = Builder.CreateBitCast(V, DestPtrTy, V->getName());
+      if (address.getAddressSpace() != 0)
+        Arg = Builder.CreateAddrSpaceCast(Arg, CGM.Int8PtrTy, V->getName());
+      EmitAnnotationCall(CGM.getIntrinsic(llvm::Intrinsic::var_annotation), Arg,
                          AnnotStr, D.getLocation());
     }
   }

clang/lib/CodeGen/CGExpr.cpp

@@ -1125,8 +1125,10 @@ Address CodeGenFunction::EmitPointerWithAlignment(const Expr *E,
                                       CodeGenFunction::CFITCK_UnrelatedCast,
                                       CE->getBeginLoc());
         }
-        return Builder.CreatePointerBitCastOrAddrSpaceCast(
-            Addr, ConvertType(E->getType()));
+        return CE->getCastKind() != CK_AddressSpaceConversion
+                   ? Builder.CreateBitCast(Addr, ConvertType(E->getType()))
+                   : Builder.CreateAddrSpaceCast(Addr,
+                                                 ConvertType(E->getType()));
       }
       break;
 
@@ -1855,16 +1857,6 @@ void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, Address Addr,
     return;
   }
 
-  if (auto *PtrTy = dyn_cast<llvm::PointerType>(Value->getType())) {
-    auto *ExpectedPtrType =
-        cast<llvm::PointerType>(Addr.getType()->getElementType());
-    unsigned ValueAS = PtrTy->getAddressSpace();
-    unsigned ExpectedAS = ExpectedPtrType->getAddressSpace();
-    if (ValueAS != ExpectedAS) {
-      Value =
-          Builder.CreatePointerBitCastOrAddrSpaceCast(Value, ExpectedPtrType);
-    }
-  }
   llvm::StoreInst *Store = Builder.CreateStore(Value, Addr, Volatile);
   if (isNontemporal) {
     llvm::MDNode *Node =
@@ -4614,39 +4606,14 @@ EmitConditionalOperatorLValue(const AbstractConditionalOperator *expr) {
   EmitBlock(contBlock);
 
   if (lhs && rhs) {
-    llvm::Value *lhsPtr = lhs->getPointer(*this);
-    llvm::Value *rhsPtr = rhs->getPointer(*this);
-    if (rhsPtr->getType() != lhsPtr->getType()) {
-      if (!getLangOpts().SYCLIsDevice)
-        llvm_unreachable(
-            "Unable to find a common address space for two pointers.");
-
-      auto CastToAS = [](llvm::Value *V, llvm::BasicBlock *BB, unsigned AS) {
-        auto *Ty = cast<llvm::PointerType>(V->getType());
-        if (Ty->getAddressSpace() == AS)
-          return V;
-        llvm::IRBuilder<> Builder(BB->getTerminator());
-        auto *TyAS = llvm::PointerType::get(Ty->getElementType(), AS);
-        return Builder.CreatePointerBitCastOrAddrSpaceCast(V, TyAS);
-      };
-
-      // Language rules define if it is legal to cast from one address space
-      // to another, and which address space we should use as a "common
-      // denominator". In SYCL, generic address space overlaps with all other
-      // address spaces.
-      unsigned GenericAS =
-          getContext().getTargetAddressSpace(LangAS::opencl_generic);
-
-      lhsPtr = CastToAS(lhsPtr, lhsBlock, GenericAS);
-      rhsPtr = CastToAS(rhsPtr, rhsBlock, GenericAS);
-    }
-    llvm::PHINode *phi = Builder.CreatePHI(lhsPtr->getType(), 2, "cond-lvalue");
-    phi->addIncoming(lhsPtr, lhsBlock);
-    phi->addIncoming(rhsPtr, rhsBlock);
+    llvm::PHINode *phi =
+        Builder.CreatePHI(lhs->getPointer(*this)->getType(), 2, "cond-lvalue");
+    phi->addIncoming(lhs->getPointer(*this), lhsBlock);
+    phi->addIncoming(rhs->getPointer(*this), rhsBlock);
     Address result(phi, std::min(lhs->getAlignment(), rhs->getAlignment()));
     AlignmentSource alignSource =
-        std::max(lhs->getBaseInfo().getAlignmentSource(),
-                 rhs->getBaseInfo().getAlignmentSource());
+      std::max(lhs->getBaseInfo().getAlignmentSource(),
+               rhs->getBaseInfo().getAlignmentSource());
     TBAAAccessInfo TBAAInfo = CGM.mergeTBAAInfoForConditionalOperator(
         lhs->getTBAAInfo(), rhs->getTBAAInfo());
     return MakeAddrLValue(result, expr->getType(), LValueBaseInfo(alignSource),

clang/lib/CodeGen/CGExprAgg.cpp

@@ -498,13 +498,7 @@ void AggExprEmitter::EmitArrayInit(Address DestPtr, llvm::ArrayType *AType,
       elementType.isTriviallyCopyableType(CGF.getContext())) {
     CodeGen::CodeGenModule &CGM = CGF.CGM;
     ConstantEmitter Emitter(CGF);
-    LangAS AS = ArrayQTy.getAddressSpace();
-    if (CGM.getLangOpts().SYCLIsDevice && AS == LangAS::Default) {
-      // SYCL's default AS is 'generic', which can't be used to define constant
-      // initializer data in. It is reasonable to keep it in the same AS
-      // as string literals.
-      AS = CGM.getStringLiteralAddressSpace();
-    }
+    LangAS AS = CGM.GetGlobalVarAddressSpace(/*VarDecl= */ nullptr);
     if (llvm::Constant *C = Emitter.tryEmitForInitializer(E, AS, ArrayQTy)) {
       auto GV = new llvm::GlobalVariable(
           CGM.getModule(), C->getType(),

clang/lib/CodeGen/CGExprScalar.cpp

@@ -1964,26 +1964,10 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
     Value *Src = Visit(const_cast<Expr*>(E));
     llvm::Type *SrcTy = Src->getType();
     llvm::Type *DstTy = ConvertType(DestTy);
-    bool NeedAddrspaceCast = false;
     if (SrcTy->isPtrOrPtrVectorTy() && DstTy->isPtrOrPtrVectorTy() &&
         SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace()) {
-      // If we have the same address space in AST, which is then codegen'ed to
-      // different address spaces in IR, then an address space cast should be
-      // valid.
-      //
-      // This is the case for SYCL, where both types have Default address space
-      // in AST, but in IR one of them may be in opencl_private, and another in
-      // opencl_generic address space:
-      //
-      //   int arr[5];    // automatic variable, default AS in AST,
-      //                  // private AS in IR
-      //
-      //   char* p = arr; // default AS in AST, generic AS in IR
-      //
-      if (E->getType().getAddressSpace() != DestTy.getAddressSpace())
-        llvm_unreachable("wrong cast for pointers in different address spaces"
-                         "(must be an address space cast)!");
-      NeedAddrspaceCast = true;
+      llvm_unreachable("wrong cast for pointers in different address spaces"
+                       "(must be an address space cast)!");
     }
 
     if (CGF.SanOpts.has(SanitizerKind::CFIUnrelatedCast)) {
@@ -2022,14 +2006,6 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
       }
     }
 
-    if (NeedAddrspaceCast) {
-      llvm::Type *SrcPointeeTy = Src->getType()->getPointerElementType();
-      llvm::Type *SrcNewAS = llvm::PointerType::get(
-          SrcPointeeTy, cast<llvm::PointerType>(DstTy)->getAddressSpace());
-
-      Src = Builder.CreateAddrSpaceCast(Src, SrcNewAS);
-    }
-
     // If Src is a fixed vector and Dst is a scalable vector, and both have the
     // same element type, use the llvm.experimental.vector.insert intrinsic to
     // perform the bitcast.
@@ -2966,53 +2942,6 @@ Value *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) {
 //                           Binary Operators
 //===----------------------------------------------------------------------===//
 
-static Value *insertAddressSpaceCast(Value *V, unsigned NewAS) {
-  auto *VTy = cast<llvm::PointerType>(V->getType());
-  if (VTy->getAddressSpace() == NewAS)
-    return V;
-
-  llvm::PointerType *VTyNewAS =
-      llvm::PointerType::get(VTy->getElementType(), NewAS);
-
-  if (auto *Constant = dyn_cast<llvm::Constant>(V))
-    return llvm::ConstantExpr::getAddrSpaceCast(Constant, VTyNewAS);
-
-  llvm::Instruction *NewV =
-      new llvm::AddrSpaceCastInst(V, VTyNewAS, V->getName() + ".ascast");
-  NewV->insertAfter(cast<llvm::Instruction>(V));
-  return NewV;
-}
-
-static void ensureSameAddrSpace(Value *&RHS, Value *&LHS,
-                                bool CanInsertAddrspaceCast,
-                                const LangOptions &Opts,
-                                const ASTContext &Context) {
-  if (RHS->getType() == LHS->getType())
-    return;
-
-  auto *RHSTy = dyn_cast<llvm::PointerType>(RHS->getType());
-  auto *LHSTy = dyn_cast<llvm::PointerType>(LHS->getType());
-  if (!RHSTy || !LHSTy || RHSTy->getAddressSpace() == LHSTy->getAddressSpace())
-    return;
-
-  if (!CanInsertAddrspaceCast)
-    // Pointers have different address spaces and we cannot do anything with
-    // this.
-    llvm_unreachable("Pointers are expected to have the same address space.");
-
-  // Language rules define if it is legal to cast from one address space to
-  // another, and which address space we should use as a "common
-  // denominator". In SYCL, generic address space overlaps with all other
-  // address spaces.
-  if (Opts.SYCLIsDevice) {
-    unsigned GenericAS = Context.getTargetAddressSpace(LangAS::opencl_generic);
-    RHS = insertAddressSpaceCast(RHS, GenericAS);
-    LHS = insertAddressSpaceCast(LHS, GenericAS);
-  } else
-    llvm_unreachable("Unable to find a common address space for "
-                     "two pointers.");
-}
-
 BinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) {
   TestAndClearIgnoreResultAssign();
   BinOpInfo Result;
@@ -4134,14 +4063,6 @@ Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,
           RHS = Builder.CreateStripInvariantGroup(RHS);
       }
 
-      // Expression operands may have the same addrspace in AST, but different
-      // addrspaces in LLVM IR, in which case an addrspacecast should be valid.
-      bool CanInsertAddrspaceCast =
-             LHSTy.getAddressSpace() == RHSTy.getAddressSpace();
-
-      ensureSameAddrSpace(RHS, LHS, CanInsertAddrspaceCast, CGF.getLangOpts(),
-                          CGF.getContext());
-
       Result = Builder.CreateICmp(UICmpOpc, LHS, RHS, "cmp");
     }
 
@@ -4513,6 +4434,7 @@ static bool isCheapEnoughToEvaluateUnconditionally(const Expr *E,
   // exist in the source-level program.
 }
 
+
 Value *ScalarExprEmitter::
 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
   TestAndClearIgnoreResultAssign();
@@ -4621,15 +4543,6 @@ VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
       assert(!RHS && "LHS and RHS types must match");
       return nullptr;
     }
-
-    // Expressions may have the same addrspace in AST, but different address
-    // space in LLVM IR, in which case an addrspacecast should be valid.
-    bool CanInsertAddrspaceCast = rhsExpr->getType().getAddressSpace() ==
-                                  lhsExpr->getType().getAddressSpace();
-
-    ensureSameAddrSpace(RHS, LHS, CanInsertAddrspaceCast, CGF.getLangOpts(),
-                        CGF.getContext());
-
     return Builder.CreateSelect(CondV, LHS, RHS, "cond");
   }
 
@@ -4664,14 +4577,6 @@ VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
   if (!RHS)
     return LHS;
 
-  // Expressions may have the same addrspace in AST, but different address
-  // space in LLVM IR, in which case an addrspacecast should be valid.
-  bool CanInsertAddrspaceCast = rhsExpr->getType().getAddressSpace() ==
-                                lhsExpr->getType().getAddressSpace();
-
-  ensureSameAddrSpace(RHS, LHS, CanInsertAddrspaceCast, CGF.getLangOpts(),
-                      CGF.getContext());
-
   // Create a PHI node for the real part.
   llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), 2, "cond");
   PN->addIncoming(LHS, LHSBlock);