[flang] Make f18 build with GCC 11.2.0 and with --std=c++20

[klausler]

Summary

C++20 deprecates the implicit access to the value of "this" in
a lambda closure with "[=]"; rewrite some as "[this]".

Address a legitimate, but benign, warning about overindexing when
converting REAL(10) 80-bit x87 floating-point constants to host
long doubles (when available), which GCC pads out to 16 bytes.

Add an explicit no-op constructor to Fortran::parser::Verbatim.
(It has worked fine without one until now, but now it seems necessary.)

Builds were verified out-of-tree against LLVM built with GCC 9.3.0
in both shared and static library linkage modes.

[rovka]

Seems fine.

flang/CMakeLists.txt

113

Nit: How about if (NOT LLVM_CXX_STD EQUAL CMAKE_CXX_STANDARD)?

[klausler]

flang/CMakeLists.txt

113

Only one of them has a "c++" prefix, so they would never compare equal.

[rovka]

flang/CMakeLists.txt

113

Right. Also, EQUAL is for "numbers", we should use STREQUAL: if (NOT LLVM_CXX_STD STREQUAL "c++${CMAKE_CXX_STANDARD}").

[klausler]

Michael K., would this change pose any trouble for MSVC builds?

[klausler]

Extend patch to cover newly "upstreamed" code.

[Meinersbur]

Sorry for the long wait. msvc successfully compiles this with CMAKE_CXX_STANDARD set to 20 (which cmake translates to /std:c++20).

LGTM

flang/CMakeLists.txt

6–7

[suggestion] CMAKE_CXX_STANDARD is set by the user, so this will just overwrite it even if the user set it to CMAKE_CXX_STANDARD=20. Why not just check that the value is at least 17 and if not, override it with a warning like lined 117ff?

120

mvsc's option is /std:... (see https://docs.microsoft.com/en-us/cpp/build/reference/std-specify-language-standard-version?view=msvc-170), so the string(REPLACE -std= ...) will not work.

LLVM_CXX_STD has been removed in rG2724d9e12960cc1d93eeabbfc9aa1bffffa041cc, so this code will never trigger anyway.

flang/lib/Lower/ConvertExpr.cpp

3732–3733

mvcs complains about arrLoad missing here, probably a result of changes this this patch.

flang/CMakeLists.txt

 
 set(CMAKE_BUILD_WITH_INSTALL_NAME_DIR ON)
 
-# Flang requires C++17.
+# Flang requires C++17 or later.
 set(CMAKE_CXX_STANDARD 17)
+#set(CMAKE_CXX_STANDARD 20) # also works
 set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
 set(CMAKE_CXX_EXTENSIONS OFF)
 

   # avoid some mixed compilation flangs (e.g. -std=c++11 ... -std=c++17).
   if (DEFINED LLVM_CXX_STD)
     message("LLVM configuration set a C++ standard: ${LLVM_CXX_STD}")
-    if (NOT LLVM_CXX_STD EQUAL "c++17")
+    if (NOT LLVM_CXX_STD STREQUAL "c++${CMAKE_CXX_STANDARD}")
       message("Flang: Overriding LLVM's 'cxx_std' setting...")
       message("    removing '-std=${LLVM_CXX_STD}'")
       message("    CMAKE_CXX_FLAGS='${CMAKE_CXX_FLAGS}'")

flang/include/flang/Parser/parse-tree.h

 
 // A parse tree node with provenance only
 struct Verbatim {
-  BOILERPLATE(Verbatim);
+  COPY_AND_ASSIGN_BOILERPLATE(Verbatim);
+  constexpr Verbatim() {}
   using EmptyTrait = std::true_type;
   CharBlock source;
 };

