The classical plain-text representation of source code is convenient for programmers but requires parsing to uncover the deep structure of the program. While sophisticated software tools parse source code to gain access to the program's structure, many lightweight programming aids such as grep rely instead on only the lexical structure of source code. I describe a new XML application that provides an alternative representation of Java source code. This XML-based representation, called JavaML, is more natural for tools and permits easy specification of numerous software-engineering analyses by leveraging the abundance of XML tools and techniques. A robust converter built with the Jikes Java compiler framework translates from the classical Java source code representation to JavaML, and an XSLT stylesheet converts from JavaML back into the classical textual form. Keywords: Java, XML, abstract syntax tree representation, software-engineering analysis, Jikes compiler. 1 Introduction Since...

In this dissertation, we show how a relatively simple and extremely fast interprocedural optimization algorithm can be used to optimize many of the expensive features of statically typed, object-oriented languages --- in particular, C++ and Java. We present a new program analysis algorithm, Rapid Type Analysis, and show that it is fast both in theory and in practice, and significantly out-performs other "fast" algorithms for virtual function call resolution. We present optimization algorithms for the resolution of virtual function calls, conversion of virtual inheritance to direct inheritance, elimination of dynamic casts and dynamic type checks, and removal of object synchronization. These algorithms are all presented within a common framework that allows them to be driven by the information collected by Rapid Type Analysis, or by some other type analysis algorithm. Collectively, the optimizations in this dissertation free the programmer from having to sacrifice modularity and extensibility for performance. Instead, the programmer can freely make use of the most powerful features of object-oriented programming, since the optimizer will remove unnecessary extensibility from the program.

Object-oriented applications may contain data members that can be removed from the application without affecting program behavior. Such "dead" data members may occur due to unused functionality in class libraries, or due to the programmer losing track of member usage as the application changes over time. We present a simple and efficient algorithm for detecting dead data members in C++ applications. This algorithm has been implemented using a prototype version of the IBM VisualAge C++ compiler, and applied to a number of realistic benchmark programs ranging from 600 to 58,000 lines of code. For the non-trivial benchmarks, we found that up to 27.3% of the data members in the benchmarks are dead (average 12.5%), and that up to 11.6% of the object space of these applications may be occupied by dead data members at run-time (average 4.4%). 1 Introduction Object-oriented applications may contain data members (instance variables) that can be removed from the application without affecting p...

The abstract mathematical theory of... may be useful for other styles and in other application domains as well.

This paper describes an empirical comparison of the effectiveness of six context-insensitive pointer analysis algorithms that use varying degrees of flow-sensitivity. Four of the algorithms are flow-insensitive, one is flow-sensitive, and another is flow-insensitive, but uses precomputed flow-sensitive information. The effectiveness of each analysis is quantified in terms of compile-time efficiency and precision. Efficiency is reported by measuring CPU time and memory consumption of each analysis. Precision is reported by measuring the computed solutions at the program points where a pointer is dereferenced. The results of this paper will help implementors determine which pointer analysis is appropriate for their application.

The information computed by a pointer alias analysis can be used to improve the precision of subsequent analyses, such as conditional constant propagation. Conditional constant propagation can, in turn, discover unexecutable code, which can improve the precision of pointer analysis. This improved alias precision, in turn, may increase the effectiveness of the conditional constant propagation, and so on. One way to resolved this mutual dependence between conditional constant propagation and pointer alias analysis is to iterate over the two analyses until a fixed point is reached. In addition to raising efficiency concerns, the resulting precision may also not be optimal, i.e., a more tightly coupled analysis can have better precision for both alias analysis and conditional constant propagation than iterating over the two analyses. In this work we explore three combinations of pointer alias analysis and conditional constant propagation: a one-pass-over-analyses approach, an iterate-ove...

This paper describes an empirical comparison of three pointer alias analysis algorithms: flow-sensitive, flow-insensitive, and flow-insensitive with precomputed kill information. In addition to contrasting the precision and efficiency of these analyses, it describes implementation techniques and quantifies their analysis-time speed-up. Lastly, it illustrates the object-oriented approach used in the design of the system, which provides a natural example of multiple inheritance.

The Internet has grown in popularity in recent years, and thus it has gained importance for many current businesses. They need to o#er their products and services through their Web sites. To present not only static content but also interactive services, the logic behind these services needs to be programmed.

Abstract. Though programming languages and programming styles evolve with remarkable speed today, there is no such evolution in the field of program documentation. And although there exist some popular approaches like Knuth’s literate programming system WEB [26], and nowadays JavaDoc [15] or Doxygen [16], tools for managing software development and documentation are not as widespread as desirable. This paper analyses a wide range of literate programming tools available during the past two decades and introduces ProgDOC, a new software documentation system. It is simple, language independent, and it keeps documentation and the documented software consistent. It uses L ATEX for typesetting purposes, supports syntax highlighting for various languages, and produces output in Postscript, PDF or HTML format. 1