stewSquared
commented
1 year ago Here's some prototype target code @smarter paired with me to write:
```java
/*
* Decompiled with CFR 0.152.
*
* Could not load the following classes:
* scala.runtime.LazyVals$
*/
import scala.runtime.LazyVals$;
import java.lang.invoke.VarHandle;
import java.lang.invoke.MethodHandles;
/*
* Illegal identifiers - consider using --renameillegalidents true
*/
public class Decompiled {
// public static final long OFFSET$0 = LazyVals$.MODULE$.getOffsetStatic(LazyVal.package.Foo.1.class.getDeclaredField("bitmap$1"));
// get a varhandle instead of an offset
private static final VarHandle handle;
static {
try {
MethodHandles.Lookup l = MethodHandles.lookup();
handle = l.findVarHandle(Decompiled.class, "bitmap$1", long.class);
} catch (ReflectiveOperationException e) {
throw new ExceptionInInitializerError(e);
}
}
public long bitmap$1;
public int value$lzy1;
static final long LAZY_VAL_MASK = 3;
static final long BITS_PER_LAZY_VAL = 2;
public long casHelper(long current, long newState, int ord) {
long mask = ~(LAZY_VAL_MASK << ord * BITS_PER_LAZY_VAL);
return (current & mask) | (newState << (ord * BITS_PER_LAZY_VAL));
}
private boolean CAS(Object t, long current, long newState, int ord) {
return handle.compareAndSet(t, current, casHelper(current, newState, ord));
}
public static void setFlag(Object t, int v, int ord) {
boolean retry = true;
while (retry) {
long cur = handle.getVolatile(t);
if (LazyVals$.MODULE$.STATE(cur, ord) == 1)
retry = !CAS(t, cur, v, ord);
else {
// cur == 2, somebody is waiting on monitor
if (CAS(t, cur, v, ord)) {
Class clazz = LazyVals$.class;
var privateMethod = clazz.getDeclaredMethod("getMonitor", Object.class, int.class);
privateMethod.setAccessible(true);
Object monitor = privateMethod.invokew(LazyVals$.MODULE$, t, ord);
synchronized (monitor) {
monitor.notifyAll();
}
retry = false;
}
}
}
}
public static void wait4Notification(Object t, long cur, int ord) {
boolean retry = true;
while (retry) {
long current = handle.getVolatile(t);
int state = LazyVals$.MODULE$.STATE(current, ord);
if (state == 1)
CAS(t, current, 2, ord);
else if (state == 2) {
Class clazz = LazyVals$.class;
var privateMethod = clazz.getDeclaredMethod("getMonitor", Object.class, int.class);
privateMethod.setAccessible(true);
Object monitor = privateMethod.invokew(LazyVals$.MODULE$, t, ord);
synchronized (monitor) {
if (LazyVal$.MODULE$.STATE(handle.getVolatile(t), ord) == 2) // make sure notification did not happen yet.
monitor.wait();
}
} else {
retry = false;
}
}
}
public int value() {
long l;
long l2;
while ((l2 = LazyVals$.MODULE$.STATE(l = handle.getVolatile(this), 0)) != 3L) {
if (l2 == 0L) {
if (!handle.compareAndSet(this, l, casHelper(l, 1, 0))) continue;
try {
int n;
this.value$lzy1 = n = 13;
handle.
setFlag((Object)this, 3, 0);
return n;
}
catch (Throwable throwable) {
setFlag((Object)this, 0, 0);
throw throwable;
}
}
wait4Notification((Object)this, l, 0);
}
return this.value$lzy1;
}
}
```
reid-spencer
alexklibisz
SethTisue
Gedochao
bishabosha
Currently, any usage of a lazy val requires getitng an instance of sun.misc.Unsafe at runtime: https://github.com/lampepfl/dotty/blob/43e4bfa5598e9cdbebb1dc56ed25a319d5aa8fbe/library/src/dotty/runtime/LazyVals.scala#L7 which is problematic for various reasons (e.g. usage of a security manager, using Graal Native (https://github.com/lampepfl/dotty/issues/13985)).
On Java 8, there's no good alternative, but on Java 9+ we should be able to replace that using VarHandle.
We should be able to use the same trick used in scala.runtime.Statics to check once at runtime if VarHandle is available to stay compatible with Java 8: https://github.com/scala/scala/blob/a8a726118d06c90b5506f907b1524457c0d401a7/src/library/scala/runtime/Statics.java#L158-L173(EDIT: actually I don't think this is good enough: using VarHandle would require adding static fields in any class that has a lazy val, so we need to know at compile-time the version of Java we support (via -release/-Xtarget)