Topic
Definite assignment analysis
About: Definite assignment analysis is a research topic. Over the lifetime, 7 publications have been published within this topic receiving 64 citations.
Papers
TL;DR: The definite assignment analysis of the C# compiler with data flow equations is formalized and the correctness of the analysis is proved.
Abstract: The compilation of C] requires a flow analysis to ensure that every local variable is definitely assigned when any access to its value occurs. A variable is definitely assigned at a use of its value if every execution path leading to that use contains an assignment to the variable. Since local variables are uninitialized by default, this prevents access to uninitialized memory which is a crucial ingredient for the type safety of C]. We formalize the rules of the definite assignment analysis of C] with data flow equations and we prove the correctness of the analysis, i.e. if the analysis will infer a local variable as definitely assigned at a certain program point, then the variable will actually be initialized at that point during every execution of the program. We actually prove more than correctness: we show that the solution of the analysis is a perfect solution (and not only a safe approximation).
25 citations
TL;DR: This work reuse the method developed for similar work for Java and the Java Virtual Machine (JVM) in [25] with the aim of establishing some important properties of C and CLR by mathematical proofs.
Abstract: This work is part of a larger project [17] which aims at establishing some important properties of C] and CLR by mathematical proofs. Examples are the correctness of the bytecode verifier of CLR [11], the type safety (along the lines of the first author’s correctness proof [14, 15] for the definite assignment rules) of C], the correctness of a general compilation scheme. We reuse the method developed for similar work for Java and the Java Virtual Machine (JVM) in [25]. As part of this effort, in [5, 13, 20] an abstract interpreter has been developed for C], including a thread and memory model [24, 23]; see also [8] for a comparative view of the abstract interpreters for Java and for C].
12 citations
TL;DR: This work proposes to restrict the rules of definite assignment for the try-finally statement as well as for the labeled statement so that the example programs are no longer allowed, and proves that each program from the slightly restricted Java language is accepted by the Bytecode Verifier.
Abstract: During an attempt to prove that the Java-to-JVM compiler generates code that is accepted by the bytecode verifier, we found examples of legal Java programs that are rejected by the verifier. We propose therefore to restrict the rules of definite assignment for the try-finally statement as well as for the labeled statement so that the example programs are no longer allowed. Then we can prove, using the framework of Abstract State Machines, that each program from the slightly restricted Java language is accepted by the Bytecode Verifier. In the proof we use a new notion of bytecode type assignment without subroutine call stacks.
10 citations
1 Jan 2003
TL;DR: The definite assignment analysis of the Java compiler in the theorem prover Isabelle/HOL is formalised and proved correct.
Abstract: In Java the compiler guarantees that each local variable is initialised when we attempt to access it at runtime. This prohibits access to uninitialised memory during execution and is a key ingredient for type safety. We have formalised the definite assignment analysis of the Java compiler in the theorem prover Isabelle/HOL and proved it correct.
10 citations
TL;DR: This work formalizes the rules of the definite assignment analysis of C] with data flow equations and proves the correctness of the analysis, i.e. if the analysis will infer a local variable as definitely assigned at a certain program point, then the variable will actually be initialized at that point during every execution of the program.
Abstract: The compilation of C] requires a flow analysis to ensure that every local variable is definitely assigned when any access to its value occurs. A variable is definitely assigned at a use of its value if every execution path leading to that use contains an assignment to the variable. Since local variables are uninitialized by default, this prevents access to uninitialized memory which is a crucial ingredient for the type safety of C]. We formalize the rules of the definite assignment analysis of C] with data flow equations and we prove the correctness of the analysis, i.e. if the analysis will infer a local variable as definitely assigned at a certain program point, then the variable will actually be initialized at that point during every execution of the program. We actually prove more than correctness: we show that the solution of the analysis is a perfect solution (and not only a safe approximation).
5 citations
Related Topics (5)
Performance Metrics
| Year | Papers |
|---|---|
| 2020 | 1 |
| 2006 | 1 |
| 2004 | 2 |
| 2003 | 2 |
| 1998 | 1 |