Modeling the .NET CLR Exception Handling Mechanism for a Mathematical Analysis

@article{Fruja2006ModelingT,
  title={Modeling the .NET CLR Exception Handling Mechanism for a Mathematical Analysis},
  author={Nicu G. Fruja and Egon B{\"o}rger},
  journal={J. Object Technol.},
  year={2006},
  volume={5},
  pages={5-34}
}
This work is part of a larger project [17] which aims at establishing some important properties of C] and CLR by mathematical proofs. [] Key Method 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].

Figures from this paper

Towards proving type safety of .NET CIL

Construction and analysis of ground models and their refinements as a foundation for validating computer-based systems

  • E. Börger
  • Computer Science
    Formal Aspects of Computing
  • 2006
The Abstract State Machines (ASM) method is outlined, a discipline for reliable system development which allows one to bridge the gap between informal requirements and executable code by combining application-centric experimentally validatable system modelling with mathematically verifiable stepwise detailing of abstract models to compile-time-verifiable code.

Modularizing Theorems for Software Product Lines: The Jbook Case Study

The investigation in this paper reveals a striking similarity of the refinement concepts used in Abstract State Machines (ASM) based system development and Feature-Oriented Programming (FOP) of software product lines.

Linking the Meaning of Programs to What the Compiler Can Verify

The ASM method is explained how it allows one to bridge the gap between informal requirements and detailed code by combining application-centric experimentally validatable system modeling with mathematically verifiable refinementsof abstract models to compiler-verifiable code.

On The Modularization of Theorems for Software Product Lines

This paper explains how theorems about program properties can be integrated into feature-based development of software product lines, and analyses an existing Java/JVM compilation correctness proof for defining, interpreting, compiling, and executing bytecode for the Java language.

Towards proving type safety of C#

The Subject-Oriented Approach to Software Design and the Abstract State Machines Method

  • E. Börger
  • Computer Science
    Conceptual Modelling and Its Theoretical Foundations
  • 2012
This paper investigates the relation between S-BPM and the ASM method for software design and analysis more closely and uses the analysis to evaluate S- BPM as an approach to business process modeling and to suggest some challenging practical extension of the system.

Coupling Design and Verification in Software Product Lines

An ASM-based method to integrate into current feature-based software design practice modular verification techniques and show the benefits of using ASM techniques for modular verification in software development.

Contribution to a Rigorous Analysis of Web Application Frameworks

An approach for accurate modeling and analysis of web application frameworks is suggested and it is suggested that the model-based approach may be more accurate than the models currently in use.

A tribute

  • Deepak Chauhan
  • Medicine
    Journal of the Indian Society of Pedodontics and Preventive Dentistry
  • 2016
Dr. Kapil Rajiv Sharma, who was working as the Professor and head of the Department of Pediatric Dentistry at H. P. Government Dental College and Hospital, Shimla, left for heavenly abode on June 19,

References

SHOWING 1-10 OF 30 REFERENCES

A Practical Method for Specification and Analysis of Exception Handling - A Java/JVM Case Study

A compilation scheme of Java to JVM code can be used as a standard reference for Java exception handling compilation and it is proved that, in corresponding runs, Java and the JVM throw the same exceptions and with equivalent effect.

Formal specification and verification of the C# thread model

  • R. Stärk
  • Computer Science
    Theor. Comput. Sci.
  • 2005

A high-level modular definition of the semantics of C#

Exploiting Abstraction for Specification Reuse. The Java/C# Case Study

The resulting model reveals the kernel of object-oriented programming language constructs and can be used for teaching them without being bound to a particular language.

Analysis of the .NET CLR Exception Handling Mechanism

We provide a complete mathematical model for the exception handling mechanism of the Common Language Runtime (CLR), the virtual machine underlying the interpretation of .NET programs. The goal is to

Typing a multi-language intermediate code

The main theorem asserts type safety, that well-typed programs in their IL fragment do not lead to untrapped execution errors, and the formal system of this paper is an abstraction of informal and executable specifications the authors wrote for the full product during its development.

Specification and Implementation Problems for C#

During the attempts to build an Abstract State Machine (ASM) model for the semantics of C# programs, this work and the comparison between the corresponding ASM models for C# and Java brought to light a few gaps and mistakes in the C# reference manual, inconsistencies with different implementations ofC#.

An Executable Specification of C++

The developed AsM model is validated here by providing an executable model which supports the experimentation with the ASM model by depicting the techniques on building and using AsmL as a Specification Language.

The Correctness of the Definite Assignment Analysis in C#

The definite assignment analysis of the C# compiler with data flow equations is formalized and the correctness of the analysis is proved.

An ASM Specification of C# Threads and the .NET Memory Model

A high-level ASM model of C# threads and the .NET memory model is presented, which provides a sound basis for the development of multi-threaded applications in C#.