[flang] [llvm] [flang][llvm][OpenMP][OpenACC] Add implicit casts to omp.atomic and acc.atomic (PR #131603)

[Tom Eccles via llvm-commits]

================
@@ -386,6 +442,7 @@ void genOmpAccAtomicRead(Fortran::lower::AbstractConverter &converter,
       fir::getBase(converter.genExprAddr(fromExpr, stmtCtx));
   mlir::Value toAddress = fir::getBase(converter.genExprAddr(
       *Fortran::semantics::GetExpr(assignmentStmtVariable), stmtCtx));
+  emitImplicitCast(converter, loc, fromAddress, toAddress, elementType);
----------------
tblah wrote:

If we imagine some IR requiring implicit casts like this:
```
%i64 = fir.alloca i64
%i32 = fir.alloca i32

// !$omp atomic capture
//   old_val = counter
//   counter = counter + 1
// !$omp end atomic

omp.atomic.capture {
  omp.atomic.read %i32 = %i64 : !fir.ref<i32>, !fir.ref<i64>, i64
  omp.atomic.update %i64 : !fir.ref<i64> {
  ^bb0(%arg0: i64):
    %c1_i64 = arith.constant 1 : i64
    %4 = arith.addi %arg0, %c1_i64 : i64
    omp.yield(%4 : i64)
  }
}
```

The references to %i64 have to stay the same because this is the variable which must be atomically accessed. I think in this case we need to add a new i64 local temporary to perform the atomic access into, and then non-atomically update the intended local result. E.g.

```
%i64 = fir.alloca i64
%tmp = fir.alloca i64
%i32 = fir.alloca i32

// !$omp atomic capture
//   old_val = counter
//   counter = counter + 1
// !$omp end atomic

omp.atomic.capture {
  omp.atomic.read %tmp = %i64 : !fir.ref<i64>, !fir.ref<i64>, i64
  omp.atomic.update %i64 : !fir.ref<i64> {
  ^bb0(%arg0: i64):
    %c1_i64 = arith.constant 1 : i64
    %4 = arith.addi %arg0, %c1_i64 : i64
    omp.yield(%4 : i64)
  }
}

%load = fir.load %tmp : i64
%convert = fir.convert %load to i32 : (i64) -> i32
fir.store %convert to %i32
```

Overall it is probably simpler not to allow atomic operations with different types between the arguments at all. This might not be possible in the IR verifier because the OpenMP dialect doesn't understand fir types and we might want to allow different pointer types like !fir.ref<T> and !fir.heap<T> to be used together.

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