merge main into amd-staging

Author: z1.cciauto

clang-tools-extra/clang-tidy/modernize/UseDesignatedInitializersCheck.cpp

@@ -121,8 +121,9 @@ void UseDesignatedInitializersCheck::registerMatchers(MatchFinder *Finder) {
       hasAnyBase(hasType(cxxRecordDecl(has(fieldDecl()))));
   Finder->addMatcher(
       initListExpr(
-          hasType(cxxRecordDecl(RestrictToPODTypes ? isPOD() : isAggregate(),
-                                unless(HasBaseWithFields))
+          hasType(cxxRecordDecl(
+                      RestrictToPODTypes ? isPOD() : isAggregate(),
+                      unless(anyOf(HasBaseWithFields, hasName("::std::array"))))
                       .bind("type")),
           IgnoreSingleElementAggregates ? hasMoreThanOneElement() : anything(),
           unless(isFullyDesignated()))

clang-tools-extra/docs/ReleaseNotes.rst

@@ -182,6 +182,10 @@ Changes in existing checks
   ``constexpr`` and ``static``` values on member initialization and by detecting
   explicit casting of built-in types within member list initialization.
 
+- Improved :doc:`modernize-use-designated-initializers
+  <clang-tidy/checks/modernize/use-designated-initializers>` check by avoiding
+  diagnosing designated initializers for ``std::array`` initializations.
+
 - Improved :doc:`modernize-use-ranges
   <clang-tidy/checks/modernize/use-ranges>` check by updating suppress 
   warnings logic for ``nullptr`` in ``std::find``.

clang-tools-extra/docs/clang-tidy/checks/modernize/use-designated-initializers.rst

@@ -54,6 +54,9 @@ Options
 
     The value `false` specifies that even initializers for aggregate types with
     only a single element should be checked. The default value is `true`.
+    ``std::array`` initializations are always excluded, as the type is a
+    standard library abstraction and not intended to be initialized with
+    designated initializers.
 
 .. option:: RestrictToPODTypes
 

clang-tools-extra/test/clang-tidy/checkers/modernize/use-designated-initializers.cpp

@@ -209,3 +209,18 @@ struct S15{
   S15(S14& d):d{d}{}
   S14& d;
 };
+
+//Issue #133715
+namespace std {
+  template<typename T, unsigned int N>
+  struct array {
+    T __elems[N];
+  };
+    template<typename T, typename... U>
+    array(T, U...) -> array<T, 1 + sizeof...(U)>;
+}
+
+std::array a{1,2,3};
+std::array<int,2> b{10, 11};
+using array = std::array<int, 2>;
+array c{10, 11};

clang/include/clang/Frontend/CompilerInvocation.h

@@ -89,7 +89,7 @@ class CompilerInvocationBase {
   std::shared_ptr<PreprocessorOptions> PPOpts;
 
   /// Options controlling the static analyzer.
-  AnalyzerOptionsRef AnalyzerOpts;
+  std::shared_ptr<AnalyzerOptions> AnalyzerOpts;
 
   std::shared_ptr<MigratorOptions> MigratorOpts;
 

clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

@@ -176,7 +176,7 @@ class PositiveAnalyzerOption {
 /// and should be eventually converted into -analyzer-config flags. New analyzer
 /// options should not be implemented as frontend flags. Frontend flags still
 /// make sense for things that do not affect the actual analysis.
-class AnalyzerOptions : public RefCountedBase<AnalyzerOptions> {
+class AnalyzerOptions {
 public:
   using ConfigTable = llvm::StringMap<std::string>;
 
@@ -416,8 +416,6 @@ class AnalyzerOptions : public RefCountedBase<AnalyzerOptions> {
   }
 };
 
-using AnalyzerOptionsRef = IntrusiveRefCntPtr<AnalyzerOptions>;
-
 //===----------------------------------------------------------------------===//
 // We'll use AnalyzerOptions in the frontend, but we can't link the frontend
 // with clangStaticAnalyzerCore, because clangStaticAnalyzerCore depends on

clang/lib/Basic/Targets/SPIR.h

@@ -58,15 +58,13 @@ static const unsigned SPIRDefIsPrivMap[] = {
 // Used by both the SPIR and SPIR-V targets.
 static const unsigned SPIRDefIsGenMap[] = {
     4, // Default
-    // Some OpenCL address space values for this map are dummy and they can't be
-    // used
     1, // opencl_global
-    0, // opencl_local
-    0, // opencl_constant
+    3, // opencl_local
+    2, // opencl_constant
     0, // opencl_private
-    0, // opencl_generic
-    0, // opencl_global_device
-    0, // opencl_global_host
+    4, // opencl_generic
+    5, // opencl_global_device
+    6, // opencl_global_host
     // cuda_* address space mapping is intended for HIPSPV (HIP to SPIR-V
     // translation). This mapping is enabled when the language mode is HIP.
     1, // cuda_device

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -311,7 +311,7 @@ LValue CIRGenFunction::emitLValueForField(LValue base, const FieldDecl *field) {
   assert(!cir::MissingFeatures::opTBAA());
 
   Address addr = base.getAddress();
-  if (auto *classDef = dyn_cast<CXXRecordDecl>(rec)) {
+  if (isa<CXXRecordDecl>(rec)) {
     cgm.errorNYI(field->getSourceRange(), "emitLValueForField: C++ class");
     return LValue();
   }
@@ -701,7 +701,7 @@ CIRGenFunction::emitArraySubscriptExpr(const clang::ArraySubscriptExpr *e) {
 }
 
 LValue CIRGenFunction::emitMemberExpr(const MemberExpr *e) {
-  if (auto *vd = dyn_cast<VarDecl>(e->getMemberDecl())) {
+  if (isa<VarDecl>(e->getMemberDecl())) {
     cgm.errorNYI(e->getSourceRange(), "emitMemberExpr: VarDecl");
     return LValue();
   }
@@ -734,7 +734,7 @@ LValue CIRGenFunction::emitMemberExpr(const MemberExpr *e) {
     return lv;
   }
 
-  if (const auto *fd = dyn_cast<FunctionDecl>(nd)) {
+  if (isa<FunctionDecl>(nd)) {
     cgm.errorNYI(e->getSourceRange(), "emitMemberExpr: FunctionDecl");
     return LValue();
   }

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -366,7 +366,7 @@ void CIRGenModule::emitGlobalVarDefinition(const clang::VarDecl *vd,
                                            bool isTentative) {
   const QualType astTy = vd->getType();
   const mlir::Type type = convertType(vd->getType());
-  if (clang::IdentifierInfo *identifier = vd->getIdentifier()) {
+  if (vd->getIdentifier()) {
     StringRef name = getMangledName(GlobalDecl(vd));
     auto varOp =
         builder.create<cir::GlobalOp>(getLoc(vd->getSourceRange()), name, type);

clang/lib/Driver/SanitizerArgs.cpp

@@ -1028,10 +1028,6 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC,
     StableABI = Args.hasFlag(options::OPT_fsanitize_stable_abi,
                              options::OPT_fno_sanitize_stable_abi, false);
 
-    AsanUseAfterScope = Args.hasFlag(
-        options::OPT_fsanitize_address_use_after_scope,
-        options::OPT_fno_sanitize_address_use_after_scope, AsanUseAfterScope);
-
     AsanPoisonCustomArrayCookie = Args.hasFlag(
         options::OPT_fsanitize_address_poison_custom_array_cookie,
         options::OPT_fno_sanitize_address_poison_custom_array_cookie,
@@ -1093,7 +1089,6 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC,
     }
 
   } else {
-    AsanUseAfterScope = false;
     // -fsanitize=pointer-compare/pointer-subtract requires -fsanitize=address.
     SanitizerMask DetectInvalidPointerPairs =
         SanitizerKind::PointerCompare | SanitizerKind::PointerSubtract;
@@ -1107,6 +1102,14 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC,
     }
   }
 
+  if (AllAddedKinds & (SanitizerKind::Address | SanitizerKind::KernelAddress)) {
+    AsanUseAfterScope = Args.hasFlag(
+        options::OPT_fsanitize_address_use_after_scope,
+        options::OPT_fno_sanitize_address_use_after_scope, AsanUseAfterScope);
+  } else {
+    AsanUseAfterScope = false;
+  }
+
   if (AllAddedKinds & SanitizerKind::HWAddress) {
     if (Arg *HwasanAbiArg =
             Args.getLastArg(options::OPT_fsanitize_hwaddress_abi_EQ)) {