Slicing of Object-Oriented Software

Software maintenance activities generally account for more than one third of time during the software development cycle. It has been found out that certain regions of a program can cause more damage than other regions, if they contain bugs. In order to find these high-risk areas, we use slicing to obtain a static backward slice of a program. Our project deals with the implementation of different intermediate graphical representations for an input source program such as the Control Dependence Graph, the Program Dependence Graph, the Class Dependence Graph and the System Dependence Graph. Once a graphical representation of an input program is obtained, slicing is performed on the program using its System Dependence Graph and a two pass graph reachability algorithm proposed by Horwitz, to obtain a static backward slice

Model Checking with Program Slicing Based on Variable Dependence Graphs

In embedded control systems, the potential risks of software defects have been increasing because of software complexity which leads to, for example, timing related problems. These defects are rarely found by tests or simulations. To detect such defects, we propose a modeling method which can generate software models for model checking with a program slicing technique based on a variable dependence graph. We have applied the proposed method to one case in automotive control software and demonstrated the effectiveness of the method. Furthermore, we developed a software tool to automate model generation and achieved a 35% decrease in total verification time on model checking.Comment: In Proceedings FTSCS 2012, arXiv:1212.657

Generalized Points-to Graphs: A New Abstraction of Memory in the Presence of Pointers

Flow- and context-sensitive points-to analysis is difficult to scale; for top-down approaches, the problem centers on repeated analysis of the same procedure; for bottom-up approaches, the abstractions used to represent procedure summaries have not scaled while preserving precision. We propose a novel abstraction called the Generalized Points-to Graph (GPG) which views points-to relations as memory updates and generalizes them using the counts of indirection levels leaving the unknown pointees implicit. This allows us to construct GPGs as compact representations of bottom-up procedure summaries in terms of memory updates and control flow between them. Their compactness is ensured by the following optimizations: strength reduction reduces the indirection levels, redundancy elimination removes redundant memory updates and minimizes control flow (without over-approximating data dependence between memory updates), and call inlining enhances the opportunities of these optimizations. We devise novel operations and data flow analyses for these optimizations. Our quest for scalability of points-to analysis leads to the following insight: The real killer of scalability in program analysis is not the amount of data but the amount of control flow that it may be subjected to in search of precision. The effectiveness of GPGs lies in the fact that they discard as much control flow as possible without losing precision (i.e., by preserving data dependence without over-approximation). This is the reason why the GPGs are very small even for main procedures that contain the effect of the entire program. This allows our implementation to scale to 158kLoC for C programs

Static Slicing of Interprocedural Programs

Program slicing has many applications in a software development environment such as debugging, testing, anomaly detection, program understanding and many more. The concept being introduced by Weiser and it was started with static slicing calculation. Talking about static slicing, it is a subset of statements of a program which directly or indirectly affect the values of the variables computed providing a slicing criterion. In this project, we have developed an approach for creating an intermediate representation of a program in the form of System Dependence Graph (SDG) which is to be, again taken as input for computing the slicing of a program with respect to slicing criterion. The slicing approach computes the slices with respect to a given slicing criterion. For generating the graph, we have analysed the input program, identified the tokens and finally generated the relation between tokens as data dependent or control dependent. For calculating the slice, we have used two-phase graph reachability algorithm developed by Horwitz, Reps and Binkley, which creates a graph consisting of only those nodes that are dependent on slicing criterion. Finally we have plotted a graph between time taken to create graph versus number of functions used in program. Our approach of calculating slices has been limited only to C programs

Slicing Object Oriented Programs for Maintenance Purposes

Object oriented approach is growing very fast in various applications of the computer science. Those applications may contain a lot of entity relationships which, need to be understood by the maintainers. These relationships (involving classes, message, variables, etc.) will make maintainers and developers face several problems to understand, make changes, modify, or enhance a huge software system that contains thousands of classes without automatic aids. Therefore several problems arise in the maintenance of object oriented program that is software understanding, complex dependencies, inheritance, polymorphism and dynamic binding. An approach for formally defining slices for object oriented programs is an important problem in the maintenance phase. This thesis proposes definitions of slices for object oriented programs. Basic relations such as Usage, Affect and Inheritance are defined, and they are extended to a family of dependence relations between entities in object oriented programs and defines slicing techniques based on these relations. Slice collection methods for specified slice criteria are given. This approach shows how the proposed slicing concepts and rules can be applied within the software maintenance process by giving an illustration through examples written by Java and Delphi programming languages. The research also develop a prototype of an object oriented system tool (02SMt) which represent an automatically extractable and captures an object oriented software system dependencies i n order to aid in maintenance phase. The dependencies occurs and explain in this research are control dependence, statement dependence on a variable, statement dependence on a method, variable dependence on statement, variable dependent on a method, Class-Class dependence through usage, Class-Class dependence through inheritance, Class-Class dependence for causing side effects, method dependence on another method, and method dependence on a variable. The 02SMt captures program slicing according to the slicing concepts, rules and definitions to feature out the dependencies with the basic object oriented relations. This research also, discusses an object oriented dependence graph (02DG). The 02DG categorized according levels. The first category is class-level involving a class to another class. The second category is method-level involving a method or a statement within a method to another method or variable in a class. The final category is statement level which is basically intra-method involving statements within a given method. Slices, intum, can also be categorized according to such levels of dependencies they intend to capture