[flang][OpenMP][OpenACC] Support stop statement in OpenMP/OpenACC region

[kiranchandramohan]

Summary

[flang][OpenMP][OpenACC] Support stop statement in OpenMP/OpenACC region

This supports lowering of stop statement in OpenMP/OpenACC region.

• OpenMP/OpenACC: Emit fir.unreachable only if the block is not terminated by any terminator. This avoids knocking off an existing OpenMP/OpenACC terminator.
• OpenMP: Emit the OpenMP terminator instead of fir.unreachable since OpenMP regions can only be terminated by OpenMP terminators. This is currently skipped for OpenACC since unstructured code is not yet handled specially in OpenACC lowering.

Fixes #60737
Fixes #61877

Co-authored-by: Peixin Qiao <[e-mail]>
Co-authored-by: Val Donaldson <[e-mail]>

[peixin]

1. For OpenMP code, I noticed that fir.if operation is not generated even with -emit-fir enabled. But for OpenACC code, it is generated.
2. For OpenMP code, the redundant branch is not optimized in test_stop_in_region2 in flang/test/Lower/OpenMP/stop-stmt-in-region.f90. But for OpenACC code, it is optimized.

@kiranchandramohan Do you know what's going on here?

3. For OpenACC code, I got the following error for test_stop_in_region3 in flang/test/Lower/OpenACC/stop-stmt-in-region.f90:

error: loc("./acc.f90":18:5): operation with block successors must terminate its parent block
FATAL: verification of lowering to FIR failed

@clementval Could you please help check with this? The similar OpenMP code does not fail.

[peixin]

rebase and ping for review @kiranchandramohan @clementval

[clementval]

I think for OpenACC, this should be a simple semantic check because it is not allowed.

2.5.4
A program may not branch into or out of a compute construct.

[clementval]

We have such condition enforce in flang/lib/Semantics/check-directive-structure.h by the NoBranchingEnforce. I think STOP should follow this. Sorry I didn't think about this restriction before.

[peixin]

In D129969#4181006, @clementval wrote:

I think for OpenACC, this should be a simple semantic check because it is not allowed.

2.5.4
A program may not branch into or out of a compute construct.

As Fortran 2018 11.2, branching refers to GO TO statement. I also tried the following:

$ cat test.f90 
subroutine test_stop_in_region3()
  integer :: x
  !$acc parallel
    x = 3
    if (x > 1) stop x
  !$acc end parallel
end

$ gfortran -fopenacc -c test.f90
$ cat case.f90 
subroutine test_stop_in_region3()
  integer :: x
  !$acc parallel
    x = 3
    if (x > 1) goto 10
  !$acc end parallel
10 stop 1
end

$ gfortran -fopenacc -c case.f90
case.f90:5:22:

    5 |     if (x > 1) goto 10
      |                      ^
Error: invalid branch to/from OpenACC structured block

[peixin]

In D129969#4181028, @clementval wrote:

We have such condition enforce in flang/lib/Semantics/check-directive-structure.h by the NoBranchingEnforce. I think STOP should follow this. Sorry I didn't think about this restriction before.

I removed the semantic checks in https://reviews.llvm.org/D126471. At that time, I have tested using gfortran to confirm it should be removed. Not your fault :)

[clementval]

In D129969#4181034, @peixin wrote:

In D129969#4181028, @clementval wrote:

We have such condition enforce in flang/lib/Semantics/check-directive-structure.h by the NoBranchingEnforce. I think STOP should follow this. Sorry I didn't think about this restriction before.

I removed the semantic checks in https://reviews.llvm.org/D126471. At that time, I have tested using gfortran to confirm it should be removed. Not your fault :)

Ok fine. nvfortran also accept this.

[peixin]

In D129969#4181090, @clementval wrote:

In D129969#4181034, @peixin wrote:

In D129969#4181028, @clementval wrote:

We have such condition enforce in flang/lib/Semantics/check-directive-structure.h by the NoBranchingEnforce. I think STOP should follow this. Sorry I didn't think about this restriction before.

I removed the semantic checks in https://reviews.llvm.org/D126471. At that time, I have tested using gfortran to confirm it should be removed. Not your fault :)

Ok fine. nvfortran also accept this.

OK. Thanks for the confirm.

