[Flang][OpenMP] Correct location information 1/n

[kiranchandramohan]

Summary

This patch fixes location information of a few OpenMP constructs
and clauses. More fixes will come in follow-up patches.

This patch follows the same fixes for OpenACC (D131659).

Addresses some of the issues in https://github.com/llvm/llvm-project/issues/57215

[kiranchandramohan]

Fix patch application issue.

[kiranchandramohan]

Update comment in test file.

[clementval]

Thanks Kiran for working on this. LGTM

flang/lib/Lower/OpenMP.cpp

for (const Fortran::parser::OmpObject &ompObject : objectList.v) {
     Fortran::semantics::Symbol *sym = getOmpObjectSymbol(ompObject);
     addOperands(*sym);
   }
 }
 
 static mlir::Value
 getIfClauseOperand(Fortran::lower::AbstractConverter &converter,
                    Fortran::lower::StatementContext &stmtCtx,
-                   const Fortran::parser::OmpClause::If *ifClause) {
+                   const Fortran::parser::OmpClause::If *ifClause,
+                   mlir::Location clauseLocation) {
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
-  mlir::Location currentLocation = converter.getCurrentLocation();
   auto &expr = std::get<Fortran::parser::ScalarLogicalExpr>(ifClause->v.t);
   mlir::Value ifVal = fir::getBase(
       converter.genExprValue(*Fortran::semantics::GetExpr(expr), stmtCtx));
-  return firOpBuilder.createConvert(currentLocation, firOpBuilder.getI1Type(),
+  return firOpBuilder.createConvert(clauseLocation, firOpBuilder.getI1Type(),
                                     ifVal);
 }
 
 static mlir::Type getLoopVarType(Fortran::lower::AbstractConverter &converter,
                                  std::size_t loopVarTypeSize) {
   // OpenMP runtime requires 32-bit or 64-bit loop variables.
   loopVarTypeSize = loopVarTypeSize * 8;
   if (loopVarTypeSize < 32) {
for (auto *sym : useDeviceSymbols) {
     }
     argIndex++;
   }
 }
 
 static void createTargetOp(Fortran::lower::AbstractConverter &converter,
                            const Fortran::parser::OmpClauseList &opClauseList,
                            const llvm::omp::Directive &directive,
+                           mlir::Location currentLocation,
                            Fortran::lower::pft::Evaluation *eval = nullptr) {
   Fortran::lower::StatementContext stmtCtx;
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
 
   mlir::Value ifClauseOperand, deviceOperand, threadLmtOperand;
   mlir::UnitAttr nowaitAttr;
   llvm::SmallVector<mlir::Value> mapOperands, devicePtrOperands,
       deviceAddrOperands;
   llvm::SmallVector<mlir::IntegerAttr> mapTypes;
   llvm::SmallVector<mlir::Type> useDeviceTypes;
   llvm::SmallVector<mlir::Location> useDeviceLocs;
   SmallVector<const Fortran::semantics::Symbol *> useDeviceSymbols;
 
   /// Check for unsupported map operand types.
-  auto checkType = [](auto currentLocation, mlir::Type type) {
+  auto checkType = [](mlir::Location location, mlir::Type type) {
     if (auto refType = type.dyn_cast<fir::ReferenceType>())
       type = refType.getElementType();
     if (auto boxType = type.dyn_cast_or_null<fir::BoxType>())
       if (!boxType.getElementType().isa<fir::PointerType>())
-        TODO(currentLocation, "OMPD_target_data MapOperand BoxType");
+        TODO(location, "OMPD_target_data MapOperand BoxType");
   };
 
-  auto addMapClause = [&](const auto &mapClause,
-                          mlir::Location &currentLocation) {
+  auto addMapClause = [&](const auto &mapClause, mlir::Location &location) {
     auto mapType = std::get<Fortran::parser::OmpMapType::Type>(
         std::get<std::optional<Fortran::parser::OmpMapType>>(mapClause->v.t)
             ->t);
     llvm::omp::OpenMPOffloadMappingFlags mapTypeBits =
         llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_NONE;
     switch (mapType) {
     case Fortran::parser::OmpMapType::Type::To:
       mapTypeBits |= llvm::omp::OpenMPOffloadMappingFlags::OMP_MAP_TO;
auto addMapClause = [&](const auto &mapClause, mlir::Location &location) {
 
     llvm::SmallVector<mlir::Value> mapOperand;
     /// Check for unsupported map operand types.
     for (const Fortran::parser::OmpObject &ompObject :
          std::get<Fortran::parser::OmpObjectList>(mapClause->v.t).v) {
       if (Fortran::parser::Unwrap<Fortran::parser::ArrayElement>(ompObject) ||
           Fortran::parser::Unwrap<Fortran::parser::StructureComponent>(
               ompObject))
-        TODO(currentLocation,
+        TODO(location,
              "OMPD_target_data for Array Expressions or Structure Components");
     }
     genObjectList(std::get<Fortran::parser::OmpObjectList>(mapClause->v.t),
                   converter, mapOperand);
 
     for (mlir::Value mapOp : mapOperand) {
       checkType(mapOp.getLoc(), mapOp.getType());
       mapOperands.push_back(mapOp);
auto addUseDeviceClause = [&](const auto &useDeviceClause, auto &operands) {
     }
     for (const Fortran::parser::OmpObject &ompObject : useDeviceClause.v) {
       Fortran::semantics::Symbol *sym = getOmpObjectSymbol(ompObject);
       useDeviceSymbols.push_back(sym);
     }
   };
 
   for (const Fortran::parser::OmpClause &clause : opClauseList.v) {
-    mlir::Location currentLocation = converter.genLocation(clause.source);
+    mlir::Location clauseLocation = converter.genLocation(clause.source);
     if (const auto &ifClause =
             std::get_if<Fortran::parser::OmpClause::If>(&clause.u)) {
-      ifClauseOperand = getIfClauseOperand(converter, stmtCtx, ifClause);
+      ifClauseOperand =
+          getIfClauseOperand(converter, stmtCtx, ifClause, clauseLocation);
     } else if (const auto &deviceClause =
                    std::get_if<Fortran::parser::OmpClause::Device>(&clause.u)) {
       if (auto deviceModifier = std::get<
               std::optional<Fortran::parser::OmpDeviceClause::DeviceModifier>>(
               deviceClause->v.t)) {
         if (deviceModifier ==
             Fortran::parser::OmpDeviceClause::DeviceModifier::Ancestor) {
-          TODO(currentLocation, "OMPD_target Device Modifier Ancestor");
+          TODO(clauseLocation, "OMPD_target Device Modifier Ancestor");
         }
       }
       if (const auto *deviceExpr = Fortran::semantics::GetExpr(
               std::get<Fortran::parser::ScalarIntExpr>(deviceClause->v.t))) {
         deviceOperand =
             fir::getBase(converter.genExprValue(*deviceExpr, stmtCtx));
       }
     } else if (const auto &threadLmtClause =
                    std::get_if<Fortran::parser::OmpClause::ThreadLimit>(
                        &clause.u)) {
       threadLmtOperand = fir::getBase(converter.genExprValue(
           *Fortran::semantics::GetExpr(threadLmtClause->v), stmtCtx));
     } else if (std::get_if<Fortran::parser::OmpClause::Nowait>(&clause.u)) {
       nowaitAttr = firOpBuilder.getUnitAttr();
     } else if (const auto &devPtrClause =
                    std::get_if<Fortran::parser::OmpClause::UseDevicePtr>(
                        &clause.u)) {
       addUseDeviceClause(devPtrClause->v, devicePtrOperands);
     } else if (const auto &devAddrClause =
                    std::get_if<Fortran::parser::OmpClause::UseDeviceAddr>(
                        &clause.u)) {
       addUseDeviceClause(devAddrClause->v, deviceAddrOperands);
     } else if (const auto &mapClause =
                    std::get_if<Fortran::parser::OmpClause::Map>(&clause.u)) {
-      addMapClause(mapClause, currentLocation);
+      addMapClause(mapClause, clauseLocation);
     } else {
-      TODO(currentLocation, "OMPD_target unhandled clause");
+      TODO(clauseLocation, "OMPD_target unhandled clause");
     }
   }
 
   llvm::SmallVector<mlir::Attribute> mapTypesAttr(mapTypes.begin(),
                                                   mapTypes.end());
   mlir::ArrayAttr mapTypesArrayAttr =
       ArrayAttr::get(firOpBuilder.getContext(), mapTypesAttr);
-  mlir::Location currentLocation = converter.getCurrentLocation();
 
   if (directive == llvm::omp::Directive::OMPD_target) {
     auto targetOp = firOpBuilder.create<omp::TargetOp>(
         currentLocation, ifClauseOperand, deviceOperand, threadLmtOperand,
         nowaitAttr, mapOperands, mapTypesArrayAttr);
     createBodyOfOp(targetOp, converter, currentLocation, *eval, &opClauseList);
   } else if (directive == llvm::omp::Directive::OMPD_target_data) {
     auto dataOp = firOpBuilder.create<omp::DataOp>(
static void genOMP(Fortran::lower::AbstractConverter &converter,
                    const Fortran::parser::OpenMPSimpleStandaloneConstruct
                        &simpleStandaloneConstruct) {
   const auto &directive =
       std::get<Fortran::parser::OmpSimpleStandaloneDirective>(
           simpleStandaloneConstruct.t);
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
   const Fortran::parser::OmpClauseList &opClauseList =
       std::get<Fortran::parser::OmpClauseList>(simpleStandaloneConstruct.t);
+  mlir::Location currentLocation = converter.genLocation(directive.source);
 
   switch (directive.v) {
   default:
     break;
   case llvm::omp::Directive::OMPD_barrier:
-    firOpBuilder.create<omp::BarrierOp>(converter.getCurrentLocation());
+    firOpBuilder.create<omp::BarrierOp>(currentLocation);
     break;
   case llvm::omp::Directive::OMPD_taskwait:
-    firOpBuilder.create<omp::TaskwaitOp>(converter.getCurrentLocation());
+    firOpBuilder.create<omp::TaskwaitOp>(currentLocation);
     break;
   case llvm::omp::Directive::OMPD_taskyield:
-    firOpBuilder.create<omp::TaskyieldOp>(converter.getCurrentLocation());
+    firOpBuilder.create<omp::TaskyieldOp>(currentLocation);
     break;
   case llvm::omp::Directive::OMPD_target_data:
   case llvm::omp::Directive::OMPD_target_enter_data:
   case llvm::omp::Directive::OMPD_target_exit_data:
-    createTargetOp(converter, opClauseList, directive.v);
+    createTargetOp(converter, opClauseList, directive.v, currentLocation);
     break;
   case llvm::omp::Directive::OMPD_target_update:
-    TODO(converter.getCurrentLocation(), "OMPD_target_update");
+    TODO(currentLocation, "OMPD_target_update");
   case llvm::omp::Directive::OMPD_ordered:
-    TODO(converter.getCurrentLocation(), "OMPD_ordered");
+    TODO(currentLocation, "OMPD_ordered");
   }
 }
 
 static void
 genAllocateClause(Fortran::lower::AbstractConverter &converter,
                   const Fortran::parser::OmpAllocateClause &ompAllocateClause,
                   SmallVector<Value> &allocatorOperands,
                   SmallVector<Value> &allocateOperands) {
createCombinedParallelOp(Fortran::lower::AbstractConverter &converter,
   SmallVector<Value> allocatorOperands, allocateOperands;
   mlir::omp::ClauseProcBindKindAttr procBindKindAttr;
   const auto &opClauseList =
       std::get<Fortran::parser::OmpClauseList>(directive.t);
   // TODO: Handle the following clauses
   // 1. default
   // Note: rest of the clauses are handled when the inner operation is created
   for (const Fortran::parser::OmpClause &clause : opClauseList.v) {
+    mlir::Location clauseLocation = converter.genLocation(clause.source);
     if (const auto &ifClause =
             std::get_if<Fortran::parser::OmpClause::If>(&clause.u)) {
-      ifClauseOperand = getIfClauseOperand(converter, stmtCtx, ifClause);
+      ifClauseOperand =
+          getIfClauseOperand(converter, stmtCtx, ifClause, clauseLocation);
     } else if (const auto &numThreadsClause =
                    std::get_if<Fortran::parser::OmpClause::NumThreads>(
                        &clause.u)) {
       numThreadsClauseOperand = fir::getBase(converter.genExprValue(
           *Fortran::semantics::GetExpr(numThreadsClause->v), stmtCtx));
     } else if (const auto &procBindClause =
                    std::get_if<Fortran::parser::OmpClause::ProcBind>(
                        &clause.u)) {
genOMP(Fortran::lower::AbstractConverter &converter,
        const Fortran::parser::OpenMPBlockConstruct &blockConstruct) {
   const auto &beginBlockDirective =
       std::get<Fortran::parser::OmpBeginBlockDirective>(blockConstruct.t);
   const auto &blockDirective =
       std::get<Fortran::parser::OmpBlockDirective>(beginBlockDirective.t);
   const auto &endBlockDirective =
       std::get<Fortran::parser::OmpEndBlockDirective>(blockConstruct.t);
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
-  mlir::Location currentLocation = converter.getCurrentLocation();
+  mlir::Location currentLocation = converter.genLocation(blockDirective.source);
 
   Fortran::lower::StatementContext stmtCtx;
   llvm::ArrayRef<mlir::Type> argTy;
   mlir::Value ifClauseOperand, numThreadsClauseOperand, finalClauseOperand,
       priorityClauseOperand;
   mlir::omp::ClauseProcBindKindAttr procBindKindAttr;
   SmallVector<Value> allocateOperands, allocatorOperands, dependOperands;
   SmallVector<Attribute> dependTypeOperands;
   mlir::UnitAttr nowaitAttr, untiedAttr, mergeableAttr;
 
   const auto &opClauseList =
       std::get<Fortran::parser::OmpClauseList>(beginBlockDirective.t);
   for (const auto &clause : opClauseList.v) {
+    mlir::Location clauseLocation = converter.genLocation(clause.source);
     if (const auto &ifClause =
             std::get_if<Fortran::parser::OmpClause::If>(&clause.u)) {
-      ifClauseOperand = getIfClauseOperand(converter, stmtCtx, ifClause);
+      ifClauseOperand =
+          getIfClauseOperand(converter, stmtCtx, ifClause, clauseLocation);
     } else if (const auto &numThreadsClause =
                    std::get_if<Fortran::parser::OmpClause::NumThreads>(
                        &clause.u)) {
       // OMPIRBuilder expects `NUM_THREAD` clause as a `Value`.
       numThreadsClauseOperand = fir::getBase(converter.genExprValue(
           *Fortran::semantics::GetExpr(numThreadsClause->v), stmtCtx));
     } else if (const auto &procBindClause =
                    std::get_if<Fortran::parser::OmpClause::ProcBind>(
genOMP(Fortran::lower::AbstractConverter &converter,
   } else if (blockDirective.v == llvm::omp::OMPD_taskgroup) {
     // TODO: Add task_reduction support
     auto taskGroupOp = firOpBuilder.create<mlir::omp::TaskGroupOp>(
         currentLocation, /*task_reduction_vars=*/ValueRange(),
         /*task_reductions=*/nullptr, allocateOperands, allocatorOperands);
     createBodyOfOp(taskGroupOp, converter, currentLocation, eval,
                    &opClauseList);
   } else if (blockDirective.v == llvm::omp::OMPD_target) {
-    createTargetOp(converter, opClauseList, blockDirective.v, &eval);
+    createTargetOp(converter, opClauseList, blockDirective.v, currentLocation,
+                   &eval);
   } else if (blockDirective.v == llvm::omp::OMPD_target_data) {
-    createTargetOp(converter, opClauseList, blockDirective.v, &eval);
+    createTargetOp(converter, opClauseList, blockDirective.v, currentLocation,
+                   &eval);
   } else {
-    TODO(converter.getCurrentLocation(), "Unhandled block directive");
+    TODO(currentLocation, "Unhandled block directive");
   }
 }
 
 /// This function returns the identity value of the operator \p reductionOpName.
 /// For example:
 ///    0 + x = x,
 ///    1 * x = x
 static int getOperationIdentity(llvm::StringRef reductionOpName,
static std::string getReductionName(
   return getReductionName(reductionName, ty);
 }
 
 static void genOMP(Fortran::lower::AbstractConverter &converter,
                    Fortran::lower::pft::Evaluation &eval,
                    const Fortran::parser::OpenMPLoopConstruct &loopConstruct) {
 
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
-  mlir::Location currentLocation = converter.getCurrentLocation();
   llvm::SmallVector<mlir::Value> lowerBound, upperBound, step, linearVars,
       linearStepVars, reductionVars, alignedVars, nontemporalVars;
   mlir::Value scheduleChunkClauseOperand, ifClauseOperand;
   mlir::Attribute scheduleClauseOperand, noWaitClauseOperand,
       orderedClauseOperand, orderClauseOperand;
   mlir::IntegerAttr simdlenClauseOperand, safelenClauseOperand;
   SmallVector<Attribute> reductionDeclSymbols;
   Fortran::lower::StatementContext stmtCtx;
   const auto &loopOpClauseList = std::get<Fortran::parser::OmpClauseList>(
       std::get<Fortran::parser::OmpBeginLoopDirective>(loopConstruct.t).t);
 
+  const auto &beginLoopDirective =
+      std::get<Fortran::parser::OmpBeginLoopDirective>(loopConstruct.t);
+  mlir::Location currentLocation =
+      converter.genLocation(beginLoopDirective.source);
   const auto ompDirective =
-      std::get<Fortran::parser::OmpLoopDirective>(
-          std::get<Fortran::parser::OmpBeginLoopDirective>(loopConstruct.t).t)
-          .v;
+      std::get<Fortran::parser::OmpLoopDirective>(beginLoopDirective.t).v;
+
   if (llvm::omp::OMPD_parallel_do == ompDirective) {
     createCombinedParallelOp<Fortran::parser::OmpBeginLoopDirective>(
         converter, eval,
         std::get<Fortran::parser::OmpBeginLoopDirective>(loopConstruct.t));
   } else if (llvm::omp::OMPD_do != ompDirective &&
              llvm::omp::OMPD_simd != ompDirective) {
-    TODO(converter.getCurrentLocation(), "Construct enclosing do loop");
+    TODO(currentLocation, "Construct enclosing do loop");
   }
 
   DataSharingProcessor dsp(converter, loopOpClauseList, eval);
   dsp.processStep1();
 
   // Collect the loops to collapse.
   auto *doConstructEval = &eval.getFirstNestedEvaluation();
   if (doConstructEval->getIf<Fortran::parser::DoConstruct>()
           ->IsDoConcurrent()) {
-    TODO(converter.getCurrentLocation(),
-         "Do Concurrent in Worksharing loop construct");
+    TODO(currentLocation, "Do Concurrent in Worksharing loop construct");
   }
 
   std::int64_t collapseValue =
       Fortran::lower::getCollapseValue(loopOpClauseList);
   std::size_t loopVarTypeSize = 0;
   SmallVector<const Fortran::semantics::Symbol *> iv;
   do {
     auto *doLoop = &doConstructEval->getFirstNestedEvaluation();
loopVarTypeSize = std::max(loopVarTypeSize,
                                bounds->name.thing.symbol->GetUltimate().size());
 
     collapseValue--;
     doConstructEval =
         &*std::next(doConstructEval->getNestedEvaluations().begin());
   } while (collapseValue > 0);
 
   for (const auto &clause : loopOpClauseList.v) {
+    mlir::Location clauseLocation = converter.genLocation(clause.source);
     if (const auto &scheduleClause =
             std::get_if<Fortran::parser::OmpClause::Schedule>(&clause.u)) {
       if (const auto &chunkExpr =
               std::get<std::optional<Fortran::parser::ScalarIntExpr>>(
                   scheduleClause->v.t)) {
         if (const auto *expr = Fortran::semantics::GetExpr(*chunkExpr)) {
           scheduleChunkClauseOperand =
               fir::getBase(converter.genExprValue(*expr, stmtCtx));
         }
       }
     } else if (const auto &ifClause =
                    std::get_if<Fortran::parser::OmpClause::If>(&clause.u)) {
-      ifClauseOperand = getIfClauseOperand(converter, stmtCtx, ifClause);
+      ifClauseOperand =
+          getIfClauseOperand(converter, stmtCtx, ifClause, clauseLocation);
     } else if (const auto &reductionClause =
                    std::get_if<Fortran::parser::OmpClause::Reduction>(
                        &clause.u)) {
       omp::ReductionDeclareOp decl;
       const auto &redOperator{std::get<Fortran::parser::OmpReductionOperator>(
           reductionClause->v.t)};
       const auto &objectList{
           std::get<Fortran::parser::OmpObjectList>(reductionClause->v.t)};

flang/test/Lower/OpenMP/location.f90

+! This test checks location of OpenMP constructs and clauses
+
+!RUN: %flang_fc1 -emit-fir -fopenmp -mmlir --mlir-print-debuginfo %s -o - | FileCheck %s
+
+!CHECK-LABEL: sub_parallel
+subroutine sub_parallel()
+  print *, x
+!CHECK: omp.parallel   {
+  !$omp parallel
+    print *, x
+!CHECK:   omp.terminator loc(#[[PAR_LOC:.*]])
+!CHECK: } loc(#[[PAR_LOC]])
+  !$omp end parallel
+  print *, x
+end
+
+!CHECK-LABEL: sub_target
+subroutine sub_target()
+  print *, x
+!CHECK: omp.target {{.*}}  {
+  !$omp target
+    print *, x
+!CHECK:   omp.terminator loc(#[[TAR_LOC:.*]])
+!CHECK: } loc(#[[TAR_LOC]])
+  !$omp end target
+  print *, x
+end
+
+!CHECK-LABEL: sub_loop
+subroutine sub_loop()
+!CHECK: omp.wsloop {{.*}}  {
+  !$omp do
+  do i=1,10
+    print *, i
+!CHECK:   omp.yield loc(#[[LOOP_LOC:.*]])
+!CHECK: } loc(#[[LOOP_LOC]])
+  end do
+  !$omp end do
+end
+
+!CHECK-LABEL: sub_standalone
+subroutine sub_standalone()
+  !CHECK: omp.barrier loc(#[[BAR_LOC:.*]])
+  !$omp barrier
+  !CHECK: omp.taskwait loc(#[[TW_LOC:.*]])
+  !$omp taskwait
+  !CHECK: omp.taskyield loc(#[[TY_LOC:.*]])
+  !$omp taskyield
+end
+
+subroutine sub_if(c)
+  logical(kind=4) :: c
+  !CHECK: %[[CVT:.*]] = fir.convert %{{.*}} : (!fir.logical<4>) -> i1 loc(#[[IF_LOC:.*]])
+  !CHECK: omp.task if(%[[CVT]])
+  !$omp task if(c)
+    print *, "Task"
+  !$omp end task
+  !CHECK: } loc(#[[TASK_LOC:.*]])
+end subroutine
+
+!CHECK: #[[PAR_LOC]] = loc("{{.*}}location.f90":9:9)
+!CHECK: #[[TAR_LOC]] = loc("{{.*}}location.f90":21:9)
+!CHECK: #[[LOOP_LOC]] = loc("{{.*}}location.f90":32:9)
+!CHECK: #[[BAR_LOC]] = loc("{{.*}}location.f90":44:9)
+!CHECK: #[[TW_LOC]] = loc("{{.*}}location.f90":46:9)
+!CHECK: #[[TY_LOC]] = loc("{{.*}}location.f90":48:9)
+!CHECK: #[[IF_LOC]] = loc("{{.*}}location.f90":55:14)
+!CHECK: #[[TASK_LOC]] = loc("{{.*}}location.f90":55:9)