[flang-commits] [flang] [flang][OpenMP] Fix construct privatization in default clause (PR #72510)

[via flang-commits]

NimishMishra wrote:

Thanks @luporl. Yeah, I think recursion is the best way to go forward. I made the required changes for a recursive solution, and for the following:

```
program main
      integer :: y, z
      !$omp parallel default(private) firstprivate(y)
      do i = 1, 10 
            y = 1
            do j = 1, 10
            z = 20
            !$omp parallel default(private)
                y = 2
            !$omp end parallel
            end do
        end do
      !$omp end parallel 
end program
```

I have the following FIR:

```
%0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFEi"}
    %1 = fir.declare %0 {uniq_name = "_QFEi"} : (!fir.ref<i32>) -> !fir.ref<i32>
    %2 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFEj"}
    %3 = fir.declare %2 {uniq_name = "_QFEj"} : (!fir.ref<i32>) -> !fir.ref<i32>
    %4 = fir.alloca i32 {bindc_name = "y", uniq_name = "_QFEy"}
    %5 = fir.declare %4 {uniq_name = "_QFEy"} : (!fir.ref<i32>) -> !fir.ref<i32>
    %6 = fir.alloca i32 {bindc_name = "z", uniq_name = "_QFEz"}
    %7 = fir.declare %6 {uniq_name = "_QFEz"} : (!fir.ref<i32>) -> !fir.ref<i32>
    omp.parallel {
      %8 = fir.alloca i32 {bindc_name = "j", pinned}
      %9 = fir.declare %8 {uniq_name = "_QFEj"} : (!fir.ref<i32>) -> !fir.ref<i32>
      %10 = fir.alloca i32 {bindc_name = "i", pinned}
      %11 = fir.declare %10 {uniq_name = "_QFEi"} : (!fir.ref<i32>) -> !fir.ref<i32>
      %12 = fir.alloca i32 {bindc_name = "y", pinned, uniq_name = "_QFEy"}
      %13 = fir.declare %12 {uniq_name = "_QFEy"} : (!fir.ref<i32>) -> !fir.ref<i32>
      %14 = fir.load %5 : !fir.ref<i32>
      fir.store %14 to %13 : !fir.ref<i32>
      %15 = fir.alloca i32 {bindc_name = "z", pinned, uniq_name = "_QFEz"}
      %16 = fir.declare %15 {uniq_name = "_QFEz"} : (!fir.ref<i32>) -> !fir.ref<i32>
      %17 = fir.convert %c1_i32 : (i32) -> index
      %18 = fir.convert %c10_i32 : (i32) -> index
      %19 = fir.convert %17 : (index) -> i32
      %20:2 = fir.do_loop %arg0 = %17 to %18 step %c1 iter_args(%arg1 = %19) -> (index, i32) {
        fir.store %arg1 to %11 : !fir.ref<i32>
        fir.store %c1_i32 to %13 : !fir.ref<i32>
        %21 = fir.convert %c1_i32 : (i32) -> index
        %22 = fir.convert %c10_i32 : (i32) -> index
        %23 = fir.convert %21 : (index) -> i32
        %24:2 = fir.do_loop %arg2 = %21 to %22 step %c1 iter_args(%arg3 = %23) -> (index, i32) {
          fir.store %arg3 to %9 : !fir.ref<i32>
          fir.store %c20_i32 to %16 : !fir.ref<i32>
          omp.parallel {
            %33 = fir.alloca i32 {bindc_name = "y", pinned, uniq_name = "_QFEy"}
            %34 = fir.declare %33 {uniq_name = "_QFEy"} : (!fir.ref<i32>) -> !fir.ref<i32>
            fir.store %c2_i32 to %34 : !fir.ref<i32>
            omp.terminator
          }
          %29 = arith.addi %arg2, %c1 : index
          %30 = fir.convert %c1 : (index) -> i32
          %31 = fir.load %9 : !fir.ref<i32>
          %32 = arith.addi %31, %30 : i32
          fir.result %29, %32 : index, i32
        }
        fir.store %24#1 to %9 : !fir.ref<i32>
        %25 = arith.addi %arg0, %c1 : index
        %26 = fir.convert %c1 : (index) -> i32
        %27 = fir.load %11 : !fir.ref<i32>
        %28 = arith.addi %27, %26 : i32
        fir.result %25, %28 : index, i32
      }
      fir.store %20#1 to %11 : !fir.ref<i32>
      omp.terminator
```

The behaviour of the IR seems fine to me. Is it okay with you? I'll push the revision thereafter.

https://github.com/llvm/llvm-project/pull/72510