Static analysis of Sequential Function Charts using abstract interpretation

2016 ◽  
Author(s):  
Hendrik Simon ◽  
Stefan Kowalewski
Keyword(s):  
Static Analysis ◽  
Abstract Interpretation

A Survey of Parametric Static Analysis

2021 ◽  
Vol 54 (7) ◽  
pp. 1-37
Author(s):  
Jihyeok Park ◽  
Hongki Lee ◽  
Sukyoung Ryu
Keyword(s):  
Recent Work ◽  
Static Analysis ◽  
Abstract Interpretation ◽  
Black Box ◽  
Parameter Selection ◽  
Survey Analysis ◽  
Future Directions ◽  
Analysis Techniques ◽  
Analysis Quality

Understanding program behaviors is important to verify program properties or to optimize programs. Static analysis is a widely used technique to approximate program behaviors via abstract interpretation. To evaluate the quality of static analysis, researchers have used three metrics: performance, precision, and soundness. The static analysis quality depends on the analysis techniques used, but the best combination of such techniques may be different for different programs. To find the best combination of analysis techniques for specific programs, recent work has proposed parametric static analysis . It considers static analysis as black-box parameterized by analysis parameters , which are techniques that may be configured without analysis details. We formally define the parametric static analysis, and we survey analysis parameters and their parameter selection in the literature. We also discuss open challenges and future directions of the parametric static analysis.

Verification of Non-Functional Requirements by Abstract Interpretation

2012 ◽  
pp. 22-35
Author(s):  
Agostino Cortesi ◽  
Francesco Logozzo
Keyword(s):  
Static Analysis ◽  
Abstract Interpretation ◽  
Software Requirements ◽  
Functional Requirements ◽  
Formal Approach ◽  
Space Efficiency ◽  
Source Program ◽  
Service Oriented ◽  
Abstract Domains ◽  
Functional Software

This chapter investigates a formal approach to the verification of non-functional software requirements that are crucial in Service-oriented Systems, like portability, time and space efficiency, and dependability/robustness. The key-idea is the notion of observable, i.e., an abstraction of the concrete semantics when focusing on a behavioral property of interest. By applying an abstract interpretation-based static analysis of the source program, and by a suitable choice of abstract domains, it is possible to design formal and effective tools for non-functional requirements validation.

scholarly journals Optimality in goal-dependent analysis of Sharing

2009 ◽  
Vol 9 (05) ◽  
pp. 617-689 ◽  
Author(s):  
GIANLUCA AMATO ◽  
FRANCESCA SCOZZARI
Keyword(s):  
Logic Programming ◽  
Static Analysis ◽  
Abstract Interpretation ◽  
Logic Programs ◽  
Semantic Operators

AbstractWe face the problems of correctness, optimality, and precision for the static analysis of logic programs, using the theory of abstract interpretation. We propose a framework with a denotational, goal-dependent semantics equipped with two unification operators for forward unification (calling a procedure) and backward unification (returning from a procedure). The latter is implemented through a matching operation. Our proposal clarifies and unifies many different frameworks and ideas on static analysis of logic programming in a single, formal setting. On the abstract side, we focus on the domainsharingby Jacobs and Langen (The Journal of Logic Programming, 1992, vol. 13, nos. 2–3, pp. 291–314) and provide the best correct approximation of all the primitive semantic operators, namely, projection, renaming, and forward and backward unifications. We show that the abstract unification operators are strictly more precise than those in the literature defined over the same abstract domain. In some cases, our operators are more precise than those developed for more complex domains involving linearity and freeness.

scholarly journals Static Analysis for ECMAScript String Manipulation Programs

2020 ◽  
Vol 10 (10) ◽  
pp. 3525 ◽  
Author(s):  
Vincenzo Arceri ◽  
Isabella Mastroeni ◽  
Sunyi Xu
Keyword(s):  
Static Analysis ◽  
Abstract Interpretation ◽  
Finite State Automata ◽  
Language Program ◽  
Object Property ◽  
Wide Range ◽  
Dynamic Languages ◽  
Finite State ◽  
Dynamic Language

In recent years, dynamic languages, such as JavaScript or Python, have been increasingly used in a wide range of fields and applications. Their tricky and misunderstood behaviors pose a great challenge for static analysis of these languages. A key aspect of any dynamic language program is the multiple usage of strings, since they can be implicitly converted to another type value, transformed by string-to-code primitives or used to access an object-property. Unfortunately, string analyses for dynamic languages still lack precision and do not take into account some important string features. In this scenario, more precise string analyses become a necessity. The goal of this paper is to place a first step for precisely handling dynamic language string features. In particular, we propose a new abstract domain approximating strings as finite state automata and an abstract interpretation-based static analysis for the most common string manipulating operations provided by the ECMAScript specification. The proposed analysis comes with a prototype static analyzer implementation for an imperative string manipulating language, allowing us to show and evaluate the improved precision of the proposed analysis.

scholarly journals Goblint: Thread-Modular Abstract Interpretation Using Side-Effecting Constraints

2021 ◽  
pp. 438-442
Author(s):  
Simmo Saan ◽  
Michael Schwarz ◽  
Kalmer Apinis ◽  
Julian Erhard ◽  
Helmut Seidl ◽  
...  
Keyword(s):  
Static Analysis ◽  
Abstract Interpretation ◽  
Analysis Framework ◽  
Data Race ◽  
C Programs ◽  
Global Invariants ◽  
Race Analysis

AbstractGoblintis a static analysis framework for C programs specializing in data race analysis. It relies on thread-modular abstract interpretation where thread interferences are accounted for by means of flow-insensitive global invariants.

scholarly journals Systematic abstraction of abstract machines

2012 ◽  
Vol 22 (4-5) ◽  
pp. 705-746 ◽  
Author(s):  
DAVID VAN HORN ◽  
MATTHEW MIGHT
Keyword(s):  
Programming Languages ◽  
Static Analysis ◽  
Abstract Interpretation ◽  
Garbage Collection ◽  
Higher Order ◽  
Return Flow ◽  
Initial Development ◽  
Abstract Machines ◽  
Temporal Ordering

AbstractWe describe a derivational approach to abstract interpretation that yields novel and transparently sound static analyses when applied to well-established abstract machines for higher-order and imperative programming languages. To demonstrate the technique and support our claim, we transform the CEK machine of Felleisen and Friedman (Proc. of the 14th ACM SIGACT-SIGPLAN Symp. Prin. Program. Langs, 1987, pp. 314–325), a lazy variant of Krivine's machine (Higher-Order Symb. Comput. Vol 20, 2007, pp. 199–207), and the stack-inspecting CM machine of Clements and Felleisen (ACM Trans. Program. Lang. Syst. Vol 26, 2004, pp. 1029–1052) into abstract interpretations of themselves. The resulting analyses bound temporal ordering of program events; predict return-flow and stack-inspection behavior; and approximate the flow and evaluation of by-need parameters. For all of these machines, we find that a series of well-known concrete machine refactorings, plus a technique of store-allocated continuations, leads to machines that abstract into static analyses simply by bounding their stores. These machines are parameterized by allocation functions that tune performance and precision and substantially expand the space of analyses that this framework can represent. We demonstrate that the technique scales up uniformly to allow static analysis of realistic language features, including tail calls, conditionals, mutation, exceptions, first-class continuations, and even garbage collection. In order to close the gap between formalism and implementation, we provide translations of the mathematics as running Haskell code for the initial development of our method.

Sign in / Sign up

Export Citation Format

Share Document