The induction variable analysis is a fundamental component of loop optimizations in compilers. Algorithms in literature and implementations in free-source compilers such as GCC and LLVM rely on SSA form IR. However, only the uses of scalar stack variables whose address is not taken are replaced with a single definition in the SSA form IR. In this paper, we describe how Interprocedural SSA (ISSA) form IR can be leveraged to extend the induction variable analysis interprocedurally to: globals, singleton heap variables, record elements, and files. We implemented our induction variable analysis and compared it against the LLVM infrastructure for a set of MediaBench and SPEC2K benchmarks. We observed an average increase of 8.1% and 58.4% in the number of polynomial and monotonic induction variables, respectively. Furthermore, due to ISSA form IR and our induction variable analysis we computed 1.02 times more constant tripcounts and 2.06 times more loop invariant tripcounts.

One of the bottlenecks in the recent movement of hardware synthesis from behavioral C programs is the difficulty in reasoning about runtime pointer values at compile time. The pointer analysis problem has been investigated in the compiler community for two decades and has yielded efficient, polynomial time algorithms for context-insensitive (CI) analysis. However, at the accuracy level for which hardware synthesis is desired, namely context and flow sensitive analysis, the time and space complexity of the best algorithms reported grow exponentially with program size. In this paper, we propose a new analysis technology to combat the inefficiency encountered in traditional algorithms. The key idea is to implicitly encode the pointer-to relation in the Boolean domain by Bryant's binary decision diagram, thereby capturing the procedure transfer function completely, compactly and canonically. With symbolic transfer functions, we can establish a common framework to perform both CI and context-sensitive (CS) pointer analysis efficiently. In addition, we propose a symbolic representation of the invocation graph, which can otherwise be exponentially large. In contrast to the classical frameworks, where CS point-to information of a procedure has to be obtained by the application of its transfer function exponentially many times, our method can obtain point-to information of all contexts in a single application. Our experimental evaluation on a wide range of C benchmarks indicates that our CS pointer analysis can be made almost as fast as its CI counterpart.

Pointer analysis is a critical problem in optimizing compiler, parallelizing compiler, software engineering and most recently, hardware synthesis. While recent efforts have suggested symbolic method, which uses Bryant's Binary Decision Diagram as an alternative to capture the point-to relation, no speed advantage has been demonstrated for context-insensitive analysis, and results for context-sensitive analysis are only preliminary.In this paper, we refine the concept of symbolic transfer function proposed earlier and establish a common framework for both context-insensitive and context-sensitive pointer analysis. With this framework, our transfer function of a procedure can abstract away the impact of its callers and callees, and represent its point-to information completely, compactly and canonically. In addition, we propose a symbolic representation of the invocation graph, which can otherwise be exponentially large. In contrast to the classical frameworks where context-sensitive point-to information of a procedure has to be obtained by the application of its transfer function exponentially many times, our method can obtain point-to information of all contexts in a single application. Our experimental evaluation on a wide range of C benchmarks indicates that our context-sensitive pointer analysis can be made almost as fast as its context-insensitive counterpart.