research-article

Dynamic slicing with soot

Authors:

Matthias UflackerAuthors Info & Claims

SOAP '14: Proceedings of the 3rd ACM SIGPLAN International Workshop on the State of the Art in Java Program Analysis

Pages 1 - 6

https://doi.org/10.1145/2614628.2614631

Published: 12 June 2014 Publication History

Abstract

Slicing is a powerful technique that can help a developer to understand how the interaction of different parts of a program causes a specific outcome. Dynamic slicing uses runtime information to compute a precise slice for a given execution. However, dynamic slicing is not possible without a static analysis of the underlying code to reveal dependencies between the instructions that have been recorded.

In this paper, we present a new algorithm for computing dynamic slices. We describe how the optimization framework Soot was used to compute specialized intraprocedural dependency graphs that better reflect the programmer's view of a program than previous approaches. Combining these dependency graphs with recorded execution traces allowed us to create debuggable dynamic slices. For this, a mapping of the debugger's model of the execution to the static code model of Soot was needed, and could be found with only few ambiguities.

This results in the ability to produce a dynamic slice that can not only be visualized, but explored interactively and adjusted to better answer specific questions.

References

[1]

H. Agrawal and J. R. Horgan. Dynamic program slicing. In Proceedings of the ACM SIGPLAN 1990 Conference on Programming Language Design and Implementation, PLDI '90, page 246--256, New York, NY, USA, 1990. ACM. ISBN 0-89791-364-7. URL http://doi.acm.org/10.1145/93542.93576.

Digital Library

[2]

H. Agrawal, R. A. Demillo, and E. H. Spafford. Debugging with dynamic slicing and backtracking. Software: Practice and Experience, 23(6):589--616, 1993. ISSN 1097-024X. URL http://onlinelibrary.wiley.com/doi/10.1002/spe.4380230603/abstract.

Digital Library

[3]

D. Arvind and P. Shankar. Slicing of Java Programs using the Soot Framework. 2006.

[4]

D. Binkley, S. Danicic, T. Gyimóthy, M. Harman, k. Kiss, and B. Korel. Theoretical foundations of dynamic program slicing. Theoretical Computer Science, 360(1--3):23--41, 2006. ISSN 0304-3975. URL http://www.sciencedirect.com/science/article/pii/S030439750600020X.

Digital Library

[5]

A. De Lucia. Program slicing: methods and applications. In First IEEE International Workshop on Source Code Analysis and Manipulation, 2001. Proceedings, pages 142--149, 2001.

[6]

B. Dufour, L. Hendren, and C. Verbrugge. *J: a tool for dynamic analysis of java programs. In Companion of the 18th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications, OOPSLA '03, page 306--307, New York, NY, USA, 2003. ACM. ISBN 1-58113-751-6. URL http://doi.acm.org/10.1145/949344.949425.

Digital Library

[7]

S. I. Feldman and C. B. Brown. IGOR: a system for program debugging via reversible execution. In Proceedings of the 1988 ACM SIGPLAN and SIGOPS workshop on Parallel and distributed debugging, PADD '88, page 112--123, New York, NY, USA, 1988. ACM. ISBN 0-89791-296-9. URL http://doi.acm.org/10.1145/68210.69226.

Digital Library

[8]

C. Hammacher. Design and Implementation of an Efficient Dynamic Slicer for Java. Saarland University, Nov. 2008. Published: Bachelor's Thesis.

[9]

T. Hoffner. Evaluation and comparison of program slicing tools. Cite-seer, 1995. URL http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.219.6109&rep=rep1&type=pdf.

[10]

A. J. Ko and B. A. Myers. Debugging reinvented: asking and answering why and why not questions about program behavior. In Proceedings of the 30th international conference on Software engineering, ICSE '08, page 301--310, New York, NY, USA, 2008. ACM. ISBN 978-1-60558-079-1. URL http://doi.acm.org/10.1145/1368088.1368130.

Digital Library

[11]

B. Korel and J. Laski. Dynamic slicing of computer programs. Journal of Systems and Software, 13(3):187--195, Nov. 1990. ISSN 0164-1212. URL http://www.sciencedirect.com/science/article/pii/0164121290900943.

Digital Library

[12]

P. Lam, E. Bodden, O. Lhoták, and L. Hendren. The soot framework for java program analysis: a retrospective. In Cetus Users and Compiler Infrastructure Workshop, Galveston Island, TX, Oct. 2011.

[13]

B. Lewis. Debugging backwards in time. Computing Research Repository, cs.SE/0310016, 2003. URL http://arxiv.org/abs/cs/0310016.

[14]

A. Lienhard, T. Gîrba, and O. Nierstrasz. Practical object-oriented back-in-time debugging. In J. Vitek, editor, ECOOP 2008 -- Object-Oriented Programming, number 5142 in Lecture Notes in Computer Science, pages 592--615. Springer Berlin Heidelberg, Jan. 2008. ISBN 978-3-540-70591-8, 978-3-540-70592-5. URL http://link.springer.com/chapter/10.1007/978-3-540-70592-5_25.

Digital Library

[15]

G. Pothier, E. Tanter, and J. Piquer. Scalable omniscient debugging. In Proceedings of the 22nd annual ACM SIGPLAN conference on Object-oriented programming systems and applications, OOPSLA '07, page 535--552, New York, NY, USA, 2007. ACM. ISBN 978-1-59593-786-5. URL http://doi.acm.org/10.1145/1297027.1297067.

Digital Library

[16]

A. Szegedi and T. Gyimothy. Dynamic slicing of java bytecode programs. In Fifth IEEE International Workshop on Source Code Analysis and Manipulation, 2005, pages 35--44, Sept. 2005.

