[flang][OpenMP] Handle the data race for firstprivate and lastprivate

[peixin]

Summary

Remove barriers for firstprivate except if the variable is also
lastprivatized. Re-arrange the code and put all last-privates inside a
single scf.if.

As OpenMP Spec 5.0, to avoid the data races, concurrent updates of the
original list item must be synchronized with the read of the original
list item that occurs as a result of the firstprivate clause. Adding
barrier(s) before and/or after the worksharing region would remove the
data races, and it is the application(user)'s job. However, when
one list item is in both firstprivate and lastprivate clauses, the
standard (https://www.openmp.org/spec-html/5.0/openmpsu105.html) states
the following:

If a list item appears in both firstprivate and lastprivate clauses, the 
update required for the lastprivate clause occurs after all 
initializations for the firstprivate clause.

So, the synchronization should be ensured by compiler such as emiting
one barrier since the lastprivate clause follows the reads of the
original list item performed for the initialization of each of the
firstprivate list item.

Add FIXME for two special cases, sections construct and linear clause.

The data race problem for single construct will be handled later.

This implementation is based on the discussion with OpenMP committee and
clang code (clang/lib/CodeGen/CGStmtOpenMP.cpp).

[NimishMishra]

Thank you for the patch. I have a couple of questions.

flang/test/Lower/OpenMP/default-clause.f90

18

I do not understand this. Does firstprivate no longer require omp.barrier in absence of a lastprivate?

flang/test/Lower/OpenMP/omp-parallel-lastprivate-clause-scalar.f90

94

So if I understand correctly, lastprivate will capture the last value of the loop and store it back into the variable. Is it necessary to wrap these in an atomic region? I am wondering if parallel execution of threads could result in the last iteration's values not being captured in these variables.

[peixin]

Thanks, Deepak.

That's the case I am referring to. Thanks for pointing out the source of Spec and confirmation of inserting a barrier at the beginning of the region.

All my problems are solved. Your help is really appreciated.

All the best,
Peixin

---

Qiao Peixin
Mobile: [phone](For Welink,eSpace Calls)
Email: [e-mail]
From：Eachempati, Deepak <[e-mail]>
To：qiaopeixin <[e-mail]>;Protze, Joachim <[e-mail]>;omp-lang <[e-mail]>;omp-lang <[e-mail]>
Cc：abidmuslim <[e-mail]>;Vaishay, Shraiysh <[e-mail]>;kirankumartp <[e-mail]>;kiranchandramohan <[e-mail]>;jdoerfert <[e-mail]>
Sent：2022-07-07 23:11:37
Subject：RE: 【Technical】 Questions about the data race problem for firstprivate clause

Are you referring to this case?

x = 10;
#pragma omp parallel copyin(x)
{

const int tid = omp_get_thread_num();
x += tid; // race?
printf(“%d: x = %d\n”, tid, x);

}

This is what the spec says:

“The copy is performed after the team is formed and prior to the execution of the associated structured block.”

An implementation inserting a barrier at the beginning of the region would satisfy that requirement.

• Deepak

From: qiaopeixin <[e-mail]>
Sent: Wednesday, July 6, 2022 10:49 AM
To: Eachempati, Deepak <[e-mail]>; Protze, Joachim <[e-mail]>; omp-lang <[e-mail]>; omp-lang <[e-mail]>
Cc: abidmuslim <[e-mail]>; Vaishay, Shraiysh <[e-mail]>; kirankumartp <[e-mail]>; kiranchandramohan <[e-mail]>; jdoerfert <[e-mail]>
Subject: RE: 【Technical】 Questions about the data race problem for firstprivate clause

Thanks, Deepak and Johannes.

Another interesting case is firstprivate(x) and lastprivate(x) on the same construct. In what case, I believe an implementation should ensure that the update to the original list iterm due to the lastprivate clause follows the reads of the original list item performed for the initialization of each of the firstprivate list items.

Right. I do see one barrier after copies operation of firstprivate clause in gcc, icc, and clang when firstprivate(x) and lastprivate(x) are on the same construct. There is no barrier for one single firstprivate(x) without lastprivate(x) for those three compilers.

The behaviors for copyin clause seems to be different from firstprivate clause. The OpenMP Spec does not mention the data race things. For copyin clause, the implementation should ensure one synchronization (one barrier is one option) no matter whether there is one copyprivate clause. This is what clang does. Do I understand it correctly?

All the best,
Peixin

---

Qiao Peixin
Mobile: [phone](For Welink,eSpace Calls)
Email: [e-mail]
From：Eachempati, Deepak <[e-mail]>
To：qiaopeixin <[e-mail]>;Protze, Joachim <[e-mail]>;omp-lang <[e-mail]>;omp-lang <[e-mail]>
Cc：abidmuslim <[e-mail]>;Vaishay, Shraiysh <[e-mail]>;kirankumartp <[e-mail]>;kiranchandramohan <[e-mail]>
Sent：2022-07-06 22:28:05
Subject：RE: 【Technical】 Questions about the data race problem for firstprivate clause

Yes. That is what this sentence is saying:

“To avoid data races, concurrent updates of the original list item must be synchronized with the read
of the original list item that occurs as a result of the firstprivate clause.”

Another interesting case is firstprivate(x) lastprivate(x) on the same construct. In that case, I believe an implementation should ensure that the update to the original list item due to the lastprivate clause follows the reads of the original list item performed for the initialization of each of the firstprivate list items.

• Deepak

From: qiaopeixin <[e-mail]>
Sent: Wednesday, July 6, 2022 9:03 AM
To: Eachempati, Deepak <[e-mail]>; Protze, Joachim <[e-mail]>; [e-mail]; [e-mail]
Cc: [e-mail]; Vaishay, Shraiysh <[e-mail]>; [e-mail]; [e-mail]
Subject: RE: 【Technical】 Questions about the data race problem for firstprivate clause

Thanks a lot for the reply, Deepak and Jochim.

Adding barriers before and after the loop construct would remove the data races.

I tested your provided test cases using gcc, icc and clang. All of them have the data race problems. @Deepak So, do you mean that it is application’s job to add the barriers to avoid the data race instead of compiler’s job.

All the best,
Peixin

From: Eachempati, Deepak [mailto:[e-mail]]
Sent: Wednesday, July 6, 2022 9:19 PM
To: [e-mail]; [e-mail]
Cc: qiaopeixin <[e-mail]>; [e-mail]; Vaishay, Shraiysh <[e-mail]>; [e-mail]; [e-mail]
Subject: RE: 【Technical】 Questions about the data race problem for firstprivate clause

Here’s an example:

int x = 0;
#pragma omp parallel num_threads(4)
{

#pragma omp atomic
x++;
#pragma omp for nowait schedule(static,1) firstprivate(x)
for (int i = 0; i < 4; i++) {
   printf(“%d: x = %d\n”, i, x);
}
#pragma omp atomic
x--;

}

There is a data race due to the atomic increment before the loop construct and the initialization of the firstprivate x inside the loop region. Also, due to the nowait clause, there is a race between the that firstprivate initialization and the subsequent atomic decrement after the loop construct.

Adding barriers before and after the loop construct would remove the data races.

For your second question, a race is still possible with a single construct or sections construct. Replace the above loop construct with single or sections, and it is still a race. A firstprivate on a task construct can also result in a race. Example:

int x = 0;
#pragma omp parallel num_threads(4) shared(x)
{

#pragma omp atomic
x++;
#pragma omp masked
   #pragma omp task firstprivate(x)
   {
     printf(“x = %d\n”, x);
   }
#pragma omp atomic
x--;

}

As before, the atomic updates concurrent with the read of x for the firstprivate initialization results in a data race.

• Deepak

From: Omp-lang <[e-mail]> On Behalf Of qiaopeixin via Omp-lang
Sent: Wednesday, July 6, 2022 7:23 AM
To: [e-mail]
Cc: qiaopeixin <[e-mail]>; [e-mail]; Vaishay, Shraiysh <[e-mail]>; [e-mail]; [e-mail]
Subject: [Omp-lang] 【Technical】 Questions about the data race problem for firstprivate clause

Hi OpenMP committee,

I am Peixin from Huawei. I am working on Flang OpenMP development in LLVM. We have some questions about the data race problem for firstprivate clause.

As OpenMP 5.0 Spec 2.19.4.4, to avoid data races, concurrent updates of the original list item must be synchronized with the read of the original list item that occurs as a result of the firstprivate clause.

We have some discussions about this in LLVM: https://discourse.llvm.org/t/issues-with-the-current-implementation-of-privatization-in-openmp-with-fortran/62335.

Question 1: Does the OpenMP Spec mean that there is one implicit barrier at the beginning of the firstprivate region? Or similar thing which can synchronize the data?

Question 2: The firstprivate clause can be in parallel, teams, sections, single, worksharing-loop, distribute, task, taskloop, and target constructs and combined/composite contructs containing those contructs. The synchronization is not needed for single, sections, task constructs since there is only one thread in the region of these three constructs (section region for sections construct), right?

All the best,
Peixin Qiao

flang/test/Lower/OpenMP/default-clause.f90

18

Yes. The previous understanding was wrong. I attached the discussion with OpenMP committee, which may help you and other reviewers understand this fix.

flang/test/Lower/OpenMP/omp-parallel-lastprivate-clause-scalar.f90

94

This patch is not to change anything about lastprivate lowering. But to my understanding, there is no need to do it in an atomic region since it checks the IV_CMP1, which is the loop index check. If you emit the LLVM IR, you will see the loop index is unique for each thread and it is managed by the runtime function.

[NimishMishra]

LGTM.

flang/lib/Lower/OpenMP.cpp

220

This FIXME on sections is probably something I can pick up. If you have not started working on it, let me know.

flang/test/Lower/OpenMP/default-clause.f90

18

Thank you. The discussion is helpful. I guess it sounds ok to offload the job of inserting barriers to the application.

[peixin]

flang/lib/Lower/OpenMP.cpp

220

Sure. You can take it up. Actually you have taken up this :) https://flang-compiler.slack.com/archives/C01PY03PP9P/p1657855039246809.

