Patent Application
20090172638
1. Field of the Invention
The present invention is directed to technology for adding functionality to existing code at exits.
2. Description of the Related Art
Performance profiling (or analysis) tools are popular tools used to debug software and to analyze an application's run time execution. Many performance profiling tools provide timing data on how long each method (or procedure or other process) is being executed, report how many times each method is executed and/or identify the function call architecture. Other functions can also be performed by various performance profiling tools. Some of the tools provide their results in text files or on a monitor. Other tools graphically display their results.
Many performance analysis tools perform their intended function by either instrumenting source code or instrumenting object code. Object code can be generated by a compiler or an assembler. Alternatively, object code can be generated manually. Object code can be machine executable or suitable for processing to produce executable machine code.
Instrumenting source code involves adding new instructions to source code and/or modifying existing instructions in the source code. Instrumenting object code includes adding new instructions to the object code and/or modifying existing instructions in the object code. Instrumenting object code does not involve accessing the source code. An example of instrumenting object code can be found in U.S. patent application Ser. No. 09/137,666, filed on Aug. 20, 1998, by Lewis K. Cirne, incorporated herein by reference.
One problem with instrumenting source code to provide performance profiling is that the source code may not be available. Thus, many performance profiling tools will add the performance profiling functionality by instrumenting the object code.
One difficulty in instrumenting code is that a method (or other set of instructions) may include many exits. Consider the following code for a method called “isNegative” which returns a Boolean value indicating whether a parameter is negative:
The above method includes at least two exit points. If the parameter x is less than 0, then the method exits at the “return true” instruction. If the parameter x is not less than 0, then the method exits at the “return false” instruction. Prior art systems that add performance profiling functionality will add new code to each of the exits in the code. For example, code will be added to the return clause and the else clause of the code above.
Adding performance profiling code to each of the instructions that can be an exit has its drawbacks. First, the same code may be added in several places which can significantly increase the amount of code in an application. A significant increase in code may impact the performance of the application and increase the chance of adding an error to the application. Additionally, the greater the number of exits, the greater chance that the system adding performance profiling code will miss one of the exits. Finally, not all of the exits are explicitly stated in the code. For example, there can be errors or exceptions. When an error or an exception occurs, the normal flow of the method can be halted, in which case none of the explicit exits will be performed and an exit associated with the error or exception will be performed. Previous performance profiling tools have not adequately accounted for all the possible exits in the software.
Therefore, what is needed is a system for adding performance profiling functionality to object code such that the new functionality is provided for all (or almost all) exits of the method (or other set of code). This need extends beyond just performance profiling tools. Thus, there is a need to add functionality to existing object code at the exits for a particular method (or other set of code) under consideration.
The present invention, roughly described, provides for a system for adding functionality to existing object code. The functionality is added so that multiple exits are accounted for. That is, if a method has multiple exits, and it is desired that the added functionality includes some type of action at each of the exits, then code is added to the existing object code such that the relevant action is performed at each of the exits.
In one embodiment, new code is added to existing object code to add the new functionality. For example, a call to start a profile action can be added at the beginning of a method and calls to stop the profile action can be added at the various exits of the method. A method may have many exits. The new code is added to insure that the profile action is stopped regardless of which of the exits is performed. In one embodiment using Java byte code, the byte code for a method and the method's exception table can be modified to implement the functions of the source code statements “try” and “finally.”
In one implementation, the method of the present invention comprises the steps of adding exit code to the existing object code and adding an entry to an exceptions data store pointing to the exit code. One alternative also includes adding start code to the existing object code; however, some embodiments do not add start code. The start code, the exit code and the entry into the exceptions data store are used to add the additional functionality. The additional functionality can be any functionality desired to be added to the existing object code. One example is to add performance profiling functionality.
In one embodiment, the start code starts an action and the exit code stops the action. The start code is positioned to be executed previous to the original byte code and the exit code is positioned to be executed subsequent to the original byte code. The step of adding exit code includes adding an instruction to jump to the exit code from the original byte code. In one implementation, the step of adding an entry in the exceptions data store includes adding a new entry into an exceptions table for that method. The new entry indicates a range of indices of byte code, reference to the exit code and an indication that the entry pertains to all types of exceptions. In one implementation, the method described above is implemented using the Java programming language.
The present invention can be implemented using hardware, software, or a combination of both hardware and software. The software used for the present invention is stored on one or more processor readable storage media including hard disk drives, CD-ROMs, DVDs, optical disks, floppy disks, tape drives, RAM, ROM or other suitable storage devices. In alternative embodiments, some or all of the software can be replaced by dedicated hardware including custom integrated circuits, gate arrays, FPGAs, PLDs, special purpose computers and programmed general computers. Hardware that can be used for the present invention includes computers, handheld devices, telephones (e.g. cellular, Internet enabled, etc.), two-way pagers, etc. Some of these hardware devices include processors, memory, nonvolatile storage, input devices and output devices.
These and other objects and advantages of the present invention will appear more clearly from the following description in which the preferred embodiment of the invention has been set forth in conjunction with the drawings.
In one embodiment of the present invention, new functionality is added to a method such that all or part of the new functionality is executed upon exit from the method. Rather than add many copies of the exit code in different places, the present invention adds exit code using “try” and “finally” functionality. Consider the following example pseudo code for a method called “foo” that includes a set of Java instructions:
For example purposes, assume that a user wishes to add a profiling function to the method so that the user can determine how time elapses while the method is being performed. To do this, code has to be inserted into the method to start a timer and code has to be inserted into the method to stop the timer. After the timer is stopped, the amount of time measured will be reported to the user. The present invention, conceptually, adds code to the above method foo( ) as follows:
As can be seen, new instructions represented by “start code” have been added to start the profiling function (e.g., start the timer). Additionally new code called “stop code” has been added that stops the profiling function. Rather than physically insert copies of the stop code at every possible explicit exit, the present invention conceptually encloses the [Java instructions] within a “try” block and places the stop code within a “finally” block. This implementation provides that the stop code will be performed regardless of the exit from the “try” block, including intentional exits and exceptions. Note that the “profiling function” can be a method, procedure, function, routine, subroutine, or any other set of code to implement profiling.
Many kinds of errors can cause exceptions. They range from serious hardware errors, such as a hard disk crash, to simple programming errors, such as trying to access an out-of-bounds array element. When such an error occurs within a Java method, the method creates an exception object and hands it off to the run time system. The exception object contains the information about the error, including its type and, possibly, the state of the program when the error occurred. The run time system is then responsible for finding some code to handle the error. In Java terminology, creating an exception object and handing it to the run time system is called throwing an exception.
After a method throws an exception, the run time system attempts to find something to handle the exception. The set of possible “somethings” to handle the exception is the set of methods in the call stack of the method where the error occurred. The run time system searches backwards through the call stack, beginning with the method in which the error occurred, until it finds a method that contains an appropriate exception handler. An exception handler is considered appropriate if the type of exception thrown is the same type as the type of exception handled by the handler. The exception bubbles up through the call stack until an appropriate handler is found and one of the calling methods handles the exception. The exception handler chosen is said to catch the exception. If the run time system exhaustively searches all the methods in the call stack without finding an appropriate exception handler, the thread terminates. A method can catch an exception by providing an exception handler for that type of exception. One type of exception handler is the “catch” handler.
The first step in constructing an exception handler is to enclose the statements that might throw an exception within a “try” block. Exception handlers are associated with a “try” block by providing one or more “catch” blocks directly after the “try” block. Each “catch” block is an exception handler and handles the type of exception indicated by its argument. Exception handling may optionally include a means for cleaning up before (possibly) allowing control to be passed to a different part of the program. This can be done by enclosing the clean up code within a “finally” block. Java's “finally” block provides a mechanism that allows a method to clean up after itself regardless of what happens within the try block. Typically, the “finally” block is used to close files or release other system resources.
To further understand the above discussion, below is example pseudo code for a method called “exampleMethod.” This method receives an integer parameter, adds 1 to the integer parameter, and returns the sum:
The present invention will instrument this code, conceptually, by including a call to a tracer method, grouping the original instructions from the method in a “try” block and adding a “finally” block with a code that stops the tracer:
IMethodTracer is an interface that defines a tracer for profiling. AMethodTracer is an abstract class that implements IMethodTracer. IMethodTracer includes the methods startTrace and finishTrace. AMethodTracer includes the methods startTrace, finishTrace, dostartTrace and dofinishTrace. The method startTrace is called to start a tracer, perform error handling and perform setup for starting the tracer. The actual tracer is started by the method doStartTrace, which is called by startTrace. The method finishTrace is called to stop a tracer, and to perform overhead and error handling. The method finishTrace calls doFinishTrace to actually stop the tracer. Within AMethodTracer, startTrace and finishTracer are final and void methods; and doStartTrace and doFinishTrace are protected, abstract and void methods. Thus, the methods doStartTrace and do FinishTrace must be implemented in subclasses of AMethodTracer. Each of the subclasses of AMethodTracer implement the actual tracers (e.g., timer, counter, etc.). The method loadTracer is a static method that calls startTrace and includes five parameters. The first parameter, “com.introscope . . . ” is the name of the class that is intended to be instantiated that implements the interface (e.g., the timer, which is a subclass of AMethodTracer). The second parameter, “this” is the object being traced. The third parameter “com.wily.example . . . ” is the name of the class that the current instruction is inside of. The fourth parameter, “exampleMethod” is the name of the method the current instruction is inside of. The fifth parameter, “name=. . . ” is the name to record the statistics under. The original instruction (return x+1) is placed inside a “try” block. The code for stopping the tracer (a call to the static method tracer.finishTrace) is put within the finally block.
The above example shows source code being instrumented. In one embodiment, the present invention doesn't actually modify source code. Rather, the present invention modifies object code. The source code examples above are used for illustration to explain the concept of the present invention. The object code is modified conceptually in the same manner that source code modifications are done above. That is, the object code is modified to add the functionality of the “try” block and “finally” block.
In one embodiment of the present invention, the system will add code to the existing object code to detect the start of a first method. The detection of the start of the method causes the starting of a countdown timer. If the first method ends (or exits), the end of the first method will be detected and the timer will be terminated. If the first method does not end in a reasonable amount of time, the timer will reach zero and set off an alarm. Upon receiving an alarm, the system will conclude that the first method is lost. A lost method will be reported to the user. In one implementation, the system will cease capturing profiling information for the lost method. In one implementation, the end of the method is detected by code in the “finally” block, with the original code in the “try” block.
As described above, step 102 includes receiving the existing object code. In one embodiment, the received code is stored in a class data structure according to the Java Virtual Machine Specification.
The value of access flags item 214 is a mask of modifiers used with class and interface declarations. The access flags modifiers are public, final, super, interface and abstract. The value of this class item 214 must be a valid index into the constant pool table. The constant pool entry at that index must be a CONSTANT_Class_info structure representing the class or interface defined by this class file. For a class, the value of superclass item 216 either must be zero or must be a valid index into the constant pool. If the value of the superclass item is nonzero, the constant pool entry at that index must be a CONSTANT_Class_info structure representing the superclass of the class defined by this class file. Neither the superclass nor any of its superclasses may be a final class. If the value of a superclass item is zero, then this class file must represent the class java.lang.Object, the only class or interface without a superclass.
The value of interfaces count item 218 provides the number of direct superinterfaces of this class or interface type. Each value in the interfaces array 220 must be a valid index into the constant pool. The constant pool entry at each value of interfaces[i], where 0≦i<interfaces count, must be a CONSTANT_Class_info structure representing an interface which is a direct superinterface of this class or interface type. The value of the fields count item 222 provides the number of field_info structures in the fields table 224. The field_info structures represent all fields, both class variables and instance variables, declared by this class or interface type. Each value in the fields must be a variable-length field_info structure giving a complete description of a field in the class or interface type. The fields table includes only those fields that are declared by this class or interface. It does not include item fields that are inherited from superclasses or superinterfaces.
The value of methods count item 226 provides the number of method_info structures in methods table 228. Each entry in methods table 228 must be a variable-length method_info structure providing a complete description of the Java Virtual Machine code for a method in the class or interface. The method_info structures represent all methods, both instance methods and, for classes, class (static) methods, declared by this class or interface type.
The value of the attributes count item 230 provides the number of attributes in attributes table 232. Each entry in attributes table 232 must be a variable-length attribute structure. A class data structure can have any number of attributes associated with it. More information about ClassFile formats and the Java Virtual Machine can be found in The Java Virtual Machine Specification, Tim Lindholm and Frank Yellin, Addison-Wesley, 1997, incorporated herein by reference.
All constant pool entries have the following general format:
Each item in the constant pool must begin with a 1-byte tag indicating the type of cp_info entry. The contents of the info array varies with the value of the tag. The valid tags and their values are CONSTANT_Class, CONSTANT_Fieldref, CONSTANT_Methodref, CONSTANT_InterfaceMethodref, CONSTANT_String, CONSTANT_integer, CONSTANT_Float, CONSTANT_Long, CONSTANT_Double, CONSTANT_NameAndType, CONSTANT_Utf8. The following discussion explains the different types of constant pool entries.
The CONSTANT_Class_info structure is used to represent a class or an interface:
The tag item has the value CONSTANT_Class. The value of the name_index item must be a valid index into the constant pool. The constant pool entry at that index must be a CONSTANT_Utf8_info structure representing a valid fully qualified Java class name that has been converted to the class file's internal form. The values u1, u2 and u4 represent an unsigned one, two or four byte quantities, respectively.
Fields, methods, and interface methods are represented by similar structures:
The tag item of a CONSTANT_Fieldref_info structure has the value CONSTANT_Fieldref. The tag item of a CONSTANT_Methodref_info structure has the value CONSTANT_Methodref. The tag item of a CONSTANT_InterfaceMethodref_info structure has the value CONSTANT_InterfaceMethodref.
The value of the class_index item must be a valid index into the constant pool. The constant pool entry at that index must be a CONSTANT_Class_info structure representing the class or interface type that contains the declaration of the field or method.
The value of the name_and_type_index item must be a valid index into the constant pool. The constant pool entry at that index must be a CONSTANT_NameAndType_info structure. This constant pool entry indicates the name and descriptor of the field or method.
The CONSTANT_String_info structure is used to represent constant objects of the type java.lang.String:
The tag item of the CONSTANT_String_info structure has the value CONSTANT_String. The value of the string_index item must be a valid index into the constant pool. The constant pool entry at that index must be a CONSTANT_Utf8_info structure representing the sequence of characters to which the java.lang.String object is to be initialized.
The CONSTANT_integer info and CONSTANT Float info structures represent four-byte numeric (int and float) constants:
The tag item of the CONSTANT_Integer_info structure has the value CONSTANT_Integer. The tag item of the CONSTANT_Float_info structure has the value CONSTANT_Float. The bytes item of the CONSTANT_Integer_info structure contains the value of the int constant. The bytes of the value are stored in big-endian (high byte first) order. The bytes item of the CONSTANT_Float_info structure contains the value of the float constant in IEEE 754 floating-point “single format” bit layout. The bytes of the value are stored in big-endian (high byte first) order, and are first converted into an int argument.
The CONSTANT_Long_info and CONSTANT_Double_info represent eight-byte numeric (long and double) constants:
All eight-byte constants take up two entries in the constant pool. If a CONSTANT_Long_info or CONSTANT_-Double_info structure is the item in the constant pool at index n, then the next valid item in the pool is located at index n+2. The constant pool index n+1 must be considered invalid and must not be used.
The tag item of the CONSTANT_Long_info structure has the value CONSTANT_Long. The tag item of the CONSTANT_Double_info structure has the value CONSTANT_Double. The unsigned high bytes and low bytes items of the CONSTANT_Long structure together contain the value of the long constant ((long)high_bytes<<32)+low_bytes, where the bytes of each of high bytes and low bytes are stored in big-endian (high byte first) order. The high bytes and low bytes items of the CONSTANT_Double_info structure contain the double value in IEEE 754 floating point “double format” bit layout. The bytes of each item are stored in big-endian (high byte first) order.
The CONSTANT_NameAndType_info structure is used to represent a field or method, without indicating which class or interface type it belongs to:
The tag item of the CONSTANT_NameAndType_info structure has the value CONSTANT_NameAndType. The value of the name_index item must be a valid index into the constant pool. The constant pool entry at that index must be a CONSTANT_Utf8_info structure representing a valid Java field name or method name. The value of the descriptor index item must be a valid index into the constant pool. The constant_pool entry at that index must be a CONSTANT_Utf8_info structure representing a valid Java field descriptor or method descriptor.
The CONSTANT_Utf8_info structure is used to represent constant string values:
The tag item of the CONSTANT_Utf8_info structure has the value CONSTANT_Utf8. The value of the length item gives the number of bytes in the bytes array (not the length of the resulting sring). The strings in the CONSTANT_Utf8_info structure are not null-terminated.
Each field is described by a variable-length field_info structure. The format of this structure is
The value of the access_flags item is a mask of modifiers used to describe access permission to and properties of a field. The access_flags modifiers are public, private, protected, static, final, volatile and transient.
The value of the name_index item must be a valid index into the constant pool. The constant pool entry at that index must be a CONSTANT_Utf8_info structure which must represent a valid Java field name. The value of the descriptor_index item must be a valid index into the constant pool. The constant pool entry at that index must be a CONSTANT_Utf8 structure which must represent a valid Java field descriptor. The value of the attributes_count item indicates the number of additional attributes of this field. Each value of the attributes table must be a variable-length attribute structure. A field can have any number of attributes associated with it.
Each method is described by a variable-length method_info structure. The structure has the following format:
The value of the access_flags item is a mask of modifiers used to describe access permission to and properties of a method. The access_flags modifiers are public, private, protected, static, final, synchronized, native and abstract. The value of the name_index item must be a valid index into the constant pool. The constant pool entry at that index must be a CONSTANT_Utf8_info structure representing a valid Java method name. The value of the descriptor_index item must be a valid index into the constant pool. The constant pool entry at that index must be a CONSTANT_Utf8_info structure representing a valid Java method descriptor. The value of the attributes_count item indicates the number of additional attributes of this method. Each value of the attributes table must be a variable-length attribute structure. A method can have code attributes and exception attributes.
Attributes have the following general format:
The attribute_name_index must be a valid unsigned 16 bit index into the constant pool of the class. The constant pool entry at the attribute_name_index must be a CONSTANT_Utf8_info structure representing the name of the attribute. The value of the attribute_length item indicates the length of the subsequent information in bytes. The length does not include the initial 6 bytes that contain the attribute_name_index and attribute_length items.
The Java virtual machine recognizes code and exception attributes for a method_info structure. The Code attribute is a variable-length attribute used in the attributes table of method_info structures. A Code attribute contains the Java virtual machine instructions and auxiliary information for a single Java method, instance initialization method or class interface initialization method. Every Java virtual machine implementation must recognize code attributes. There must be exactly one Code attribute in each method_info structure.
The Code attribute has the following format:
The attribute_name_index must be a valid index into the constant pool table. The constant pool entry at the index must be a CONSTANT_Utf8_info structure representing the string “Code.” The value of the attribute length item indicates the length of the attribute, excluding the initial six bytes. The value of the max_stack item gives the maximum number of words on the operand stack at any point during execution of this method. The value of the max_locals item gives the number of local variables used by this method, including the parameters passed to the method on invocation. The index of the first local variable is 0. The value of the code_length item gives the number of bytes in the code array for this method. The code array stores the actual bytes of code that implement the method. The exception table_length provides the number of entries in the exception_table.
Each entry in the exception table array describes one exception handler in the code array. Each exception table entry contains the following items: start_pc, end_pc, handler_pc and catch_type. The values of start_pc and end_pc indicate the ranges in the code array at which the exception handler is active. The value of start_pc must be a valid index into the code array of the opcode of an instruction. The value of end_pc must be a valid index into the code array of the opcode of an instruction, or must be equal to code_length, the length of the code array. The value of start_pc must be less than the value of end_pc. Start_pc is inclusive and end_pc is exclusive. The value of handler_pc indicates the start of the exception handler code, is a valid index into the code array, is the index of the opcode of an instruction, and is less than the value of code_length. If the value of catch_type is non 0, then catch_type must be a valid index into the constant pool table. The constant pool entry at that index must be a CONSTANT_Class_info structure representing a class of exceptions that this exception handler is designed to catch. This class must be the class Throwable or one of the subclasses. The exception handler will be called only if the thrown exception is an instance of the given class or one of its subclasses. If the value of the catch type item is 0, this exception handler is called for all exceptions
this is used to implement “finally.” The value of the attributes_count item indicates the number of attributes in the code attribute. Each value of the attributes table must be a variable-length structure.
The Exceptions attribute is a variable-length attribute used in the attributes table of a method_info structure. The Exceptions attribute indicates which checked exceptions a method may throw. There must be exactly one exceptions attribute in each method_info structure. The exceptions attribute has the following format:
The value of attribute_name_index must be a valid index into the constant pool table. The constant pool entry at that index must be a CONSTANT_Utf8_info structure representing the string “Exceptions.” The value of the attribute_length item indicates the attribute length, including the initial 6 bytes. The value of the number_of exceptions item indicates the number of entries in the exception_index_table. Each non-zero value in the exception_index_table array must be a valid index into the constant pool to a CONSTANT_Class_info structure representing a class type that this method is prepared to throw.
The class file structure of
In step 302 of
In step 312 of
In step 314, a new entry is added to the exception table. This new entry correlates to the new “finally” block. The new entry has a catch_type of zero, indicating it is for all exceptions. Additionally, the new entry in the exceptions table will be added to the end of the exceptions table. The start_pc and end_pc the new entry would be set to include the original Java byte code for the method being instrumented. The value of the handler_pc for the new entry would point to the new byte code added in step 310.
To better understand the present invention, an example is provided. This example explains one embodiment for performing the present invention. Described above is example pseudo code for “exampleMethod.” Below is the pseudo object code (converted to a human readable form) for exampleMethod (which does not have an exceptions table):
The pseudo object code for exampleMethod includes four instructions. The first instruction (iload—1) pushes the parameter x onto the stack. The second instruction (iconst—1) pushes a constant (1) onto the stack. The third instruction (iadd) adds the top two quantities on the stack. The fourth instruction returns whatever is on top of the stack, which in this case is the sum from the previous instruction. The code above is an example of the existing object code that would be an input to code modifier 10. In one example, code modifier 10 modifies this existing object code as follows:
Code modifier 10 modified the original object code to add start code and exit code. The first section of the modified code, identified by indices 0-15, corresponds to the source code “IMethodTracer tracer=AMethodTracer.loadTracer(. . . parameter . . . ).” These byte codes push the parameters, call AMethodTracer.loadTracer, and store the result in a local variable. The nops at the end are just to make coding easier. In one embodiment, the longest sequence needed to generate is 16 bytes long. In one implementation, the code modifier always adds 16 bytes. Sometimes not all 16 bytes are used, so the code is padded with nops.
Section two of the modified code corresponds to instructions with indices 16, 17 and 18. These three instructions correspond to existing object code for implementing “x=x+1.”
The third section of the modified code corresponds to instructions from indices 19-27, and is performed in the case where there are no exceptions. This code calls the “finally handler.” Basically, the code of the third section sets aside the computed value (puts it into a temporary, here, local number 5). The code then jumps to the finally handler (jsr 36). When control returns back from the finally handler, the code gets the answer out of local number 5 and puts it back on the stack. Then, it returns.
Section four corresponds to code with indices 28-35. This is the “catch all exceptions” handler. Any exceptions not otherwise handled would jump to this code. This code jumps to the “finally handler” (jsr 36). This sequence of instructions saves the pending exception object, jumps to the “finally handler,” restores the pending exception object, and then re-throws the pending exception object.
Section five of the code, corresponding to indices 36-47, represents the “finally handler” itself. This code stores its own return address, loads the tracer out of local 4 (where it put it back at index 12), calls the finish trace handler, and returns back to where it came from.
The example above also includes an exception table which has one entry. This entry indicates that for code between indices 16 and 28, if there is any type of exception go to the handler starting at index 28. Note that instruction 28 is the “catch all exceptions handler” described above.
Note that ranges of instructions protected by two different exception handlers always are either completely disjoint, or else one is a subrange of the other. If there are multiple entries in the exception table, the first, innermost, applicable exception handler in the exception table is chosen to handle the exception. The code for that exception handler performs its intended function and then makes a subroutine call to the “finally handler.”
The system of
Portable storage medium drive 562 operates in conjunction with a portable non-volatile storage medium, such as a floppy disk, to input and output data and code to and from the computer system of
User input device(s) 560 provides a portion of a user interface. User input device(s) 560 may include an alpha-numeric keypad for inputting alpha-numeric and other information, or a pointing device, such as a mouse, a trackball, stylus, or cursor direction keys. In order to display textual and graphical information, the computer system of
The components contained in the computer system of
The foregoing detailed description of the invention has been presented for purposes of illustration and description. It is not intended to be exhaustive or to limit the invention to the precise form disclosed. Many modifications and variations are possible in light of the above teaching. The described embodiments were chosen in order to best explain the principles of the invention and its practical application to thereby enable others skilled in the art to best utilize the invention in various embodiments and with various modifications as are suited to the particular use contemplated. It is intended that the scope of the invention be defined by the claims appended hereto.
This application is a continuation application of U.S. patent application Ser. No. 09/795,901, entitled “ADDING FUNCTIONALITY TO EXISTING CODE AT EXITS,” filed Feb. 28, 2001, incorporated herein by reference in its entirety.
| Number | Date | Country | |
|---|---|---|---|
| Parent | 09795901 | Feb 2001 | US |
| Child | 12400586 | US |
