Merged main:89a080cb79972abae240c226090af9a3094e2269 into amd-gfx:93971a479db3

Local branch amd-gfx 93971a4 Merged main:9f858c7b79f9edff082050b930fee347887f8e6d into amd-gfx:d168cedb5f80
Remote branch main 89a080c [llvm][NFC] Document cl::opt MisExpectTolerance and fix typo

Author: SC llvm team

clang/include/clang/AST/OpenACCClause.h

@@ -17,8 +17,6 @@
 #include "clang/AST/StmtIterator.h"
 #include "clang/Basic/OpenACCKinds.h"
 
-#include <utility>
-
 namespace clang {
 /// This is the base type for all OpenACC Clauses.
 class OpenACCClause {
@@ -77,63 +75,6 @@ class OpenACCClauseWithParams : public OpenACCClause {
   }
 };
 
-using DeviceTypeArgument = std::pair<IdentifierInfo *, SourceLocation>;
-/// A 'device_type' or 'dtype' clause, takes a list of either an 'asterisk' or
-/// an identifier. The 'asterisk' means 'the rest'.
-class OpenACCDeviceTypeClause final
-    : public OpenACCClauseWithParams,
-      public llvm::TrailingObjects<OpenACCDeviceTypeClause,
-                                   DeviceTypeArgument> {
-  // Data stored in trailing objects as IdentifierInfo* /SourceLocation pairs. A
-  // nullptr IdentifierInfo* represents an asterisk.
-  unsigned NumArchs;
-  OpenACCDeviceTypeClause(OpenACCClauseKind K, SourceLocation BeginLoc,
-                          SourceLocation LParenLoc,
-                          ArrayRef<DeviceTypeArgument> Archs,
-                          SourceLocation EndLoc)
-      : OpenACCClauseWithParams(K, BeginLoc, LParenLoc, EndLoc),
-        NumArchs(Archs.size()) {
-    assert(
-        (K == OpenACCClauseKind::DeviceType || K == OpenACCClauseKind::DType) &&
-        "Invalid clause kind for device-type");
-
-    assert(!llvm::any_of(Archs, [](const DeviceTypeArgument &Arg) {
-      return Arg.second.isInvalid();
-    }) && "Invalid SourceLocation for an argument");
-
-    assert(Archs.size() == 1 ||
-           !llvm::any_of(Archs,
-                         [](const DeviceTypeArgument &Arg) {
-                           return Arg.first == nullptr;
-                         }) &&
-               "Only a single asterisk version is permitted, and must be the "
-               "only one");
-
-    std::uninitialized_copy(Archs.begin(), Archs.end(),
-                            getTrailingObjects<DeviceTypeArgument>());
-  }
-
-public:
-  static bool classof(const OpenACCClause *C) {
-    return C->getClauseKind() == OpenACCClauseKind::DType ||
-           C->getClauseKind() == OpenACCClauseKind::DeviceType;
-  }
-  bool hasAsterisk() const {
-    return getArchitectures().size() > 0 &&
-           getArchitectures()[0].first == nullptr;
-  }
-
-  ArrayRef<DeviceTypeArgument> getArchitectures() const {
-    return ArrayRef<DeviceTypeArgument>(
-        getTrailingObjects<DeviceTypeArgument>(), NumArchs);
-  }
-
-  static OpenACCDeviceTypeClause *
-  Create(const ASTContext &C, OpenACCClauseKind K, SourceLocation BeginLoc,
-         SourceLocation LParenLoc, ArrayRef<DeviceTypeArgument> Archs,
-         SourceLocation EndLoc);
-};
-
 /// A 'default' clause, has the optional 'none' or 'present' argument.
 class OpenACCDefaultClause : public OpenACCClauseWithParams {
   friend class ASTReaderStmt;

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -12344,8 +12344,4 @@ def warn_acc_deprecated_alias_name
 def err_acc_var_not_pointer_type
     : Error<"expected pointer in '%0' clause, type is %1">;
 def note_acc_expected_pointer_var : Note<"expected variable of pointer type">;
-def err_acc_clause_after_device_type
-    : Error<"OpenACC clause '%0' may not follow a '%1' clause in a "
-            "compute construct">;
-
 } // end of sema component.

clang/include/clang/Basic/OpenACCClauses.def

@@ -37,8 +37,6 @@ CLAUSE_ALIAS(PCreate, Create)
 CLAUSE_ALIAS(PresentOrCreate, Create)
 VISIT_CLAUSE(Default)
 VISIT_CLAUSE(DevicePtr)
-VISIT_CLAUSE(DeviceType)
-CLAUSE_ALIAS(DType, DeviceType)
 VISIT_CLAUSE(FirstPrivate)
 VISIT_CLAUSE(If)
 VISIT_CLAUSE(NoCreate)

clang/include/clang/Parse/Parser.h

@@ -3720,8 +3720,7 @@ class Parser : public CodeCompletionHandler {
                                SourceLocation Loc,
                                llvm::SmallVectorImpl<Expr *> &IntExprs);
   /// Parses the 'device-type-list', which is a list of identifiers.
-  bool ParseOpenACCDeviceTypeList(
-      llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>> &Archs);
+  bool ParseOpenACCDeviceTypeList();
   /// Parses the 'async-argument', which is an integral value with two
   /// 'special' values that are likely negative (but come from Macros).
   OpenACCIntExprParseResult ParseOpenACCAsyncArgument(OpenACCDirectiveKind DK,

clang/include/clang/Sema/SemaOpenACC.h

@@ -26,9 +26,6 @@ class OpenACCClause;
 
 class SemaOpenACC : public SemaBase {
 public:
-  // Redeclaration of the version in OpenACCClause.h.
-  using DeviceTypeArgument = std::pair<IdentifierInfo *, SourceLocation>;
-
   /// A type to represent all the data for an OpenACC Clause that has been
   /// parsed, but not yet created/semantically analyzed. This is effectively a
   /// discriminated union on the 'Clause Kind', with all of the individual
@@ -63,12 +60,8 @@ class SemaOpenACC : public SemaBase {
       SmallVector<Expr *> QueueIdExprs;
     };
 
-    struct DeviceTypeDetails {
-      SmallVector<DeviceTypeArgument> Archs;
-    };
-
     std::variant<std::monostate, DefaultDetails, ConditionDetails,
-                 IntExprDetails, VarListDetails, WaitDetails, DeviceTypeDetails>
+                 IntExprDetails, VarListDetails, WaitDetails>
         Details = std::monostate{};
 
   public:
@@ -216,13 +209,6 @@ class SemaOpenACC : public SemaBase {
       return std::get<VarListDetails>(Details).IsZero;
     }
 
-    ArrayRef<DeviceTypeArgument> getDeviceTypeArchitectures() const {
-      assert((ClauseKind == OpenACCClauseKind::DeviceType ||
-              ClauseKind == OpenACCClauseKind::DType) &&
-             "Only 'device_type'/'dtype' has a device-type-arg list");
-      return std::get<DeviceTypeDetails>(Details).Archs;
-    }
-
     void setLParenLoc(SourceLocation EndLoc) { LParenLoc = EndLoc; }
     void setEndLoc(SourceLocation EndLoc) { ClauseRange.setEnd(EndLoc); }
 
@@ -340,13 +326,6 @@ class SemaOpenACC : public SemaBase {
              "Parsed clause kind does not have a wait-details");
       Details = WaitDetails{DevNum, QueuesLoc, std::move(IntExprs)};
     }
-
-    void setDeviceTypeDetails(llvm::SmallVector<DeviceTypeArgument> &&Archs) {
-      assert((ClauseKind == OpenACCClauseKind::DeviceType ||
-              ClauseKind == OpenACCClauseKind::DType) &&
-             "Only 'device_type'/'dtype' has a device-type-arg list");
-      Details = DeviceTypeDetails{std::move(Archs)};
-    }
   };
 
   SemaOpenACC(Sema &S);

clang/lib/AST/Interp/ByteCodeExprGen.cpp

@@ -2159,7 +2159,9 @@ bool ByteCodeExprGen<Emitter>::VisitCXXConstructExpr(
   if (T->isArrayType()) {
     const ConstantArrayType *CAT =
         Ctx.getASTContext().getAsConstantArrayType(E->getType());
-    assert(CAT);
+    if (!CAT)
+      return false;
+
     size_t NumElems = CAT->getZExtSize();
     const Function *Func = getFunction(E->getConstructor());
     if (!Func || !Func->isConstexpr())

clang/lib/AST/Interp/Program.cpp

@@ -386,7 +386,8 @@ Descriptor *Program::createDescriptor(const DeclTy &D, const Type *Ty,
 
     // Array of unknown bounds - cannot be accessed and pointer arithmetic
     // is forbidden on pointers to such objects.
-    if (isa<IncompleteArrayType>(ArrayType)) {
+    if (isa<IncompleteArrayType>(ArrayType) ||
+        isa<VariableArrayType>(ArrayType)) {
       if (std::optional<PrimType> T = Ctx.classify(ElemTy)) {
         return allocateDescriptor(D, *T, MDSize, IsTemporary,
                                   Descriptor::UnknownSize{});

clang/lib/AST/OpenACCClause.cpp

@@ -18,8 +18,7 @@
 using namespace clang;
 
 bool OpenACCClauseWithParams::classof(const OpenACCClause *C) {
-  return OpenACCDeviceTypeClause::classof(C) ||
-         OpenACCClauseWithCondition::classof(C) ||
+  return OpenACCClauseWithCondition::classof(C) ||
          OpenACCClauseWithExprs::classof(C);
 }
 bool OpenACCClauseWithExprs::classof(const OpenACCClause *C) {
@@ -299,17 +298,6 @@ OpenACCCreateClause::Create(const ASTContext &C, OpenACCClauseKind Spelling,
                                        VarList, EndLoc);
 }
 
-OpenACCDeviceTypeClause *OpenACCDeviceTypeClause::Create(
-    const ASTContext &C, OpenACCClauseKind K, SourceLocation BeginLoc,
-    SourceLocation LParenLoc, ArrayRef<DeviceTypeArgument> Archs,
-    SourceLocation EndLoc) {
-  void *Mem =
-      C.Allocate(OpenACCDeviceTypeClause::totalSizeToAlloc<DeviceTypeArgument>(
-          Archs.size()));
-  return new (Mem)
-      OpenACCDeviceTypeClause(K, BeginLoc, LParenLoc, Archs, EndLoc);
-}
-
 //===----------------------------------------------------------------------===//
 //  OpenACC clauses printing methods
 //===----------------------------------------------------------------------===//
@@ -463,17 +451,3 @@ void OpenACCClausePrinter::VisitWaitClause(const OpenACCWaitClause &C) {
     OS << ")";
   }
 }
-
-void OpenACCClausePrinter::VisitDeviceTypeClause(
-    const OpenACCDeviceTypeClause &C) {
-  OS << C.getClauseKind();
-  OS << "(";
-  llvm::interleaveComma(C.getArchitectures(), OS,
-                        [&](const DeviceTypeArgument &Arch) {
-                          if (Arch.first == nullptr)
-                            OS << "*";
-                          else
-                            OS << Arch.first;
-                        });
-  OS << ")";
-}

clang/lib/AST/StmtProfile.cpp

@@ -2585,9 +2585,6 @@ void OpenACCClauseProfiler::VisitWaitClause(const OpenACCWaitClause &Clause) {
   for (auto *E : Clause.getQueueIdExprs())
     Profiler.VisitStmt(E);
 }
-/// Nothing to do here, there are no sub-statements.
-void OpenACCClauseProfiler::VisitDeviceTypeClause(
-    const OpenACCDeviceTypeClause &Clause) {}
 } // namespace
 
 void StmtProfiler::VisitOpenACCComputeConstruct(

clang/lib/AST/TextNodeDumper.cpp

@@ -444,19 +444,6 @@ void TextNodeDumper::Visit(const OpenACCClause *C) {
       if (cast<OpenACCWaitClause>(C)->hasQueuesTag())
         OS << " has queues tag";
       break;
-    case OpenACCClauseKind::DeviceType:
-    case OpenACCClauseKind::DType:
-      OS << "(";
-      llvm::interleaveComma(
-          cast<OpenACCDeviceTypeClause>(C)->getArchitectures(), OS,
-          [&](const DeviceTypeArgument &Arch) {
-            if (Arch.first == nullptr)
-              OS << "*";
-            else
-              OS << Arch.first->getName();
-          });
-      OS << ")";
-      break;
     default:
       // Nothing to do here.
       break;