← Back to context Comment by pizlonator 3 hours ago Yeah 4 comments pizlonator Reply amluto 3 hours ago It sounds technically possible to build a JIT where a verifier checks that the JIT-generated code is correctly pizlonated before allowing it to become executable. :) Ohentis 2 hours ago I think it makes more sense to verify that the jit is correct than to verify that it's output is correct at runtime. pizlonator 2 hours ago NahIt's damn near impossible to verify that the JIT is correct.But it is possible to verify at runtime that the code that the JIT emitted obeys some memory safety law.(V8's heap sandbox is an example of this; a sarcastic JIT would be an arguably stronger example of this.) pizlonator 2 hours ago YesI have a new tech called SaRCAsm, which is a memory-safe assembler. So the next step is a "Sarcastic JIT" :-)
amluto 3 hours ago It sounds technically possible to build a JIT where a verifier checks that the JIT-generated code is correctly pizlonated before allowing it to become executable. :) Ohentis 2 hours ago I think it makes more sense to verify that the jit is correct than to verify that it's output is correct at runtime. pizlonator 2 hours ago NahIt's damn near impossible to verify that the JIT is correct.But it is possible to verify at runtime that the code that the JIT emitted obeys some memory safety law.(V8's heap sandbox is an example of this; a sarcastic JIT would be an arguably stronger example of this.) pizlonator 2 hours ago YesI have a new tech called SaRCAsm, which is a memory-safe assembler. So the next step is a "Sarcastic JIT" :-)
Ohentis 2 hours ago I think it makes more sense to verify that the jit is correct than to verify that it's output is correct at runtime. pizlonator 2 hours ago NahIt's damn near impossible to verify that the JIT is correct.But it is possible to verify at runtime that the code that the JIT emitted obeys some memory safety law.(V8's heap sandbox is an example of this; a sarcastic JIT would be an arguably stronger example of this.)
pizlonator 2 hours ago NahIt's damn near impossible to verify that the JIT is correct.But it is possible to verify at runtime that the code that the JIT emitted obeys some memory safety law.(V8's heap sandbox is an example of this; a sarcastic JIT would be an arguably stronger example of this.)
pizlonator 2 hours ago YesI have a new tech called SaRCAsm, which is a memory-safe assembler. So the next step is a "Sarcastic JIT" :-)
It sounds technically possible to build a JIT where a verifier checks that the JIT-generated code is correctly pizlonated before allowing it to become executable. :)
I think it makes more sense to verify that the jit is correct than to verify that it's output is correct at runtime.
Nah
It's damn near impossible to verify that the JIT is correct.
But it is possible to verify at runtime that the code that the JIT emitted obeys some memory safety law.
(V8's heap sandbox is an example of this; a sarcastic JIT would be an arguably stronger example of this.)
Yes
I have a new tech called SaRCAsm, which is a memory-safe assembler. So the next step is a "Sarcastic JIT" :-)