Add null/array checks for OffHeap NotStaticField atomic case

[rmnattas]

When current code transforms an atomic call from the java/util/concurrent/atomic/ package into an intrinsic, it skips generating the static check given that it's known to not be a static field being accessed (flagged by isNotStaticField). But with OffHeap a null and array checks are still required to check if loading the dataAddrPtr is necessary for correct address calculation.

Current code adds the OffHeap checks except for java/util/concurrent/atomic/ calls which was fine in some JDK levels as it uses VarHandles but for JDK8 it still uses processUnsafeAtomicCall() and without the OffHeap check its targeting the wrong address.

This PR adds inserting the OffHeap null and array checks to the isNotStaticField case.
I tried sharing some code between the case with and without isNotStaticField but some are copied over as it would need a larger re-write of processUnsafeAtomicCall()

[rmnattas]

fyi @zl-wang @midronij

[zl-wang]

at least, this example seemed contradictory to the setting of isNotStaticField (i.e. definitely true if it is an atomic call ... this example is under isNotStaticField being false). overdoing something here? plus, it sounded like an existing bug for gencon anyway? (previously, it needs to handle ramStatics too).

[rmnattas]

That part is moved not added, I guess its confusing given that the other code between the if-condition and that comment have moved out to a shared path. But the comment only talks about the subsequent section of code.
https://github.com/eclipse-openj9/openj9/blob/v0.49.0-release/runtime/compiler/optimizer/J9RecognizedCallTransformer.cpp#L774-L808
I'll try to clean-up the code more making it less-confusing.

[zl-wang]

i still had impression i reviewed @midronij fix for off-heap in this very area ... i think it was merged. could it be in omr side instead? remember she worked on fixing fetchAndAdd for off-heap (i haven't searched the history yet).

[midronij]

@zl-wang I believe this is the PR you're referring to: #20333

Maybe Abdul can confirm if this is the case, but from what I can tell at least, I think the issue is that my changes linked above only take effect when isNotStaticField is false. They assume that if the object is known to be a non-static field at compile time, that no further checks are necessary. This works for gencon, since there are only two possible ways that the address is calculated:

1. Object is a static field: address = ramStaticsFromClass + (offset & ~mask)
2. Object is a non-static field: address = object base address + offset

So in the case where it is known at compile time that the object is NOT a static field (i.e.: isNotStaticField == true), we don't need to perform any runtime checks.

However, offheap adds a third case: if the object is a non-NULL array, then address = dataAddr + offset. So even if isNotStaticField is true, we still need to perform array and NULL checks to determine how the address should be calculated (i.e.: whether we need to load dataAddr or not).

[rmnattas]

Yes, the issue is with isNotStaticField being true in an OffHeap case.

It seems that it wasn't an issue as isNotStaticField is true for classes under java.util.concurrent.atomic which uses VarHandle in JDK11+, but in JDK8 it still uses the unsafe.getAndAdd.