Byte code instrumentation
DCFirst Claim
1. A computer program product for instrumenting an initial byte code computer program, comprising:
- machine executable code that examines the initial byte code to determine an identifier associated with at least one block of code included in the initial byte code;
machine executable code that selects portions of the initial byte code for instrumentation; and
machine executable code that instruments, while loading the initial byte code, the portions by supplementing the initial byte code with additional byte code for instrumentation that facilitates runtime data gathering to monitor execution of the computer program, wherein a portion of the additional byte code uses the identifier to instrument portions of the initial byte code associated with said at least one block of code.
6 Assignments
Litigations
0 Petitions
Accused Products
Abstract
Instrumenting a computer program to provide instrumented byte code includes examining the byte code, selecting portions of the byte code for instrumentation, and instrumenting the portions to provide instrumented byte code. Selecting the portions may include choosing portions of the byte code corresponding to method entry, method exit, a throw, a method call, or a new line number. Instrumenting a portion of the byte code corresponding to a method call may include instrumenting a local line number of source code corresponding to the byte code being instrumented. Instrumenting the portions may include adding calls to instrumentation runtime functions that pass parameters indicative of the portions being instrumented. At least one of the parameters that is passed may include a line number of the source code corresponding to the portion being instrumented or a thispointer for the method corresponding to the portion being instrumented. Data from instrumentation may be passed via a message stream that is viewed as the data is being generated and/or stored.
110 Citations
41 Claims
-
1. A computer program product for instrumenting an initial byte code computer program, comprising:
-
machine executable code that examines the initial byte code to determine an identifier associated with at least one block of code included in the initial byte code;
machine executable code that selects portions of the initial byte code for instrumentation; and
machine executable code that instruments, while loading the initial byte code, the portions by supplementing the initial byte code with additional byte code for instrumentation that facilitates runtime data gathering to monitor execution of the computer program, wherein a portion of the additional byte code uses the identifier to instrument portions of the initial byte code associated with said at least one block of code. - View Dependent Claims (2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)
selects portions of the initial byte code corresponding to at least one of;
method entry, method exit, a throw, a method call, a new line number.
-
-
3. The computer program product of claim 2, wherein said machine executable code that instruments a portion of the initial byte code corresponding to a method call includes machine executable code that:
instruments a local line number of source code corresponding to the initial byte code being instrumented.
-
4. The computer program product of claim 1, wherein said machine executable code that instruments portions includes machine executable code that:
adds calls to instrumentation runtime functions that pass parameters indicative of portions being instrumented.
-
5. The computer program product of claim 4, wherein at least one of the parameters that is passed includes a line number of source code corresponding to the portion being instrumented.
-
6. The computer program product of claim 4, wherein at least one of the parameters that is passed includes a this pointer for a method corresponding to the portion being instrumented.
-
7. The computer program product of claim 4, wherein at least one of the parameters that is passed corresponds to at least one method parameter provided to a method containing byte code that is instrumented.
-
8. The computer program product of claim 7, further comprising:
machine executable code that passes data indicative of the at least one method parameter in a message buffer from an instrumentation runtime function to at least one viewer routine that displays the data to a user.
-
9. The computer program product of claim 8, wherein the message buffer includes scalar data, array data, and object data.
-
10. The computer program product of claim 9, further comprising:
-
machine executable code that places an object header in the message buffer; and
machine executable code that places an array header in the message buffer.
-
-
11. The computer program product of claim 10, further comprising:
machine executable code that limits the message buffer to a predetermined size.
-
12. The computer program product of claim 4, further comprising:
machine executable code that stores data indicative of the parameters in a message buffer.
-
13. The computer program product of claim 12, further comprising:
machine executable code that passes data from the message buffer to at least one viewer routine that displays the data to a user.
-
14. The computer program product of claim 1, further comprising:
machine executable code that instruments an end of a method to provide instrumentation for handling an abort.
-
15. The computer program product of claim 1, further comprising:
machine executable code that instruments a call to a native function by adding a byte code wrapper to the native function and then instrumenting the wrapper.
-
16. The computer program product of claim 15, wherein the wrapper includes byte code corresponding to method entry and exit portions.
-
17. The computer program product of claim 1, further comprising:
machine executable code that instruments a call to a native function by providing a native assembly language thunk that captures data passed to and from the native function.
-
18. The computer program product of claim 17, further comprising:
machine executable code that hooks the assembly language thunk between a virtual machine and the call to the native function.
-
19. The computer program product of claim 18, wherein said machine executable code that hooks the assembly language thunk further includes:
machine executable code that intercepts a call that provides an address for a procedure.
-
20. The computer program product of claim 1, further comprising:
machine executable code that provides a routine to pass data via a message stream.
-
21. The computer program product of claim 20, further comprising:
machine executable code that provides a data storage to store data provided via the message stream.
-
22. The computer program product of claim 20, further comprising:
machine executable code that provides a viewer to allow viewing at least a subset of data from the message stream as the data is being generated.
-
23. A computer program product for instrumenting a computer program, comprising:
-
machine executable code that examines an initial byte code representation of the program to determine an identifier associated with at least one block of code included in the initial byte code;
machine executable code that creates a program counter mapping table corresponding to the initial byte code representation;
machine executable code that selects portions of the initial byte code representation for instrumenting using the program counter mapping table;
machine executable code that instruments, while loading the initial byte code representation, the portions by supplementing the initial byte code representation with calls byte code to instrumentation runtime functions at at least some of the portions to facilitate runtime data gathering for monitoring execution of the computer program, wherein a portion of the calls byte code uses the identifier to instrument portions of the initial byte code representation associated with said at least one block of code; and
machine executable code that modifies the program counter mapping table according to original byte code and supplemented byte code. - View Dependent Claims (24, 25, 26, 27, 28, 29, 30, 31, 32)
machine executable code that selects portions of the initial byte code representation corresponding to at least one of;
method entry, method exit, a throw, a method call, and a new line number.
-
-
25. The computer program product of claim 23, wherein said machine executable code that instruments the portions includes:
machine executable code that adds calls to instrumentation runtime functions that pass parameters indicative of the portions being instrumented.
-
26. The computer program product of claim 23, further comprising:
machine executable code that instruments a call to a native function by adding a byte code wrapper to the native function and then instrumenting the wrapper.
-
27. The computer program product of claim 26, wherein the wrapper includes byte code instrumentation corresponding to method entry and exit portions.
-
28. The computer program product of claim 23, further comprising:
machine executable code that instruments a call to a native function by providing a native assembly language thunk that captures data passed to and from the native function.
-
29. The computer program product of claim 28, further comprising:
machine executable code that hooks the assembly language thunk between a virtual machine and the call to the native function.
-
30. The computer program product of claim 29, wherein said machine executable code that hooks the assembly language thunk includes:
machine executable code that intercepts a call that provides an address for a procedure.
-
31. The computer program product of claim 23, further comprising:
machine executable code that, following examining an initial byte code representation of the program, registers each of the methods and corresponding line numbers thereof with runtime instrumentation code.
-
32. The computer program product of claim 31, wherein each of the methods and corresponding line numbers thereof facilitates determining source code being executed during run time debugging.
-
33. An apparatus for instrumenting an initial byte code computer program, comprising:
-
means for examining the initial byte code to determine an identifier associated with at least one block of code included in the initial byte code;
means for selecting portions of the initial byte code for instrumentation; and
means for instrumenting, while loading the initial byte code, the portions by supplementing the initial byte code with additional byte code for instrumentation that facilitates runtime data gathering to monitor execution of the computer program, wherein a portion of the additional byte code uses the identifier to instrument portions of the initial byte code associated with said at least one block of code. - View Dependent Claims (34, 35, 36, 37)
means for selecting portions of the initial byte code corresponding to at least one of;
method entry, method exit, a throw, a method call, and a new line number.
-
-
35. The apparatus of claim 34, wherein said means for instrumenting a portion of the initial byte code corresponding to a method call includes:
means for instrumenting a local line number of source code corresponding to the initial byte code being instrumented.
-
36. The apparatus of claim 33, wherein said means for instrumenting portions includes:
means for adding calls to instrumentation runtime functions that pass parameters indicative of portions being instrumented.
-
37. The apparatus of claim 36, wherein at least one of the parameters that is passed includes a line number of source code corresponding to the portion being instrumented.
-
38. An apparatus for instrumenting a computer program, comprising:
-
means for examining examines an initial byte code representation of the program to determine an identifier associated with at least one block of code included in the initial byte code;
means for creating a program counter mapping table corresponding to the initial byte code representation;
means for selecting portions of the initial byte code representation for instrumenting using the program counter mapping table;
means for instrumenting, while loading the initial byte code representation, the portions by supplementing the initial byte code representation with calls byte code to instrumentation runtime functions at at least some of the portions to facilitate runtime data gathering for monitoring execution of the computer program, wherein a portion of the calls byte code uses the identifier to instrument portions of the initial byte code representation associated with said at least one block of code; and
means for modifying the program counter mapping table according to original byte code and supplemented byte code. - View Dependent Claims (39, 40, 41)
means for selecting portions of the initial byte code intermediate representation corresponding to at least one of;
method entry, method exit, a throw, a method call, and a new line number.
-
-
40. The apparatus of claim 38, wherein said means for instrumenting the portions includes:
means for adding calls to instrumentation runtime functions that pass parameters indicative of the portions being instrumented.
-
41. The apparatus of claim 38, further comprising:
means for instrumenting a call to a native function by adding a byte code wrapper to the native function and then instrumenting the wrapper.
Specification