flang/lib/Evaluate/check-expression.cpp

     return (*this)(x.left());
   }
   template <typename T> bool operator()(const Expr<T> &x) {
-    return std::visit([=](const auto &y) { return (*this)(y); }, x.u);
+    return std::visit([this](const auto &y) { return (*this)(y); }, x.u);
   }
   bool operator()(const Expr<SomeType> &x) {
     if (IsNullPointer(x)) {

flang/lib/Lower/ConvertExpr.cpp

         if (isParenthesizedVariable(x)) {
           // Parenthesised variables are lowered to a reference to the variable
           // storage. When passing it as an argument, a copy must be passed.
-          return [=](IterSpace iters) -> ExtValue {
+          return [this, loc, cc](IterSpace iters) -> ExtValue {
             return createInMemoryScalarCopy(builder, loc, cc(iters));
           };
         }
         mlir::Type storageType =
             fir::unwrapSequenceType(converter.genType(toEvExpr(x)));
-        return [=](IterSpace iters) -> ExtValue {
+        return [this, loc, cc, storageType](IterSpace iters) -> ExtValue {
           return placeScalarValueInMemory(builder, loc, cc(iters), storageType);
         };
       }

           mlir::Value isPresent =
               genActualIsPresentTest(builder, loc, optionalArg);
           operands.emplace_back(
-              [=](IterSpace iters) -> ExtValue {
+              [this, loc, optionalArg](IterSpace iters) -> ExtValue {
                 return genLoad(builder, loc, optionalArg);
               },
               isPresent);

 
       fir::FirOpBuilder *bldr = &converter.getFirOpBuilder();
       llvm::StringRef name = intrinsic.name;
-      return [=](IterSpace iters) -> ExtValue {
+      return [this, bldr, loc, name, operands,
+              retTy](IterSpace iters) -> ExtValue {
         auto getArgument = [&](std::size_t i) -> ExtValue {
           return operands[i].first(iters);
         };

         case Fortran::lower::LowerIntrinsicArgAs::Box: {
           PushSemantics(ConstituentSemantics::RefOpaque);
           auto lambda = genElementalArgument(*expr);
-          operands.emplace_back([=](IterSpace iters) {
+          operands.emplace_back([this, lambda, loc](IterSpace iters) {
             return builder.createBox(loc, lambda(iters));
           });
         } break;

     }
 
     // Let the intrinsic library lower the intrinsic procedure call
-    return [=](IterSpace iters) {
+    return [this, loc, name, operands, retTy](IterSpace iters) {
       llvm::SmallVector<ExtValue> args;
       for (const auto &cc : operands)
         args.push_back(cc(iters));

             procRef.proc().GetSpecificIntrinsic()) {
       if (explicitSpaceIsActive() && procRef.Rank() == 0) {
         // Elide any implicit loop iters.
-        return [=, &procRef](IterSpace) {
+        return [this, intrinsic, loc, &procRef, retTy](IterSpace) {
           return ScalarExprLowering{loc, converter, symMap, stmtCtx}
               .genIntrinsicRef(procRef, *intrinsic, retTy);
         };

 
     if (explicitSpaceIsActive() && procRef.Rank() == 0) {
       // Elide any implicit loop iters.
-      return [=, &procRef](IterSpace) {
+      return [this, loc, &procRef, retTy](IterSpace) {
         return ScalarExprLowering{loc, converter, symMap, stmtCtx}
             .genProcedureRef(procRef, retTy);
       };

     mlir::Location loc = getLoc();
     auto lambda = genarr(evEx.left());
     auto rf = genarr(evEx.right());
-    return [=](IterSpace iters) -> ExtValue {
+    return [this, lambda, loc, rf](IterSpace iters) -> ExtValue {
       mlir::Value left = fir::getBase(lambda(iters));
       mlir::Value right = fir::getBase(rf(iters));
       return builder.create<OP>(loc, left, right);

   CC genAsScalar(const A &x) {
     mlir::Location loc = getLoc();
     if (isProjectedCopyInCopyOut()) {
-      return [=, &x, builder = &converter.getFirOpBuilder()](
+      return [this, loc, &x, builder = &converter.getFirOpBuilder()](
                  IterSpace iters) -> ExtValue {
         ExtValue exv = asScalarRef(x);
         mlir::Value val = fir::getBase(exv);

         return exv;
       };
     }
-    return [=, &x](IterSpace) { return asScalar(x); };
+    return [this, &x](IterSpace) { return asScalar(x); };
   }
 
   CC genarr(const Fortran::semantics::Symbol &x, ComponentPath &components) {

         ArrayOperand{memref, shape, noSlice, /*mayBeAbsent=*/true});
 
     // By value semantics.
-    auto cc = [=](IterSpace iters) -> ExtValue {
+    auto cc = [this, arrLd, arrLdTypeParams, eleType, exv, loc,
+               noSlice](IterSpace iters) -> ExtValue {
       auto arrFetch = builder.create<fir::ArrayFetchOp>(
           loc, eleType, arrLd, iters.iterVec(), arrLdTypeParams);
       return fir::factory::arraySectionElementToExtendedValue(

     mlir::Value isPresent;
     mlir::Type eleType;
     std::tie(cc, isPresent, eleType) = genOptionalArrayFetch(expr);
-    return [=](IterSpace iters) -> ExtValue {
+    return [this, cc, eleType, isPresent, loc](IterSpace iters) -> ExtValue {
       mlir::Value elementValue =
           builder
               .genIfOp(loc, {eleType}, isPresent,

       // Here the continuation will `array_fetch` a value from an array and
       // then store that value in a temporary. One can thus imitate pass by
       // value even when the call is pass by reference.
-      return [=](IterSpace iters) -> ExtValue {
+      return [this, arrLd, arrLdTypeParams, arrTy, extMemref, loc,
+              slice](IterSpace iters) -> ExtValue {
         mlir::Value base;
         mlir::Type eleTy = fir::applyPathToType(arrTy, iters.iterVec());
         if (isAdjustedArrayElementType(eleTy)) {

     }
     // In the default case, the array reference forwards an `array_fetch` or
     // `array_access` Op in the continuation.
-    return [=](IterSpace iters) -> ExtValue {
+    return [this, arrLd, arrLdTypeParams, arrTy, components, extMemref, loc,
+            slice](IterSpace iters) -> ExtValue {
       mlir::Type eleTy = fir::applyPathToType(arrTy, iters.iterVec());
       if (isAdjustedArrayElementType(eleTy)) {
         mlir::Type eleRefTy = builder.getRefType(eleTy);

   /// `iters.element` into the destination array, `iters.innerArgument`. Handles
   /// by value and by reference assignment.
   CC defaultStoreToDestination(const Fortran::evaluate::Substring *substring) {
-    return [=](IterSpace iterSpace) -> ExtValue {
+    return [this, substring](IterSpace iterSpace) -> ExtValue {
       mlir::Location loc = getLoc();
       mlir::Value innerArg = iterSpace.innerArgument();
       fir::ExtendedValue exv = iterSpace.elementExv();

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

           rewriter->create<fir::AllocaOp>(loc, dyn_cast_ptrEleTy(resTy));
       newInTys.push_back(resTy);
       newOpers.push_back(stack);
-      return [=](mlir::Operation *) -> mlir::Value {
+      return [this, loc, stack, ty](mlir::Operation *) -> mlir::Value {
         auto memTy = ReferenceType::get(ty);
         auto cast = rewriter->create<ConvertOp>(loc, memTy, stack);
         return rewriter->create<fir::LoadOp>(loc, cast);
       };
     }
     newResTys.push_back(resTy);
-    return [=](mlir::Operation *call) -> mlir::Value {
+    return [this, loc, resTy, ty](mlir::Operation *call) -> mlir::Value {
       auto mem = rewriter->create<fir::AllocaOp>(loc, resTy);
       rewriter->create<fir::StoreOp>(loc, call->getResult(0), mem);
       auto memTy = ReferenceType::get(ty);

     auto argTy = std::get<mlir::Type>(tup);
     if (attr.isSRet()) {
       unsigned argNo = newInTys.size();
-      fixups.emplace_back(
-          FixupTy::Codes::ReturnAsStore, argNo, [=](mlir::FuncOp func) {
-            func.setArgAttr(argNo, "llvm.sret", rewriter->getUnitAttr());
-          });
+      fixups.emplace_back(FixupTy::Codes::ReturnAsStore, argNo,
+                          [this, argNo](mlir::FuncOp func) {
+                            func.setArgAttr(argNo, "llvm.sret",
+                                            rewriter->getUnitAttr());
+                          });
       newInTys.push_back(argTy);
       return;
     }

       if (attr.isByVal()) {
         if (auto align = attr.getAlignment())
           fixups.emplace_back(
-              FixupTy::Codes::ArgumentAsLoad, argNo, [=](mlir::FuncOp func) {
+              FixupTy::Codes::ArgumentAsLoad, argNo,
+              [this, align, argNo](mlir::FuncOp func) {
                 func.setArgAttr(argNo, "llvm.byval", rewriter->getUnitAttr());
                 func.setArgAttr(argNo, "llvm.align",
                                 rewriter->getIntegerAttr(

               });
         else
           fixups.emplace_back(FixupTy::Codes::ArgumentAsLoad, newInTys.size(),
-                              [=](mlir::FuncOp func) {
+                              [this, argNo](mlir::FuncOp func) {
                                 func.setArgAttr(argNo, "llvm.byval",
                                                 rewriter->getUnitAttr());
                               });
       } else {
         if (auto align = attr.getAlignment())
-          fixups.emplace_back(fixupCode, argNo, index, [=](mlir::FuncOp func) {
-            func.setArgAttr(
-                argNo, "llvm.align",
-                rewriter->getIntegerAttr(rewriter->getIntegerType(32), align));
-          });
+          fixups.emplace_back(
+              fixupCode, argNo, index, [this, align, argNo](mlir::FuncOp func) {
+                func.setArgAttr(argNo, "llvm.align",
+                                rewriter->getIntegerAttr(
+                                    rewriter->getIntegerType(32), align));
+              });
         else
           fixups.emplace_back(fixupCode, argNo, index);
       }

flang/lib/Semantics/resolve-names.cpp

     const parser::TypeParamValue &x, common::TypeParamAttr attr) {
   return std::visit(
       common::visitors{
-          [=](const parser::ScalarIntExpr &x) { // C704
+          [this, attr](const parser::ScalarIntExpr &x) { // C704
             return ParamValue{EvaluateIntExpr(x), attr};
           },
           [=](const parser::Star &) { return ParamValue::Assumed(attr); },

     const parser::DataRef &x) {
   return std::visit(
       common::visitors{
-          [=](const parser::Name &y) { return ResolveName(y); },
-          [=](const Indirection<parser::StructureComponent> &y) {
+          [this](const parser::Name &y) { return ResolveName(y); },
+          [this](const Indirection<parser::StructureComponent> &y) {
             return ResolveStructureComponent(y.value());
           },
           [&](const Indirection<parser::ArrayElement> &y) {

     for (const auto &accessId : accessIds) {
       std::visit(
           common::visitors{
-              [=](const parser::Name &y) {
+              [this, accessAttr](const parser::Name &y) {
                 Resolve(y, SetAccess(y.source, accessAttr));
               },
-              [=](const Indirection<parser::GenericSpec> &y) {
+              [this, accessAttr](const Indirection<parser::GenericSpec> &y) {
                 auto info{GenericSpecInfo{y.value()}};
                 const auto &symbolName{info.symbolName()};
                 if (auto *symbol{FindInScope(symbolName)}) {