BTW, please double check the behavior of clang when you work on this. I didn't dig too much about this issue in sections directive.

[peixin]

The other implementations such as the lowering of firstprivate in single construct depends on this implementation. Will land this after waiting for two more days if no further review.

[NimishMishra]

flang/lib/Lower/OpenMP.cpp

220

Right. Thanks. I will fix this in https://reviews.llvm.org/D131463. Will check clang's behaviour too.

[kiranchandramohan]

Have a few Nits.
In the summary please call out what is implemented in the patch (Remove barriers for firstprivate except if the variable is also lastprivatized. Re-arrange code and put all last-privates inside a single scf.if) and then provide reasons.

For the lastprivate and firstprivate case, the standard explicitly calls this out. So it will be better to put a reference to the standard.
In https://www.openmp.org/spec-html/5.0/openmpsu105.html the following statement is there.

If a list item appears in both firstprivate and lastprivate clauses, the update required for the lastprivate clause occurs after all initializations for the firstprivate clause.

flang/lib/Lower/OpenMP.cpp

225

Nit: Add a line below.

[peixin]

Address the comments from @kiranchandramohan .

flang/lib/Lower/OpenMP.cpp

std::visit(Fortran::common::visitors{
                      sym = name->symbol;
                    }
                  },
                  [&](const Fortran::parser::Name &name) { sym = name.symbol; }},
              ompObject.u);
   return sym;
 }
 
-template <typename T>
 static void
-createPrivateVarSyms(Fortran::lower::AbstractConverter &converter,
-                     const T *clause,
-                     [[maybe_unused]] Block *lastPrivBlock = nullptr) {
-  const Fortran::parser::OmpObjectList &ompObjectList = clause->v;
-  for (const Fortran::parser::OmpObject &ompObject : ompObjectList.v) {
-    Fortran::semantics::Symbol *sym = getOmpObjectSymbol(ompObject);
-    // Privatization for symbols which are pre-determined (like loop index
-    // variables) happen separately, for everything else privatize here.
-    if (sym->test(Fortran::semantics::Symbol::Flag::OmpPreDetermined))
-      continue;
-    bool success = converter.createHostAssociateVarClone(*sym);
-    (void)success;
-    assert(success && "Privatization failed due to existing binding");
-    if constexpr (std::is_same_v<T, Fortran::parser::OmpClause::Firstprivate>) {
-      converter.copyHostAssociateVar(*sym);
-    } else if constexpr (std::is_same_v<
-                             T, Fortran::parser::OmpClause::Lastprivate>) {
-      converter.copyHostAssociateVar(*sym, lastPrivBlock);
-    }
-  }
-}
+privatizeSymbol(Fortran::lower::AbstractConverter &converter,
+                const Fortran::semantics::Symbol *sym,
+                [[maybe_unused]] mlir::Block *lastPrivBlock = nullptr) {
+    return;
+  if (sym->test(Fortran::semantics::Symbol::Flag::OmpFirstPrivate))
+  if (sym->test(Fortran::semantics::Symbol::Flag::OmpLastPrivate))
 
 template <typename Op>
 static bool privatizeVars(Op &op, Fortran::lower::AbstractConverter &converter,
                           const Fortran::parser::OmpClauseList &opClauseList,
                           Fortran::lower::pft::Evaluation &eval) {
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
   auto insPt = firOpBuilder.saveInsertionPoint();
-  firOpBuilder.setInsertionPointToStart(firOpBuilder.getAllocaBlock());
-  bool hasFirstPrivateOp = false;
-  bool hasLastPrivateOp = false;
-  // Symbols in private and/or firstprivate clauses.
+  // Symbols in private, firstprivate, and/or lastprivate clauses.
   llvm::SetVector<const Fortran::semantics::Symbol *> privatizedSymbols;
   auto collectOmpObjectListSymbol =
       [&](const Fortran::parser::OmpObjectList &ompObjectList,
           llvm::SetVector<const Fortran::semantics::Symbol *> &symbolSet) {
         for (const Fortran::parser::OmpObject &ompObject : ompObjectList.v) {
           Fortran::semantics::Symbol *sym = getOmpObjectSymbol(ompObject);
           symbolSet.insert(sym);
         }
       };
   // We need just one ICmpOp for multiple LastPrivate clauses.
   mlir::arith::CmpIOp cmpOp;
-
+  mlir::Block *lastPrivBlock = nullptr;
+  bool hasLastPrivateOp = false;
   for (const Fortran::parser::OmpClause &clause : opClauseList.v) {
     if (const auto &privateClause =
             std::get_if<Fortran::parser::OmpClause::Private>(&clause.u)) {
       collectOmpObjectListSymbol(privateClause->v, privatizedSymbols);
     } else if (const auto &firstPrivateClause =
                    std::get_if<Fortran::parser::OmpClause::Firstprivate>(
                        &clause.u)) {
       collectOmpObjectListSymbol(firstPrivateClause->v, privatizedSymbols);
-      hasFirstPrivateOp = true;
     } else if (const auto &lastPrivateClause =
                    std::get_if<Fortran::parser::OmpClause::Lastprivate>(
                        &clause.u)) {
       // TODO: Add lastprivate support for sections construct, simd construct
       if (std::is_same_v<Op, omp::WsLoopOp>) {
         omp::WsLoopOp *wsLoopOp = dyn_cast<omp::WsLoopOp>(&op);
-        fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
-        auto insPt = firOpBuilder.saveInsertionPoint();
+        mlir::Operation *lastOper = wsLoopOp->region().back().getTerminator();
+        firOpBuilder.setInsertionPoint(lastOper);
 
         // Our goal here is to introduce the following control flow
         // just before exiting the worksharing loop.
         // Say our wsloop is as follows:
         //
         // omp.wsloop {
         //    ...
         //    store
         //    omp.yield
         // }
         //
         // We want to convert it to the following:
         //
         // omp.wsloop {
         //    ...
         //    store
         //    %cmp = llvm.icmp "eq" %iv %ub
         //    scf.if %cmp {
         //      ^%lpv_update_blk:
         //    }
         //    omp.yield
         // }
 
-        Operation *lastOper = wsLoopOp->region().back().getTerminator();
-
-        firOpBuilder.setInsertionPoint(lastOper);
-
         // TODO: The following will not work when there is collapse present.
         // Have to modify this in future.
         for (const Fortran::parser::OmpClause &clause : opClauseList.v)
           if (const auto &collapseClause =
                   std::get_if<Fortran::parser::OmpClause::Collapse>(&clause.u))
             TODO(converter.getCurrentLocation(),
                  "Collapse clause with lastprivate");
         // Only generate the compare once in presence of multiple LastPrivate
-        // clauses
+        // clauses.
         if (!hasLastPrivateOp) {
           cmpOp = firOpBuilder.create<mlir::arith::CmpIOp>(
               wsLoopOp->getLoc(), mlir::arith::CmpIPredicate::eq,
               wsLoopOp->getRegion().front().getArguments()[0],
               wsLoopOp->upperBound()[0]);
         }
         mlir::scf::IfOp ifOp = firOpBuilder.create<mlir::scf::IfOp>(
             wsLoopOp->getLoc(), cmpOp, /*else*/ false);
-
-        firOpBuilder.restoreInsertionPoint(insPt);
-        createPrivateVarSyms(converter, lastPrivateClause,
-                             &(ifOp.getThenRegion().front()));
+        lastPrivBlock = &ifOp.getThenRegion().front();
       } else {
         TODO(converter.getCurrentLocation(),
-             "lastprivate clause in constructs other than work-share loop");
+             "lastprivate clause in constructs other than worksharing-loop");
       }
+      collectOmpObjectListSymbol(lastPrivateClause->v, privatizedSymbols);
       hasLastPrivateOp = true;
     }
   }
 
   // Symbols in regions with default(private/firstprivate) clause.
   // FIXME: Collect the symbols with private/firstprivate flag in the region of
   // the construct with default(private/firstprivate) clause excluding the
   // symbols with the same private/firstprivate flag in the inner nested
if (const auto &defaultClause =
           Fortran::parser::OmpDefaultClause::Type::Private)
         collectSymbols(Fortran::semantics::Symbol::Flag::OmpPrivate);
       else if (defaultClause->v.v ==
                Fortran::parser::OmpDefaultClause::Type::Firstprivate)
         collectSymbols(Fortran::semantics::Symbol::Flag::OmpFirstPrivate);
     }
   }
 
