On-line Java^TM Data Traces

By Milo M. Martin and Manoj Plakal

Obtaining the Java Interpreter Patch

[ Legalese | General information | Applying the patch | Using the patch ]

Legalese :
COPYING AND USE : This patch has been made publicly and freely available, to aid research in general. It is provided for free use and modification by all. However, no claim is made about its fitness for any purpose. Re-distribution (in original or modified form) is allowed provided you include a pointer to this site. In order to use this patch to obtain data for a project or publication, in compliance with proper academic scholarship, you should properly cite our contribution. We would also appreciate it if you could inform us if you find this patch useful.
DISCLAIMER : This patch is provided "AS IS", without any express or implied warranty, and we accept no responsibility for the consequences of the use or misuse of this modification to Sun Microsystem's JDK 1.0.2.
Some general information :
- This patch was prepared using Sun Microsystem's Java Development Kit (JDK) Version 1.0.2 ( NOT JDK Version 1.1) for Solaris running on x86. We haven't checked to see if this patch works for other platforms. The patch will not work with other versions (like JDK1.1) of the JDK.
- The patch was prepared by changing the file
  src/share/java/runtime/interpreter.c
  (directory relative to the root of the JDK source tree). This file contains C source code and is the meat of the Java interpreter and contains a HUGE switch statement with a case for each JVM instruction. The interpreter steps through each instruction and executes this switch statement to interpret that instruction. We defined a few macros for printing out useful address information (for code/data being referenced) and then inserted calls to these macros into each case of the switch. We did NOT change any other file. Building the JDK binaries with this modified file gave us a Java interpreter that produced a trace of code/data references (appropriately categorized) when it ran a class file (The macros were defined so that we could distinguish between stack/local/heap references). This process will NOT work with JDK1.1 because this switch statement has been replaced by equivalent assembly language..
- The JDK licensing agreement we signed before obtaining the JDK forbids us from re-distributing modified source files so we will not be able to put the entire modified file on-line. Instead we are providing a patch (produced by the Unix diff utility) which can be applied to the original interpreter.c to produce our modified version of the file.
Downloading and applying the patch :
[ Following assumes that you're using a Unix box, not a PC ]
- The patch is available here. Save the file as patch.verbose. Double-check the file sizes :
  patch.verbose : 24131 bytes, interpreter.c : 94284 bytes
- Now, apply the patch by issuing the following shell command :
  cat patch.verbose | ed - interpreter.c > interpreter.c.patched
  This creates the patched version of the file in interpreter.c.patched (its size should be 116407 bytes). You should copy the original interpreter.c to a safe backup location and rename the patched file to be interpreter.c. You should be able to successfully build the JDK binaries by issuing a make in the appropriate subdirectory of the build tree.
Using/extending the patch :
- Just run the Java interpreter (even the Java compiler is run using this interpreter because it's written in Java) on a class file and you get a trace produced on standard error. This trace can get quite big even for small Java programs, so you might want to pipe it through gzip and keep it compressed.
- The patch we've providing you is a relatively verbose one. It prints very detailed information on standard error : apart from addresses of code/data (categorized as stack/heap/local and read/written), it also prints the op-code of each executed instruction, as well as a message every time you enter or return from a method. However, since everything is implemented using macros, you can redefine the macros or simply comment out the definitions of the macro you don't need. The code for printing information on entering/returning from a method is not implemented using macros, so you'll have to comment out that code yourself.
- To help in finding the code we added, we put comments before and after each insertion, of the form :
```
	    /*
	     * -- ADDED by plakal@skipper
	     */

	     [...]

	     /*
	      * -- END ADDITION by plakal@skipper
	      */
          
```
  Also, if we've defined variables/macros we've used the number '752' in all of them (this was a project for CS752 here). So if you do a search for 752, you will find all the macros/variables we defined. The macros we defined go something like these :
```
		CS752_CODE_READ
		CS752_CODE_WRITE
		CS752_DATA_READ
		CS752_DATA_WRITE 
         
```
  and so on. You'll find the macro definitions just before the switch statement.
Last updated on