Digital Library

[17]

T. Wang and A. Roychoudhury. Dynamic slicing on java bytecode traces. ACM Trans. Program. Lang. Syst., 30(2):10:1--10:49, Mar. 2008. ISSN 0164-0925. URL http://doi.acm.org/10.1145/1330017.1330021.

Digital Library

[18]

M. Weiser. Programmers use slices when debugging. Commun. ACM, 25(7):446--452, July 1982. ISSN 0001-0782. URL http://doi.acm.org/10.1145/358557.358577.

Digital Library

[19]

X. Zhang, R. Gupta, and Y. Zhang. Precise dynamic slicing algorithms. In 25th International Conference on Software Engineering, 2003. Proceedings, pages 319--329, May 2003.

Digital Library

Cited By

Pauck FWehrheim H(2021)Jicer: Simplifying Cooperative Android App Analysis Tasks2021 IEEE 21st International Working Conference on Source Code Analysis and Manipulation (SCAM)10.1109/SCAM52516.2021.00031(187-197)Online publication date: Sep-2021
https://doi.org/10.1109/SCAM52516.2021.00031
Dashevskyi SBrucker AMassacci F(2019)A Screening Test for Disclosed Vulnerabilities in FOSS ComponentsIEEE Transactions on Software Engineering10.1109/TSE.2018.281603345:10(945-966)Online publication date: 1-Oct-2019
https://doi.org/10.1109/TSE.2018.2816033
Panda SMohapatra D(2016)A framework to measure coupling using static change impact analysisInternational Journal of Business Information Systems10.1504/IJBIS.2016.07952623:3(353-387)Online publication date: 1-Jan-2016
https://dl.acm.org/doi/10.1504/IJBIS.2016.079526
Show More Cited By

Index Terms

Dynamic slicing with soot
1. Software and its engineering
  1. Software creation and management
    1. Software verification and validation
      1. Process validation
        Traceability
      2. Software defect analysis
        Software testing and debugging

Recommendations

Improving program slicing with dynamic points-to data

Program slicing is a potentially useful analysis for aiding program understanding. However, slices of even small programs are often too large to be generally useful. Imprecise pointer analyses have been suggested as one cause of this problem. In this ...
Static slicing in the presence of goto statements

A static program slice is an extract of a program which can help our understanding of the behavior of the program; it has been proposed for use in debugging, optimization, parallelization, and integration of programs. This article considers two types of ...
Thin slicing
Proceedings of the 2007 PLDI conference

Program slicing systematically identifies parts of a program relevant to a seed statement. Unfortunately, slices of modern programs often grow too large for human consumption. We argue that unwieldy slices arise primarily from an overly broad definition ...

Comments

Please enable JavaScript to view thecomments powered by Disqus.

Information & Contributors

Information

Published In

cover image ACM Conferences

SOAP '14: Proceedings of the 3rd ACM SIGPLAN International Workshop on the State of the Art in Java Program Analysis

June 2014

36 pages

ISBN:9781450329194

DOI:10.1145/2614628

Conference Chairs:
Steven Arzt
EC SPRIDE
,
Raul Santelices
University of Notre Dame

Copyright © 2014 ACM.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected].

Sponsors

SIGPLAN: ACM Special Interest Group on Programming Languages

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 12 June 2014

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article

Conference

PLDI '14

Sponsor:

SIGPLAN

PLDI '14: ACM SIGPLAN Conference on Programming Language Design and Implementation

June 12, 2014

Edinburgh, United Kingdom

Acceptance Rates

SOAP '14 Paper Acceptance Rate 5 of 5 submissions, 100%;

Overall Acceptance Rate 11 of 11 submissions, 100%

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

5
Total Citations
View Citations
359
Total Downloads

Downloads (Last 12 months)8
Downloads (Last 6 weeks)0

Reflects downloads up to 14 Nov 2024

Other Metrics

View Author Metrics

Citations

Cited By

Pauck FWehrheim H(2021)Jicer: Simplifying Cooperative Android App Analysis Tasks2021 IEEE 21st International Working Conference on Source Code Analysis and Manipulation (SCAM)10.1109/SCAM52516.2021.00031(187-197)Online publication date: Sep-2021
https://doi.org/10.1109/SCAM52516.2021.00031
Dashevskyi SBrucker AMassacci F(2019)A Screening Test for Disclosed Vulnerabilities in FOSS ComponentsIEEE Transactions on Software Engineering10.1109/TSE.2018.281603345:10(945-966)Online publication date: 1-Oct-2019
https://doi.org/10.1109/TSE.2018.2816033
Panda SMohapatra D(2016)A framework to measure coupling using static change impact analysisInternational Journal of Business Information Systems10.1504/IJBIS.2016.07952623:3(353-387)Online publication date: 1-Jan-2016
https://dl.acm.org/doi/10.1504/IJBIS.2016.079526
Treffer AUflacker M(2016)The Slice Navigator: Focused Debugging with Interactive Dynamic Slicing2016 IEEE International Symposium on Software Reliability Engineering Workshops (ISSREW)10.1109/ISSREW.2016.17(175-180)Online publication date: Oct-2016
https://doi.org/10.1109/ISSREW.2016.17
Jiang YZhang CWu DLiu P(2016)Feature-Based Software CustomizationProceedings of the 2016 IEEE 17th International Symposium on High Assurance Systems Engineering (HASE)10.1109/HASE.2016.27(122-131)Online publication date: 7-Jan-2016
https://dl.acm.org/doi/10.1109/HASE.2016.27

View Options

Get Access

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Publication

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Media

Figures

Other

Tables

View Table of Contents