[flang][OpenMP] Duplicate the utils needed by DoConcurrentConversion (

#88)

This adds a temporary (but more localy workaround) for the linker issue
resulted from linking with `OpenMP/Utils.cpp`. This duplicates the
required functions until we find a proper CMake solution.

flang/lib/Optimizer/Transforms/CMakeLists.txt

@@ -24,10 +24,6 @@ add_flang_library(FIRTransforms
   FunctionAttr.cpp
   DebugTypeGenerator.cpp
   DoConcurrentConversion.cpp
-  # TODO Find a cleaner solution for this. This is a workaround to expose 
-  # `Utils.cpp` so that it be used the `DoConcurrentConversion` pass. We should
-  # probably split this is a shared lib.
-  ../../Lower/OpenMP/Utils.cpp
 
   DEPENDS
   FIRDialect

flang/lib/Optimizer/Transforms/DoConcurrentConversion.cpp

@@ -6,7 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "flang/Lower/OpenMP/Utils.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
@@ -35,6 +34,115 @@ namespace fir {
 
 #define DEBUG_TYPE "fopenmp-do-concurrent-conversion"
 
+namespace Fortran {
+namespace lower {
+namespace omp {
+mlir::omp::MapInfoOp
+createMapInfoOp(mlir::OpBuilder &builder, mlir::Location loc,
+                mlir::Value baseAddr, mlir::Value varPtrPtr, std::string name,
+                llvm::ArrayRef<mlir::Value> bounds,
+                llvm::ArrayRef<mlir::Value> members,
+                mlir::DenseIntElementsAttr membersIndex, uint64_t mapType,
+                mlir::omp::VariableCaptureKind mapCaptureType, mlir::Type retTy,
+                bool partialMap = false) {
+  if (auto boxTy = llvm::dyn_cast<fir::BaseBoxType>(baseAddr.getType())) {
+    baseAddr = builder.create<fir::BoxAddrOp>(loc, baseAddr);
+    retTy = baseAddr.getType();
+  }
+
+  mlir::TypeAttr varType = mlir::TypeAttr::get(
+      llvm::cast<mlir::omp::PointerLikeType>(retTy).getElementType());
+
+  mlir::omp::MapInfoOp op = builder.create<mlir::omp::MapInfoOp>(
+      loc, retTy, baseAddr, varType, varPtrPtr, members, membersIndex, bounds,
+      builder.getIntegerAttr(builder.getIntegerType(64, false), mapType),
+      builder.getAttr<mlir::omp::VariableCaptureKindAttr>(mapCaptureType),
+      builder.getStringAttr(name), builder.getBoolAttr(partialMap));
+
+  return op;
+}
+
+mlir::Value calculateTripCount(fir::FirOpBuilder &builder, mlir::Location loc,
+                               const mlir::omp::CollapseClauseOps &ops) {
+  using namespace mlir::arith;
+  assert(ops.loopLBVar.size() == ops.loopUBVar.size() &&
+         ops.loopLBVar.size() == ops.loopStepVar.size() &&
+         !ops.loopLBVar.empty() && "Invalid bounds or step");
+
+  // Get the bit width of an integer-like type.
+  auto widthOf = [](mlir::Type ty) -> unsigned {
+    if (mlir::isa<mlir::IndexType>(ty)) {
+      return mlir::IndexType::kInternalStorageBitWidth;
+    }
+    if (auto tyInt = mlir::dyn_cast<mlir::IntegerType>(ty)) {
+      return tyInt.getWidth();
+    }
+    llvm_unreachable("Unexpected type");
+  };
+
+  // For a type that is either IntegerType or IndexType, return the
+  // equivalent IntegerType. In the former case this is a no-op.
+  auto asIntTy = [&](mlir::Type ty) -> mlir::IntegerType {
+    if (ty.isIndex()) {
+      return mlir::IntegerType::get(ty.getContext(), widthOf(ty));
+    }
+    assert(ty.isIntOrIndex() && "Unexpected type");
+    return mlir::cast<mlir::IntegerType>(ty);
+  };
+
+  // For two given values, establish a common signless IntegerType
+  // that can represent any value of type of x and of type of y,
+  // and return the pair of x, y converted to the new type.
+  auto unifyToSignless =
+      [&](fir::FirOpBuilder &b, mlir::Value x,
+          mlir::Value y) -> std::pair<mlir::Value, mlir::Value> {
+    auto tyX = asIntTy(x.getType()), tyY = asIntTy(y.getType());
+    unsigned width = std::max(widthOf(tyX), widthOf(tyY));
+    auto wideTy = mlir::IntegerType::get(b.getContext(), width,
+                                         mlir::IntegerType::Signless);
+    return std::make_pair(b.createConvert(loc, wideTy, x),
+                          b.createConvert(loc, wideTy, y));
+  };
+
+  // Start with signless i32 by default.
+  auto tripCount = builder.createIntegerConstant(loc, builder.getI32Type(), 1);
+
+  for (auto [origLb, origUb, origStep] :
+       llvm::zip(ops.loopLBVar, ops.loopUBVar, ops.loopStepVar)) {
+    auto tmpS0 = builder.createIntegerConstant(loc, origStep.getType(), 0);
+    auto [step, step0] = unifyToSignless(builder, origStep, tmpS0);
+    auto reverseCond =
+        builder.create<CmpIOp>(loc, CmpIPredicate::slt, step, step0);
+    auto negStep = builder.create<SubIOp>(loc, step0, step);
+    mlir::Value absStep =
+        builder.create<SelectOp>(loc, reverseCond, negStep, step);
+
+    auto [lb, ub] = unifyToSignless(builder, origLb, origUb);
+    auto start = builder.create<SelectOp>(loc, reverseCond, ub, lb);
+    auto end = builder.create<SelectOp>(loc, reverseCond, lb, ub);
+
+    mlir::Value range = builder.create<SubIOp>(loc, end, start);
+    auto rangeCond =
+        builder.create<CmpIOp>(loc, CmpIPredicate::slt, end, start);
+    std::tie(range, absStep) = unifyToSignless(builder, range, absStep);
+    // numSteps = (range /u absStep) + 1
+    auto numSteps = builder.create<AddIOp>(
+        loc, builder.create<DivUIOp>(loc, range, absStep),
+        builder.createIntegerConstant(loc, range.getType(), 1));
+
+    auto trip0 = builder.createIntegerConstant(loc, numSteps.getType(), 0);
+    auto loopTripCount =
+        builder.create<SelectOp>(loc, rangeCond, trip0, numSteps);
+    auto [totalTC, thisTC] = unifyToSignless(builder, tripCount, loopTripCount);
+    tripCount = builder.create<MulIOp>(loc, totalTC, thisTC);
+  }
+
+  return tripCount;
+}
+} // namespace omp
+} // namespace lower
+} // namespace Fortran
+
 namespace {
 class DoConcurrentConversion : public mlir::OpConversionPattern<fir::DoLoopOp> {
 public: