clang-format

Author: akuhlens

flang/include/flang/Lower/OpenACC.h

@@ -76,7 +76,8 @@ static constexpr llvm::StringRef declarePostDeallocSuffix =
 
 static constexpr llvm::StringRef privatizationRecipePrefix = "privatization";
 
-bool needsOpenACCRoutineConstruct(const Fortran::evaluate::ProcedureDesignator *);
+bool needsOpenACCRoutineConstruct(
+    const Fortran::evaluate::ProcedureDesignator *);
 
 mlir::Value genOpenACCConstruct(AbstractConverter &,
                                 Fortran::semantics::SemanticsContext &,

flang/include/flang/Semantics/symbol.h

@@ -143,7 +143,8 @@ class OpenACCRoutineDeviceTypeInfo {
   const std::variant<std::string, SymbolRef> *bindName() const {
     return bindName_.has_value() ? &*bindName_ : nullptr;
   }
-  const std::optional<std::variant<std::string, SymbolRef>> &bindNameOpt() const {
+  const std::optional<std::variant<std::string, SymbolRef>> &
+  bindNameOpt() const {
     return bindName_;
   }
   void set_bindName(std::string &&name) { bindName_.emplace(std::move(name)); }
@@ -153,6 +154,7 @@ class OpenACCRoutineDeviceTypeInfo {
 
   friend llvm::raw_ostream &operator<<(
       llvm::raw_ostream &, const OpenACCRoutineDeviceTypeInfo &);
+
 private:
   bool isSeq_{false};
   bool isVector_{false};

flang/lib/Lower/Bridge.cpp

@@ -465,8 +465,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
   /// Declare a function.
   void declareFunction(Fortran::lower::pft::FunctionLikeUnit &funit) {
     setCurrentPosition(funit.getStartingSourceLoc());
-    builder = new fir::FirOpBuilder(
-        bridge.getModule(), bridge.getKindMap(), &mlirSymbolTable);
+    builder = new fir::FirOpBuilder(bridge.getModule(), bridge.getKindMap(),
+                                    &mlirSymbolTable);
     for (int entryIndex = 0, last = funit.entryPointList.size();
          entryIndex < last; ++entryIndex) {
       funit.setActiveEntry(entryIndex);
@@ -1031,9 +1031,9 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     return bridge.getSemanticsContext().FindScope(currentPosition);
   }
 
-  fir::FirOpBuilder &getFirOpBuilder() override final { 
+  fir::FirOpBuilder &getFirOpBuilder() override final {
     CHECK(builder && "builder is not set before calling getFirOpBuilder");
-    return *builder; 
+    return *builder;
   }
 
   mlir::ModuleOp getModuleOp() override final { return bridge.getModule(); }
@@ -5616,10 +5616,10 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     LLVM_DEBUG(llvm::dbgs() << "\n[bridge - startNewFunction]";
                if (auto *sym = scope.symbol()) llvm::dbgs() << " " << *sym;
                llvm::dbgs() << "\n");
-    // I don't think setting the builder is necessary here, because callee 
+    // I don't think setting the builder is necessary here, because callee
     // always looks up the FuncOp from the module. If there was a function that
     // was not declared yet. This call to callee will cause an assertion
-    //failure.
+    // failure.
     Fortran::lower::CalleeInterface callee(funit, *this);
     mlir::func::FuncOp func = callee.addEntryBlockAndMapArguments();
     builder =

flang/lib/Lower/CallInterface.cpp

@@ -717,11 +717,14 @@ void Fortran::lower::CallInterface<T>::declare() {
           func.setArgAttrs(placeHolder.index(), placeHolder.value().attributes);
 
       setCUDAAttributes(func, side().getProcedureSymbol(), characteristic);
-      
+
       if (const Fortran::semantics::Symbol *sym = side().getProcedureSymbol()) {
-        if (const auto &info{sym->GetUltimate().detailsIf<Fortran::semantics::SubprogramDetails>()}) {
+        if (const auto &info{
+                sym->GetUltimate()
+                    .detailsIf<Fortran::semantics::SubprogramDetails>()}) {
           if (!info->openACCRoutineInfos().empty()) {
-            genOpenACCRoutineConstruct(converter, module, func, info->openACCRoutineInfos());
+            genOpenACCRoutineConstruct(converter, module, func,
+                                       info->openACCRoutineInfos());
           }
         }
       }

flang/lib/Lower/OpenACC.cpp

@@ -32,14 +32,14 @@
 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/scope.h"
 #include "flang/Semantics/tools.h"
+#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
+#include "mlir/IR/MLIRContext.h"
+#include "mlir/Support/LLVM.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Frontend/OpenACC/ACC.h.inc"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
-#include "mlir/IR/MLIRContext.h"
-#include "mlir/Support/LLVM.h"
 
 #define DEBUG_TYPE "flang-lower-openacc"
 
@@ -4141,7 +4141,9 @@ static void attachRoutineInfo(mlir::func::FuncOp func,
       mlir::acc::RoutineInfoAttr::get(func.getContext(), routines));
 }
 
-static mlir::ArrayAttr getArrayAttrOrNull(fir::FirOpBuilder &builder, llvm::SmallVector<mlir::Attribute> &attributes) {
+static mlir::ArrayAttr
+getArrayAttrOrNull(fir::FirOpBuilder &builder,
+                   llvm::SmallVector<mlir::Attribute> &attributes) {
   if (attributes.empty()) {
     return nullptr;
   } else {
@@ -4181,25 +4183,24 @@ void createOpenACCRoutineConstruct(
   mlir::OpBuilder modBuilder(mod.getBodyRegion());
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   modBuilder.create<mlir::acc::RoutineOp>(
-      loc, routineOpStr, funcName,
-      getArrayAttrOrNull(builder, bindNames),
+      loc, routineOpStr, funcName, getArrayAttrOrNull(builder, bindNames),
       getArrayAttrOrNull(builder, bindNameDeviceTypes),
       getArrayAttrOrNull(builder, workerDeviceTypes),
       getArrayAttrOrNull(builder, vectorDeviceTypes),
-      getArrayAttrOrNull(builder, seqDeviceTypes),
-      hasNohost, /*implicit=*/false,
-      getArrayAttrOrNull(builder, gangDeviceTypes),
+      getArrayAttrOrNull(builder, seqDeviceTypes), hasNohost,
+      /*implicit=*/false, getArrayAttrOrNull(builder, gangDeviceTypes),
       getArrayAttrOrNull(builder, gangDimValues),
       getArrayAttrOrNull(builder, gangDimDeviceTypes));
 
   auto symbolRefAttr = builder.getSymbolRefAttr(routineOpStr);
   if (funcOp) {
-    
+
     attachRoutineInfo(funcOp, symbolRefAttr);
   } else {
     // FuncOp is not lowered yet. Keep the information so the routine info
     // can be attached later to the funcOp.
-    converter.getAccDelayedRoutines().push_back(std::make_pair(funcName, symbolRefAttr));
+    converter.getAccDelayedRoutines().push_back(
+        std::make_pair(funcName, symbolRefAttr));
   }
 }
 
@@ -4218,7 +4219,7 @@ static void interpretRoutineDeviceInfo(
   auto getDeviceTypeAttr = [&]() -> mlir::Attribute {
     auto context = builder.getContext();
     auto value = getDeviceType(dinfo.dType());
-    return mlir::acc::DeviceTypeAttr::get(context, value );
+    return mlir::acc::DeviceTypeAttr::get(context, value);
   };
   if (dinfo.isSeq()) {
     seqDeviceTypes.push_back(getDeviceTypeAttr());
@@ -4244,14 +4245,15 @@ static void interpretRoutineDeviceInfo(
     const auto &bindName = dinfo.bindNameOpt().value();
     mlir::Attribute bindNameAttr;
     if (const auto &bindStr{std::get_if<std::string>(&bindName)}) {
-        bindNameAttr = builder.getStringAttr(*bindStr);
-      } else if (const auto &bindSym{std::get_if<Fortran::semantics::SymbolRef>(&bindName)}) {
-        bindNameAttr = builder.getStringAttr(converter.mangleName(*bindSym));
-      } else {
-        llvm_unreachable("Unsupported bind name type");     
-      }
-      bindNames.push_back(bindNameAttr);
-      bindNameDeviceTypes.push_back(getDeviceTypeAttr());
+      bindNameAttr = builder.getStringAttr(*bindStr);
+    } else if (const auto &bindSym{
+                   std::get_if<Fortran::semantics::SymbolRef>(&bindName)}) {
+      bindNameAttr = builder.getStringAttr(converter.mangleName(*bindSym));
+    } else {
+      llvm_unreachable("Unsupported bind name type");
+    }
+    bindNames.push_back(bindNameAttr);
+    bindNameDeviceTypes.push_back(getDeviceTypeAttr());
   }
 }
 
@@ -4277,18 +4279,18 @@ void Fortran::lower::genOpenACCRoutineConstruct(
     }
     // Note: Device Independent Attributes are set to the
     // none device type in `info`.
-    interpretRoutineDeviceInfo(converter, info, seqDeviceTypes, vectorDeviceTypes,
-                               workerDeviceTypes, bindNameDeviceTypes,
-                               bindNames, gangDeviceTypes, gangDimValues,
-                               gangDimDeviceTypes);
+    interpretRoutineDeviceInfo(converter, info, seqDeviceTypes,
+                               vectorDeviceTypes, workerDeviceTypes,
+                               bindNameDeviceTypes, bindNames, gangDeviceTypes,
+                               gangDimValues, gangDimDeviceTypes);
 
     // Device Dependent Attributes
     for (const Fortran::semantics::OpenACCRoutineDeviceTypeInfo &dinfo :
          info.deviceTypeInfos()) {
       interpretRoutineDeviceInfo(
-          converter, dinfo, seqDeviceTypes, vectorDeviceTypes, workerDeviceTypes,
-          bindNameDeviceTypes, bindNames, gangDeviceTypes, gangDimValues,
-          gangDimDeviceTypes);
+          converter, dinfo, seqDeviceTypes, vectorDeviceTypes,
+          workerDeviceTypes, bindNameDeviceTypes, bindNames, gangDeviceTypes,
+          gangDimValues, gangDimDeviceTypes);
     }
   }
   createOpenACCRoutineConstruct(

flang/lib/Semantics/resolve-directives.cpp

@@ -1103,7 +1103,8 @@ void AccAttributeVisitor::AddRoutineInfoToSymbol(
     }
     symbol.get<SubprogramDetails>().add_openACCRoutineInfo(info);
   } else {
-    llvm::errs() << "Couldnot add routine info to symbol: " << symbol.name() << "\n";
+    llvm::errs() << "Couldnot add routine info to symbol: " << symbol.name()
+                 << "\n";
   }
 }