[flang][openacc] Propagate correct location information from directive

[clementval]

Summary

Location information was not correctly propagated when creating OpenACC
operations. This patch propagate the correct location information from
the parse tree nodes to OpenACC MLIR operations.

[clementval]

Do not check the full file path to be platform agnostic

[razvanlupusoru]

Looks great!

I double-checked that you don't have any more converter.getCurrentLocation() calls. The line numbers in the test match what I expected.

One thing missing in the test is clause location testing - is it possible to add to test that an expression from an "if" clause gets correct line and offset?

[clementval]

In D131659#3716236, @razvanlupusoru wrote:

Looks great!

I double-checked that you don't have any more converter.getCurrentLocation() calls. The line numbers in the test match what I expected.

One thing missing in the test is clause location testing - is it possible to add to test that an expression from an "if" clause gets correct line and offset?

Yeah I'll add a test in that sense.

[clementval]

Add test for if clause expr location

[razvanlupusoru]

Thank you for adding the line number functionality and testing for the clause expressions. Looks great!

flang/lib/Lower/OpenACC.cpp

if (asyncClauseValue) { // async has a value.
     async = fir::getBase(converter.genExprValue(
         *Fortran::semantics::GetExpr(*asyncClauseValue), stmtCtx));
   } else {
     addAsyncAttr = true;
   }
 }
 
 static void genDeviceTypeClause(
-    Fortran::lower::AbstractConverter &converter,
+    Fortran::lower::AbstractConverter &converter, mlir::Location clauseLocation,
     const Fortran::parser::AccClause::DeviceType *deviceTypeClause,
     llvm::SmallVectorImpl<mlir::Value> &operands,
     Fortran::lower::StatementContext &stmtCtx) {
   const Fortran::parser::AccDeviceTypeExprList &deviceTypeExprList =
       deviceTypeClause->v;
   for (const auto &deviceTypeExpr : deviceTypeExprList.v) {
     const auto &expr = std::get<std::optional<Fortran::parser::ScalarIntExpr>>(
         deviceTypeExpr.t);
     if (expr) {
-      operands.push_back(fir::getBase(
-          converter.genExprValue(*Fortran::semantics::GetExpr(expr), stmtCtx)));
+      operands.push_back(fir::getBase(converter.genExprValue(
+          *Fortran::semantics::GetExpr(expr), stmtCtx, &clauseLocation)));
     } else {
       // * was passed as value and will be represented as a special constant.
       fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
       mlir::Value star = firOpBuilder.createIntegerConstant(
-          converter.getCurrentLocation(), firOpBuilder.getIndexType(), starCst);
+          clauseLocation, firOpBuilder.getIndexType(), starCst);
       operands.push_back(star);
     }
   }
 }
 
 static void genIfClause(Fortran::lower::AbstractConverter &converter,
+                        mlir::Location clauseLocation,
                         const Fortran::parser::AccClause::If *ifClause,
                         mlir::Value &ifCond,
                         Fortran::lower::StatementContext &stmtCtx) {
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
   mlir::Value cond = fir::getBase(converter.genExprValue(
-      *Fortran::semantics::GetExpr(ifClause->v), stmtCtx));
-  ifCond = firOpBuilder.createConvert(converter.getCurrentLocation(),
-                                      firOpBuilder.getI1Type(), cond);
+      *Fortran::semantics::GetExpr(ifClause->v), stmtCtx, &clauseLocation));
+  ifCond = firOpBuilder.createConvert(clauseLocation, firOpBuilder.getI1Type(),
+                                      cond);
 }
 
 static void genWaitClause(Fortran::lower::AbstractConverter &converter,
                           const Fortran::parser::AccClause::Wait *waitClause,
                           llvm::SmallVectorImpl<mlir::Value> &operands,
                           mlir::Value &waitDevnum, bool &addWaitAttr,
                           Fortran::lower::StatementContext &stmtCtx) {
   const auto &waitClauseValue = waitClause->v;
if (waitDevnumValue)
           *Fortran::semantics::GetExpr(*waitDevnumValue), stmtCtx));
   } else {
     addWaitAttr = true;
   }
 }
 
 static mlir::acc::LoopOp
 createLoopOp(Fortran::lower::AbstractConverter &converter,
+             mlir::Location currentLocation,
              const Fortran::parser::AccClauseList &accClauseList) {
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
-  mlir::Location currentLocation = converter.getCurrentLocation();
   Fortran::lower::StatementContext stmtCtx;
 
   mlir::Value workerNum;
   mlir::Value vectorNum;
   mlir::Value gangNum;
   mlir::Value gangStatic;
   llvm::SmallVector<mlir::Value, 2> tileOperands, privateOperands,
       reductionOperands;
   std::int64_t executionMapping = mlir::acc::OpenACCExecMapping::NONE;
 
   for (const Fortran::parser::AccClause &clause : accClauseList.v) {
+    mlir::Location clauseLocation = converter.genLocation(clause.source);
     if (const auto *gangClause =
             std::get_if<Fortran::parser::AccClause::Gang>(&clause.u)) {
       if (gangClause->v) {
         const Fortran::parser::AccGangArgument &x = *gangClause->v;
         if (const auto &gangNumValue =
                 std::get<std::optional<Fortran::parser::ScalarIntExpr>>(x.t)) {
           gangNum = fir::getBase(converter.genExprValue(
               *Fortran::semantics::GetExpr(gangNumValue.value()), stmtCtx));
         }
         if (const auto &gangStaticValue =
                 std::get<std::optional<Fortran::parser::AccSizeExpr>>(x.t)) {
           const auto &expr =
               std::get<std::optional<Fortran::parser::ScalarIntExpr>>(
                   gangStaticValue.value().t);
           if (expr) {
             gangStatic = fir::getBase(converter.genExprValue(
                 *Fortran::semantics::GetExpr(*expr), stmtCtx));
           } else {
             // * was passed as value and will be represented as a special
             // constant.
             gangStatic = firOpBuilder.createIntegerConstant(
-                currentLocation, firOpBuilder.getIndexType(), starCst);
+                clauseLocation, firOpBuilder.getIndexType(), starCst);
           }
         }
       }
       executionMapping |= mlir::acc::OpenACCExecMapping::GANG;
     } else if (const auto *workerClause =
                    std::get_if<Fortran::parser::AccClause::Worker>(&clause.u)) {
       if (workerClause->v) {
         workerNum = fir::getBase(converter.genExprValue(
if (const auto *gangClause =
                 accTileExpr.t);
         if (expr) {
           tileOperands.push_back(fir::getBase(converter.genExprValue(
               *Fortran::semantics::GetExpr(*expr), stmtCtx)));
         } else {
           // * was passed as value and will be represented as a -1 constant
           // integer.
           mlir::Value tileStar = firOpBuilder.createIntegerConstant(
-              currentLocation, firOpBuilder.getIntegerType(32),
+              clauseLocation, firOpBuilder.getIntegerType(32),
               /* STAR */ -1);
           tileOperands.push_back(tileStar);
         }
       }
     } else if (const auto *privateClause =
                    std::get_if<Fortran::parser::AccClause::Private>(
                        &clause.u)) {
       genObjectList(privateClause->v, converter, privateOperands);
static void genACC(Fortran::lower::AbstractConverter &converter,
                    Fortran::lower::pft::Evaluation &eval,
                    const Fortran::parser::OpenACCLoopConstruct &loopConstruct) {
 
   const auto &beginLoopDirective =
       std::get<Fortran::parser::AccBeginLoopDirective>(loopConstruct.t);
   const auto &loopDirective =
       std::get<Fortran::parser::AccLoopDirective>(beginLoopDirective.t);
 
+  mlir::Location currentLocation =
+      converter.genLocation(beginLoopDirective.source);
+
   if (loopDirective.v == llvm::acc::ACCD_loop) {
     const auto &accClauseList =
         std::get<Fortran::parser::AccClauseList>(beginLoopDirective.t);
-    createLoopOp(converter, accClauseList);
+    createLoopOp(converter, currentLocation, accClauseList);
   }
 }
 
 static mlir::acc::ParallelOp
 createParallelOp(Fortran::lower::AbstractConverter &converter,
+                 mlir::Location currentLocation,
                  const Fortran::parser::AccClauseList &accClauseList) {
 
   // Parallel operation operands
   mlir::Value async;
   mlir::Value numGangs;
   mlir::Value numWorkers;
   mlir::Value vectorLength;
   mlir::Value ifCond;
   mlir::Value selfCond;
   mlir::Value waitDevnum;
   llvm::SmallVector<mlir::Value, 2> waitOperands, reductionOperands,
       copyOperands, copyinOperands, copyinReadonlyOperands, copyoutOperands,
       copyoutZeroOperands, createOperands, createZeroOperands, noCreateOperands,
       presentOperands, devicePtrOperands, attachOperands, firstprivateOperands,
       privateOperands;
 
   // Async, wait and self clause have optional values but can be present with
   // no value as well. When there is no value, the op has an attribute to
   // represent the clause.
   bool addAsyncAttr = false;
   bool addWaitAttr = false;
   bool addSelfAttr = false;
 
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
-  mlir::Location currentLocation = converter.getCurrentLocation();
   Fortran::lower::StatementContext stmtCtx;
 
   // Lower clauses values mapped to operands.
   // Keep track of each group of operands separatly as clauses can appear
   // more than once.
   for (const Fortran::parser::AccClause &clause : accClauseList.v) {
+    mlir::Location clauseLocation = converter.genLocation(clause.source);
     if (const auto *asyncClause =
             std::get_if<Fortran::parser::AccClause::Async>(&clause.u)) {
       genAsyncClause(converter, asyncClause, async, addAsyncAttr, stmtCtx);
     } else if (const auto *waitClause =
                    std::get_if<Fortran::parser::AccClause::Wait>(&clause.u)) {
       genWaitClause(converter, waitClause, waitOperands, waitDevnum,
                     addWaitAttr, stmtCtx);
     } else if (const auto *numGangsClause =
                    std::get_if<Fortran::parser::AccClause::NumGangs>(
                        &clause.u)) {
       numGangs = fir::getBase(converter.genExprValue(
           *Fortran::semantics::GetExpr(numGangsClause->v), stmtCtx));
     } else if (const auto *numWorkersClause =
                    std::get_if<Fortran::parser::AccClause::NumWorkers>(
                        &clause.u)) {
       numWorkers = fir::getBase(converter.genExprValue(
           *Fortran::semantics::GetExpr(numWorkersClause->v), stmtCtx));
     } else if (const auto *vectorLengthClause =
                    std::get_if<Fortran::parser::AccClause::VectorLength>(
                        &clause.u)) {
       vectorLength = fir::getBase(converter.genExprValue(
           *Fortran::semantics::GetExpr(vectorLengthClause->v), stmtCtx));
     } else if (const auto *ifClause =
                    std::get_if<Fortran::parser::AccClause::If>(&clause.u)) {
-      genIfClause(converter, ifClause, ifCond, stmtCtx);
+      genIfClause(converter, clauseLocation, ifClause, ifCond, stmtCtx);
     } else if (const auto *selfClause =
                    std::get_if<Fortran::parser::AccClause::Self>(&clause.u)) {
       const std::optional<Fortran::parser::AccSelfClause> &accSelfClause =
           selfClause->v;
       if (accSelfClause) {
         if (const auto *optCondition =
                 std::get_if<std::optional<Fortran::parser::ScalarLogicalExpr>>(
                     &(*accSelfClause).u)) {
           if (*optCondition) {
             mlir::Value cond = fir::getBase(converter.genExprValue(
                 *Fortran::semantics::GetExpr(*optCondition), stmtCtx));
             selfCond = firOpBuilder.createConvert(
-                currentLocation, firOpBuilder.getI1Type(), cond);
+                clauseLocation, firOpBuilder.getI1Type(), cond);
           }
         } else if (const auto *accClauseList =
                        std::get_if<Fortran::parser::AccObjectList>(
                            &(*accSelfClause).u)) {
           // TODO This would be nicer to be done in canonicalization step.
           if (accClauseList->v.size() == 1) {
             const auto &accObject = accClauseList->v.front();
             if (const auto *designator =
                     std::get_if<Fortran::parser::Designator>(&accObject.u)) {
               if (const auto *name = getDesignatorNameIfDataRef(*designator)) {
                 auto cond = converter.getSymbolAddress(*name->symbol);
                 selfCond = firOpBuilder.createConvert(
-                    currentLocation, firOpBuilder.getI1Type(), cond);
+                    clauseLocation, firOpBuilder.getI1Type(), cond);
               }
             }
           }
         }
       } else {
         addSelfAttr = true;
       }
     } else if (const auto *copyClause =
if (addSelfAttr)
     parallelOp->setAttr(mlir::acc::ParallelOp::getSelfAttrName(),
                         firOpBuilder.getUnitAttr());
 
   return parallelOp;
 }
 
 static void
 genACCParallelOp(Fortran::lower::AbstractConverter &converter,
+                 mlir::Location currentLocation,
                  const Fortran::parser::AccClauseList &accClauseList) {
-  createParallelOp(converter, accClauseList);
+  createParallelOp(converter, currentLocation, accClauseList);
 }
 
 static void genACCDataOp(Fortran::lower::AbstractConverter &converter,
+                         mlir::Location currentLocation,
                          const Fortran::parser::AccClauseList &accClauseList) {
   mlir::Value ifCond;
   llvm::SmallVector<mlir::Value> copyOperands, copyinOperands,
       copyinReadonlyOperands, copyoutOperands, copyoutZeroOperands,
       createOperands, createZeroOperands, noCreateOperands, presentOperands,
       deviceptrOperands, attachOperands;
 
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
-  mlir::Location currentLocation = converter.getCurrentLocation();
   Fortran::lower::StatementContext stmtCtx;
 
   // Lower clauses values mapped to operands.
   // Keep track of each group of operands separatly as clauses can appear
   // more than once.
   for (const Fortran::parser::AccClause &clause : accClauseList.v) {
+    mlir::Location clauseLocation = converter.genLocation(clause.source);
     if (const auto *ifClause =
             std::get_if<Fortran::parser::AccClause::If>(&clause.u)) {
-      genIfClause(converter, ifClause, ifCond, stmtCtx);
+      genIfClause(converter, clauseLocation, ifClause, ifCond, stmtCtx);
     } else if (const auto *copyClause =
                    std::get_if<Fortran::parser::AccClause::Copy>(&clause.u)) {
       genObjectList(copyClause->v, converter, copyOperands);
     } else if (const auto *copyinClause =
                    std::get_if<Fortran::parser::AccClause::Copyin>(&clause.u)) {
       genObjectListWithModifier<Fortran::parser::AccClause::Copyin>(
           copyinClause, converter,
           Fortran::parser::AccDataModifier::Modifier::ReadOnly,
genACC(Fortran::lower::AbstractConverter &converter,
        const Fortran::parser::OpenACCBlockConstruct &blockConstruct) {
   const auto &beginBlockDirective =
       std::get<Fortran::parser::AccBeginBlockDirective>(blockConstruct.t);
   const auto &blockDirective =
       std::get<Fortran::parser::AccBlockDirective>(beginBlockDirective.t);
   const auto &accClauseList =
       std::get<Fortran::parser::AccClauseList>(beginBlockDirective.t);
 
+  mlir::Location currentLocation = converter.genLocation(blockDirective.source);
+
   if (blockDirective.v == llvm::acc::ACCD_parallel) {
-    genACCParallelOp(converter, accClauseList);
+    genACCParallelOp(converter, currentLocation, accClauseList);
   } else if (blockDirective.v == llvm::acc::ACCD_data) {
-    genACCDataOp(converter, accClauseList);
+    genACCDataOp(converter, currentLocation, accClauseList);
   }
 }
 
 static void
 genACCParallelLoopOps(Fortran::lower::AbstractConverter &converter,
+                      mlir::Location currentLocation,
                       const Fortran::parser::AccClauseList &accClauseList) {
-  createParallelOp(converter, accClauseList);
-  createLoopOp(converter, accClauseList);
+  createParallelOp(converter, currentLocation, accClauseList);
+  createLoopOp(converter, currentLocation, accClauseList);
 }
 
 static void
 genACC(Fortran::lower::AbstractConverter &converter,
        Fortran::lower::pft::Evaluation &eval,
        const Fortran::parser::OpenACCCombinedConstruct &combinedConstruct) {
   const auto &beginCombinedDirective =
       std::get<Fortran::parser::AccBeginCombinedDirective>(combinedConstruct.t);
   const auto &combinedDirective =
       std::get<Fortran::parser::AccCombinedDirective>(beginCombinedDirective.t);
   const auto &accClauseList =
       std::get<Fortran::parser::AccClauseList>(beginCombinedDirective.t);
 
+  mlir::Location currentLocation =
+      converter.genLocation(beginCombinedDirective.source);
+
   if (combinedDirective.v == llvm::acc::ACCD_kernels_loop) {
-    TODO(converter.getCurrentLocation(),
-         "OpenACC Kernels Loop construct not lowered yet!");
+    TODO(currentLocation, "OpenACC Kernels Loop construct not lowered yet!");
   } else if (combinedDirective.v == llvm::acc::ACCD_parallel_loop) {
-    genACCParallelLoopOps(converter, accClauseList);
+    genACCParallelLoopOps(converter, currentLocation, accClauseList);
   } else if (combinedDirective.v == llvm::acc::ACCD_serial_loop) {
-    TODO(converter.getCurrentLocation(),
-         "OpenACC Serial Loop construct not lowered yet!");
+    TODO(currentLocation, "OpenACC Serial Loop construct not lowered yet!");
   } else {
     llvm::report_fatal_error("Unknown combined construct encountered");
   }
 }
 
 static void
 genACCEnterDataOp(Fortran::lower::AbstractConverter &converter,
+                  mlir::Location currentLocation,
                   const Fortran::parser::AccClauseList &accClauseList) {
   mlir::Value ifCond, async, waitDevnum;
   llvm::SmallVector<mlir::Value> copyinOperands, createOperands,
       createZeroOperands, attachOperands, waitOperands;
 
   // Async, wait and self clause have optional values but can be present with
   // no value as well. When there is no value, the op has an attribute to
   // represent the clause.
   bool addAsyncAttr = false;
   bool addWaitAttr = false;
 
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
-  mlir::Location currentLocation = converter.getCurrentLocation();
   Fortran::lower::StatementContext stmtCtx;
 
   // Lower clauses values mapped to operands.
   // Keep track of each group of operands separatly as clauses can appear
   // more than once.
   for (const Fortran::parser::AccClause &clause : accClauseList.v) {
+    mlir::Location clauseLocation = converter.genLocation(clause.source);
     if (const auto *ifClause =
             std::get_if<Fortran::parser::AccClause::If>(&clause.u)) {
-      genIfClause(converter, ifClause, ifCond, stmtCtx);
+      genIfClause(converter, clauseLocation, ifClause, ifCond, stmtCtx);
     } else if (const auto *asyncClause =
                    std::get_if<Fortran::parser::AccClause::Async>(&clause.u)) {
       genAsyncClause(converter, asyncClause, async, addAsyncAttr, stmtCtx);
     } else if (const auto *waitClause =
                    std::get_if<Fortran::parser::AccClause::Wait>(&clause.u)) {
       genWaitClause(converter, waitClause, waitOperands, waitDevnum,
                     addWaitAttr, stmtCtx);
     } else if (const auto *copyinClause =
genACCEnterDataOp(Fortran::lower::AbstractConverter &converter,
   if (addAsyncAttr)
     enterDataOp.asyncAttr(firOpBuilder.getUnitAttr());
   if (addWaitAttr)
     enterDataOp.waitAttr(firOpBuilder.getUnitAttr());
 }
 
 static void
 genACCExitDataOp(Fortran::lower::AbstractConverter &converter,
+                 mlir::Location currentLocation,
                  const Fortran::parser::AccClauseList &accClauseList) {
   mlir::Value ifCond, async, waitDevnum;
   llvm::SmallVector<mlir::Value> copyoutOperands, deleteOperands,
       detachOperands, waitOperands;
 
   // Async and wait clause have optional values but can be present with
   // no value as well. When there is no value, the op has an attribute to
   // represent the clause.
   bool addAsyncAttr = false;
   bool addWaitAttr = false;
   bool addFinalizeAttr = false;
 
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
-  mlir::Location currentLocation = converter.getCurrentLocation();
   Fortran::lower::StatementContext stmtCtx;
 
   // Lower clauses values mapped to operands.
   // Keep track of each group of operands separatly as clauses can appear
   // more than once.
   for (const Fortran::parser::AccClause &clause : accClauseList.v) {
+    mlir::Location clauseLocation = converter.genLocation(clause.source);
     if (const auto *ifClause =
             std::get_if<Fortran::parser::AccClause::If>(&clause.u)) {
-      genIfClause(converter, ifClause, ifCond, stmtCtx);
+      genIfClause(converter, clauseLocation, ifClause, ifCond, stmtCtx);
     } else if (const auto *asyncClause =
                    std::get_if<Fortran::parser::AccClause::Async>(&clause.u)) {
       genAsyncClause(converter, asyncClause, async, addAsyncAttr, stmtCtx);
     } else if (const auto *waitClause =
                    std::get_if<Fortran::parser::AccClause::Wait>(&clause.u)) {
       genWaitClause(converter, waitClause, waitOperands, waitDevnum,
                     addWaitAttr, stmtCtx);
     } else if (const auto *copyoutClause =
if (addWaitAttr)
     exitDataOp.waitAttr(firOpBuilder.getUnitAttr());
   if (addFinalizeAttr)
     exitDataOp.finalizeAttr(firOpBuilder.getUnitAttr());
 }
 
 template <typename Op>
 static void
 genACCInitShutdownOp(Fortran::lower::AbstractConverter &converter,
+                     mlir::Location currentLocation,
                      const Fortran::parser::AccClauseList &accClauseList) {
   mlir::Value ifCond, deviceNum;
   llvm::SmallVector<mlir::Value> deviceTypeOperands;
 
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
-  mlir::Location currentLocation = converter.getCurrentLocation();
   Fortran::lower::StatementContext stmtCtx;
 
   // Lower clauses values mapped to operands.
   // Keep track of each group of operands separatly as clauses can appear
   // more than once.
   for (const Fortran::parser::AccClause &clause : accClauseList.v) {
+    mlir::Location clauseLocation = converter.genLocation(clause.source);
     if (const auto *ifClause =
             std::get_if<Fortran::parser::AccClause::If>(&clause.u)) {
-      genIfClause(converter, ifClause, ifCond, stmtCtx);
+      genIfClause(converter, clauseLocation, ifClause, ifCond, stmtCtx);
     } else if (const auto *deviceNumClause =
                    std::get_if<Fortran::parser::AccClause::DeviceNum>(
                        &clause.u)) {
       deviceNum = fir::getBase(converter.genExprValue(
           *Fortran::semantics::GetExpr(deviceNumClause->v), stmtCtx));
     } else if (const auto *deviceTypeClause =
                    std::get_if<Fortran::parser::AccClause::DeviceType>(
                        &clause.u)) {
-      genDeviceTypeClause(converter, deviceTypeClause, deviceTypeOperands,
-                          stmtCtx);
+      genDeviceTypeClause(converter, clauseLocation, deviceTypeClause,
+                          deviceTypeOperands, stmtCtx);
     }
   }
 
   // Prepare the operand segement size attribute and the operands value range.
   llvm::SmallVector<mlir::Value, 6> operands;
   llvm::SmallVector<int32_t, 3> operandSegments;
   addOperands(operands, operandSegments, deviceTypeOperands);
   addOperand(operands, operandSegments, deviceNum);
   addOperand(operands, operandSegments, ifCond);
 
   createSimpleOp<Op>(firOpBuilder, currentLocation, operands, operandSegments);
 }
 
 static void
 genACCUpdateOp(Fortran::lower::AbstractConverter &converter,
+               mlir::Location currentLocation,
                const Fortran::parser::AccClauseList &accClauseList) {
   mlir::Value ifCond, async, waitDevnum;
   llvm::SmallVector<mlir::Value> hostOperands, deviceOperands, waitOperands,
       deviceTypeOperands;
 
   // Async and wait clause have optional values but can be present with
   // no value as well. When there is no value, the op has an attribute to
   // represent the clause.
   bool addAsyncAttr = false;
   bool addWaitAttr = false;
   bool addIfPresentAttr = false;
 
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
-  mlir::Location currentLocation = converter.getCurrentLocation();
   Fortran::lower::StatementContext stmtCtx;
 
   // Lower clauses values mapped to operands.
   // Keep track of each group of operands separatly as clauses can appear
   // more than once.
   for (const Fortran::parser::AccClause &clause : accClauseList.v) {
+    mlir::Location clauseLocation = converter.genLocation(clause.source);
     if (const auto *ifClause =
             std::get_if<Fortran::parser::AccClause::If>(&clause.u)) {
-      genIfClause(converter, ifClause, ifCond, stmtCtx);
+      genIfClause(converter, clauseLocation, ifClause, ifCond, stmtCtx);
     } else if (const auto *asyncClause =
                    std::get_if<Fortran::parser::AccClause::Async>(&clause.u)) {
       genAsyncClause(converter, asyncClause, async, addAsyncAttr, stmtCtx);
     } else if (const auto *waitClause =
                    std::get_if<Fortran::parser::AccClause::Wait>(&clause.u)) {
       genWaitClause(converter, waitClause, waitOperands, waitDevnum,
                     addWaitAttr, stmtCtx);
     } else if (const auto *deviceTypeClause =
                    std::get_if<Fortran::parser::AccClause::DeviceType>(
                        &clause.u)) {
-      genDeviceTypeClause(converter, deviceTypeClause, deviceTypeOperands,
-                          stmtCtx);
+      genDeviceTypeClause(converter, clauseLocation, deviceTypeClause,
+                          deviceTypeOperands, stmtCtx);
     } else if (const auto *hostClause =
                    std::get_if<Fortran::parser::AccClause::Host>(&clause.u)) {
       genObjectList(hostClause->v, converter, hostOperands);
     } else if (const auto *deviceClause =
                    std::get_if<Fortran::parser::AccClause::Device>(&clause.u)) {
       genObjectList(deviceClause->v, converter, deviceOperands);
     }
   }

 genACC(Fortran::lower::AbstractConverter &converter,
        Fortran::lower::pft::Evaluation &eval,
        const Fortran::parser::OpenACCStandaloneConstruct &standaloneConstruct) {
   const auto &standaloneDirective =
       std::get<Fortran::parser::AccStandaloneDirective>(standaloneConstruct.t);
   const auto &accClauseList =
       std::get<Fortran::parser::AccClauseList>(standaloneConstruct.t);
 
+  mlir::Location currentLocation =
+      converter.genLocation(standaloneDirective.source);
+
   if (standaloneDirective.v == llvm::acc::Directive::ACCD_enter_data) {
-    genACCEnterDataOp(converter, accClauseList);
+    genACCEnterDataOp(converter, currentLocation, accClauseList);
   } else if (standaloneDirective.v == llvm::acc::Directive::ACCD_exit_data) {
-    genACCExitDataOp(converter, accClauseList);
+    genACCExitDataOp(converter, currentLocation, accClauseList);
   } else if (standaloneDirective.v == llvm::acc::Directive::ACCD_init) {
-    genACCInitShutdownOp<mlir::acc::InitOp>(converter, accClauseList);
+    genACCInitShutdownOp<mlir::acc::InitOp>(converter, currentLocation,
+                                            accClauseList);
   } else if (standaloneDirective.v == llvm::acc::Directive::ACCD_shutdown) {
-    genACCInitShutdownOp<mlir::acc::ShutdownOp>(converter, accClauseList);
+    genACCInitShutdownOp<mlir::acc::ShutdownOp>(converter, currentLocation,
+                                                accClauseList);
   } else if (standaloneDirective.v == llvm::acc::Directive::ACCD_set) {
-    TODO(converter.getCurrentLocation(),
-         "OpenACC set directive not lowered yet!");
+    TODO(currentLocation, "OpenACC set directive not lowered yet!");
   } else if (standaloneDirective.v == llvm::acc::Directive::ACCD_update) {
-    genACCUpdateOp(converter, accClauseList);
+    genACCUpdateOp(converter, currentLocation, accClauseList);
   }
 }
 
 static void genACC(Fortran::lower::AbstractConverter &converter,
                    Fortran::lower::pft::Evaluation &eval,
                    const Fortran::parser::OpenACCWaitConstruct &waitConstruct) {
 
   const auto &waitArgument =
       std::get<std::optional<Fortran::parser::AccWaitArgument>>(
           waitConstruct.t);
   const auto &accClauseList =
       std::get<Fortran::parser::AccClauseList>(waitConstruct.t);
 
   mlir::Value ifCond, waitDevnum, async;
   llvm::SmallVector<mlir::Value> waitOperands;
 
   // Async clause have optional values but can be present with
   // no value as well. When there is no value, the op has an attribute to
   // represent the clause.
   bool addAsyncAttr = false;
 
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
-  mlir::Location currentLocation = converter.getCurrentLocation();
+  mlir::Location currentLocation = converter.genLocation(waitConstruct.source);
   Fortran::lower::StatementContext stmtCtx;
 
   if (waitArgument) { // wait has a value.
     const Fortran::parser::AccWaitArgument &waitArg = *waitArgument;
     const auto &waitList =
         std::get<std::list<Fortran::parser::ScalarIntExpr>>(waitArg.t);
     for (const Fortran::parser::ScalarIntExpr &value : waitList) {
       mlir::Value v = fir::getBase(
           converter.genExprValue(*Fortran::semantics::GetExpr(value), stmtCtx));
       waitOperands.push_back(v);
     }
 
     const auto &waitDevnumValue =
         std::get<std::optional<Fortran::parser::ScalarIntExpr>>(waitArg.t);
     if (waitDevnumValue)
       waitDevnum = fir::getBase(converter.genExprValue(
           *Fortran::semantics::GetExpr(*waitDevnumValue), stmtCtx));
   }
 
   // Lower clauses values mapped to operands.
   // Keep track of each group of operands separatly as clauses can appear
   // more than once.
   for (const Fortran::parser::AccClause &clause : accClauseList.v) {
+    mlir::Location clauseLocation = converter.genLocation(clause.source);
     if (const auto *ifClause =
             std::get_if<Fortran::parser::AccClause::If>(&clause.u)) {
-      genIfClause(converter, ifClause, ifCond, stmtCtx);
+      genIfClause(converter, clauseLocation, ifClause, ifCond, stmtCtx);
     } else if (const auto *asyncClause =
                    std::get_if<Fortran::parser::AccClause::Async>(&clause.u)) {
       genAsyncClause(converter, asyncClause, async, addAsyncAttr, stmtCtx);
     }
   }
 
   // Prepare the operand segement size attribute and the operands value range.
   llvm::SmallVector<mlir::Value> operands;
std::visit(
           [&](const Fortran::parser::OpenACCLoopConstruct &loopConstruct) {
             genACC(converter, eval, loopConstruct);
           },
           [&](const Fortran::parser::OpenACCStandaloneConstruct
                   &standaloneConstruct) {
             genACC(converter, eval, standaloneConstruct);
           },
           [&](const Fortran::parser::OpenACCCacheConstruct &cacheConstruct) {
-            TODO(converter.getCurrentLocation(),
+            TODO(converter.genLocation(cacheConstruct.source),
                  "OpenACC Cache construct not lowered yet!");
           },
           [&](const Fortran::parser::OpenACCWaitConstruct &waitConstruct) {
             genACC(converter, eval, waitConstruct);
           },
           [&](const Fortran::parser::OpenACCAtomicConstruct &atomicConstruct) {
-            TODO(converter.getCurrentLocation(),
+            TODO(converter.genLocation(atomicConstruct.source),
                  "OpenACC Atomic construct not lowered yet!");
           },
       },
       accConstruct.u);
 }
 
 void Fortran::lower::genOpenACCDeclarativeConstruct(
     Fortran::lower::AbstractConverter &converter,
     Fortran::lower::pft::Evaluation &eval,
     const Fortran::parser::OpenACCDeclarativeConstruct &accDeclConstruct) {
 
   std::visit(
       common::visitors{
           [&](const Fortran::parser::OpenACCStandaloneDeclarativeConstruct
                   &standaloneDeclarativeConstruct) {
-            TODO(converter.getCurrentLocation(),
+            TODO(converter.genLocation(standaloneDeclarativeConstruct.source),
                  "OpenACC Standalone Declarative construct not lowered yet!");
           },
           [&](const Fortran::parser::OpenACCRoutineConstruct
                   &routineConstruct) {
-            TODO(converter.getCurrentLocation(),
+            TODO(converter.genLocation(routineConstruct.source),
                  "OpenACC Routine construct not lowered yet!");
           },
       },
       accDeclConstruct.u);
 }

flang/test/Lower/OpenACC/locations.f90

+! This test checks correct propagation of location information in OpenACC
+! operations.
+
+! RUN: bbc -fopenacc -emit-fir --mlir-print-debuginfo --mlir-print-local-scope %s -o - | FileCheck %s
+
+module acc_locations
+  implicit none
+
+  contains
+
+  subroutine standalone_data_directive_locations(arr)
+    real, dimension(10) :: arr
+
+    !$acc enter data create(arr)
+    !CHECK-LABEL: acc.enter_data
+    !CHECK-SAME:  loc("{{.*}}locations.f90":14:11)
+
+    !$acc update device(arr)
+    !CHECK-LABEL: acc.update device
+    !CHECK-SAME:  loc("{{.*}}locations.f90":18:11)
+
+    !$acc update host(arr)
+    !CHECK-LABEL: acc.update host
+    !CHECK-SAME:  loc("{{.*}}locations.f90":22:11)
+
+    !$acc exit data delete(arr)
+    !CHECK-LABEL: acc.exit_data
+    !CHECK-SAME:  loc("{{.*}}locations.f90":26:11)
+
+  end subroutine
+
+  subroutine nested_acc_locations(arr1d)
+    real, dimension(10) :: arr1d
+    integer :: i
+
+    !$acc data copy(arr1d)
+    !$acc parallel
+    !$acc loop
+    do i = 1, 10
+      arr1d(i) = arr1d(i) * 2
+    end do
+    !$acc end parallel
+    !$acc end data
+
+    !CHECK: acc.data
+    !CHECK: acc.parallel
+    !CHECK: acc.loop
+
+    !CHECK:        acc.yield loc("{{.*}}locations.f90":38:11)
+    !CHECK-NEXT: } loc("{{.*}}locations.f90":38:11)
+
+    !CHECK:        acc.yield loc("{{.*}}locations.f90":37:11)
+    !CHECK-NEXT: } loc("{{.*}}locations.f90":37:11)
+
+    !CHECK-NEXT:   acc.terminator loc("{{.*}}locations.f90":36:11)
+    !CHECK-NEXT: } loc("{{.*}}locations.f90":36:11)
+
+  end subroutine
+
+  subroutine runtime_directive()
+
+    !$acc init
+    !CHECK-LABEL: acc.init
+    !CHECK-SAME:  loc("{{.*}}locations.f90":62:11)
+
+    !$acc shutdown
+    !CHECK-LABEL: acc.shutdown
+    !CHECK-SAME:  loc("{{.*}}locations.f90":66:11)
+
+  end subroutine
+
+  subroutine combined_directive_locations(arr)
+    real :: arr(:)
+    integer :: i
+
+    !$acc parallel loop
+    do i = 1, size(arr)
+      arr(i) = arr(i) * arr(i)
+    end do
+
+    !CHECK: acc.parallel
+    !CHECK: acc.loop
+    !CHECK:      acc.yield loc("{{.*}}locations.f90":76:11)
+    !CHECK-NEXT: } loc("{{.*}}locations.f90":76:11)
+    !CHECK:      acc.yield loc("{{.*}}locations.f90":76:11)
+    !CHECK-NEXT: } loc("{{.*}}locations.f90":76:11)
+  end subroutine
+
+  subroutine if_clause_expr_location(arr)
+    real :: arr(:)
+    integer :: i
+
+    !$acc parallel loop if(.true.)
+    do i = 1, size(arr)
+      arr(i) = arr(i) * arr(i)
+    end do
+
+    !CHECK: %{{.*}} = arith.constant true loc("{{.*}}locations.f90":93:25)
+
+    !CHECK: acc.parallel
+    !CHECK: acc.loop
+    !CHECK:      acc.yield loc("{{.*}}locations.f90":93:11)
+    !CHECK-NEXT: } loc("{{.*}}locations.f90":93:11)
+    !CHECK:      acc.yield loc("{{.*}}locations.f90":93:11)
+    !CHECK-NEXT: } loc("{{.*}}locations.f90":93:11)
+  end subroutine
+
+end module

flang/tools/bbc/bbc.cpp

static mlir::LogicalResult convertFortranSourceToMLIR(
   return mlir::failure();
 }
 
 int main(int argc, char **argv) {
   [[maybe_unused]] llvm::InitLLVM y(argc, argv);
   registerAllPasses();
 
   mlir::registerMLIRContextCLOptions();
+  mlir::registerAsmPrinterCLOptions();
   mlir::registerPassManagerCLOptions();
   mlir::PassPipelineCLParser passPipe("", "Compiler passes to run");
   llvm::cl::ParseCommandLineOptions(argc, argv, "Burnside Bridge Compiler\n");
 
   ProgramName programPrefix;
   programPrefix = argv[0] + ": "s;
 
   if (includeDirs.size() == 0) {