merge main into amd-staging

.github/workflows/issue-write.yml

@@ -162,4 +162,4 @@ jobs:
         if: >-
           always() &&
           steps.download-artifact.outputs.artifact-ids != ''
-        run: cat comments
+        run: cat comments*

clang-tools-extra/clang-tidy/readability/RedundantCastingCheck.cpp

@@ -9,6 +9,7 @@
 #include "RedundantCastingCheck.h"
 #include "../utils/FixItHintUtils.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/TypeBase.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 
@@ -29,7 +30,7 @@ static bool areTypesEqual(QualType S, QualType D) {
   const QualType PtrD = D->getPointeeType();
 
   if (!PtrS.isNull() && !PtrD.isNull())
-    return areTypesEqual(PtrS, PtrD);
+    return areTypesEqual(PtrS.IgnoreParens(), PtrD.IgnoreParens());
 
   const DeducedType *DT = S->getContainedDeducedType();
   if (DT && DT->isDeduced())

clang-tools-extra/docs/ReleaseNotes.rst

@@ -567,6 +567,10 @@ Changes in existing checks
   <clang-tidy/checks/readability/qualified-auto>` check by adding the option
   `IgnoreAliasing`, that allows not looking at underlying types of type aliases.
 
+- Improved :doc:`readability-redundant-casting
+  <clang-tidy/checks/readability/redundant-casting>` check by fixing false
+  negatives when explicitly cast from function pointer.
+
 - Improved :doc:`readability-uppercase-literal-suffix
   <clang-tidy/checks/readability/uppercase-literal-suffix>` check to recognize
   literal suffixes added in C++23 and C23.

clang-tools-extra/test/clang-tidy/checkers/readability/redundant-casting.cpp

@@ -235,3 +235,13 @@ void testRedundantDependentNTTPCasting() {
   // CHECK-MESSAGES: :[[@LINE-4]]:25: note: source type originates from referencing this non-type template parameter
   // CHECK-FIXES: T a = V;
 }
+
+namespace gh170476 {
+int f(void);
+int g1() {
+  int (*fp)() = (int(*)(void))&f;
+  // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: redundant explicit casting to the same type 'int (*)()' as the sub-expression, remove this casting [readability-redundant-casting]
+  // CHECK-FIXES: int (*fp)() = (&f);
+  return fp();
+}
+} // namespace gh170476

flang-rt/test/Driver/exec.f90

@@ -1,4 +1,3 @@
-! REQUIRES: flang-rt
 ! UNSUPPORTED: offload-cuda
 
 ! Verify that flang can correctly build executables.

flang/include/flang/Parser/openmp-utils.h

@@ -14,6 +14,7 @@
 #define FORTRAN_PARSER_OPENMP_UTILS_H
 
 #include "flang/Common/indirection.h"
+#include "flang/Common/template.h"
 #include "flang/Parser/parse-tree.h"
 #include "llvm/Frontend/OpenMP/OMP.h"
 
@@ -127,7 +128,88 @@ template <typename T> struct IsStatement<Statement<T>> {
 std::optional<Label> GetStatementLabel(const ExecutionPartConstruct &x);
 std::optional<Label> GetFinalLabel(const OpenMPConstruct &x);
 
+namespace detail {
+// Clauses with flangClass = "OmpObjectList".
+using MemberObjectListClauses =
+    std::tuple<OmpClause::Copyin, OmpClause::Copyprivate, OmpClause::Exclusive,
+        OmpClause::Firstprivate, OmpClause::HasDeviceAddr, OmpClause::Inclusive,
+        OmpClause::IsDevicePtr, OmpClause::Link, OmpClause::Private,
+        OmpClause::Shared, OmpClause::UseDeviceAddr, OmpClause::UseDevicePtr>;
+
+// Clauses with flangClass = "OmpSomeClause", and OmpObjectList a
+// member of tuple OmpSomeClause::t.
+using TupleObjectListClauses = std::tuple<OmpClause::AdjustArgs,
+    OmpClause::Affinity, OmpClause::Aligned, OmpClause::Allocate,
+    OmpClause::Enter, OmpClause::From, OmpClause::InReduction,
+    OmpClause::Lastprivate, OmpClause::Linear, OmpClause::Map,
+    OmpClause::Reduction, OmpClause::TaskReduction, OmpClause::To>;
+
+// Does U have WrapperTrait (i.e. has a member 'v'), and if so, is T the
+// type of v?
+template <typename T, typename U, bool IsWrapper> struct WrappedInType {
+  static constexpr bool value{false};
+};
+
+template <typename T, typename U> struct WrappedInType<T, U, true> {
+  static constexpr bool value{std::is_same_v<T, decltype(U::v)>};
+};
+
+// Same as WrappedInType, but with a list of types Us. Satisfied if any
+// type U in Us satisfies WrappedInType<T, U>.
+template <typename...> struct WrappedInTypes;
+
+template <typename T> struct WrappedInTypes<T> {
+  static constexpr bool value{false};
+};
+
+template <typename T, typename U, typename... Us>
+struct WrappedInTypes<T, U, Us...> {
+  static constexpr bool value{WrappedInType<T, U, WrapperTrait<U>>::value ||
+      WrappedInTypes<T, Us...>::value};
+};
+
+// Same as WrappedInTypes, but takes type list in a form of a tuple or
+// a variant.
+template <typename...> struct WrappedInTupleOrVariant {
+  static constexpr bool value{false};
+};
+template <typename T, typename... Us>
+struct WrappedInTupleOrVariant<T, std::tuple<Us...>> {
+  static constexpr bool value{WrappedInTypes<T, Us...>::value};
+};
+template <typename T, typename... Us>
+struct WrappedInTupleOrVariant<T, std::variant<Us...>> {
+  static constexpr bool value{WrappedInTypes<T, Us...>::value};
+};
+template <typename T, typename U>
+constexpr bool WrappedInTupleOrVariantV{WrappedInTupleOrVariant<T, U>::value};
+} // namespace detail
+
+template <typename T> const OmpObjectList *GetOmpObjectList(const T &clause) {
+  using namespace detail;
+  static_assert(std::is_class_v<T>, "Unexpected argument type");
+
+  if constexpr (common::HasMember<T, decltype(OmpClause::u)>) {
+    if constexpr (common::HasMember<T, MemberObjectListClauses>) {
+      return &clause.v;
+    } else if constexpr (common::HasMember<T, TupleObjectListClauses>) {
+      return &std::get<OmpObjectList>(clause.v.t);
+    } else {
+      return nullptr;
+    }
+  } else if constexpr (WrappedInTupleOrVariantV<T, TupleObjectListClauses>) {
+    return &std::get<OmpObjectList>(clause.t);
+  } else if constexpr (WrappedInTupleOrVariantV<T, decltype(OmpClause::u)>) {
+    return nullptr;
+  } else {
+    // The condition should be type-dependent, but it should always be false.
+    static_assert(sizeof(T) < 0 && "Unexpected argument type");
+  }
+}
+
 const OmpObjectList *GetOmpObjectList(const OmpClause &clause);
+const OmpObjectList *GetOmpObjectList(const OmpClause::Depend &clause);
+const OmpObjectList *GetOmpObjectList(const OmpDependClause::TaskDep &x);
 
 template <typename T>
 const T *GetFirstArgument(const OmpDirectiveSpecification &spec) {

flang/lib/Optimizer/Transforms/FIRToSCF.cpp

@@ -126,6 +126,7 @@ struct IterWhileConversion : public mlir::OpRewritePattern<fir::IterWhileOp> {
 
     mlir::Value okInit = iterWhileOp.getIterateIn();
     mlir::ValueRange iterArgs = iterWhileOp.getInitArgs();
+    bool hasFinalValue = iterWhileOp.getFinalValue().has_value();
 
     mlir::SmallVector<mlir::Value> initVals;
     initVals.push_back(lowerBound);
@@ -164,17 +165,22 @@ struct IterWhileConversion : public mlir::OpRewritePattern<fir::IterWhileOp> {
 
     auto *afterBody = scfWhileOp.getAfterBody();
     auto resultOp = mlir::cast<fir::ResultOp>(afterBody->getTerminator());
-    mlir::SmallVector<mlir::Value> results(resultOp->getOperands());
-    mlir::Value ivInAfter = scfWhileOp.getAfterArguments()[0];
+    mlir::SmallVector<mlir::Value> results;
+    mlir::Value iv = scfWhileOp.getAfterArguments()[0];
 
     rewriter.setInsertionPointToStart(afterBody);
-    results[0] = mlir::arith::AddIOp::create(rewriter, loc, ivInAfter, step);
+    results.push_back(mlir::arith::AddIOp::create(rewriter, loc, iv, step));
+    llvm::append_range(results, hasFinalValue
+                                    ? resultOp->getOperands().drop_front()
+                                    : resultOp->getOperands());
 
     rewriter.setInsertionPointToEnd(afterBody);
     rewriter.replaceOpWithNewOp<mlir::scf::YieldOp>(resultOp, results);
 
     scfWhileOp->setAttrs(iterWhileOp->getAttrs());
-    rewriter.replaceOp(iterWhileOp, scfWhileOp);
+    rewriter.replaceOp(iterWhileOp,
+                       hasFinalValue ? scfWhileOp->getResults()
+                                     : scfWhileOp->getResults().drop_front());
     return mlir::success();
   }
 };

flang/lib/Parser/openmp-utils.cpp

@@ -117,43 +117,20 @@ std::optional<Label> GetFinalLabel(const OpenMPConstruct &x) {
 }
 
 const OmpObjectList *GetOmpObjectList(const OmpClause &clause) {
-  // Clauses with OmpObjectList as its data member
-  using MemberObjectListClauses = std::tuple<OmpClause::Copyin,
-      OmpClause::Copyprivate, OmpClause::Exclusive, OmpClause::Firstprivate,
-      OmpClause::HasDeviceAddr, OmpClause::Inclusive, OmpClause::IsDevicePtr,
-      OmpClause::Link, OmpClause::Private, OmpClause::Shared,
-      OmpClause::UseDeviceAddr, OmpClause::UseDevicePtr>;
-
-  // Clauses with OmpObjectList in the tuple
-  using TupleObjectListClauses = std::tuple<OmpClause::AdjustArgs,
-      OmpClause::Affinity, OmpClause::Aligned, OmpClause::Allocate,
-      OmpClause::Enter, OmpClause::From, OmpClause::InReduction,
-      OmpClause::Lastprivate, OmpClause::Linear, OmpClause::Map,
-      OmpClause::Reduction, OmpClause::TaskReduction, OmpClause::To>;
-
-  // TODO:: Generate the tuples using TableGen.
+  return common::visit([](auto &&s) { return GetOmpObjectList(s); }, clause.u);
+}
+
+const OmpObjectList *GetOmpObjectList(const OmpClause::Depend &clause) {
   return common::visit(
       common::visitors{
-          [&](const OmpClause::Depend &x) -> const OmpObjectList * {
-            if (auto *taskDep{std::get_if<OmpDependClause::TaskDep>(&x.v.u)}) {
-              return &std::get<OmpObjectList>(taskDep->t);
-            } else {
-              return nullptr;
-            }
-          },
-          [&](const auto &x) -> const OmpObjectList * {
-            using Ty = std::decay_t<decltype(x)>;
-            if constexpr (common::HasMember<Ty, MemberObjectListClauses>) {
-              return &x.v;
-            } else if constexpr (common::HasMember<Ty,
-                                     TupleObjectListClauses>) {
-              return &std::get<OmpObjectList>(x.v.t);
-            } else {
-              return nullptr;
-            }
-          },
+          [](const OmpDoacross &) { return nullptr; },
+          [](const OmpDependClause::TaskDep &x) { return GetOmpObjectList(x); },
       },
-      clause.u);
+      clause.v.u);
+}
+
+const OmpObjectList *GetOmpObjectList(const OmpDependClause::TaskDep &x) {
+  return &std::get<OmpObjectList>(x.t);
 }
 
 const BlockConstruct *GetFortranBlockConstruct(

flang/lib/Semantics/check-omp-loop.cpp

@@ -480,9 +480,8 @@ void OmpStructureChecker::CheckDistLinear(
 
   // Collect symbols of all the variables from linear clauses
   for (auto &clause : clauses.v) {
-    if (auto *linearClause{std::get_if<parser::OmpClause::Linear>(&clause.u)}) {
-      auto &objects{std::get<parser::OmpObjectList>(linearClause->v.t)};
-      GetSymbolsInObjectList(objects, indexVars);
+    if (std::get_if<parser::OmpClause::Linear>(&clause.u)) {
+      GetSymbolsInObjectList(*parser::omp::GetOmpObjectList(clause), indexVars);
     }
   }
 
@@ -604,8 +603,6 @@ void OmpStructureChecker::Leave(const parser::OpenMPLoopConstruct &x) {
       auto *maybeModifier{OmpGetUniqueModifier<ReductionModifier>(modifiers)};
       if (maybeModifier &&
           maybeModifier->v == ReductionModifier::Value::Inscan) {
-        const auto &objectList{
-            std::get<parser::OmpObjectList>(reductionClause->v.t)};
         auto checkReductionSymbolInScan = [&](const parser::Name *name) {
           if (auto &symbol = name->symbol) {
             if (!symbol->test(Symbol::Flag::OmpInclusiveScan) &&
@@ -618,7 +615,7 @@ void OmpStructureChecker::Leave(const parser::OpenMPLoopConstruct &x) {
             }
           }
         };
-        for (const auto &ompObj : objectList.v) {
+        for (const auto &ompObj : parser::omp::GetOmpObjectList(clause)->v) {
           common::visit(
               common::visitors{
                   [&](const parser::Designator &designator) {