[kiranchandramohan]

Adding @vdonaldson also to check whether this is the right way to do this and also for the interaction with the block construct.

flang/lib/Lower/Bridge.cpp

3318

I am a bit surprised that this works. From the tests, it does work. How does it detect correctly whether the Stop is not in the final basic block for insertion of fir.unreachable?

This will have issues with the Block construct.

subroutine test_stop_in_region1()
  !$omp parallel
  block
    stop 1
  end block
  !$omp end parallel
end

For the following test, something goes wrong. Could be an existing issue.

subroutine test_stop_in_region1(x)
  integer :: x
  !$omp parallel
  if (x .gt. 1) then
    stop 1
  else
    stop 2
  end if
  !$omp end parallel
end

[peixin]

Thanks @kiranchandramohan for the provided test cases. It looks like this method is not good one.

There is FIXME in endNewFunction for dead code elimination (https://github.com/llvm/llvm-project/blob/c417266db506c2e000931c1f7a78e81879135c0d/flang/lib/Lower/Bridge.cpp#L3691-L3694). There is also SimplifyRegionLite handling DCE (https://github.com/llvm/llvm-project/blob/c417266db506c2e000931c1f7a78e81879135c0d/flang/lib/Optimizer/Transforms/SimplifyRegionLite.cpp#L37-L47). I am thinking if we should handle it in SimplifyRegionLite pass:

void SimplifyRegionLitePass::runOnOperation() {
  auto op = getOperation();
  auto regions = op->getRegions();
  mlir::RewritePatternSet patterns(op.getContext());
  DummyRewriter rewriter(op.getContext());
  if (regions.empty())
    return;

  traverse the ops in the region:
    if op is `fir.unreachable`
      if it is not in the last Basic Block of one OpenMP/OpenACC region:
        erase this `fir.unreachable`

  (void)mlir::eraseUnreachableBlocks(rewriter, regions);
  (void)mlir::runRegionDCE(rewriter, regions);
}

For now, we can do the above things in Bridge.cpp. When the FIXME is removed, the code can be moved to SimplifyRegionLite pass.

[vdonaldson]

In D129969#4182999, @kiranchandramohan wrote:

Adding @vdonaldson also to check whether this is the right way to do this and also for the interaction with the block construct.

If the problem is that an existing required omp.terminator or omp.yield op is in danger of being deleted, would it suffice to check for that in genStopStatement code? If blockIsUnterminated from Bridge.cpp were available for use in Runtime.cpp that could be done like this:

@@ -106,6 +106,7 @@ void Fortran::lower::genStopStatement(
   }

   builder.create<fir::CallOp>(loc, callee, operands);
+  if (blockIsUnterminated())
     genUnreachable(builder, loc);
 }

If that is the right idea, then blockIsUnterminated or an alternative way of getting that information must be available in Runtime.cpp.

[kiranchandramohan]

In D129969#4183536, @vdonaldson wrote:

In D129969#4182999, @kiranchandramohan wrote:

Adding @vdonaldson also to check whether this is the right way to do this and also for the interaction with the block construct.

If the problem is that an existing required omp.terminator or omp.yield op is in danger of being deleted, would it suffice to check for that in genStopStatement code? If blockIsUnterminated from Bridge.cpp were available for use in Runtime.cpp that could be done like this:

@@ -106,6 +106,7 @@ void Fortran::lower::genStopStatement(
   }

   builder.create<fir::CallOp>(loc, callee, operands);
+  if (blockIsUnterminated())
     genUnreachable(builder, loc);
 }

If that is the right idea, then blockIsUnterminated or an alternative way of getting that information must be available in Runtime.cpp.

@peixin Can you implement what Val is suggesting here? This will not fix the two examples that I have provided but will fix a lot of usages of STOP. We can handle the other cases separately.

[peixin]

In D129969#4410385, @kiranchandramohan wrote:

In D129969#4183536, @vdonaldson wrote:

In D129969#4182999, @kiranchandramohan wrote:

Adding @vdonaldson also to check whether this is the right way to do this and also for the interaction with the block construct.

If the problem is that an existing required omp.terminator or omp.yield op is in danger of being deleted, would it suffice to check for that in genStopStatement code? If blockIsUnterminated from Bridge.cpp were available for use in Runtime.cpp that could be done like this:

