VADA: A transformation-based system for variable dependence analysis

Variable dependence is an analysis problem in which the aim is to determine the set of input variables that can affect the values stored in a chosen set of intermediate program variables. This paper shows the relationship between the variable dependence analysis problem and slicing and describes VADA, a system that implements variable dependence analysis. In order to cover the full range of C constructs and features, a transformation to a core language is employed Thus, the full analysis is required only for the core language, which is relatively simple. This reduces the overall effort required for dependency analysis. The transformations used need preserve only the variable dependence relation, and therefore need not be meaning preserving in the traditional sense. The paper describes how this relaxed meaning further simplifies the transformation phase of the approach. Finally, the results of an empirical study into the performance of the system are presented

Branch-coverage testability transformation for unstructured programs

Test data generation by hand is a tedious, expensive and error-prone activity, yet testing is a vital part of the development process. Several techniques have been proposed to automate the generation of test data, but all of these are hindered by the presence of unstructured control flow. This paper addresses the problem using testability transformation. Testability transformation does not preserve the traditional meaning of the program, rather it deals with preserving test-adequate sets of input data. This requires new equivalence relations which, in turn, entail novel proof obligations. The paper illustrates this using the branch coverage adequacy criterion and develops a branch adequacy equivalence relation and a testability transformation for restructuring. It then presents a proof that the transformation preserves branch adequacy

Amorphous slicing of extended finite state machines

Slicing is useful for many Software Engineering applications and has been widely studied for three decades, but there has been comparatively little work on slicing Extended Finite State Machines (EFSMs). This paper introduces a set of dependency based EFSM slicing algorithms and an accompanying tool. We demonstrate that our algorithms are suitable for dependence based slicing. We use our tool to conduct experiments on ten EFSMs, including benchmarks and industrial EFSMs. Ours is the first empirical study of dependence based program slicing for EFSMs. Compared to the only previously published dependence based algorithm, our average slice is smaller 40% of the time and larger only 10% of the time, with an average slice size of 35% for termination insensitive slicing

Search-based amorphous slicing

Amorphous slicing is an automated source code extraction technique with applications in many areas of software engineering, including comprehension, reuse, testing and reverse engineering. Algorithms for syntax-preserving slicing are well established, but amorphous slicing is harder because it requires arbitrary transformation; finding good general purpose amorphous slicing algorithms therefore remains as hard as general program transformation. In this paper we show how amorphous slices can be computed using search techniques. The paper presents results from a set of experiments designed to explore the application of genetic algorithms, hill climbing, random search and systematic search to a set of six subject programs. As a benchmark, the results are compared to those from an existing analytical algorithm for amorphous slicing, which was written specifically to perform well with the sorts of program under consideration. The results, while tentative at this stage, do give grounds for optimism. The search techniques proved able to reduce the size of the programs under consideration in all cases, sometimes equaling the performance of the specifically-tailored analytic algorithm. In one case, the search techniques performed better, highlighting a fault in the existing algorith

A slicing-based approach for locating type errors

The effectiveness of a type checking tool strongly depends on the accuracy of the positional information that is associated with type errors. We present an approach where the location associated with an error message e is defined as a slice P_e of the program P being type checked. We show that this approach yields highly accurate positional information: P_e is a program that contains precisely those program constructs in P that caused error e. Semantically, we have the interesting property that type checking P_e is guaranteed to produce the same error e. Our approach is completely language-independent, and has been implemented for a significant subset of Pascal

Fragmentación de programas con excepciones

[ES] La fragmentación de programas es una técnica de análisis de programas que puede ser aplicada prácticamente a todos los lenguajes de programación. Sin embargo, en presencia de excepciones, los fragmentadores de programas tienen un problema de precisión. Este proyecto aborda el problema de la fragmentación de programas en presencia de excepciones, analizando el problema desde una perspectiva general (para cualquier tipo de sistema de excepciones), pero concentrando nuestros esfuerzos en el paradigma de la orientación a objetos, más específicamente en el lenguaje Java. En esta tesis, estudiamos las soluciones existentes al problema planteado, y proponemos una generalización que incluye por lo menos las instrucciones 'try-catch' y 'throw'. Damos descripciones detalladas, generalizaciones y soluciones a dos problemas que aumentan innecesariamente el tamaño de los fragmentos de programa y un problema que reduce bastante la precisión. Las soluciones que proponemos producen fragmentos que garantizan la completitud y son tan correctos como es posible, dadas las restricciones marcadas por el sistema de manejo de excepciones. El análisis realizado y las soluciones propuestas son específicas para el lenguaje de programación Java y su sistema de manejo de excepciones, pero también son lo suficientemente generales como para poder ser empleadas en otros lenguajes de programación que posean un sistema de excepciones. También son específicas para la fragmentación estática hacia atrás, pero, del mismo modo, son compatibles con otras variantes en la fragmentación de programas.[EN] Program slicing is an analysis technique that can be applied to practically all programming languages. However, in the presence of exception handling, current program slicing software has a precision problem. This project tackles the problem of program slicing with exception handling, analysing the problem from a general perspective (for any kind of exception system), but focusing our efforts in the object-oriented paradigm, specifically the Java language. In this thesis, we study the currently available solutions to the problem, and we propose a generalization that includes at least the 'try-catch' and 'throw' statements. We provide detailed descriptions, generalizations and solutions for two problems that increase the size of slices and one problem that greatly reduces the precision of slices. The solutions we propose produce slices that guarantee completeness and are as correct as possible, given the restrictions set by the exception handling system. The analysis performed and solutions proposed are specific for the Java programming language, but are general enough that they can be ported effortlessly to other programming languages with similar exception handling capabilities. They are also specific for static backward slicing, but are likewise compatible with other variants of program slicing.Galindo Jiménez, CS. (2019). Fragmentación de programas con excepciones. http://hdl.handle.net/10251/136752TFG