-  auto privatizeSymbol = [&](const Fortran::semantics::Symbol *sym) {
-    // Privatization for symbols which are pre-determined (like loop index
-    // variables) happen separately, for everything else privatize here.
-    if (sym->test(Fortran::semantics::Symbol::Flag::OmpPreDetermined))
-      return;
-    bool success = converter.createHostAssociateVarClone(*sym);
-    (void)success;
-    assert(success && "Privatization failed due to existing binding");
-    if (sym->test(Fortran::semantics::Symbol::Flag::OmpFirstPrivate)) {
-      converter.copyHostAssociateVar(*sym);
-      hasFirstPrivateOp = true;
-    }
-  };
-
-  for (auto sym : privatizedSymbols)
-    privatizeSymbol(sym);
+  bool needBarrier = false;
+  firOpBuilder.setInsertionPointToStart(firOpBuilder.getAllocaBlock());
+  for (auto sym : privatizedSymbols) {
+    privatizeSymbol(converter, sym, lastPrivBlock);
+    if (sym->test(Fortran::semantics::Symbol::Flag::OmpFirstPrivate) &&
+        sym->test(Fortran::semantics::Symbol::Flag::OmpLastPrivate))
+      needBarrier = true;
 
   for (auto sym : defaultSymbols)
     if (!symbolsInNestedRegions.contains(sym) &&
         !symbolsInParentRegions.contains(sym) &&
         !privatizedSymbols.contains(sym))
-      privatizeSymbol(sym);
-  if (hasFirstPrivateOp)
+      privatizeSymbol(converter, sym);
+
+  // Emit implicit barrier to synchronize threads and avoid data races on
+  // initialization of firstprivate variables and post-update of lastprivate
+  // variables.
+  // FIXME: Emit barrier for lastprivate clause when 'sections' directive has
+  // 'nowait' clause. Otherwise, emit barrier when 'sections' directive has
+  // both firstprivate and lastprivate clause.
+  // Emit implicit barrier for linear clause. Maybe on somewhere else.
+  if (needBarrier)
     firOpBuilder.create<mlir::omp::BarrierOp>(converter.getCurrentLocation());
   firOpBuilder.restoreInsertionPoint(insPt);
   return hasLastPrivateOp;
 }
 
 /// The COMMON block is a global structure. \p commonValue is the base address
 /// of the the COMMON block. As the offset from the symbol \p sym, generate the
 /// COMMON block member value (commonValue + offset) for the symbol.
 /// FIXME: Share the code with `instantiateCommon` in ConvertVariable.cpp.