@@ -106,6 +106,7 @@ void Fortran::lower::genStopStatement(
   }

   builder.create<fir::CallOp>(loc, callee, operands);
+  if (blockIsUnterminated())
     genUnreachable(builder, loc);
 }

If that is the right idea, then blockIsUnterminated or an alternative way of getting that information must be available in Runtime.cpp.

@peixin Can you implement what Val is suggesting here? This will not fix the two examples that I have provided but will fix a lot of usages of STOP. We can handle the other cases separately.

I tried that. It's not working for all cases. I had planned to investigate what the problem is in the MLIR DCE optimization code, but it was stopped by other works. blockIsUnterminated() is not the condition to generate the unreachable instruction. Maybe there is something wrong in the MLIR DCE.

[kiranchandramohan]

In D129969#4412465, @peixin wrote:

In D129969#4410385, @kiranchandramohan wrote:

In D129969#4183536, @vdonaldson wrote:

In D129969#4182999, @kiranchandramohan wrote:

Adding @vdonaldson also to check whether this is the right way to do this and also for the interaction with the block construct.

If the problem is that an existing required omp.terminator or omp.yield op is in danger of being deleted, would it suffice to check for that in genStopStatement code? If blockIsUnterminated from Bridge.cpp were available for use in Runtime.cpp that could be done like this:

@@ -106,6 +106,7 @@ void Fortran::lower::genStopStatement(
   }

   builder.create<fir::CallOp>(loc, callee, operands);
+  if (blockIsUnterminated())
     genUnreachable(builder, loc);
 }

If that is the right idea, then blockIsUnterminated or an alternative way of getting that information must be available in Runtime.cpp.

@peixin Can you implement what Val is suggesting here? This will not fix the two examples that I have provided but will fix a lot of usages of STOP. We can handle the other cases separately.

I tried that. It's not working for all cases. I had planned to investigate what the problem is in the MLIR DCE optimization code, but it was stopped by other works. blockIsUnterminated() is not the condition to generate the unreachable instruction. Maybe there is something wrong in the MLIR DCE.

@peixin Could you share a testcase that shows the MLIR DCE issue and a case where the blockIsUnterminated does not work? Lack of support for STOP leads to a lot of failures in testsuites which makes categorisation of issues difficult. For an example, In a testsuite, the blockIsUnterminated() fix removed half of the crashes (~90 -> 45). Have not checked whether there are other issues.

[peixin]

@peixin Could you share a testcase that shows the MLIR DCE issue

One example is what you provided:

subroutine test_stop_in_region1(x)
  integer :: x
  !$omp parallel
  if (x .gt. 1) then
    stop 1
  else
    stop 2
  end if
  !$omp end parallel
end

These two stop statements should behave the same after DCE, but it is not for now. I guess there is something wrong in DCE.

and a case where the blockIsUnterminated does not work?

Checking blockIsUnterminated in if-else statement (the else branch) does not work, if I remeber correctly.

[kiranchandramohan]

In D129969#4413140, @peixin wrote:

@peixin Could you share a testcase that shows the MLIR DCE issue

One example is what you provided:

subroutine test_stop_in_region1(x)
  integer :: x
  !$omp parallel
  if (x .gt. 1) then
    stop 1
  else
    stop 2
  end if
  !$omp end parallel
end

These two stop statements should behave the same after DCE, but it is not for now. I guess there is something wrong in DCE.

and a case where the blockIsUnterminated does not work?

Checking blockIsUnterminated in if-else statement (the else branch) does not work, if I remeber correctly.

I see. Pasting the code with blockIsUnterminated below (without running simplifyRegions). Basically, all paths leading to the region terminator are lost due to the insertion of fir.unreachable instead of cf.br. This leads to the region terminator omp.terminator being removed in the simplifyRegions code.

@vdonaldson would you have any suggestions here?

