Java bytecode as a typed term calculus

Science of Computer Programming

2004

Self Cite

This paper presents a proof-theoretical framework that accounts for the entire process of register allocation-liveness analysis is proof reconstruction (similar to type inference), and register allocation is proof transformation from a proof system with unrestricted variable accesses to a proof system with restricted variable access. In our framework, the set of registers acts as a "working set" of the live variables at each instruction step, which changes during the execution of the code. This eliminates the ad hoc notion of "spilling". Memory-register moves are systematically incorporated in our proof transformation process. Its correctness is a direct corollary of our construction; the resulting proof is equivalent to the proof of the original code modulo treatment of structural rules. The framework serves as a basis for reasoning about formal properties of register allocation process, and it also yields a clean and systematic register allocation algorithm. The algorithm has been implemented, demonstrating the feasibility of the framework.

Section: Conclusion and Discussionmentioning

confidence: 99%

Register allocation by proof transformation

Science of Computer Programming

2004

Self Cite

“…The general idea underlying the logical abstract machine developed in this paper can be applied to various other code languages, yielding their static type systems. As an example, in [Higuchi and Ohori 2002], a type system for the Java bytecode language has been developed by extending the stack-based logical abstract machine with jumps and the primitives to manipulate objects. This would provide an alternative basis for bytecode verification.…”

Section: -Analysis Of Low-level Codementioning

confidence: 99%

“…Since the underlying constructive interpretation is similar to the one that underlies the typed lambda calculus, this approach would also allow one to transfer some results of type-based analysis for the lambda calculus to low-level code languages. Recently, it has been shown in [Higuchi and Ohori 2003] that the static verification of access control for the lambda calculus by Skalka and Smith [2000] can be transfered to the Java bytecode language by refining the type system of [Higuchi and Ohori 2002]. …”

Section: -Analysis Of Low-level Codementioning

confidence: 99%

“…In addition to these rigorous logical correspondences, the obtained type system captures the properties of low-level code in a direct and natural manner · 3 so that it can be applied to various code languages. For example, this framework has already been successfully used for register allocation by proof transformation [Ohori 2004], the development of a type system of Java bytecode [Higuchi and Ohori 2002], proof-directed de-compilation of Java bytecode [Katsumata and Ohori 2001], and static access control for Java bytecode [Higuchi and Ohori 2003]. …”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

A proof theory for machine code

ACM Trans. Program. Lang. Syst.

2007

Self Cite

This paper develops a proof theory for low-level code languages. We first define a proof system, which we refer to as the sequential sequent calculus, and show that it enjoys the cut elimination property and that its expressive power is the same as that of the natural deduction proof system. We then establish the Curry-Howard isomorphism between this proof system and a low-level code language by showing the following properties: (1) the set of proofs and the set of typed codes is in one-to-one correspondence, (2) the operational semantics of the code language is directly derived from the cut elimination procedure of the proof system, and (3) compilation and de-compilation algorithms between the code language and the typed lambda calculus are extracted from the proof transformations between the sequential sequent calculus and the natural deduction proof system. This logical framework serves as a basis for the development of type systems of various low-level code languages, type-preserving compilation, and static code analysis.

“…We base our development on our earlier work [Higuchi and Ohori 2002], in which we have shown that the JVM language can be regarded as a typed term calculus based on a proof theory for low-level code [Ohori 1999]. In this formalism, the type system represents static semantics of a code language, just as the type system of the lambda calculus does.…”

Section: Introductionmentioning

confidence: 99%

A static type system for JVM access control

Higuchi

ACM Trans. Program. Lang. Syst.

2007

Self Cite

This article presents a static type system for the Java virtual machine (JVM) code that enforces an access control mechanism similar to that found in a Java implementation. In addition to verifying type consistency of a given JVM code, the type system statically verifies whether the code accesses only those resources that are granted by the prescribed access policy. The type system is proved to be sound with respect to an operational semantics that enforces access control dynamically, similar to Java stack inspection. This result ensures that "well-typed code cannot violate access policy." The authors then develop a type inference algorithm and show that it is sound with respect to the type system. These results allow us to develop a static system for JVM access control, without resorting to costly runtime stack inspection. ACM Reference Format:Higuchi, T. and Ohori, A. 2007. A static type system for JVM access control.