A type system for Java bytecode subroutines

@article{Stata1999ATS,
  title={A type system for Java bytecode subroutines},
  author={Raymie Stata and Mart{\'i}n Abadi},
  journal={ACM Trans. Program. Lang. Syst.},
  year={1999},
  volume={21},
  pages={90-137}
}
Java is typically compiled into an intermediate language, JVML, that is interpreted by the Java Virtual Machine. Because mobile JVML code is not always trusted, a bytecode verifier enforces static constraints that prevent various dynamic errors. Given the importance of the bytecode verifier for security, its current descriptions are inadequate. This article proposes using typing rules to describe the bytecode verifier because they are more precise than prose, clearer than code, and easier to… 

Type-based Information Flow Analysis for a Low-level Language

Taking a subset of the Java virtual machine language as a target language, this research formalizes a type system for information flow analysis and implements an information flow analyzer based on the type system.

A New Type System for JVM Lock Primitives

A prototype Java bytecode verifier is implemented based on Stata and Abadi's type system for JVML by augmenting types with information about how each object is locked and unlocked, which guarantees that when a thread terminates, it has released all the locks it has acquired.

Java Bytecode Verification: Algorithms and Formalizations

  • X. Leroy
  • Computer Science
    Journal of Automated Reasoning
  • 2004
This paper reviews the various bytecode verification algorithms that have been proposed, recasts them in a common framework of dataflow analysis, and surveys the use of proof assistants to specifybytecode verification and prove its correctness.

Type-Based Information Analysis for Low-Level Languages

Proof-Directed De-compilation of Java Bytecode

We present a proof system for the Java bytecode language based on a Curry-Howard isomorphism for machine code, where an executable code is regarded as a proof of a variant of a sequent calculus of

Run-time bytecode specialization: A portable approach to generating optimized specialized code

It is observed that the overall performance of the application can be improved and that a non-trivial application program specialized at run-time by BCS runs approximately 3-4 times faster than the unspecialized one.

Standard fixpoint iteration for Java bytecode verification

A chaotic fixpoint iteration is presented, which represents a family of fixpoint computation strategies to compute a least type for each JVM program within a finite number of iteration steps.

A type system for object initialization in the Java bytecode language

For this subset of the bytecode language dealing with object creation and initialization, it is proved, that, for every Java bytecode program that satisfies the authors' typing constraints, every object is initialized before it is used.

The Fox Project: Advanced Language Technology for Extensible Systems

This project is working to demonstrate the viability and benefits of advanced languages for programming real world systems, and in particular Active Networks, by organized the research into the areas of language technology, safety infrastructure, compiler technology, and applications.

A specification of Java loading and bytecode verification

The approach is to specify a generic dataflow architecture and formalize the JVM verifier as an instance of this architecture, and focuses on the use of data flow analysis and typing contexts to insure global type consistency in the context of an arbitrary strategy for dynamic class loading.
...

References

SHOWING 1-10 OF 39 REFERENCES

The Java Virtual Machine Specification

This second edition specifies the newest version of the Java virtual machine and provides a fascinating view into the inner workings of theJava 2 platform.

Phd by thesis

  • R. Lathe
  • Geography, Environmental Science
    Nature
  • 1988
Deposits of clastic carbonate-dominated (calciclastic) sedimentary slope systems in the rock record have been identified mostly as linearly-consistent carbonate apron deposits, even though most

A Formal Specification of Java Virtual Machine Instructions for Objects, Methods and Subrountines

  • Zhenyu Qian
  • Computer Science
    Formal Syntax and Semantics of Java
  • 1999
This chapter formally specify a subset of Java Virtual Machine instructions for objects, methods and subroutines based on the official JVM Specification, the official Java Language Specification and Sun's JDK 1.1.4 implementation of the JVM so that if a JVM program is statically well-typed with respect to the typing system, then the runtime data of the program will be type-correct.

Javalight is type-safe—definitely

This paper demonstrates that machine-checking the design of non-trivial programming languages has become a reality and can express and prove type soundness.

On a New Method for Dataflow Analysis of Java Virtual Machine Subroutines

This paper presents yet another type system for Java Virtual Machine sub-routines that can analyze instructions purely in terms of type, and as a result the correctness proof of bytecode verification becomes extremely simple.

Compiling with Types

This thesis provides a general framework, called type-directed compilation, that allows compiler writers to take advantage of types at all stages in compilation, and builds a new compiler for SML called TIL that eliminates most restrictions on the representations of values.

A specification of Java loading and bytecode verification

The approach is to specify a generic dataflow architecture and formalize the JVM verifier as an instance of this architecture, and focuses on the use of data flow analysis and typing contexts to insure global type consistency in the context of an arbitrary strategy for dynamic class loading.

The TIL/ML Compiler: Performance and Safety through Types

In principle, using static type checking should provide superior performance to either hardware protection or SFI, simply because checks are performed at compile or link time instead of run time.

A type system for object initialization in the Java bytecode language

A precise specification of statically-correct Java bytecode, in the form of a type system, is developed and it is proved that for every Javabytecode program that satisfies the authors' typing constraints, every object is initialized before it is used.