func.func @_QPtest_stop_in_region1(%arg0: !fir.ref<i32> {fir.bindc_name = "x"}) {
  omp.parallel   {
    %0 = fir.load %arg0 : !fir.ref<i32>
    %c1_i32 = arith.constant 1 : i32
    %1 = arith.cmpi sgt, %0, %c1_i32 : i32
    cf.cond_br %1, ^bb1, ^bb3
  ^bb1:  // pred: ^bb0
    %c1_i32_0 = arith.constant 1 : i32
    %false = arith.constant false
    %false_1 = arith.constant false
    %2 = fir.call @_FortranAStopStatement(%c1_i32_0, %false, %false_1) fastmath<contract> : (i32, i1, i1) -> none
    fir.unreachable
  ^bb2:  // no predecessors
    cf.br ^bb5
  ^bb3:  // pred: ^bb0
    %c2_i32 = arith.constant 2 : i32
    %false_2 = arith.constant false
    %false_3 = arith.constant false
    %3 = fir.call @_FortranAStopStatement(%c2_i32, %false_2, %false_3) fastmath<contract> : (i32, i1, i1) -> none
    fir.unreachable
  ^bb4:  // no predecessors
    cf.br ^bb5
  ^bb5:  // 2 preds: ^bb2, ^bb4
    omp.terminator
  }
  return
}

If there is only a single if and no else then there is still path to the terminator and it works fine there.

func.func @_QPtest_stop_in_region1(%arg0: !fir.ref<i32> {fir.bindc_name = "x"}) {
  omp.parallel   {
    %0 = fir.load %arg0 : !fir.ref<i32>
    %c1_i32 = arith.constant 1 : i32
    %1 = arith.cmpi sgt, %0, %c1_i32 : i32
    cf.cond_br %1, ^bb1, ^bb3
  ^bb1:  // pred: ^bb0
    %false = arith.constant false
    %2 = fir.call @_FortranAStopStatement(%c1_i32, %false, %false) fastmath<contract> : (i32, i1, i1) -> none
    fir.unreachable
  ^bb2:  // no predecessors
    cf.br ^bb3
  ^bb3:  // 2 preds: ^bb0, ^bb2
    omp.terminator
  }
  return
}

[vdonaldson]

I see. Pasting the code with blockIsUnterminated below (without running simplifyRegions). Basically, all paths leading to the region terminator are lost due to the insertion of fir.unreachable instead of cf.br. This leads to the region terminator omp.terminator being removed in the simplifyRegions code.

It does make nominal sense to delete the omp.terminator if it can never be reached and executed.

As far as I'm aware the insertion of a fir.unreachable op is a performance choice, not a correctness choice. If that assumption holds, one possibility would be to suppress fir.unreachable ops after all STOP statements in parallel code.

if (not in OpenMP code)
  genUnreachable(builder, loc);

And as a variation on that, can there be more than one omp.terminator op? If yes, you could try changing the STOP code to

if (in OpenMP code)
  generate an omp.terminator or omp.yield op
else
  genUnreachable(builder, loc);

[kiranchandramohan]

In D129969#4414577, @vdonaldson wrote:

I see. Pasting the code with blockIsUnterminated below (without running simplifyRegions). Basically, all paths leading to the region terminator are lost due to the insertion of fir.unreachable instead of cf.br. This leads to the region terminator omp.terminator being removed in the simplifyRegions code.

It does make nominal sense to delete the omp.terminator if it can never be reached and executed.

As far as I'm aware the insertion of a fir.unreachable op is a performance choice, not a correctness choice. If that assumption holds, one possibility would be to suppress fir.unreachable ops after all STOP statements in parallel code.

if (not in OpenMP code)
  genUnreachable(builder, loc);

And as a variation on that, can there be more than one omp.terminator op? If yes, you could try changing the STOP code to

if (in OpenMP code)
  generate an omp.terminator or omp.yield op
else
  genUnreachable(builder, loc);

Thanks @vdonaldson. That sounds fine to me. Multiple OpenMP terminators are allowed. This will fix the two tests I had previously put up.

[peixin]

Thanks @vdonaldson. That sounds fine to me. Multiple OpenMP terminators are allowed. This will fix the two tests I had previously put up.

@kiranchandramohan Do you want to commandeer this revision? I am distracted by other works recently. I am afraid I don't have time to work on this patch before June 30.

[kiranchandramohan]

In D129969#4416054, @peixin wrote:

Thanks @vdonaldson. That sounds fine to me. Multiple OpenMP terminators are allowed. This will fix the two tests I had previously put up.

