This paper described a flexible instrumentation toolkit (FIT), intended to instrument binary code in “Alpha, x86, and ARM architectures and Tru64Unix, Linux, and ARM firmware execution environments. The paper focuses on some of the problems that needed to be addressed for providing this degree of portability. It also discusses the trade-off between instrumentation precision and low overhead.” The instrumentation is static, and follows the general design of ATOM, a widely used instrumentation tool, available in the field since 1994, with some improvements, as mentioned below. It appears to be addressed to compiler designers and researchers, however it clearly could be used by sufficiently capable application developers, to obtain control flow data about their programs.
Some of the shortcomings of ATOM are discussed, as are other approaches to program instrumentation and data collection, such as dynamic instrumentation and simulation. The paper cites some of the disadvantages of these approaches. The stated objectives of FIT are clearly valid for the use of compiler designers and researchers. Further, the dynamic and simulation-based tools most likely weren’t meant for compiler designers and researchers. They have advantages of their own, in areas for which they were intended, such as in the instrumentation of self-modifying or dynamically generated code (as stated by the authors), in the case of dynamic instrumentation, and in the collection of much more detailed data about machine architecture, cycle level counts and timings, and memory access patterns, albeit suffering a much higher overhead, in the case of simulation-based tools. The authors appear to short-change these tools, because they weren’t intended for compiler design and research.
The paper also short-changes ATOM, by overemphasizing some shortcomings that would appear to impact only a very small percentage of the cases in which it is used. Given the large user base of ATOM, apparently it is useful in a large number of applications. The advantages cited for FIT over ATOM are dependent on how much accuracy is really needed, the architecture and execution environment being used, and the type of code being instrumented. Further, it is natural that a tool being developed after ATOM should be better, since it is based on the experience gained by using the latter. It is also possible that some of the problems cited for ATOM have now been resolved or improved.
The design of FIT is described well, in particular the ordinary and reverse translation of addresses, and the problems due to indirect accesses. The general difficulty of distinguishing data and addresses that need to be preserved is discussed nicely, with some examples. Finally, an analysis and evaluation of the overhead cost of the tool in various architectures, using combinations of block tracing, memory access, ordinary translation, and reverse translation techniques is presented.
The paper contains a good list of references, despite the fact that a great deal of literature exists on this subject. See, for instance, the papers on Diota, ATOM, and Simics cited in this paper.
Overall, this is an important paper for developers and users of program instrumentation tools, particularly those involved in compiler design and research.