flang/test/Lower/OpenMP/default-clause.f90

 !CHECK: %[[X:.*]] = fir.alloca i32 {bindc_name = "x", uniq_name = "_QFEx"}
 !CHECK: %[[Y:.*]] = fir.alloca i32 {bindc_name = "y", uniq_name = "_QFEy"}
 !CHECK: %[[Z:.*]] = fir.alloca i32 {bindc_name = "z", uniq_name = "_QFEz"}
 !CHECK: omp.parallel {
 !CHECK: %[[PRIVATE_X:.*]] = fir.alloca i32 {bindc_name = "x", pinned, uniq_name = "_QFEx"}
 !CHECK: %[[const:.*]] = fir.load %[[X]] : !fir.ref<i32>
 !CHECK: fir.store %[[const]] to %[[PRIVATE_X]] : !fir.ref<i32>
 !CHECK: %[[PRIVATE_Y:.*]] = fir.alloca i32 {bindc_name = "y", pinned, uniq_name = "_QFEy"}
 !CHECK: %[[PRIVATE_W:.*]] = fir.alloca i32 {bindc_name = "w", pinned, uniq_name = "_QFEw"}
-!CHECK: omp.barrier
 !CHECK: %[[const:.*]] = arith.constant 2 : i32
 !CHECK: %[[temp:.*]] = fir.load %[[PRIVATE_Y]] : !fir.ref<i32>
 !CHECK: %[[result:.*]] = arith.muli %[[const]], %[[temp]] : i32
 !CHECK: fir.store %[[result]] to %[[PRIVATE_X]] : !fir.ref<i32>
 !CHECK: %[[temp:.*]] = fir.load %[[PRIVATE_W]] : !fir.ref<i32>
 !CHECK: %[[const:.*]] = arith.constant 45 : i32
 !CHECK: %[[result:.*]] = arith.addi %[[temp]], %[[const]] : i32
 !CHECK: fir.store %[[result]] to %[[Z]] : !fir.ref<i32>

 
 !CHECK: omp.parallel   {
 !CHECK: %[[PRIVATE_Y:.*]] = fir.alloca i32 {bindc_name = "y", pinned, uniq_name = "_QFEy"}
 !CHECK: %[[temp:.*]] = fir.load %[[Y]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[PRIVATE_Y]] : !fir.ref<i32>
 !CHECK: %[[PRIVATE_X:.*]] = fir.alloca i32 {bindc_name = "x", pinned, uniq_name = "_QFEx"}
 !CHECK: %[[temp:.*]] = fir.load %[[X]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[PRIVATE_X]] : !fir.ref<i32>
-!CHECK: omp.barrier
 !CHECK: %[[temp:.*]] = fir.load %[[PRIVATE_Y]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[PRIVATE_X]] : !fir.ref<i32>
 !CHECK: omp.terminator
 !CHECK: }
 
     !$omp parallel default(firstprivate) firstprivate(y)
         x = y
     !$omp end parallel
 
 !CHECK: omp.parallel {
 !CHECK: %[[PRIVATE_X:.*]] = fir.alloca i32 {bindc_name = "x", pinned, uniq_name = "_QFEx"}
 !CHECK: %[[PRIVATE_Y:.*]] = fir.alloca i32 {bindc_name = "y", pinned, uniq_name = "_QFEy"}
 !CHECK: %[[temp:.*]] = fir.load %[[Y]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[PRIVATE_Y]] : !fir.ref<i32>
 !CHECK: %[[PRIVATE_W:.*]] = fir.alloca i32 {bindc_name = "w", pinned, uniq_name = "_QFEw"}
 !CHECK: %[[temp:.*]] = fir.load %[[W]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[PRIVATE_W]] : !fir.ref<i32>
-!CHECK: omp.barrier
 !CHECK: %[[const:.*]] = arith.constant 2 : i32
 !CHECK: %[[temp:.*]] = fir.load %[[PRIVATE_Y]] : !fir.ref<i32>
 !CHECK: %[[result:.*]] = arith.muli %[[const]], %[[temp]] : i32
 !CHECK: fir.store %[[result]] to %[[PRIVATE_X]] : !fir.ref<i32>
 !CHECK: %[[temp:.*]] = fir.load %[[PRIVATE_W]] : !fir.ref<i32>
 !CHECK: %[[const:.*]] = arith.constant 45 : i32
 !CHECK: %[[result:.*]] = arith.addi %[[temp]], %[[const]] : i32
 !CHECK: fir.store %[[result]] to %[[Z]] : !fir.ref<i32>

 !CHECK: }
 !CHECK: omp.parallel {
 !CHECK: %[[PRIVATE_W:.*]] = fir.alloca i32 {bindc_name = "w", pinned, uniq_name = "_QFEw"}
 !CHECK: %[[temp:.*]] = fir.load %[[W]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[PRIVATE_W]] : !fir.ref<i32>
 !CHECK: %[[PRIVATE_X:.*]] = fir.alloca i32 {bindc_name = "x", pinned, uniq_name = "_QFEx"}
 !CHECK: %[[temp:.*]] = fir.load %[[X]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[PRIVATE_X]] : !fir.ref<i32>
-!CHECK: omp.barrier
 !CHECK: %[[temp:.*]] = fir.load %[[PRIVATE_X]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[PRIVATE_W]] : !fir.ref<i32>
 !CHECK: omp.terminator
 !CHECK: }
 !CHECK: omp.terminator
 !CHECK: }
     !$omp parallel
         !$omp parallel default(private)

 !CHECK: %[[Z:.*]] = fir.alloca i32 {bindc_name = "z", uniq_name = "_QFnested_default_clause_testsEz"}
 !CHECK: omp.parallel   {
 !CHECK: %[[PRIVATE_X:.*]] = fir.alloca i32 {bindc_name = "x", pinned, uniq_name = "_QFnested_default_clause_testsEx"}
 !CHECK: %[[temp:.*]] = fir.load %[[X]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[PRIVATE_X]] : !fir.ref<i32>
 !CHECK: %[[PRIVATE_Y:.*]] = fir.alloca i32 {bindc_name = "y", pinned, uniq_name = "_QFnested_default_clause_testsEy"}
 !CHECK: %[[PRIVATE_Z:.*]] = fir.alloca i32 {bindc_name = "z", pinned, uniq_name = "_QFnested_default_clause_testsEz"}
 !CHECK: %[[PRIVATE_K:.*]] = fir.alloca i32 {bindc_name = "k", pinned, uniq_name = "_QFnested_default_clause_testsEk"}
-!CHECK: omp.barrier
 !CHECK: omp.parallel {
 !CHECK: %[[INNER_PRIVATE_Y:.*]] = fir.alloca i32 {bindc_name = "y", pinned, uniq_name = "_QFnested_default_clause_testsEy"}
 !CHECK: %[[INNER_PRIVATE_X:.*]] = fir.alloca i32 {bindc_name = "x", pinned, uniq_name = "_QFnested_default_clause_testsEx"}
 !CHECK: %[[const:.*]] = arith.constant 20 : i32
 !CHECK: fir.store %[[const]] to %[[INNER_PRIVATE_Y]] : !fir.ref<i32>
 !CHECK: %[[const:.*]] = arith.constant 10 : i32
 !CHECK: fir.store %[[const]] to %[[INNER_PRIVATE_X]] : !fir.ref<i32>
 !CHECK: omp.terminator
 !CHECK: }
 !CHECK: omp.parallel   {
 !CHECK: %[[INNER_PRIVATE_W:.*]] = fir.alloca i32 {bindc_name = "w", pinned, uniq_name = "_QFnested_default_clause_testsEw"}
 !CHECK: %[[INNER_PRIVATE_Z:.*]] = fir.alloca i32 {bindc_name = "z", pinned, uniq_name = "_QFnested_default_clause_testsEz"}
 !CHECK: %[[temp:.*]] = fir.load %[[PRIVATE_Z]]
 !CHECK: fir.store %[[temp]] to %[[INNER_PRIVATE_Z]] : !fir.ref<i32>
 !CHECK: %[[INNER_PRIVATE_K:.*]] = fir.alloca i32 {bindc_name = "k", pinned, uniq_name = "_QFnested_default_clause_testsEk"}
 !CHECK: %[[temp:.*]] = fir.load %[[PRIVATE_K]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[INNER_PRIVATE_K]] : !fir.ref<i32>
-!CHECK: omp.barrier
 !CHECK: %[[const:.*]] = arith.constant 30 : i32
 !CHECK: fir.store %[[const]] to %[[PRIVATE_Y]] : !fir.ref<i32>
 !CHECK: %[[const:.*]] = arith.constant 40 : i32
 !CHECK: fir.store %[[const]] to %[[INNER_PRIVATE_W]] : !fir.ref<i32>
 !CHECK: %[[const:.*]] = arith.constant 50 : i32
 !CHECK: fir.store %[[const]] to %[[INNER_PRIVATE_Z]] : !fir.ref<i32>
 !CHECK: %[[const:.*]] = arith.constant 40 : i32
 !CHECK: fir.store %[[const]] to %[[INNER_PRIVATE_K]] : !fir.ref<i32>

 !CHECK: %[[PRIVATE_W:.*]] = fir.alloca i32 {bindc_name = "w", pinned, uniq_name = "_QFnested_default_clause_testsEw"} 
 !CHECK: omp.parallel {
 !CHECK: %[[PRIVATE_INNER_X:.*]] = fir.alloca i32 {bindc_name = "x", pinned, uniq_name = "_QFnested_default_clause_testsEx"}
 !CHECK: %[[temp:.*]] = fir.load %[[PRIVATE_X]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[PRIVATE_INNER_X]] : !fir.ref<i32>
 !CHECK: %[[INNER_PRIVATE_Y:.*]] = fir.alloca i32 {bindc_name = "y", pinned, uniq_name = "_QFnested_default_clause_testsEy"}
 !CHECK: %[[temp:.*]] = fir.load %[[PRIVATE_Y]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[INNER_PRIVATE_Y]] : !fir.ref<i32>
-!CHECK: omp.barrier
 !CHECK: %[[temp:.*]] = fir.load %[[INNER_PRIVATE_Y]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[PRIVATE_INNER_X]] : !fir.ref<i32>
 !CHECK: omp.terminator
 !CHECK: }
 !CHECK: omp.parallel {
 !CHECK: %[[PRIVATE_INNER_W:.*]] = fir.alloca i32 {bindc_name = "w", pinned, uniq_name = "_QFnested_default_clause_testsEw"} 
 !CHECK: %[[PRIVATE_INNER_X:.*]] = fir.alloca i32 {bindc_name = "x", pinned, uniq_name = "_QFnested_default_clause_testsEx"}
 !CHECK: %[[temp_1:.*]] = fir.load %[[PRIVATE_INNER_X]] : !fir.ref<i32>

 !CHECK: %[[PRIVATE_Z:.*]] = fir.alloca i32 {bindc_name = "z", pinned, uniq_name = "_QFnested_default_clause_testsEz"}
 !CHECK: omp.parallel {
 !CHECK: %[[INNER_PRIVATE_X:.*]] = fir.alloca i32 {bindc_name = "x", pinned, uniq_name = "_QFnested_default_clause_testsEx"}
 !CHECK: %[[temp:.*]] = fir.load %[[PRIVATE_X]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[INNER_PRIVATE_X]] : !fir.ref<i32>
 !CHECK: %[[INNER_PRIVATE_Y:.*]] = fir.alloca i32 {bindc_name = "y", pinned, uniq_name = "_QFnested_default_clause_testsEy"}
 !CHECK: %[[temp:.*]] = fir.load %[[PRIVATE_Y]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[INNER_PRIVATE_Y]] : !fir.ref<i32>
-!CHECK: omp.barrier
 !CHECK: %[[temp:.*]] = fir.load %[[INNER_PRIVATE_Y]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[INNER_PRIVATE_X]] : !fir.ref<i32>
 !CHECK: omp.terminator
 !CHECK: }
 !CHECK: omp.parallel {
 !CHECK: %[[temp_1:.*]] = fir.load %[[PRIVATE_X]] : !fir.ref<i32>
 !CHECK: %[[temp_2:.*]] = fir.load %[[PRIVATE_Z]] : !fir.ref<i32>
 !CHECK: %[[temp_3:.*]] = arith.addi %[[temp_1]], %[[temp_2]] : i32

 
 !CHECK: omp.parallel {
 !CHECK: %[[PRIVATE_X:.*]] = fir.alloca i32 {bindc_name = "x", pinned, uniq_name = "_QFnested_default_clause_testsEx"}
 !CHECK: %[[temp:.*]] = fir.load %[[X]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[PRIVATE_X]] : !fir.ref<i32>
 !CHECK: %[[PRIVATE_Y:.*]] = fir.alloca i32 {bindc_name = "y", pinned, uniq_name = "_QFnested_default_clause_testsEy"}
 !CHECK: %[[temp:.*]] = fir.load %[[Y]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[PRIVATE_Y]] : !fir.ref<i32>
-!CHECK: omp.barrier
 !CHECK: omp.single {
 !CHECK: %[[temp:.*]] = fir.load %[[PRIVATE_Y]] : !fir.ref<i32>
 !CHECK: fir.store %[[temp]] to %[[PRIVATE_X]] : !fir.ref<i32>
 !CHECK: omp.terminator
 !CHECK: }
 !CHECK: omp.terminator
 !CHECK: }
 !CHECK: } 
   !$omp parallel default(firstprivate)
     !$omp single
       x = y
     !$omp end single
   !$omp end parallel
 end subroutine

flang/test/Lower/OpenMP/omp-parallel-firstprivate-clause-scalar.f90

 ! This test checks lowering of `FIRSTPRIVATE` clause for scalar types.
 
 ! REQUIRES: shell
 ! RUN: bbc -fopenmp -emit-fir %s -o - | FileCheck %s --check-prefix=FIRDialect
 
 !FIRDialect-DAG: func @_QPfirstprivate_complex(%[[ARG1:.*]]: !fir.ref<!fir.complex<4>>{{.*}}, %[[ARG2:.*]]: !fir.ref<!fir.complex<8>>{{.*}}) {
 !FIRDialect:   omp.parallel {
 !FIRDialect:     %[[ARG1_PVT:.*]] = fir.alloca !fir.complex<4> {bindc_name = "arg1", pinned, uniq_name = "_QFfirstprivate_complexEarg1"}
 !FIRDialect:     %[[ARG1_VAL:.*]] = fir.load %[[ARG1]] : !fir.ref<!fir.complex<4>>
 !FIRDialect:     fir.store %[[ARG1_VAL]] to %[[ARG1_PVT]] : !fir.ref<!fir.complex<4>>
 !FIRDialect:     %[[ARG2_PVT:.*]] = fir.alloca !fir.complex<8> {bindc_name = "arg2", pinned, uniq_name = "_QFfirstprivate_complexEarg2"}
 !FIRDialect:     %[[ARG2_VAL:.*]] = fir.load %[[ARG2]] : !fir.ref<!fir.complex<8>>
 !FIRDialect:     fir.store %[[ARG2_VAL]] to %[[ARG2_PVT]] : !fir.ref<!fir.complex<8>>
-!FIRDialect:     omp.barrier
 !FIRDialect:     fir.call @_QPfoo(%[[ARG1_PVT]], %[[ARG2_PVT]]) : (!fir.ref<!fir.complex<4>>, !fir.ref<!fir.complex<8>>) -> ()
 !FIRDialect:     omp.terminator
 !FIRDialect:   }
 
 subroutine firstprivate_complex(arg1, arg2)
         complex(4) :: arg1
         complex(8) :: arg2
 

 !FIRDialect:    %[[ARG4_VAL:.*]] = fir.load %[[ARG4]] : !fir.ref<i32>
 !FIRDialect:    fir.store %[[ARG4_VAL]] to %[[ARG4_PVT]] : !fir.ref<i32>
 !FIRDialect:    %[[ARG5_PVT:.*]] = fir.alloca i64 {bindc_name = "arg5", pinned, uniq_name = "_QFfirstprivate_integerEarg5"}
 !FIRDialect:    %[[ARG5_VAL:.*]] = fir.load %[[ARG5]] : !fir.ref<i64>
 !FIRDialect:    fir.store %[[ARG5_VAL]] to %[[ARG5_PVT]] : !fir.ref<i64>
 !FIRDialect:    %[[ARG6_PVT:.*]] = fir.alloca i128 {bindc_name = "arg6", pinned, uniq_name = "_QFfirstprivate_integerEarg6"}
 !FIRDialect:    %[[ARG6_VAL:.*]] = fir.load %[[ARG6]] : !fir.ref<i128>
 !FIRDialect:    fir.store %[[ARG6_VAL]] to %[[ARG6_PVT]] : !fir.ref<i128>
-!FIRDialect:    omp.barrier
 !FIRDialect:    fir.call @_QPbar(%[[ARG1_PVT]], %[[ARG2_PVT]], %[[ARG3_PVT]], %[[ARG4_PVT]], %[[ARG5_PVT]], %[[ARG6_PVT]]) : (!fir.ref<i32>, !fir.ref<i8>, !fir.ref<i16>, !fir.ref<i32>, !fir.ref<i64>, !fir.ref<i128>) -> ()
 !FIRDialect:    omp.terminator
 !FIRDialect:  }
 
 subroutine firstprivate_integer(arg1, arg2, arg3, arg4, arg5, arg6)
         integer :: arg1
         integer(kind=1) :: arg2
         integer(kind=2) :: arg3

 !FIRDialect:     %[[ARG3_VAL:.*]] = fir.load %[[ARG3]] : !fir.ref<!fir.logical<2>>
 !FIRDialect:     fir.store %[[ARG3_VAL]] to %[[ARG3_PVT]] : !fir.ref<!fir.logical<2>>
 !FIRDialect:     %[[ARG4_PVT:.*]] = fir.alloca !fir.logical<4> {bindc_name = "arg4", pinned, uniq_name = "_QFfirstprivate_logicalEarg4"}
 !FIRDialect:     %[[ARG4_VAL:.*]] = fir.load %[[ARG4]] : !fir.ref<!fir.logical<4>>
 !FIRDialect:     fir.store %[[ARG4_VAL]] to %[[ARG4_PVT]] : !fir.ref<!fir.logical<4>>
 !FIRDialect:     %[[ARG5_PVT:.*]] = fir.alloca !fir.logical<8> {bindc_name = "arg5", pinned, uniq_name = "_QFfirstprivate_logicalEarg5"}
 !FIRDialect:     %[[ARG5_VAL:.*]] = fir.load %[[ARG5]] : !fir.ref<!fir.logical<8>>
 !FIRDialect:     fir.store %[[ARG5_VAL]] to %[[ARG5_PVT]] : !fir.ref<!fir.logical<8>>
-!FIRDialect:     omp.barrier
 !FIRDialect:     fir.call @_QPbaz(%[[ARG1_PVT]], %[[ARG2_PVT]], %[[ARG3_PVT]], %[[ARG4_PVT]], %[[ARG5_PVT]]) : (!fir.ref<!fir.logical<4>>, !fir.ref<!fir.logical<1>>, !fir.ref<!fir.logical<2>>, !fir.ref<!fir.logical<4>>, !fir.ref<!fir.logical<8>>) -> ()
 !FIRDialect:     omp.terminator
 !FIRDialect:   }
 
 subroutine firstprivate_logical(arg1, arg2, arg3, arg4, arg5)
         logical :: arg1
         logical(kind=1) :: arg2
         logical(kind=2) :: arg3

 !FIRDialect:     %[[ARG4_VAL:.*]] = fir.load %[[ARG4]] : !fir.ref<f64>
 !FIRDialect:     fir.store %[[ARG4_VAL]] to %[[ARG4_PVT]] : !fir.ref<f64>
 !FIRDialect:     %[[ARG5_PVT:.*]] = fir.alloca f80 {bindc_name = "arg5", pinned, uniq_name = "_QFfirstprivate_realEarg5"}
 !FIRDialect:     %[[ARG5_VAL:.*]] = fir.load %[[ARG5]] : !fir.ref<f80>
 !FIRDialect:     fir.store %[[ARG5_VAL]] to %[[ARG5_PVT]] : !fir.ref<f80>
 !FIRDialect:     %[[ARG6_PVT:.*]] = fir.alloca f128 {bindc_name = "arg6", pinned, uniq_name = "_QFfirstprivate_realEarg6"}
 !FIRDialect:     %[[ARG6_VAL:.*]] = fir.load %[[ARG6]] : !fir.ref<f128>
 !FIRDialect:     fir.store %[[ARG6_VAL]] to %[[ARG6_PVT]] : !fir.ref<f128>
-!FIRDialect:     omp.barrier
 !FIRDialect:     fir.call @_QPqux(%[[ARG1_PVT]], %[[ARG2_PVT]], %[[ARG3_PVT]], %[[ARG4_PVT]], %[[ARG5_PVT]], %[[ARG6_PVT]]) : (!fir.ref<f32>, !fir.ref<f16>, !fir.ref<f32>, !fir.ref<f64>, !fir.ref<f80>, !fir.ref<f128>) -> ()
 !FIRDialect:     omp.terminator
 !FIRDialect:   }
 
 subroutine firstprivate_real(arg1, arg2, arg3, arg4, arg5, arg6)
         real :: arg1
         real(kind=2) :: arg2
         real(kind=4) :: arg3

 !FIRDialect-SAME:                                        %[[B_ADDR:.*]]: !fir.ref<i32> {fir.bindc_name = "b"}) {
 !FIRDialect:           omp.parallel   {
 !FIRDialect:             %[[A_PRIV_ADDR:.*]] = fir.alloca i32 {bindc_name = "a", pinned, uniq_name = "_QFmultiple_firstprivateEa"}
 !FIRDialect:             %[[A:.*]] = fir.load %[[A_ADDR]] : !fir.ref<i32>
 !FIRDialect:             fir.store %[[A]] to %[[A_PRIV_ADDR]] : !fir.ref<i32>
 !FIRDialect:             %[[B_PRIV_ADDR:.*]] = fir.alloca i32 {bindc_name = "b", pinned, uniq_name = "_QFmultiple_firstprivateEb"}
 !FIRDialect:             %[[B:.*]] = fir.load %[[B_ADDR]] : !fir.ref<i32>
 !FIRDialect:             fir.store %[[B]] to %[[B_PRIV_ADDR]] : !fir.ref<i32>
-!FIRDialect:             omp.barrier
-!FIRDialect-NOT:         omp.barrier
 !FIRDialect:             fir.call @_QPquux(%[[A_PRIV_ADDR]], %[[B_PRIV_ADDR]]) : (!fir.ref<i32>, !fir.ref<i32>) -> ()
 !FIRDialect:             omp.terminator
 !FIRDialect:           }
 !FIRDialect:           return
 !FIRDialect:         }
 
 subroutine multiple_firstprivate(a, b)
         integer :: a, b
 !$OMP PARALLEL FIRSTPRIVATE(a) FIRSTPRIVATE(b)
         call quux(a, b)
 !$OMP END PARALLEL
 end subroutine multiple_firstprivate

