Slicing Software for Model Construction

Applying finite-state verification techniques (e.g., model checking) to software requires that program source code be translated to a finite-state transition system that safely models program behavior. Automatically checking such a transition system for a correctness property is typically very costly, thus it is necessary to reduce the size of the transition system as much as possible. In fact, it is often the case that much of a program's source code is irrelevant for verifying a given correctness property.In this paper, we apply program slicing techniques to remove automatically such irrelevant code and thus reduce the size of the corresponding transition system models. We give a simple extension of the classical slicing definition, and prove its safety with respect to model checking of linear temporal logic (LTL) formulae. We discuss how this slicing strategy fits into a general methodology for deriving effective software models using abstraction-based program specialization.

[1]  Thomas Reps,et al.  Program Slicing for Design Automation: An Automatic Technique for Speeding-up Hardware Design, Simul , 1998 .

[2]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[3]  Patrick Cousot,et al.  Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints , 1977, POPL.

[4]  Orna Grumberg,et al.  Abstract interpretation of reactive systems , 1997, TOPL.

[5]  George S. Avrunin,et al.  Patterns in property specifications for finite-state verification , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[6]  Lynette I. Millett,et al.  Slicing Promela and its Applications to Model Checking, Simulation, and Protocol Understanding , 2002 .

[7]  Mark Ryan,et al.  Logic in Computer Science: Modelling and Reasoning about Systems , 2000 .

[8]  Thierry Cattel Process Control Design Using SPIN , 2002 .

[9]  Matthew B. Dwyer,et al.  Filter-based model checking of partial systems , 1998, SIGSOFT '98/FSE-6.

[10]  James C. Corbett,et al.  A Formal Study of Slicing for Multi-threaded Programs with JVM Concurrency Primitives , 1999, SAS.

[11]  Neil D. Jones,et al.  Compiler generation by partial evaluation , 1989 .

[12]  Wuu Yang,et al.  The Semantics of Program Slicing , 1988 .

[13]  Lori A. Clarke,et al.  A Formal Model of Program Dependences and Its Implications for Software Testing, Debugging, and Maintenance , 1990, IEEE Trans. Software Eng..

[14]  Jesper Jørgensen,et al.  Compiler Generation by Partial Evaluation , 1992 .

[15]  Zohar Manna,et al.  The Temporal Logic of Reactive and Concurrent Systems , 1991, Springer New York.

[16]  Mats Per Erik Heimdahl,et al.  Reduction and slicing of hierarchical state machines , 1997, ESEC '97/FSE-5.

[17]  Pierre Wolper,et al.  Using partial orders for the efficient verification of deadlock freedom and safety properties , 1991, Formal Methods Syst. Des..

[18]  James C. Corbett,et al.  Evaluating Deadlock Detection Methods for Concurrent Software , 1996, IEEE Trans. Software Eng..

[19]  S. Laubach,et al.  Specializing Conngurable Systems for Finite-state Veriication , 1998 .

[20]  Matthew B. DwyerKansas Patterns in Property Speciications for Finite-state Veriication , 1999 .

[21]  Fausto Giunchiglia,et al.  Model Checking Safety Critical Software with SPIN: An Application to a Railway Interlocking System , 1998, SAFECOMP.

[22]  Matthew B. Dwyer,et al.  Staging Static Analyses Using Abstraction-Based Program Specialization , 1998, PLILP/ALP.

[23]  HatcliffJohn,et al.  Slicing Software for Model Construction , 2000 .

[24]  David W. Binkley,et al.  Program slicing , 2008, 2008 Frontiers of Software Maintenance.

[25]  Anthony M. Sloane,et al.  Beyond traditional program slicing , 1996, ISSTA '96.

[26]  David A. Schmidt,et al.  Program Analysis as Model Checking of Abstract Interpretations , 1998, SAS.

[27]  Neil D. Jones,et al.  Compiler Generation by Partial Evaluation: A Case Study , 1991, Struct. Program..

[28]  Chris Hankin,et al.  Abstract Interpretation of Declarative Languages , 1987 .

[29]  Wuu Yang,et al.  The Semantics of Program Slicing and Program Integration , 1989, TAPSOFT, Vol.2.

[30]  Thomas W. Reps,et al.  Program Specialization via Program Slicing , 1996, Dagstuhl Seminar on Partial Evaluation.

[31]  John Hatcliff,et al.  An Introduction to Online and Offline Partial Evaluation using a Simple Flowchart Language , 1998, Partial Evaluation.

[32]  Laurie Hendren,et al.  Jimple: Simplifying Java Bytecode for Analyses and Transformations , 1998 .

[33]  Barbara M. Chapman,et al.  Supercompilers for parallel and vector computers , 1990, ACM Press frontier series.

[34]  Edmund M. Clarke,et al.  Model checking and abstraction , 1994, TOPL.

[35]  James C. Corbett,et al.  Bandera: extracting finite-state models from Java source code , 2000, ICSE.

[36]  Dennis Dams,et al.  Abstract interpretation and partition refinement for model checking , 1996 .

[37]  Thomas Ball,et al.  Slicing Programs with Arbitrary Control-flow , 1993, AADEBUG.

[38]  Torben Æ. Mogensen,et al.  Partial Evaluation. Practice and Theory: DIKU 1998 International Summer School, Copenhagen, Denmark, June 29 - July 10, 1998 , 1998 .

[39]  Joseph Sifakis,et al.  Property preserving abstractions for the verification of concurrent systems , 1995, Formal Methods Syst. Des..

[40]  Debra J. Richardson,et al.  Static and Dynamic Speci cation Slicing , 1994 .

[41]  Peter Sestoft,et al.  Partial evaluation and automatic program generation , 1993, Prentice Hall international series in computer science.

[42]  Frank Tip,et al.  A survey of program slicing techniques , 1994, J. Program. Lang..

[43]  Kenneth L. McMillan,et al.  Symbolic model checking , 1992 .

[44]  Thomas W. Reps,et al.  On the adequacy of program dependence graphs for representing programs , 1988, POPL '88.

[45]  Aniello Cimitile,et al.  Identifying reusable functions using specification driven program slicing: a case study , 1995, Proceedings of International Conference on Software Maintenance.

[46]  Edmund M. Clarke,et al.  Symbolic Model Checking: 10^20 States and Beyond , 1990, Inf. Comput..

[47]  Matthew B. Dwyer,et al.  Model Checking Generic Container Implementations , 1998, Generic Programming.

[48]  Matthew B. Dwyer,et al.  Using partial evaluation to enable verification of concurrent software , 1998, CSUR.

[49]  Corina S. Pasareanu,et al.  Translating Ada Programs for Model Checking : A , 1998 .

[50]  Gerard J. Holzmann,et al.  The Model Checker SPIN , 1997, IEEE Trans. Software Eng..

[51]  George S. Avrunin,et al.  Property specification patterns for finite-state verification , 1998, FMSP '98.

[52]  Masahiro Fujita,et al.  Program Slicing of Hardware Description Languages , 1999, CHARME.

[53]  Matthew B. DwyerKansas,et al.  Property Speciication Patterns for Finite-state Veriication , 1998 .

[54]  Jong-Deok Choi,et al.  Static slicing in the presence of goto statements , 1994, TOPL.

[55]  Susan Horwitz,et al.  Incremental program testing using program dependence graphs , 1993, POPL '93.