A Model-Derivation Framework for Software Analysis

Software Technologies: Applications and Foundations

Bockisch

Rensink

et al. 2018

Self Cite

Program analyses are an important tool to check if a system fulfills its specification. A typical implementation strategy for program analyses is to use an imperative, general-purpose language like Java; and access the program to be analyzed through libraries for manipulating intermediate code, such as ASM for Java bytecode. We show that this hampers composability, interoperability and reuse of analysis implementations.We propose a complete Ecore-metamodel for Java bytecode as a common basis for program analysis implementations, as well as an Eclipse plug-in to create bytecode metamodel instances from Java bytecode and vice versa. Code analyses can be defined as model transformations in a declarative, domain-specific language. As a consequence, the implementations of program analyses become more composable and more modular in general. We demonstrate the effectiveness of this approach with a case study.

Section: Discussionmentioning

confidence: 99%

Section: Motivationmentioning

confidence: 99%

See 1 more Smart Citation

A Java Bytecode Metamodel for Composable Program Analyses

Software Technologies: Applications and Foundations

Bockisch

Rensink

et al. 2018

Self Cite

“…The framework we have introduced in [38] adopts the generic approach presented in this paper for automatically deriving timed-automata models to validate Java applications, timing requirements in particular, using model checking. In this framework, the bytecode metamodel [37] and its timing analysis extension are introduced as the domain metamodels.…”

Section: Analysis Of Java Programsmentioning

confidence: 99%

“…Queries are currently manually written and results of the model checking process are not translated back to a domain-specific representation such as to a source-code view. However, the implementation of these points using MDE is suggested in the generic approach is a future direction of the study in [38].…”

Section: Analysis Of Java Programsmentioning

confidence: 99%

How to Efficiently Build a Front-End Tool for UPPAAL: A Model-Driven Approach

Schivo

Dependable Software Engineering. Theories, Tools, and Applications

Ruijters

et al. 2017

Self Cite

We propose a model-driven engineering approach that facilitates the production of tool chains that use the popular model checker Uppaal as a back-end analysis tool. In this approach, we introduce a metamodel for Uppaal's input model, containing both timed-automata concepts and syntax-related elements for C-like expressions. We also introduce a metamodel for Uppaal's query language to specify temporal properties; as well as a metamodel for traces to interpret Uppaal's counterexamples and witnesses. The approach provides a systematic way to build software bridging tools (i.e., tools that translate from a domainspecific language to Uppaal's input language) such that these tools become easier to debug, extend, reuse and maintain. We demonstrate our approach on five different domains: cyber-physical systems, hardwaresoftware co-design, cyber-security, reliability engineering and software timing analysis. IntroductionUppaal [3] is a leading model checker for real-time systems, allowing one to verify automatically whether a system meets its timing requirements. Uppaal and its extensions have been applied to a large number of domains, ranging from communication protocols [28], over planning [4] to systems biology [31]. As such, Uppaal is a popular back-end for various other real-time analysis tools, such as ANIMO [31], sdf2ta [13] and STATE [19]. Typically such tools take their inputs in a domain-specific language (DSL) and translate these inputs into timed automata, which are then fed into Uppaal to perform the analysis. In this way, domain experts can write their models in a DSL that they are familiar with, while still using Uppaal's powerful analysis algorithms behind the scenes.A disadvantage of this approach is, however, that the tools that translate from a DSL to Uppaal's input language, i.e., software bridging tools, are often implemented ad hoc, and hence difficult to debug, reuse, extend and maintain.

An MDE Approach for Modular Program Analyses

Companion to the First International Conference on the Art, Science and Engineering of Programming

Bockisch

Rensink

et al. 2017

Program analyses are an important tool to check if a system ful lls its speci cation. A typical implementation strategy for program analyses is to use an imperative, general-purpose language like Java, and access the program to be analyzed through libraries that o er an API for reading, writing and manipulating intermediate code, such as BCEL or ASM for Java bytecode. We claim that this hampers reuse and interoperability.In this paper, we propose an Ecore-metamodel for covering Java bytecode completely, which can act as a common basis for program analyses. Code analyses as well as instrumentations can then be de ned as model transformations in a declarative language. As a consequence, the implementation of program analysis becomes more concise, more readable and more modular. We demonstrate the e ectiveness of this approach by two case studies: pro ling of timing performance and model checking of reachability requirements. We also provide tools to generate instances of our bytecode metamodel from Java code in the class le format and vice versa.