Skip to main content

Better Debugging of Logical Errors Using Optimized Call Stack Restricted Slicing

  • Conference paper
  • 1724 Accesses

Part of the book series: Communications in Computer and Information Science ((CCIS,volume 190))

Abstract

Logical errors are the program bugs that are caused due to the programmer’s faulty reasoning. Logical errors in a program are not easy to find since the point of failure is shown in a statement but actual bug may be in any other statement(s). Debugging of this kind of errors is tedious. To debug the logical errors backward slicing is very useful. But, in most cases, backward slices are as large as the original program itself. This again creates problem in finding the original bug. This paper presents Optimized Call-stack Restricted slicing which reduces the number of lines to be checked while debugging. In other words, this technique reduces the size of the slice and also ensures that Optimized Call-Stack Restricted slices are smaller than the slices produced by any other slicing techniques. Optimized Call-stack restricted slicing is very effective. The size of slice ranges from 3 to 80 percent of the original program. Under any circumstances, the size of slices produced by optimized call stack restricted slicer is not greater than that of other slicers.

This is a preview of subscription content, log in via an institution.

Buying options

Chapter
USD   29.95
Price excludes VAT (USA)
  • Available as PDF
  • Read on any device
  • Instant download
  • Own it forever
eBook
USD   84.99
Price excludes VAT (USA)
  • Available as PDF
  • Read on any device
  • Instant download
  • Own it forever
Softcover Book
USD   109.99
Price excludes VAT (USA)
  • Compact, lightweight edition
  • Dispatched in 3 to 5 business days
  • Free shipping worldwide - see info

Tax calculation will be finalised at checkout

Purchases are for personal use only

Learn about institutional subscriptions

Preview

Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.

References

  1. Weiser, M.: Program Slicing. IEEE Trans. Software Eng. 10(4), 352–357 (1984)

    Article  MATH  Google Scholar 

  2. Horwitz, S., Reps, T., Binkley, D.: Interprocedural Slicing Using Dependence Graphs. ACM Trans. Programming Languages and Systems 12(1), 26–60 (1990)

    Article  Google Scholar 

  3. Krinke, J.: Context-Sensitivity Matters, but Context Does Not. In: Proc. Int’l Workshop Source Code Analysis and Manipulation, p. 2935 (2004)

    Google Scholar 

  4. Krinke, J.: Evaluating context-sensitive slicing and chopping. In: International Conference on Software Maintenance, pp. 22–31 (2002)

    Google Scholar 

  5. Horwitz, S., Liblit, B., Polishchuk, M.: Better Debugging via Output Tracing and Callstack-Sensitive Slicing. IEEE Trans. Soft. Eng. 36(1) (January/February 2010)

    Google Scholar 

  6. Wisconsin Program-Slicing Tool 1.1 Reference Manual, Wisconsin

    Google Scholar 

  7. Alumni Research Foundation (November 2000), http://www.cs.wisc.edu/wpis/slicing-tool/slicing-manual.ps

  8. Binkley, D., Harman, M.: A Large-Scale Empirical Study of Forward and Backward Static Slice Size and Context Sensitivity. In: Proc. 2003 Int’l Conf. Software Maintenance (September 2003)

    Google Scholar 

  9. Korel, B., Laski, J.: Dynamic Program Slicing. Information Processing Letters 29(3), 155–163 (1988)

    Article  MATH  Google Scholar 

  10. Krinke, J.: Effects of Context on Program Slicing. J. Systems and Software 79(9), 1249–1260 (2006)

    Article  Google Scholar 

  11. The GNU C Library, 0th ed., The Free Software Foundation (July 2001)

    Google Scholar 

  12. GNU Binutils, binutils 2.17 ed., The Free Software Foundation (June 2006)

    Google Scholar 

  13. Stallman, R.M., and the GCC Developer Community: Using the GNU Compiler Collection (GCC), gcc 4.1.1 ed., The Free Software Foundation (May 2006)

    Google Scholar 

  14. GrammaTech, Codesurfer (September 2006), http://www.codesurfer.com

  15. Reps, T., Horwitz, S., Rosay, G.: Speeding up Slicing. In: Proc. ACM SIGSOFT Int’l Symp. Foundations of Software Eng., pp. 11–20 (December 1994)

    Google Scholar 

  16. Agrawal, G., Guo, L.: Evaluating explicitly context sensitive program slicing. In: Workshop on Program Analysis for Software Tools and Engineering, pp. 6–12 (2001)

    Google Scholar 

  17. Mock, M., Atkinson, D.C., Chambers, C., Eggers, S.J.: Improving program slicing with dynamic points-to data. In: Proceedings of the 10th International Symposium on the Foundations of Software Engineering (2002)

    Google Scholar 

  18. Ferrante, J., Ottenstein, K.J., Warren, J.D.: The program dependence graph and its use in optimization. ACM Trans. Program. Lang. Syst. 9(3), 319–349 (1987)

    Article  MATH  Google Scholar 

  19. http://everything2.com/title/data+dependency

  20. http://hpc.serc.iisc.ernet.in/~govind/hpc/L10-Pipeline.txt

Download references

Author information

Authors and Affiliations

Authors

Editor information

Editors and Affiliations

Rights and permissions

Reprints and permissions

Copyright information

© 2011 Springer-Verlag Berlin Heidelberg

About this paper

Cite this paper

Babu, L.D.D., Nirmala, M., Santhoshkumar, S., Panneerselvam, S. (2011). Better Debugging of Logical Errors Using Optimized Call Stack Restricted Slicing. In: Abraham, A., Lloret Mauri, J., Buford, J.F., Suzuki, J., Thampi, S.M. (eds) Advances in Computing and Communications. ACC 2011. Communications in Computer and Information Science, vol 190. Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-642-22709-7_23

Download citation

  • DOI: https://doi.org/10.1007/978-3-642-22709-7_23

  • Publisher Name: Springer, Berlin, Heidelberg

  • Print ISBN: 978-3-642-22708-0

  • Online ISBN: 978-3-642-22709-7

  • eBook Packages: Computer ScienceComputer Science (R0)

Publish with us

Policies and ethics