merge main into amd-staging

Author: ronlieb

clang/docs/ReleaseNotes.rst

@@ -866,7 +866,7 @@ Miscellaneous Clang Crashes Fixed
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - Fixed crash when ``-print-stats`` is enabled in compiling IR files. (#GH131608)
-- Fix code completion crash involving PCH serialzied templates. (#GH139019)
+- Fix code completion crash involving PCH serialized templates. (#GH139019)
 
 OpenACC Specific Changes
 ------------------------

clang/include/clang/AST/ExprCXX.h

@@ -1290,7 +1290,7 @@ class CXXDefaultArgExpr final
     CXXDefaultArgExprBits.Loc = Loc;
     CXXDefaultArgExprBits.HasRewrittenInit = RewrittenExpr != nullptr;
     if (RewrittenExpr)
-      *getTrailingObjects<Expr *>() = RewrittenExpr;
+      *getTrailingObjects() = RewrittenExpr;
     setDependence(computeDependence(this));
   }
 
@@ -1323,7 +1323,7 @@ class CXXDefaultArgExpr final
   }
 
   Expr *getRewrittenExpr() {
-    return hasRewrittenInit() ? *getTrailingObjects<Expr *>() : nullptr;
+    return hasRewrittenInit() ? *getTrailingObjects() : nullptr;
   }
 
   const Expr *getRewrittenExpr() const {
@@ -1421,14 +1421,14 @@ class CXXDefaultInitExpr final
   /// any.
   const Expr *getRewrittenExpr() const {
     assert(hasRewrittenInit() && "expected a rewritten init expression");
-    return *getTrailingObjects<Expr *>();
+    return *getTrailingObjects();
   }
 
   /// Retrieve the initializing expression with evaluated immediate calls, if
   /// any.
   Expr *getRewrittenExpr() {
     assert(hasRewrittenInit() && "expected a rewritten init expression");
-    return *getTrailingObjects<Expr *>();
+    return *getTrailingObjects();
   }
 
   const DeclContext *getUsedContext() const { return UsedContext; }
@@ -1982,8 +1982,8 @@ class LambdaExpr final : public Expr,
   /// Construct an empty lambda expression.
   LambdaExpr(EmptyShell Empty, unsigned NumCaptures);
 
-  Stmt **getStoredStmts() { return getTrailingObjects<Stmt *>(); }
-  Stmt *const *getStoredStmts() const { return getTrailingObjects<Stmt *>(); }
+  Stmt **getStoredStmts() { return getTrailingObjects(); }
+  Stmt *const *getStoredStmts() const { return getTrailingObjects(); }
 
   void initBodyIfNeeded() const;
 
@@ -3621,7 +3621,7 @@ class ExprWithCleanups final
                                   ArrayRef<CleanupObject> objects);
 
   ArrayRef<CleanupObject> getObjects() const {
-    return getTrailingObjects<CleanupObject>(getNumObjects());
+    return getTrailingObjects(getNumObjects());
   }
 
   unsigned getNumObjects() const { return ExprWithCleanupsBits.NumObjects; }
@@ -3742,14 +3742,14 @@ class CXXUnresolvedConstructExpr final
   using arg_iterator = Expr **;
   using arg_range = llvm::iterator_range<arg_iterator>;
 
-  arg_iterator arg_begin() { return getTrailingObjects<Expr *>(); }
+  arg_iterator arg_begin() { return getTrailingObjects(); }
   arg_iterator arg_end() { return arg_begin() + getNumArgs(); }
   arg_range arguments() { return arg_range(arg_begin(), arg_end()); }
 
   using const_arg_iterator = const Expr* const *;
   using const_arg_range = llvm::iterator_range<const_arg_iterator>;
 
-  const_arg_iterator arg_begin() const { return getTrailingObjects<Expr *>(); }
+  const_arg_iterator arg_begin() const { return getTrailingObjects(); }
   const_arg_iterator arg_end() const { return arg_begin() + getNumArgs(); }
   const_arg_range arguments() const {
     return const_arg_range(arg_begin(), arg_end());
@@ -3860,10 +3860,6 @@ class CXXDependentScopeMemberExpr final
     return getNumTemplateArgs();
   }
 
-  unsigned numTrailingObjects(OverloadToken<NamedDecl *>) const {
-    return hasFirstQualifierFoundInScope();
-  }
-
   CXXDependentScopeMemberExpr(const ASTContext &Ctx, Expr *Base,
                               QualType BaseType, bool IsArrow,
                               SourceLocation OperatorLoc,
@@ -4419,7 +4415,7 @@ class SizeOfPackExpr final
         Length(Length ? *Length : PartialArgs.size()), Pack(Pack) {
     assert((!Length || PartialArgs.empty()) &&
            "have partial args for non-dependent sizeof... expression");
-    auto *Args = getTrailingObjects<TemplateArgument>();
+    auto *Args = getTrailingObjects();
     llvm::uninitialized_copy(PartialArgs, Args);
     setDependence(Length ? ExprDependence::None
                          : ExprDependence::ValueInstantiation);
@@ -4472,8 +4468,7 @@ class SizeOfPackExpr final
   /// Get
   ArrayRef<TemplateArgument> getPartialArguments() const {
     assert(isPartiallySubstituted());
-    const auto *Args = getTrailingObjects<TemplateArgument>();
-    return llvm::ArrayRef(Args, Args + Length);
+    return getTrailingObjects(Length);
   }
 
   SourceLocation getBeginLoc() const LLVM_READONLY { return OperatorLoc; }
@@ -4517,8 +4512,7 @@ class PackIndexingExpr final
         SubExprs{PackIdExpr, IndexExpr} {
     PackIndexingExprBits.TransformedExpressions = SubstitutedExprs.size();
     PackIndexingExprBits.FullySubstituted = FullySubstituted;
-    auto *Exprs = getTrailingObjects<Expr *>();
-    llvm::uninitialized_copy(SubstitutedExprs, Exprs);
+    llvm::uninitialized_copy(SubstitutedExprs, getTrailingObjects());
 
     setDependence(computeDependence(this));
     if (!isInstantiationDependent())
@@ -4583,13 +4577,12 @@ class PackIndexingExpr final
   Expr *getSelectedExpr() const {
     UnsignedOrNone Index = getSelectedIndex();
     assert(Index && "extracting the indexed expression of a dependant pack");
-    return getTrailingObjects<Expr *>()[*Index];
+    return getTrailingObjects()[*Index];
   }
 
   /// Return the trailing expressions, regardless of the expansion.
   ArrayRef<Expr *> getExpressions() const {
-    return {getTrailingObjects<Expr *>(),
-            PackIndexingExprBits.TransformedExpressions};
+    return getTrailingObjects(PackIndexingExprBits.TransformedExpressions);
   }
 
   static bool classof(const Stmt *T) {
@@ -4817,7 +4810,7 @@ class FunctionParmPackExpr final
   /// Iterators over the parameters which the parameter pack expanded
   /// into.
   using iterator = ValueDecl *const *;
-  iterator begin() const { return getTrailingObjects<ValueDecl *>(); }
+  iterator begin() const { return getTrailingObjects(); }
   iterator end() const { return begin() + NumParameters; }
 
   /// Get the number of parameters in this parameter pack.
@@ -5099,7 +5092,7 @@ class CXXParenListInitExpr final
       : Expr(CXXParenListInitExprClass, T, getValueKindForType(T), OK_Ordinary),
         NumExprs(Args.size()), NumUserSpecifiedExprs(NumUserSpecifiedExprs),
         InitLoc(InitLoc), LParenLoc(LParenLoc), RParenLoc(RParenLoc) {
-    std::copy(Args.begin(), Args.end(), getTrailingObjects<Expr *>());
+    llvm::copy(Args, getTrailingObjects());
     assert(NumExprs >= NumUserSpecifiedExprs &&
            "number of user specified inits is greater than the number of "
            "passed inits");
@@ -5124,19 +5117,17 @@ class CXXParenListInitExpr final
   void updateDependence() { setDependence(computeDependence(this)); }
 
   MutableArrayRef<Expr *> getInitExprs() {
-    return getTrailingObjects<Expr *>(NumExprs);
+    return getTrailingObjects(NumExprs);
   }
 
-  ArrayRef<Expr *> getInitExprs() const {
-    return getTrailingObjects<Expr *>(NumExprs);
-  }
+  ArrayRef<Expr *> getInitExprs() const { return getTrailingObjects(NumExprs); }
 
   ArrayRef<Expr *> getUserSpecifiedInitExprs() {
-    return getTrailingObjects<Expr *>(NumUserSpecifiedExprs);
+    return getTrailingObjects(NumUserSpecifiedExprs);
   }
 
   ArrayRef<Expr *> getUserSpecifiedInitExprs() const {
-    return getTrailingObjects<Expr *>(NumUserSpecifiedExprs);
+    return getTrailingObjects(NumUserSpecifiedExprs);
   }
 
   SourceLocation getBeginLoc() const LLVM_READONLY { return LParenLoc; }
@@ -5172,13 +5163,12 @@ class CXXParenListInitExpr final
   }
 
   child_range children() {
-    Stmt **Begin = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>());
+    Stmt **Begin = reinterpret_cast<Stmt **>(getTrailingObjects());
     return child_range(Begin, Begin + NumExprs);
   }
 
   const_child_range children() const {
-    Stmt *const *Begin =
-        reinterpret_cast<Stmt *const *>(getTrailingObjects<Expr *>());
+    Stmt *const *Begin = reinterpret_cast<Stmt *const *>(getTrailingObjects());
     return const_child_range(Begin, Begin + NumExprs);
   }
 

clang/include/clang/Sema/Redeclaration.h

@@ -28,4 +28,4 @@ enum class RedeclarationKind {
   ForExternalRedeclaration
 };
 
-#endif // LLVM_CLANG_SEMA_REDECLARATION_H
+#endif // LLVM_CLANG_SEMA_REDECLARATION_H

clang/include/clang/Sema/SemaPseudoObject.h

@@ -37,4 +37,4 @@ class SemaPseudoObject : public SemaBase {
 
 } // namespace clang
 
-#endif // LLVM_CLANG_SEMA_SEMAPSEUDOOBJECT_H
+#endif // LLVM_CLANG_SEMA_SEMAPSEUDOOBJECT_H

clang/lib/AST/ExprCXX.cpp

@@ -1067,7 +1067,7 @@ CXXDefaultInitExpr::CXXDefaultInitExpr(const ASTContext &Ctx,
   CXXDefaultInitExprBits.HasRewrittenInit = RewrittenInitExpr != nullptr;
 
   if (CXXDefaultInitExprBits.HasRewrittenInit)
-    *getTrailingObjects<Expr *>() = RewrittenInitExpr;
+    *getTrailingObjects() = RewrittenInitExpr;
 
   assert(Field->hasInClassInitializer());
 
@@ -1437,8 +1437,7 @@ ExprWithCleanups::ExprWithCleanups(Expr *subexpr,
     : FullExpr(ExprWithCleanupsClass, subexpr) {
   ExprWithCleanupsBits.CleanupsHaveSideEffects = CleanupsHaveSideEffects;
   ExprWithCleanupsBits.NumObjects = objects.size();
-  for (unsigned i = 0, e = objects.size(); i != e; ++i)
-    getTrailingObjects<CleanupObject>()[i] = objects[i];
+  llvm::copy(objects, getTrailingObjects());
 }
 
 ExprWithCleanups *ExprWithCleanups::Create(const ASTContext &C, Expr *subexpr,
@@ -1474,7 +1473,7 @@ CXXUnresolvedConstructExpr::CXXUnresolvedConstructExpr(
       TypeAndInitForm(TSI, IsListInit), LParenLoc(LParenLoc),
       RParenLoc(RParenLoc) {
   CXXUnresolvedConstructExprBits.NumArgs = Args.size();
-  auto **StoredArgs = getTrailingObjects<Expr *>();
+  auto **StoredArgs = getTrailingObjects();
   for (unsigned I = 0; I != Args.size(); ++I)
     StoredArgs[I] = Args[I];
   setDependence(computeDependence(this));
@@ -1800,8 +1799,7 @@ FunctionParmPackExpr::FunctionParmPackExpr(QualType T, ValueDecl *ParamPack,
     : Expr(FunctionParmPackExprClass, T, VK_LValue, OK_Ordinary),
       ParamPack(ParamPack), NameLoc(NameLoc), NumParameters(NumParams) {
   if (Params)
-    std::uninitialized_copy(Params, Params + NumParams,
-                            getTrailingObjects<ValueDecl *>());
+    std::uninitialized_copy(Params, Params + NumParams, getTrailingObjects());
   setDependence(ExprDependence::TypeValueInstantiation |
                 ExprDependence::UnexpandedPack);
 }

clang/lib/AST/ExprConstant.cpp

@@ -15245,21 +15245,7 @@ bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {
       return Info.Ctx.getTypeSize(DestType) == Info.Ctx.getTypeSize(SrcType);
     }
 
-    if (Info.Ctx.getLangOpts().CPlusPlus && Info.InConstantContext &&
-        Info.EvalMode == EvalInfo::EM_ConstantExpression &&
-        DestType->isEnumeralType()) {
-
-      bool ConstexprVar = true;
-
-      // We know if we are here that we are in a context that we might require
-      // a constant expression or a context that requires a constant
-      // value. But if we are initializing a value we don't know if it is a
-      // constexpr variable or not. We can check the EvaluatingDecl to determine
-      // if it constexpr or not. If not then we don't want to emit a diagnostic.
-      if (const auto *VD = dyn_cast_or_null<VarDecl>(
-              Info.EvaluatingDecl.dyn_cast<const ValueDecl *>()))
-        ConstexprVar = VD->isConstexpr();
-
+    if (Info.Ctx.getLangOpts().CPlusPlus && DestType->isEnumeralType()) {
       const EnumType *ET = dyn_cast<EnumType>(DestType.getCanonicalType());
       const EnumDecl *ED = ET->getDecl();
       // Check that the value is within the range of the enumeration values.
@@ -15279,13 +15265,13 @@ bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {
         ED->getValueRange(Max, Min);
         --Max;
 
-        if (ED->getNumNegativeBits() && ConstexprVar &&
+        if (ED->getNumNegativeBits() &&
             (Max.slt(Result.getInt().getSExtValue()) ||
              Min.sgt(Result.getInt().getSExtValue())))
           Info.CCEDiag(E, diag::note_constexpr_unscoped_enum_out_of_range)
               << llvm::toString(Result.getInt(), 10) << Min.getSExtValue()
               << Max.getSExtValue() << ED;
-        else if (!ED->getNumNegativeBits() && ConstexprVar &&
+        else if (!ED->getNumNegativeBits() &&
                  Max.ult(Result.getInt().getZExtValue()))
           Info.CCEDiag(E, diag::note_constexpr_unscoped_enum_out_of_range)
               << llvm::toString(Result.getInt(), 10) << Min.getZExtValue()

clang/lib/Analysis/FlowSensitive/Formula.cpp

@@ -90,4 +90,4 @@ void Formula::print(llvm::raw_ostream &OS, const AtomNames *Names) const {
   }
 }
 
-} // namespace clang::dataflow
+} // namespace clang::dataflow

clang/lib/CIR/CodeGen/CIRGenOpenACCClause.cpp

@@ -319,6 +319,21 @@ class OpenACCClauseCIREmitter final
     dataOperands.push_back(afterOp.getOperation());
   }
 
+  template <typename BeforeOpTy>
+  void addDataOperand(const Expr *varOperand, mlir::acc::DataClause dataClause,
+                      bool structured, bool implicit) {
+    DataOperandInfo opInfo = getDataOperandInfo(dirKind, varOperand);
+    auto beforeOp =
+        builder.create<BeforeOpTy>(opInfo.beginLoc, opInfo.varValue, structured,
+                                   implicit, opInfo.name, opInfo.bounds);
+    operation.getDataClauseOperandsMutable().append(beforeOp.getResult());
+
+    // Set the 'rest' of the info for the operation.
+    beforeOp.setDataClause(dataClause);
+    // Make sure we record these, so 'async' values can be updated later.
+    dataOperands.push_back(beforeOp.getOperation());
+  }
+
   // Helper function that covers for the fact that we don't have this function
   // on all operation types.
   mlir::ArrayAttr getAsyncOnlyAttr() {
@@ -550,7 +565,8 @@ class OpenACCClauseCIREmitter final
     if constexpr (isOneOfTypes<OpTy, mlir::acc::ParallelOp, mlir::acc::SerialOp,
                                mlir::acc::KernelsOp, mlir::acc::InitOp,
                                mlir::acc::ShutdownOp, mlir::acc::SetOp,
-                               mlir::acc::DataOp, mlir::acc::WaitOp>) {
+                               mlir::acc::DataOp, mlir::acc::WaitOp,
+                               mlir::acc::HostDataOp>) {
       operation.getIfCondMutable().append(
           createCondition(clause.getConditionExpr()));
     } else if constexpr (isCombinedType<OpTy>) {
@@ -566,6 +582,17 @@ class OpenACCClauseCIREmitter final
     }
   }
 
+  void VisitIfPresentClause(const OpenACCIfPresentClause &clause) {
+    if constexpr (isOneOfTypes<OpTy, mlir::acc::HostDataOp>) {
+      operation.setIfPresent(true);
+    } else if constexpr (isOneOfTypes<OpTy, mlir::acc::UpdateOp>) {
+      // Last unimplemented one here, so just put it in this way instead.
+      return clauseNotImplemented(clause);
+    } else {
+      llvm_unreachable("unknown construct kind in VisitIfPresentClause");
+    }
+  }
+
   void VisitDeviceNumClause(const OpenACCDeviceNumClause &clause) {
     if constexpr (isOneOfTypes<OpTy, mlir::acc::InitOp, mlir::acc::ShutdownOp,
                                mlir::acc::SetOp>) {
@@ -791,6 +818,33 @@ class OpenACCClauseCIREmitter final
       return clauseNotImplemented(clause);
     }
   }
+
+  void VisitUseDeviceClause(const OpenACCUseDeviceClause &clause) {
+    if constexpr (isOneOfTypes<OpTy, mlir::acc::HostDataOp>) {
+      for (auto var : clause.getVarList())
+        addDataOperand<mlir::acc::UseDeviceOp>(
+            var, mlir::acc::DataClause::acc_use_device,
+            /*structured=*/true, /*implicit=*/false);
+    } else {
+      llvm_unreachable("Unknown construct kind in VisitUseDeviceClause");
+    }
+  }
+
+  void VisitDevicePtrClause(const OpenACCDevicePtrClause &clause) {
+    if constexpr (isOneOfTypes<OpTy, mlir::acc::ParallelOp, mlir::acc::SerialOp,
+                               mlir::acc::KernelsOp>) {
+      for (auto var : clause.getVarList())
+        addDataOperand<mlir::acc::DevicePtrOp>(
+            var, mlir::acc::DataClause::acc_deviceptr, /*structured=*/true,
+            /*implicit=*/false);
+    } else if constexpr (isCombinedType<OpTy>) {
+      applyToComputeOp(clause);
+    } else {
+      // TODO: When we've implemented this for everything, switch this to an
+      // unreachable. data, declare remain.
+      return clauseNotImplemented(clause);
+    }
+  }
 };
 
 template <typename OpTy>
@@ -826,6 +880,7 @@ EXPL_SPEC(mlir::acc::InitOp)
 EXPL_SPEC(mlir::acc::ShutdownOp)
 EXPL_SPEC(mlir::acc::SetOp)
 EXPL_SPEC(mlir::acc::WaitOp)
+EXPL_SPEC(mlir::acc::HostDataOp)
 #undef EXPL_SPEC
 
 template <typename ComputeOp, typename LoopOp>