@kiranchandramohan Do you want to commandeer this revision? I am distracted by other works recently. I am afraid I don't have time to work on this patch before June 30.

OK. I will give this a go.

[kiranchandramohan]

Adding Peixin and Val as Co-authors and commandeering this patch. Authorship will revert to Peixin on submission.

[kiranchandramohan]

• OpenMP/OpenACC: Emit fir.unreachable only if the block is not terminated by any terminator. This avoids knocking off an existing OpenMP/OpenACC terminator.
• OpenMP: Emit the OpenMP terminator instead of fir.unreachable since OpenMP regions can only be terminated by OpenMP terminators. This is currently skipped for OpenACC since unstructured code is not yet handled specially in OpenACC lowering.

[vdonaldson]

@kiranchandramohan Looks ok to me. This should hopefully resolve all variations of this problem with little or no cost due to a "missing" unreachable op.

[peixin]

In D129969#4420425, @kiranchandramohan wrote:

Adding Peixin and Val as Co-authors and commandeering this patch. Authorship will revert to Peixin on submission.

@kiranchandramohan Thanks for this work. You can authorship this patch since you finished it. Adding me as co-author is OK to me.

LGTM except for one duplicate function definition.

flang/lib/Lower/Runtime.cpp

109–110

This is duplicate of https://github.com/llvm/llvm-project/blob/7371ec76299df6922911233bd6ee07d7629d09b6/flang/lib/Lower/Bridge.cpp#L4063-L4067. Anyway to use it？

[kiranchandramohan]

flang/lib/Lower/Runtime.cpp

109–110

I will try this in a separate patch. We will have to put it in a header so that it can be inlined.

flang/include/flang/Lower/PFTBuilder.h

 using Directives =
     std::tuple<parser::CompilerDirective, parser::OpenACCConstruct,
                parser::OpenACCDeclarativeConstruct, parser::OpenMPConstruct,
                parser::OpenMPDeclarativeConstruct, parser::OmpEndLoopDirective>;
 
 using DeclConstructs = std::tuple<parser::OpenMPDeclarativeConstruct,
                                   parser::OpenACCDeclarativeConstruct>;
 
+using OMPACCDirectives =
+    std::tuple<parser::OpenACCConstruct, parser::OpenMPConstruct>;
+
 template <typename A>
 static constexpr bool isActionStmt{common::HasMember<A, ActionStmts>};
 
 template <typename A>
 static constexpr bool isOtherStmt{common::HasMember<A, OtherStmts>};
 
 template <typename A>
 static constexpr bool isConstructStmt{common::HasMember<A, ConstructStmts>};
 
 template <typename A>
 static constexpr bool isEndStmt{common::HasMember<A, EndStmts>};
 
 template <typename A>
 static constexpr bool isConstruct{common::HasMember<A, Constructs>};
 
 template <typename A>
 static constexpr bool isDirective{common::HasMember<A, Directives>};
 
 template <typename A>
 static constexpr bool isDeclConstruct{common::HasMember<A, DeclConstructs>};
 
 template <typename A>
