Design And Implementation Of Points-To Analysis Tool For Aspect-Oriented Program

Aspect-oriented programming (AOP) has been proposed as a programming paradigm for improving separation of concerns in software design and implementation. AOP works by providing explicit mechanisms for capturing the structure of crosscutting concerns such as exception handling, synchronization, performance optimizations, and resource sharing, which are usually difficult to express clearly in source code using existing programming techniques. AOP can also control the code tangling problem, making the underlying concerns more apparent, and enable the software more easy to develop, maintain, and evolve.AspectJ, one of the most widely used AOP languages, is a seamless aspect-oriented extension to Java by adding some new constructs such as join point, advice, and aspect. An AspectJ program can be divided into two parts: base code which includes classes, interfaces, and other language constructs as in Java, and aspect code which includes aspects for modeling crosscutting concerns in the program. With the inclusion of join points, an aspect woven into the base code is solely responsible for a particular crosscutting concern, which raises the system's modularity.Points-to analysis is a fundamental analysis technique whose results are useful in compiler optimization and software engineering tools. Although many points-to analysis algorithms have been proposed for procedural and object-oriented languages like C and Java, there is no points-to analysis for aspect-oriented languages until now.Based on Andersen-style points-to analysis for Java, we propose a flow- and context-insensitive points-to analysis for AspectJ. The main idea is to perform the analysis crossing the boundary between aspects and classes. Therefore, our technique is able to handle the unique aspectual features. To investigate the effectiveness of our technique, we implement our analysis approach on top of the ajc AspectJ compiler and evaluate it on nine AspectJ benchmarks. The experimental result indicates that, compared to existing Java approaches, the proposed technique can achieve a significant higher precision and run in practical time and space.The main contributions of this thesis are threefold. First, we define general-purpose flow-insensitive and context-insensitive points-to analysis for AspectJ which extends the semantics of Rountev et al.'s points-to analysis for Java. Second, we implement a points-to analysis tool AJPTAT for AspectJ programs based on the ajc compiler. Third, we perform an empirical evaluation on nine AspectJ benchmarks for our points-to technique. The experimental result indicates that a significant higher precision can be achieved compared to the existing Java approach.