Home/ Questions/Q 8906367
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-06-15T02:38:08+00:00

There are some languages that support a sufficiently powerful type system that they can

  • 0

There are some languages that support a sufficiently powerful type system that they can prove at compile time that the code does not address an array outside its bounds. My question is that if we were to compile such a language to the JVM, is there some way we could take advantage of that for performance and remove the array bounds checks that occur on every array access?

1) I know that recent JDK supports some array bound check elimination, but since I know at compile time that certain calls are safe, I could remove a lot more safely.

2) Some might think this doesn’t affect performance much but it most certainly does, especially in array/computation heavy applications such as scientific computing.

The same question regarding casting. I know something is a certain type, but Java doesn’t because its limited type system. Is there some way to just tell the JVM to “trust me” and skip any checks?

I realize there is probably no way to do this as the JVM is generally distributed, could it be reasonable to modify a JVM with this feature? Is this something that has been done?

It’s one of the frustrations in compiling a more powerfully typed language to the JVM, it still is hampered by Java’s limitations.

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    In principle this cannot be done in a safe fashion without a proof-carrying code (PCC) infrastructure. PCC would allow you to embed your reasoning of safety in the class file. Your embedded proof is checked at class-loading time. The class is not loaded if there is a flaw in the proof.

    If the JVM ever allowed you to drop runtime checks without requiring a formal proof, then, as SecurityMatt put it, it would defeat the original philosophy of Java as a safe platform.

    The JVM uses a special form of PCC for type-checking local variables in a method. All local variable typing info is used by the class-loading mechanism to check its correctness, but discarded after that. But that’s the only instance of PCC concepts used in the JVM. As far as I know there is no general PCC infrastructure for the JVM.

    I once heard one existed for the JavaCard platform which supports a small subset of Java. I am not sure if that can be helpful in your problem though.

    • 0