flang/test/Lower/OpenMP/omp-parallel-lastprivate-clause-scalar.f90

 ! This test checks lowering of `FIRSTPRIVATE` clause for scalar types.
-! TODO: Add a test for same var being first and lastprivate when support is there.
 
 ! RUN: bbc -fopenmp -emit-fir %s -o - | FileCheck %s
 ! RUN: flang-new -fc1 -fopenmp -emit-fir %s -o - | FileCheck %s
 
 !CHECK: func @_QPlastprivate_character(%[[ARG1:.*]]: !fir.boxchar<1>{{.*}}) {
 !CHECK-DAG: %[[ARG1_UNBOX:.*]]:2 = fir.unboxchar
 !CHECK-DAG: %[[FIVE:.*]] = arith.constant 5 : index
 
do n = 1, 5
         print *, arg1
 end do
 !$OMP END DO
 !$OMP END PARALLEL
 print *, arg1
 end subroutine
 
 !CHECK: func.func @_QPmult_lastprivate_int(%[[ARG1:.*]]: !fir.ref<i32> {fir.bindc_name = "arg1"}, %[[ARG2:.*]]: !fir.ref<i32> {fir.bindc_name = "arg2"}) {
-!CHECK-DAG: omp.parallel  {
+!CHECK: omp.parallel  {
 !CHECK-DAG: %[[CLONE1:.*]] = fir.alloca i32 {bindc_name = "arg1"
 !CHECK-DAG: %[[CLONE2:.*]] = fir.alloca i32 {bindc_name = "arg2"
 !CHECK: omp.wsloop for (%[[INDX_WS:.*]]) : {{.*}} {
 
 ! Testing last iteration check
-!CHECK-DAG: %[[IV_CMP1:.*]] = arith.cmpi eq, %[[INDX_WS]]
-!CHECK-DAG: scf.if %[[IV_CMP1]] {
-! Testing lastprivate val update
-!CHECK-NEXT: %[[CLONE_LD1:.*]] = fir.load %[[CLONE1]] : !fir.ref<i32>
-!CHECK-NEXT: fir.store %[[CLONE_LD1]] to %[[ARG1]] : !fir.ref<i32>
-!CHECK-DAG: }
-!CHECK-DAG: scf.if %[[IV_CMP1]] {
+!CHECK: %[[IV_CMP1:.*]] = arith.cmpi eq, %[[INDX_WS]]
+!CHECK-NEXT: scf.if %[[IV_CMP1]] {
 ! Testing lastprivate val update
-!CHECK-NEXT: %[[CLONE_LD2:.*]] = fir.load %[[CLONE2]] : !fir.ref<i32>
-!CHECK-NEXT: fir.store %[[CLONE_LD2]] to %[[ARG2]] : !fir.ref<i32>
-!CHECK-DAG: }
-!CHECK-DAG: omp.yield
+!CHECK-DAG: %[[CLONE_LD1:.*]] = fir.load %[[CLONE1]] : !fir.ref<i32>
+!CHECK-DAG: fir.store %[[CLONE_LD1]] to %[[ARG1]] : !fir.ref<i32>
+!CHECK-DAG: %[[CLONE_LD2:.*]] = fir.load %[[CLONE2]] : !fir.ref<i32>
+!CHECK-DAG: fir.store %[[CLONE_LD2]] to %[[ARG2]] : !fir.ref<i32>
+!CHECK: }
+!CHECK: omp.yield
 
 subroutine mult_lastprivate_int(arg1, arg2)
         integer :: arg1, arg2
 !$OMP PARALLEL 
 !$OMP DO LASTPRIVATE(arg1) LASTPRIVATE(arg2)
 do n = 1, 5
         arg1 = 2
         arg2 = 3
         print *, arg1, arg2
 end do
 !$OMP END DO
 !$OMP END PARALLEL
 print *, arg1, arg2
 end subroutine
 
 !CHECK: func.func @_QPmult_lastprivate_int2(%[[ARG1:.*]]: !fir.ref<i32> {fir.bindc_name = "arg1"}, %[[ARG2:.*]]: !fir.ref<i32> {fir.bindc_name = "arg2"}) {
-!CHECK-DAG: omp.parallel  {
+!CHECK: omp.parallel  {
 !CHECK-DAG: %[[CLONE1:.*]] = fir.alloca i32 {bindc_name = "arg1"
 !CHECK-DAG: %[[CLONE2:.*]] = fir.alloca i32 {bindc_name = "arg2"
 !CHECK: omp.wsloop for (%[[INDX_WS:.*]]) : {{.*}} {
 
-! Testing last iteration check
-!CHECK-DAG: %[[IV_CMP1:.*]] = arith.cmpi eq, %[[INDX_WS]]
-!CHECK-DAG: scf.if %[[IV_CMP1]] {
-! Testing lastprivate val update
-!CHECK-NEXT: %[[CLONE_LD2:.*]] = fir.load %[[CLONE2]] : !fir.ref<i32>
-!CHECK-NEXT: fir.store %[[CLONE_LD2]] to %[[ARG2]] : !fir.ref<i32>
-!CHECK-NEXT: %[[CLONE_LD1:.*]] = fir.load %[[CLONE1]] : !fir.ref<i32>
-!CHECK-NEXT: fir.store %[[CLONE_LD1]] to %[[ARG1]] : !fir.ref<i32>
-!CHECK-NEXT: }
-!CHECK-NEXT: omp.yield
+!Testing last iteration check
+!CHECK: %[[IV_CMP1:.*]] = arith.cmpi eq, %[[INDX_WS]]
+!CHECK-NEXT: scf.if %[[IV_CMP1]] {
+!Testing lastprivate val update
+!CHECK-DAG: %[[CLONE_LD2:.*]] = fir.load %[[CLONE2]] : !fir.ref<i32>
+!CHECK-DAG: fir.store %[[CLONE_LD2]] to %[[ARG2]] : !fir.ref<i32>
+!CHECK-DAG: %[[CLONE_LD1:.*]] = fir.load %[[CLONE1]] : !fir.ref<i32>
+!CHECK-DAG: fir.store %[[CLONE_LD1]] to %[[ARG1]] : !fir.ref<i32>
+!CHECK: }
+!CHECK: omp.yield
 
 subroutine mult_lastprivate_int2(arg1, arg2)
         integer :: arg1, arg2
 !$OMP PARALLEL 
 !$OMP DO LASTPRIVATE(arg1, arg2)
 do n = 1, 5
         arg1 = 2
         arg2 = 3
         print *, arg1, arg2
 end do
 !$OMP END DO
 !$OMP END PARALLEL
 print *, arg1, arg2
 end subroutine
 
 !CHECK: func.func @_QPfirstpriv_lastpriv_int(%[[ARG1:.*]]: !fir.ref<i32> {fir.bindc_name = "arg1"}, %[[ARG2:.*]]: !fir.ref<i32> {fir.bindc_name = "arg2"}) {
-!CHECK-DAG: omp.parallel  {
-! Lastprivate Allocation
-!CHECK-NEXT: %[[CLONE2:.*]] = fir.alloca i32 {bindc_name = "arg2"
-!CHECK-DAG: %[[CLONE1:.*]] = fir.alloca i32 {bindc_name = "arg1"
+!CHECK: omp.parallel  {
 ! Firstprivate update
-!CHECK-NEXT: %[[FPV_LD:.*]] = fir.load %[[ARG1]] : !fir.ref<i32>
-!CHECK-NEXT: fir.store %[[FPV_LD]] to %[[CLONE1]] : !fir.ref<i32>
-!CHECK-NEXT: omp.barrier
+!CHECK-DAG: %[[CLONE1:.*]] = fir.alloca i32 {bindc_name = "arg1"
+!CHECK-DAG: %[[FPV_LD:.*]] = fir.load %[[ARG1]] : !fir.ref<i32>
+!CHECK-DAG: fir.store %[[FPV_LD]] to %[[CLONE1]] : !fir.ref<i32>
+! Lastprivate Allocation
+!CHECK-DAG: %[[CLONE2:.*]] = fir.alloca i32 {bindc_name = "arg2"
+!CHECK-NOT: omp.barrier
 !CHECK: omp.wsloop for (%[[INDX_WS:.*]]) : {{.*}} {
 
 ! Testing last iteration check
-!CHECK-DAG: %[[IV_CMP1:.*]] = arith.cmpi eq, %[[INDX_WS]]
-!CHECK-DAG: scf.if %[[IV_CMP1]] {
+!CHECK: %[[IV_CMP1:.*]] = arith.cmpi eq, %[[INDX_WS]]
+!CHECK-NEXT: scf.if %[[IV_CMP1]] {
 ! Testing lastprivate val update
 !CHECK-NEXT: %[[CLONE_LD:.*]] = fir.load %[[CLONE2]] : !fir.ref<i32>
 !CHECK-NEXT: fir.store %[[CLONE_LD]] to %[[ARG2]] : !fir.ref<i32>
 !CHECK-NEXT: }
 !CHECK-NEXT: omp.yield
 
 subroutine firstpriv_lastpriv_int(arg1, arg2)
         integer :: arg1, arg2
 !$OMP PARALLEL 
 !$OMP DO FIRSTPRIVATE(arg1) LASTPRIVATE(arg2)
 do n = 1, 5
         arg1 = 2
         arg2 = 3
         print *, arg1, arg2
 end do
 !$OMP END DO
 !$OMP END PARALLEL
 print *, arg1, arg2
 end subroutine
 
+!CHECK: func.func @_QPfirstpriv_lastpriv_int2(%[[ARG1:.*]]: !fir.ref<i32> {fir.bindc_name = "arg1"}) {
+!CHECK: omp.parallel  {
+! Firstprivate update
+!CHECK-NEXT: %[[CLONE1:.*]] = fir.alloca i32 {bindc_name = "arg1"
+!CHECK-NEXT: %[[FPV_LD:.*]] = fir.load %[[ARG1]] : !fir.ref<i32>
+!CHECK-NEXT: fir.store %[[FPV_LD]] to %[[CLONE1]] : !fir.ref<i32>
+!CHECK-NEXT: omp.barrier
+!CHECK: omp.wsloop for (%[[INDX_WS:.*]]) : {{.*}} {
+! Testing last iteration check
+!CHECK: %[[IV_CMP1:.*]] = arith.cmpi eq, %[[INDX_WS]]
+!CHECK-NEXT: scf.if %[[IV_CMP1]] {
+! Testing lastprivate val update
+!CHECK-NEXT: %[[CLONE_LD:.*]] = fir.load %[[CLONE1]] : !fir.ref<i32>
+!CHECK-NEXT: fir.store %[[CLONE_LD]] to %[[ARG1]] : !fir.ref<i32>
+!CHECK-NEXT: }
+!CHECK-NEXT: omp.yield
 
+subroutine firstpriv_lastpriv_int2(arg1)
+        integer :: arg1
+!$OMP PARALLEL 
+!$OMP DO FIRSTPRIVATE(arg1) LASTPRIVATE(arg1)
+do n = 1, 5
+        arg1 = 2
+        print *, arg1
+end do
+!$OMP END DO
+!$OMP END PARALLEL
+print *, arg1
+end subroutine

flang/test/Lower/OpenMP/omp-parallel-wsloop-firstpriv.f90

 ! This test checks lowering of OpenMP parallel DO, with the loop bound being
 ! a firstprivate variable
 
 ! RUN: bbc -fopenmp -emit-fir %s -o - | FileCheck %s
 
 ! CHECK: func @_QPomp_do_firstprivate(%[[ARG0:.*]]: !fir.ref<i32> {fir.bindc_name = "a"}) 
 subroutine omp_do_firstprivate(a)
   integer::a
   integer::n
   n = a+1
   !$omp parallel do firstprivate(a)
   ! CHECK:  omp.parallel {
   ! CHECK-NEXT: %[[CLONE:.*]] = fir.alloca i32 {bindc_name = "a", pinned
   ! CHECK-NEXT: %[[LD:.*]] = fir.load %[[ARG0]] : !fir.ref<i32>
   ! CHECK-NEXT: fir.store %[[LD]] to %[[CLONE]] : !fir.ref<i32>
-  ! CHECK-NEXT: omp.barrier
   ! CHECK-NEXT: %[[REF:.*]] = fir.alloca i32 {adapt.valuebyref, pinned}
   ! CHECK: %[[LB:.*]] = arith.constant 1 : i32
   ! CHECK-NEXT: %[[UB:.*]] = fir.load %[[CLONE]] : !fir.ref<i32>
   ! CHECK-NEXT: %[[STEP:.*]] = arith.constant 1 : i32
   ! CHECK-NEXT: omp.wsloop   for  (%[[ARG1:.*]]) : i32 = (%[[LB]]) to (%[[UB]]) inclusive step (%[[STEP]])
   ! CHECK-NEXT: fir.store %[[ARG1]] to %[[REF]] : !fir.ref<i32>
   ! CHECK-NEXT: fir.call @_QPfoo(%[[REF]], %[[CLONE]]) : (!fir.ref<i32>, !fir.ref<i32>) -> ()
   ! CHECK-NEXT: omp.yield
subroutine omp_do_firstprivate2(a, n)
   !$omp parallel do firstprivate(a, n)
   ! CHECK:  omp.parallel {
   ! CHECK-NEXT: %[[CLONE:.*]] = fir.alloca i32 {bindc_name = "a", pinned
   ! CHECK-NEXT: %[[LD:.*]] = fir.load %[[ARG0]] : !fir.ref<i32>
   ! CHECK-NEXT: fir.store %[[LD]] to %[[CLONE]] : !fir.ref<i32>
   ! CHECK-NEXT: %[[CLONE1:.*]] = fir.alloca i32 {bindc_name = "n", pinned
   ! CHECK-NEXT: %[[LD1:.*]] = fir.load %[[ARG1]] : !fir.ref<i32>
   ! CHECK-NEXT: fir.store %[[LD1]] to %[[CLONE1]] : !fir.ref<i32>
-  ! CHECK-NEXT: omp.barrier
   ! CHECK-NEXT: %[[REF:.*]] = fir.alloca i32 {adapt.valuebyref, pinned}
 
 
   ! CHECK: %[[LB:.*]] = fir.load %[[CLONE]] : !fir.ref<i32>
   ! CHECK-NEXT: %[[UB:.*]] = fir.load %[[CLONE1]] : !fir.ref<i32>
   ! CHECK-NEXT: %[[STEP:.*]] = arith.constant 1 : i32
   ! CHECK-NEXT: omp.wsloop   for  (%[[ARG2:.*]]) : i32 = (%[[LB]]) to (%[[UB]]) inclusive step (%[[STEP]])
   ! CHECK-NEXT: fir.store %[[ARG2]] to %[[REF]] : !fir.ref<i32>

flang/test/Lower/OpenMP/omp-parallel-wsloop.f90

subroutine parallel_do_with_privatisation_clauses(cond,nt)
   logical :: cond
   integer :: nt
   integer :: i
   ! CHECK:  omp.parallel
   ! CHECK:    %[[PRIVATE_COND_REF:.*]] = fir.alloca !fir.logical<4> {bindc_name = "cond", pinned, uniq_name = "_QFparallel_do_with_privatisation_clausesEcond"}
   ! CHECK:    %[[PRIVATE_NT_REF:.*]] = fir.alloca i32 {bindc_name = "nt", pinned, uniq_name = "_QFparallel_do_with_privatisation_clausesEnt"}
   ! CHECK:    %[[NT_VAL:.*]] = fir.load %[[NT_REF]] : !fir.ref<i32>
   ! CHECK:    fir.store %[[NT_VAL]] to %[[PRIVATE_NT_REF]] : !fir.ref<i32>
-  ! CHECK:    omp.barrier
   ! CHECK:    %[[WS_LB:.*]] = arith.constant 1 : i32
   ! CHECK:    %[[WS_UB:.*]] = arith.constant 9 : i32
   ! CHECK:    %[[WS_STEP:.*]] = arith.constant 1 : i32
   ! CHECK:    omp.wsloop for (%[[I:.*]]) : i32 = (%[[WS_LB]]) to (%[[WS_UB]]) inclusive step (%[[WS_STEP]])
   !$OMP PARALLEL DO PRIVATE(cond) FIRSTPRIVATE(nt)
   do i=1, 9
   ! CHECK:    fir.store %[[I]] to %[[IV_ADDR:.*]] : !fir.ref<i32>
   ! CHECK:    %[[LOAD_IV:.*]] = fir.load %[[IV_ADDR]] : !fir.ref<i32>

 ! CHECK-SAME:                                      %[[VAL_1:.*]]: !fir.ref<i32> {fir.bindc_name = "nt"}) {
 ! CHECK:           %[[I:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFparallel_private_doEi"}
 ! CHECK:           omp.parallel   {
 ! CHECK:             %[[I_PRIV:.*]] = fir.alloca i32 {adapt.valuebyref, pinned}
 ! CHECK:             %[[COND_ADDR:.*]] = fir.alloca !fir.logical<4> {bindc_name = "cond", pinned, uniq_name = "_QFparallel_private_doEcond"}
 ! CHECK:             %[[NT_ADDR:.*]] = fir.alloca i32 {bindc_name = "nt", pinned, uniq_name = "_QFparallel_private_doEnt"}
 ! CHECK:             %[[NT:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32>
 ! CHECK:             fir.store %[[NT]] to %[[NT_ADDR]] : !fir.ref<i32>
-! CHECK:             omp.barrier
 ! CHECK:             %[[VAL_7:.*]] = arith.constant 1 : i32
 ! CHECK:             %[[VAL_8:.*]] = arith.constant 9 : i32
 ! CHECK:             %[[VAL_9:.*]] = arith.constant 1 : i32
 ! CHECK:             omp.wsloop   for  (%[[I:.*]]) : i32 = (%[[VAL_7]]) to (%[[VAL_8]]) inclusive step (%[[VAL_9]]) {
 ! CHECK:               fir.store %[[I]] to %[[I_PRIV]] : !fir.ref<i32>
 ! CHECK:               fir.call @_QPfoo(%[[I_PRIV]], %[[COND_ADDR]], %[[NT_ADDR]]) : (!fir.ref<i32>, !fir.ref<!fir.logical<4>>, !fir.ref<i32>) -> ()
 ! CHECK:               omp.yield
 ! CHECK:             }
 ! CHECK:             omp.terminator
 ! CHECK:           }
 ! CHECK:           return
 ! CHECK:         }
 
 !===============================================================================
-! Checking for the following construct - multiple firstprivate clauses must emit
-! only one barrier
+! Checking for the following construct
 !   !$omp parallel
 !   !$omp do firstprivate(...) firstprivate(...)
 !===============================================================================
 
 subroutine omp_parallel_multiple_firstprivate_do(a, b)
   integer::a, b
   !$OMP PARALLEL FIRSTPRIVATE(a) FIRSTPRIVATE(b)
   !$OMP DO

 ! CHECK:           omp.parallel   {
 ! CHECK:             %[[I_PRIV_ADDR:.*]] = fir.alloca i32 {adapt.valuebyref, pinned}
 ! CHECK:             %[[A_PRIV_ADDR:.*]] = fir.alloca i32 {bindc_name = "a", pinned, uniq_name = "_QFomp_parallel_multiple_firstprivate_doEa"}
 ! CHECK:             %[[A:.*]] = fir.load %[[A_ADDR]] : !fir.ref<i32>
 ! CHECK:             fir.store %[[A]] to %[[A_PRIV_ADDR]] : !fir.ref<i32>
 ! CHECK:             %[[B_PRIV_ADDR:.*]] = fir.alloca i32 {bindc_name = "b", pinned, uniq_name = "_QFomp_parallel_multiple_firstprivate_doEb"}
 ! CHECK:             %[[B:.*]] = fir.load %[[B_ADDR]] : !fir.ref<i32>
 ! CHECK:             fir.store %[[B]] to %[[B_PRIV_ADDR]] : !fir.ref<i32>
-! CHECK:             omp.barrier
 ! CHECK:             %[[VAL_8:.*]] = arith.constant 1 : i32
 ! CHECK:             %[[VAL_9:.*]] = arith.constant 10 : i32
 ! CHECK:             %[[VAL_10:.*]] = arith.constant 1 : i32
 ! CHECK:             omp.wsloop   for  (%[[I:.*]]) : i32 = (%[[VAL_8]]) to (%[[VAL_9]]) inclusive step (%[[VAL_10]]) {
 ! CHECK:               fir.store %[[I]] to %[[I_PRIV_ADDR]] : !fir.ref<i32>
 ! CHECK:               fir.call @_QPbar(%[[I_PRIV_ADDR]], %[[A_PRIV_ADDR]]) : (!fir.ref<i32>, !fir.ref<i32>) -> ()
 ! CHECK:               omp.yield
 ! CHECK:             }

 ! CHECK-SAME:                                      %[[VAL_0:.*]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "cond"},
 ! CHECK-SAME:                                      %[[VAL_1:.*]]: !fir.ref<i32> {fir.bindc_name = "nt"}) {
 ! CHECK:           %[[I_ADDR:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFparallel_do_privateEi"}
 ! CHECK:           omp.parallel   {
 ! CHECK:             %[[COND_ADDR:.*]] = fir.alloca !fir.logical<4> {bindc_name = "cond", pinned, uniq_name = "_QFparallel_do_privateEcond"}
 ! CHECK:             %[[NT_ADDR:.*]] = fir.alloca i32 {bindc_name = "nt", pinned, uniq_name = "_QFparallel_do_privateEnt"}
 ! CHECK:             %[[NT:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32>
 ! CHECK:             fir.store %[[NT]] to %[[NT_ADDR]] : !fir.ref<i32>
-! CHECK:             omp.barrier
 ! CHECK:             %[[I_PRIV_ADDR:.*]] = fir.alloca i32 {adapt.valuebyref, pinned}
 ! CHECK:             %[[VAL_7:.*]] = arith.constant 1 : i32
 ! CHECK:             %[[VAL_8:.*]] = arith.constant 9 : i32
 ! CHECK:             %[[VAL_9:.*]] = arith.constant 1 : i32
 ! CHECK:             omp.wsloop   for  (%[[I:.*]]) : i32 = (%[[VAL_7]]) to (%[[VAL_8]]) inclusive step (%[[VAL_9]]) {
 ! CHECK:               fir.store %[[I]] to %[[I_PRIV_ADDR]] : !fir.ref<i32>
 ! CHECK:               fir.call @_QPfoo(%[[I_PRIV_ADDR]], %[[COND_ADDR]], %[[NT_ADDR]]) : (!fir.ref<i32>, !fir.ref<!fir.logical<4>>, !fir.ref<i32>) -> ()
 ! CHECK:               omp.yield
 ! CHECK:             }
 ! CHECK:             omp.terminator
 ! CHECK:           }
 ! CHECK:           return
 ! CHECK:         }
 
 !===============================================================================
-! Checking for the following construct - multiple firstprivate clauses must emit
-! only one barrier
+! Checking for the following construct
 !   !$omp parallel
 !   !$omp do firstprivate(...) firstprivate(...)
 !===============================================================================
 
 subroutine omp_parallel_do_multiple_firstprivate(a, b)
   integer::a, b
   !$OMP PARALLEL
   !$OMP DO FIRSTPRIVATE(a) FIRSTPRIVATE(b)

 ! CHECK:           %[[I_ADDR:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFomp_parallel_do_multiple_firstprivateEi"}
 ! CHECK:           omp.parallel   {
 ! CHECK:             %[[A_PRIV_ADDR:.*]] = fir.alloca i32 {bindc_name = "a", pinned, uniq_name = "_QFomp_parallel_do_multiple_firstprivateEa"}
 ! CHECK:             %[[A:.*]] = fir.load %[[A_ADDR]] : !fir.ref<i32>
 ! CHECK:             fir.store %[[A]] to %[[A_PRIV_ADDR]] : !fir.ref<i32>
 ! CHECK:             %[[B_PRIV_ADDR:.*]] = fir.alloca i32 {bindc_name = "b", pinned, uniq_name = "_QFomp_parallel_do_multiple_firstprivateEb"}
 ! CHECK:             %[[B:.*]] = fir.load %[[B_ADDR]] : !fir.ref<i32>
 ! CHECK:             fir.store %[[B]] to %[[B_PRIV_ADDR]] : !fir.ref<i32>
-! CHECK:             omp.barrier
-! CHECK-NOT:         omp.barrier
 ! CHECK:             %[[I_PRIV_ADDR:.*]] = fir.alloca i32 {adapt.valuebyref, pinned}
 ! CHECK:             %[[VAL_8:.*]] = arith.constant 1 : i32
 ! CHECK:             %[[VAL_9:.*]] = arith.constant 10 : i32
 ! CHECK:             %[[VAL_10:.*]] = arith.constant 1 : i32
 ! CHECK:             omp.wsloop   for  (%[[I:.*]]) : i32 = (%[[VAL_8]]) to (%[[VAL_9]]) inclusive step (%[[VAL_10]]) {
 ! CHECK:               fir.store %[[I]] to %[[I_PRIV_ADDR]] : !fir.ref<i32>
 ! CHECK:               fir.call @_QPbar(%[[I_PRIV_ADDR]], %[[A_PRIV_ADDR]]) : (!fir.ref<i32>, !fir.ref<i32>) -> ()
 ! CHECK:               omp.yield
 ! CHECK:             }
 ! CHECK:             omp.terminator
 ! CHECK:           }
 ! CHECK:           return
 ! CHECK:         }