+static constexpr bool isOMPACCDirective{common::HasMember<A, OMPACCDirectives>};
+
+template <typename A>
 static constexpr bool isIntermediateConstructStmt{common::HasMember<
     A, std::tuple<parser::CaseStmt, parser::ElseIfStmt, parser::ElseStmt,
                   parser::SelectRankCaseStmt, parser::TypeGuardStmt>>};
 
 template <typename A>
 static constexpr bool isNopConstructStmt{common::HasMember<
     A, std::tuple<parser::CaseStmt, parser::ElseIfStmt, parser::ElseStmt,
                   parser::EndIfStmt, parser::SelectRankCaseStmt,
struct Evaluation : EvaluationVariant {
   constexpr bool isConstruct() const {
     return visit(common::visitors{
         [](auto &r) { return pft::isConstruct<std::decay_t<decltype(r)>>; }});
   }
   constexpr bool isDirective() const {
     return visit(common::visitors{
         [](auto &r) { return pft::isDirective<std::decay_t<decltype(r)>>; }});
   }
+  constexpr bool isOMPACCDirective() const {
+    return visit(common::visitors{[](auto &r) {
+      return pft::isOMPACCDirective<std::decay_t<decltype(r)>>;
+    }});
+  }
   constexpr bool isNopConstructStmt() const {
     return visit(common::visitors{[](auto &r) {
       return pft::isNopConstructStmt<std::decay_t<decltype(r)>>;
     }});
   }
   constexpr bool isExecutableDirective() const {
     return visit(common::visitors{[](auto &r) {
       return pft::isExecutableDirective<std::decay_t<decltype(r)>>;

flang/include/flang/Lower/Runtime.h

 class AbstractConverter;
 
 // Lowering of Fortran statement related runtime (other than IO and maths)
 
 void genEventPostStatement(AbstractConverter &, const parser::EventPostStmt &);
 void genEventWaitStatement(AbstractConverter &, const parser::EventWaitStmt &);
 void genLockStatement(AbstractConverter &, const parser::LockStmt &);
 void genFailImageStatement(AbstractConverter &);
-void genStopStatement(AbstractConverter &, const parser::StopStmt &);
+void genStopStatement(AbstractConverter &, const parser::StopStmt &, bool);
 void genSyncAllStatement(AbstractConverter &, const parser::SyncAllStmt &);
 void genSyncImagesStatement(AbstractConverter &,
                             const parser::SyncImagesStmt &);
 void genSyncMemoryStatement(AbstractConverter &,
                             const parser::SyncMemoryStmt &);
 void genSyncTeamStatement(AbstractConverter &, const parser::SyncTeamStmt &);
 void genUnlockStatement(AbstractConverter &, const parser::UnlockStmt &);
 void genPauseStatement(AbstractConverter &, const parser::PauseStmt &);

flang/lib/Lower/Bridge.cpp

#endif
 
   // call FAIL IMAGE in runtime
   void genFIR(const Fortran::parser::FailImageStmt &stmt) {
     genFailImageStatement(*this);
   }
 
   // call STOP, ERROR STOP in runtime
   void genFIR(const Fortran::parser::StopStmt &stmt) {
-    genStopStatement(*this, stmt);
+    bool hasAttachedUnreachable =
+        !getEval().parentConstruct ||
+        !getEval().parentConstruct->isOMPACCDirective();
+    genStopStatement(*this, stmt, hasAttachedUnreachable);
   }
 
   void genFIR(const Fortran::parser::ReturnStmt &stmt) {
     Fortran::lower::pft::FunctionLikeUnit *funit =
         getEval().getOwningProcedure();
     assert(funit && "not inside main program, function or subroutine");
     for (auto it = activeConstructStack.rbegin(),
               rend = activeConstructStack.rend();

flang/lib/Lower/Runtime.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // Misc. Fortran statements that lower to runtime calls
 //===----------------------------------------------------------------------===//
 
 void Fortran::lower::genStopStatement(
     Fortran::lower::AbstractConverter &converter,
-    const Fortran::parser::StopStmt &stmt) {
+    const Fortran::parser::StopStmt &stmt, bool hasAttachedUnreachable = true) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   mlir::Location loc = converter.getCurrentLocation();
   Fortran::lower::StatementContext stmtCtx;
   llvm::SmallVector<mlir::Value> operands;
   mlir::func::FuncOp callee;
   mlir::FunctionType calleeType;
   // First operand is stop code (zero if absent)
   if (const auto &code =
if (const auto &quiet =
     operands.push_back(
         builder.createConvert(loc, calleeType.getInput(operands.size()), q));
   } else {
     operands.push_back(builder.createIntegerConstant(
         loc, calleeType.getInput(operands.size()), 0));
   }
 
   builder.create<fir::CallOp>(loc, callee, operands);
+  if (hasAttachedUnreachable)
     genUnreachable(builder, loc);
 }
 
 void Fortran::lower::genFailImageStatement(
     Fortran::lower::AbstractConverter &converter) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   mlir::Location loc = converter.getCurrentLocation();
   mlir::func::FuncOp callee =
       fir::runtime::getRuntimeFunc<mkRTKey(FailImageStatement)>(loc, builder);

flang/test/Lower/OpenACC/stop-stmt-in-region.f90

+! This test checks lowering of stop statement in OpenACC region.
+
+! RUN: bbc -fopenacc -emit-fir %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-fir -fopenacc %s -o - | FileCheck %s
+
+! CHECK-LABEL: func.func @_QPtest_stop_in_region1() {
+! CHECK:         acc.parallel {
+! CHECK:           %[[VAL_0:.*]] = arith.constant 1 : i32
+! CHECK:           %[[VAL_1:.*]] = arith.constant false
+! CHECK:           %[[VAL_2:.*]] = arith.constant false
+! CHECK:           %[[VAL_3:.*]] = fir.call @_FortranAStopStatement(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {{.*}} : (i32, i1, i1) -> none
+! CHECK:           acc.yield
+! CHECK:         }
+! CHECK:         return
+! CHECK:       }
+
+subroutine test_stop_in_region1()
+  !$acc parallel
+    stop 1
+  !$acc end parallel
+end
+
+! CHECK-LABEL: func.func @_QPtest_stop_in_region2() {
+! CHECK:         %[[VAL_0:.*]] = fir.alloca i32 {bindc_name = "x", uniq_name = "_QFtest_stop_in_region2Ex"}
+! CHECK:         acc.parallel {
+! CHECK:           %[[VAL_1:.*]] = arith.constant 1 : i32
+! CHECK:           %[[VAL_2:.*]] = arith.constant false
+! CHECK:           %[[VAL_3:.*]] = arith.constant false
+! CHECK:           %[[VAL_4:.*]] = fir.call @_FortranAStopStatement(%[[VAL_1]], %[[VAL_2]], %[[VAL_3]]) {{.*}} : (i32, i1, i1) -> none
+! CHECK:           acc.yield
+! CHECK:         }
+! CHECK:         return
+! CHECK:       }
+
+subroutine test_stop_in_region2()
+  integer :: x
+  !$acc parallel
+    stop 1
+    x = 2
+  !$acc end parallel
+end

flang/test/Lower/OpenMP/stop-stmt-in-region.f90

+! This test checks lowering of stop statement in OpenMP region.
+
+! RUN: bbc -fopenmp -emit-fir %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-fir -fopenmp %s -o - | FileCheck %s
+
+! CHECK-LABEL: func.func @_QPtest_stop_in_region1() {
+! CHECK:         omp.parallel   {
+! CHECK:           %[[VAL_0:.*]] = arith.constant 1 : i32
+! CHECK:           %[[VAL_1:.*]] = arith.constant false
+! CHECK:           %[[VAL_2:.*]] = arith.constant false
+! CHECK:           %[[VAL_3:.*]] = fir.call @_FortranAStopStatement(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {{.*}} : (i32, i1, i1) -> none
+! CHECK-NOT:       fir.unreachable
+! CHECK:           omp.terminator
+! CHECK:         }
+! CHECK:         return
+! CHECK:       }
+
+subroutine test_stop_in_region1()
+  !$omp parallel
+    stop 1
+  !$omp end parallel
+end
+
+! CHECK-LABEL: func.func @_QPtest_stop_in_region2() {
+! CHECK:         %[[VAL_0:.*]] = fir.alloca i32 {bindc_name = "x", uniq_name = "_QFtest_stop_in_region2Ex"}
+! CHECK:         omp.parallel   {
+! CHECK:           %[[VAL_1:.*]] = arith.constant 1 : i32
+! CHECK:           %[[VAL_2:.*]] = arith.constant false
+! CHECK:           %[[VAL_3:.*]] = arith.constant false
+! CHECK:           %[[VAL_4:.*]] = fir.call @_FortranAStopStatement(%[[VAL_1]], %[[VAL_2]], %[[VAL_3]]) {{.*}} : (i32, i1, i1) -> none
+! CHECK-NOT:       fir.unreachable
+! CHECK:           cf.br ^bb1
+! CHECK:         ^bb1:
+! CHECK:           %[[VAL_5:.*]] = arith.constant 2 : i32
+! CHECK:           fir.store %[[VAL_5]] to %[[VAL_0]] : !fir.ref<i32>
+! CHECK:           omp.terminator
+! CHECK:         }
+! CHECK:         return
+! CHECK:       }
+
+subroutine test_stop_in_region2()
+  integer :: x
+  !$omp parallel
+    stop 1
+    x = 2
+  !$omp end parallel
+end
+
+! CHECK-LABEL: func.func @_QPtest_stop_in_region3() {
+! CHECK:         %[[VAL_0:.*]] = fir.alloca i32 {bindc_name = "x", uniq_name = "_QFtest_stop_in_region3Ex"}
+! CHECK:         omp.parallel   {
+! CHECK:           %[[VAL_1:.*]] = arith.constant 3 : i32
+! CHECK:           fir.store %[[VAL_1]] to %[[VAL_0]] : !fir.ref<i32>
+! CHECK:           %[[VAL_2:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32>
+! CHECK:           %[[VAL_3:.*]] = arith.constant 1 : i32
+! CHECK:           %[[VAL_4:.*]] = arith.cmpi sgt, %[[VAL_2]], %[[VAL_3]] : i32
+! CHECK:           cf.cond_br %[[VAL_4]], ^bb1, ^bb2
+! CHECK:         ^bb1:
+! CHECK:           %[[VAL_5:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32>
+! CHECK:           %[[VAL_6:.*]] = arith.constant false
+! CHECK:           %[[VAL_7:.*]] = arith.constant false
+! CHECK:           %[[VAL_8:.*]] = fir.call @_FortranAStopStatement(%[[VAL_5]], %[[VAL_6]], %[[VAL_7]]) {{.*}} : (i32, i1, i1) -> none
+! CHECK:           fir.unreachable
+! CHECK:         ^bb2:
+! CHECK:           omp.terminator
+! CHECK:         }
+! CHECK:         return
+! CHECK:       }
+
+subroutine test_stop_in_region3()
+  integer :: x
+  !$omp parallel
+    x = 3
+    if (x > 1) stop x
+  !$omp end parallel
+end
+
+! CHECK-LABEL: func.func @_QPtest_stop_in_region4() {
+! CHECK:         %[[VAL_0:.*]] = fir.alloca i32 {adapt.valuebyref}
+! CHECK:         %[[VAL_1:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFtest_stop_in_region4Ei"}
+! CHECK:         %[[VAL_2:.*]] = fir.alloca i32 {bindc_name = "x", uniq_name = "_QFtest_stop_in_region4Ex"}
+! CHECK:         %[[VAL_3:.*]] = arith.constant 1 : i32
+! CHECK:         %[[VAL_4:.*]] = arith.constant 10 : i32
+! CHECK:         %[[VAL_5:.*]] = arith.constant 1 : i32
+! CHECK:         omp.wsloop   for  (%[[VAL_6:.*]]) : i32 = (%[[VAL_3]]) to (%[[VAL_4]]) inclusive step (%[[VAL_5]]) {
+! CHECK:           fir.store %[[VAL_6]] to %[[VAL_0]] : !fir.ref<i32>
+! CHECK:           cf.br ^bb1
+! CHECK:         ^bb1:
+! CHECK:           %[[VAL_7:.*]] = arith.constant 3 : i32
+! CHECK:           fir.store %[[VAL_7]] to %[[VAL_2]] : !fir.ref<i32>
+! CHECK:           %[[VAL_8:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
+! CHECK:           %[[VAL_9:.*]] = arith.constant 1 : i32
+! CHECK:           %[[VAL_10:.*]] = arith.cmpi sgt, %[[VAL_8]], %[[VAL_9]] : i32
+! CHECK:           cf.cond_br %[[VAL_10]], ^bb2, ^bb3
+! CHECK:         ^bb2:
+! CHECK:           %[[VAL_11:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
+! CHECK:           %[[VAL_12:.*]] = arith.constant false
+! CHECK:           %[[VAL_13:.*]] = arith.constant false
+! CHECK:           %[[VAL_14:.*]] = fir.call @_FortranAStopStatement(%[[VAL_11]], %[[VAL_12]], %[[VAL_13]]) {{.*}} : (i32, i1, i1) -> none
+! CHECK:           fir.unreachable
+! CHECK:         ^bb3:
+! CHECK:           omp.yield
+! CHECK:         }
+! CHECK:         cf.br ^bb1
+! CHECK:       ^bb1:
+! CHECK:         return
+! CHECK:       }
+
+subroutine test_stop_in_region4()
+  integer :: x
+  !$omp do
+  do i = 1, 10
+    x = 3
+    if (x > 1) stop x
+  enddo
+  !$omp end do
+end