systems and methods for implementing an execution stack which stores frames for functions written in multiple programming languages are provided. The frames for functions written in different programming languages may be interleaved on the same execution stack. A data block on the execution stack may be utilized to traverse the execution stack around a frame by storing a stack pointer and frame pointer to a previous frame. Additionally, exceptions may be propagated, with conversion if necessary, through frames on the execution stack that are written in different programming languages.
|
0. 31. A virtual machine for preallocating resources for functions written in a plurality of programming languages, wherein said virtual machine is capable of:
storing a first frame on the execution stack for a first function, the first function being written in a first programming language; and
calling a second function using the first function, the second function being written in a second programming language; and
allocating resources for functions written in programming languages other than a second programming language that may be called by the second function.
1. In a computer system, a method for allocating preallocating resources for functions written in a plurality of programming languages, the method comprising:
storing a first frame on the an execution stack for a first function, the first function being written in a first programming language; and
calling a second function using the first function, the second function being written in a second programming language; and
allocating resources for functions written in programming languages other than a the second programming language that may be called by the second function.
0. 33. A virtual machine for handling exceptions for functions written in a plurality of programming languages, wherein said virtual machine is capable of:
storing a first frame on the execution stack for a first function, the first function being written in a first programming language;
calling a second function with a first function, the second function being written in a second programming language;
catching an exception that was raised during execution of the second function that was not handled by an exception handler for the second function; and
determining if the exception can be translated.
7. In a computer system, a method for handling exceptions for functions written in a plurality of programming languages, the method comprising:
storing a first frame on the an execution stack for a first function, the first function being written in a first programming language;
calling a second function with a first function, the second function being written in a second programming language; and
catching an exception that was raised during execution of the second function that was not handled by an exception handler for the second function; and
determining if the exception can be translated.
14. In a computer system, a method for implementing an execution stack that stores frames for functions written in a plurality of programming languages, the method comprising:
storing a first frame on the execution stack for a first function, the first function being written in a first programming language;
storing a second frame on the execution stack for a second function, the second function being written in a second programming language; and
calling a third function from the second function, the third function being written in the first programming language, wherein calling the third function from the second function includes storing a data block on the execution stack that includes at least one reference to the first frame.
0. 35. A virtual machine for implementing an execution stack that stores frames for functions written in a plurality of programming languages, wherein said virtual machine is capable of:
storing a first frame on the execution stack for a first function, the first function being written in a first programming language;
storing a second frame on the execution stack for a second function, the second function being written in a second programming language; and
calling a third function from the second function, the third function being written in the first programming language, wherein calling the third function from the second function includes storing a data block on the execution stack that includes at least one reference to the first frame.
0. 18. A method of implementing a mixed execution stack that can support a plurality of different programming languages in a computing environment, said method comprising:
storing a first frame on said mixed execution stack, wherein said first frame is a frame for execution of computer program code written in a first programming language;
determining whether a second frame for execution of computer program code written in a second programming language is to be stored on said mixed execution stack, wherein said first and second programming languages are not the same programming language; and
storing at least one reference to said first frame when said determining determines that said second frame for execution of said computer program code written in said second programming language is to be stored on said mixed execution stack.
0. 26. A virtual machine capable of using a mixed execution stack that can support a plurality of different programming languages in a computing environment, said virtual machine is capable of:
storing a first frame on said mixed execution stack, wherein said first frame is a frame for execution of computer program code written in a first programming language;
determining whether a second frame for execution of computer program code written in a second programming language is to be stored on said mixed execution stack, wherein said first and second programming languages are not the same programming language; and
storing at least one reference to said first frame when said determining determines that said second frame for execution of said computer program code written in said second programming language is to be stored on said mixed execution stack.
2. The method of
3. The method of
4. The method of
identifying an exception handler for the data block to handle the exception; and
jumping from the second function to the identified exception handler.
5. The method of
6. The method of
returning to the first function from the second function; and
checking the local storage to determine whether an exception is pending; and
throwing the stored exception when it is determined that the exception is pending.
8. The method of
9. The method of
10. The method of
11. The method of
12. The method of
13. The method of
15. The method of
17. The method of
0. 19. A method as recited in
storing said second frame on said mixed execution stack.
0. 20. A method as recited in
storing said second frame on said mixed execution stack after said storing of at least one reference to said first frame.
0. 21. A method as recited in
determining whether a third frame associated with said first programming language is to be stored on said mixed execution stack; and
storing said at least one reference to said first frame on said execution stack when said determines that said third frame is to be stored on said mixed execution stack.
0. 22. A method as recited in
determining whether a third frame associated with said first programming language is to be stored on said mixed execution stack; and
storing an entry frame on said execution stack before said third frame is stored on said mixed execution stack.
0. 23. A method as recited in
storing said at least one reference to a local storage.
0. 24. A method as recited in
storing said at least one reference to a local storage before storing said at least one reference on said execution stack.
0. 25. A method as recited in
0. 27. A virtual machine as recited in
storing said second frame on said mixed execution stack.
0. 28. A virtual machine as recited in
storing said second frame on said mixed execution stack after said storing of at least one reference to said first frame.
0. 29. A virtual machine as recited in
determining whether a third frame associated with said first programming language is to be stored on said mixed execution stack; and
storing said at least one reference to said first frame on said execution stack when said determines that said third frame stored on said mixed execution stack.
0. 30. A virtual machine as recited in
0. 32. A virtual machine as recited in
upon exiting the second function, deallocating the resources for functions written in programming languages other than the second programming language.
0. 34. A virtual machine as recited in
identifying an exception handler for the data block to handle the exception; and
jumping to the identified exception handler.
0. 36. A virtual machine as recited in
storing said data block on the execution stack before a third frame for the third function.
0. 37. A virtual machine as recited in
0. 38. A virtual machine as recited in
|
This is a Continuation application of copending prior application Ser. No. 08/944,335 filed on Oct. 6 1997 now U.S. Pat. No. 6,009,517.
This application is related to U.S. patent application Ser. No. 08/944,331, entitled “Site Specific Message Dispatch in Object-Oriented Systems,” U.S. patent application Ser. No. 08/944,735, entitled “Method and Apparatus for Performing Byte-Code Optimization During Pauses,” U.S. patent application Ser. No. 08/944,326, entitled “Method and Apparatus for Implementing Multiple Return Sites,” U.S. patent application Ser. No. 08/944,332, entitled “Inline Database for Receiver Types in Object-Oriented Systems,” U.S. patent application Ser. No. 08/944,334, entitled “Method and Apparatus for Dynamically Optimizing Byte-Coded Programs,” U.S. patent application Ser. No.5,933,635, entitled “Method and Apparatus for Dynamically Optimizing Compiled Activations,” all filed concurrently herewith, U.S. patent application Ser. No. 08/884,856, entitled “Interpreting Functions Utilizing a Hybrid of Virtual and Native Machine Instructions,” filed Jun. 30, 1997, and U.S. patent application Ser. No. 08/885,008, entitled “Interpreter Generation and Implementation Utilizing Interpreter States and Register Caching,” filed Jun. 30, 1997, which are all incorporated herein by reference for all purposes in their entirety.
The present invention relates to implementations of an execution stack. More specifically, the invention relates to implementing an execution stack for use with functions that may be written in multiple programming languages such as, for example, an execution stack for a Java™ virtual machine.
The Java™ programming language is an object-oriented high level programming language developed by Sun Microsystems and designed to be portable enough to be executed on a wide range of computers ranging from small personal computers up to supercomputers. Computer programs written in Java (and other languages) may be compiled into virtual machine instructions for execution by a Java virtual machine. In general the Java virtual machine is an interpreter that decodes and executes the virtual machine instructions.
The virtual machine instructions for the Java virtual machine are bytecodes, meaning they include one or more bytes. The bytecodes are stored in a particular file format called a “class file” that includes bytecodes for methods of a class. In addition to the bytecodes for methods of a class, the class file includes a symbol table as well as other ancillary information.
A computer program embodied as Java bytecodes in one or more class files is platform independent. The computer program may be executed, unmodified, on any computer that is able to run an implementation of the Java virtual machine. The Java virtual machine is a software emulator of a “generic” computer that is a major factor in allowing computer programs for the Java virtual machine to be platform independent.
The Java virtual machine is commonly implemented as a software interpreter. Conventional interpreters decode and execute the virtual machine instructions of an interpreted program one instruction at a time during execution. Compilers, on the other hand, decode source code into native machine instructions prior to execution so that decoding is not performed during execution. Because conventional interpreters decode each instruction before it is executed repeatedly each time the instruction is encountered, execution of interpreted programs is typically quite slower than compiled programs because the native machine instructions of compiled programs can be executed on the native machine or computer system without necessitating decoding.
Typically, the Java virtual machine will be written in a programming language other than the Java programming language (e.g., the C++programming language). Therefore, execution of a Java program may involve execution of functions written in multiple programming languages. Additionally, the bytecodes themselves may call functions (e.g., system functions for input/output) that are not written in the Java programming language. It is therefore common for an executing Java program to entail the execution of functions that were written in multiple programming languages. It would be desirable to have an execution stack that stores functions written in multiple programming languages. Additionally, it would be beneficial to allow exceptions to be propagated through these functions, with conversion of the exception to the appropriate format where necessary.
The Java virtual machine allows Java programs to dynamically load and execute native methods, where a native method is implemented in a language other than the Java programming language. Native methods often require resources to execute so resources may be allocated and deallocated each time a native method is called. However, resource allocation and deallocation may be very time consuming and the continual allocation and deallocation of resources may result in a significant decrease in efficiency of the interpreted program. Therefore, it would be desirable to provide more efficient techniques of resource allocation and deallocation.
Accordingly, there is a need for techniques for implementing an execution stack capable of holding function activations for functions implemented in different programming languages, and in particular allow exceptions to be propagated through these functions and the corresponding activations. Additionally, there is a need to provide interpreters that are more efficient in the way resources are allocated and deallocated so that execution speed may be increased.
In general, embodiments of the present invention provide innovative systems and methods for implementing an execution stack that stores frames for functions written in multiple programming languages. Frames for functions written in multiple programming languages may be stored on the same execution stack utilizing an entry frame (or data block) that stores pointers to a previous frame on the execution stack for a function written in the same programming language. The entry frame allows the execution stack to be traversed “around” frames for functions written in other programming languages and exceptions may be propagated through the execution stack for handling by the appropriate exception handler, even when the functions were written in different programming languages and the format of the exceptions are different. Additionally, resources may be allocated upon entering a function written in one programming language (e.g., the Java programming language) so that the resources will be available for any subsequent functions (e.g., native) in other programming languages. The resources may then be deallocated once when the calling function terminates, thereby increasing the efficiency of resource allocation and deallocation. Several embodiments of the invention are described below.
In one embodiment, a computer implemented method for implementing an execution stack that stores frames for functions written in multiple programming languages is provided. A first frame for a function written in a first programming language may be stored on the execution stack. When the first function calls a second function written in a second programming language, a data block may be stored on the execution stack before a second frame for the second function. The data block includes at least one pointer to a previous frame on the execution stack written in the first programming language. In preferred embodiments, the data block stores a stack pointer and a frame pointer to the previous frame on the execution stack, where the stack pointer and frame pointer were stored in local storage (e.g., thread local storage).
In another embodiment, a computer implemented method for implementing an execution stack that stores frames for functions written in multiple programming languages is provided. A first frame for a function written in a first programming language may be stored on the execution stack. When the first function calls a second function written in a second programming language, at least one pointer to the first frame on the execution stack may be stored in local storage (e.g., thread local storage). The at least one pointer may be a stack pointer and a frame pointer. Subsequently, when a third function written in the first programming language is called, a data block may be stored on the execution stack before a third frame for the third function. The data block may store the at least one pointer to the first frame on the execution stack that were stored in local storage so that the data block provides a way around the second frame on the execution stack. In preferred embodiments, the first programming language is the Java programming language.
In another embodiment, a data structure stored by a computer readable medium for implementing an execution stack is provided. A first frame is stored on the execution stack for a first function written in a first programming language. A second frame is stored on the execution stack for a second function written in a second programming language. On the execution stack above the second frame on the execution stack, a data block is stored which includes at least one pointer to the first frame on the execution stack. In a preferred embodiment, the data block stores a stack pointer and a frame pointer to the first frame.
Other features and advantages of the invention will become readily apparent upon review of the following detailed description in association with the accompanying drawings.
Function—A software routine (also called a subroutine, procedure, member function, and method).
Frame (or activation frame, activation record)—A record that is stored on the execution stack for a function to store information for execution of the function, such information may include state variables, local variables and an operand stack.
Execution stack—A stack utilized during program execution to store frames for functions in their sequential calling order. When a function (“callee”) is called, a frame for the function is pushed on the execution stack. Subsequently, when the function terminates, the frame is popped off the stack and the function (“caller”) for the frame on the top of the execution stack resumes execution.
Operand stack—A stack utilized to store operands for use by machine instructions during execution.
External code—Computer code that is written in a programming language other than a specific programming language (e.g., the Java programming language). For example, the Java virtual machine may be written in the C++programming language and the Java virtual machine could be deemed external code in reference to the Java code of a program that is being interpreted. External code include native methods.
Native methods—Functions that are written in a programming language other than the Java programming language. Native methods may be called by a Java program that causes them to be dynamically loaded and executed. Additionally, native methods may call functions written in the Java programming language.
In the description that follows, the present invention will be described in reference to a preferred embodiment that implements an execution stack for a Java virtual machine that executes a Java program (e.g. bytecodes). In particular, examples will be described in which the Java virtual machine is written in the C++programming language. However, the invention is not limited to any particular language, computer architecture, or specific implementation. Therefore, the description of the embodiments that follow is for purposes of illustration and not limitation.
The system bus architecture of computer system 1 is represented by arrows 67. However, these arrows are illustrative of any interconnection scheme serving to link the subsystems. For example, a local bus could be utilized to connect the central processor to the system memory and display adapter. Computer system 1 shown in
Typically, computer programs written in the Java programming language are compiled into bytecodes or Java virtual machine instructions that are then executed by a Java virtual machine. The bytecodes are stored in class files that are input into the Java virtual machine for interpretation.
Java source code 101 includes the classic Hello World program written in Java. The source code is then input into a bytecode compiler 103 that compiles the source code into bytecodes. The bytecodes are virtual machine instructions as they will be executed by a software emulated computer. Typically, virtual machine instructions are generic (i.e., not designed for any specific microprocessor or computer architecture) but this is not required. The bytecode compiler outputs a Java class file 105 that includes the bytecodes for the Java program.
The Java class file is input into a Java virtual machine 107. The Java virtual machine is an interpreter that decodes and executes the bytecodes in the Java class file. The Java virtual machine is an interpreter, but is commonly referred to as a virtual machine as it emulates a microprocessor or computer architecture in software (e.g., the microprocessor or computer architecture that may not exist in hardware).
The Java runtime system may also interface with an operating system 209. For example, input/output functions may be handled by the operating system, including providing the Java runtime system with interfaces to Java class files 203, standard built-in Java classes 205 and native methods 207.
A dynamic class loader and verifier 211 loads Java class files 203 and standard built-in Java classes 205 via operating system 209 into a memory 213. Additionally, the dynamic class loader and verifier may verify the correctness of the bytecodes in the Java class files, reporting any errors that are detected.
A native method linker 215 links in native methods 207 via operating system 209 into the Java runtime system and stores the native methods in memory 213. As shown, memory 213 may include a class and method area for the Java classes and a native method area for native methods. The class and method area in memory 213 may be stored in a garbage collected heap. As new objects are created, they are stored in the garbage collected heap. The Java runtime system, not the application, is responsible for reclaiming memory in the garbage collected heap when space is no longer being utilized.
At the heart of the Java runtime system shown in
As a Java program executes, functions are sequentially called within each thread. For each thread there is an execution stack which stores frames for each of the functions that have not completed execution. A frame stores information for execution of the function, such information may include state variables, local variables and an operand stack. As a function is called, a frame for the function is pushed on the execution stack. When the a function terminates, the function's frame is popped off the execution stack. Accordingly, only the function corresponding to the frame on the top of the execution stack is active, the functions that correspond to frames below the top of the execution stack have had their execution suspended until the function they called returns (i.e., terminates).
Each frame is shown to include state variables, local variables and an operand stack for the function corresponding to the frame. Additionally, the last item stored in the frame is a frame pointer which points to the frame pointer in the frame below the current frame on the execution stack as shown by arrows 309 and 311.
When a function calls another function, the system first pushes the return address for the current function on execution stack 301 and then pushes a new frame for the recently called function. In this manner, when the new function returns, the system is able to pop the frame at the top of the execution stack and then pop the return address off the execution stack and set the program counter equal to this return address so that execution of the calling function may resume. Accordingly, that is the reason frames 305 and 307 include return addresses and the active frame 303 does not include a return address. However, if the function corresponding to frame 303 calls another function, the return address would be pushed on execution stack 301 before the frame for the new function is pushed on the execution stack.
The frame pointers allow the system to accurately traverse the frames on the execution stack. For example, stack pointer SP and frame pointer FP delineate the frame on the top of the execution stack. Furthermore, the frame pointer in frame 303 specifies the next frame on the execution stack. The address just below the frame pointer in frame 303 is the beginning of the next frame on the execution stack and the contents of the frame pointer of frame 303 specify the last item in the next frame on the execution stack which is frame 305. Similarly, the frame pointer in frame 305 specifies the location of the next frame on the execution stack. Therefore, the chain of frame pointers allows the system to traverse the frames on the execution stack (e.g., when the frames are popped off the execution stack).
Although
The execution stack shown in
In order to more clearly demonstrate the problem, it may be beneficial to describe an example utilizing the execution stack shown in FIG. 5. Assume for the moment that the frames 305 and 307 are for functions that are written in a different programming language than the function for frame 303. When the function for frame 303 is executing, the contents or size of frames 305 and 307 may not be known. Therefore, even if the frame pointer of frame 303 were set to a previous frame on the execution stack for a function that is written in the same programming language as frame 303 (not shown), it may still not be known where that frame begins on the execution stack. Accordingly, these problems make it difficult to implement an execution stack that stores frames for functions written in multiple programming languages. The present invention provides implementations for execution stacks that store frames for functions written in multiple programming language and also provides other advantages as well, including improved resource allocation and exception handling.
When the first function calls a second function written in another programming language, the system stores in local storage a pointer or pointers to the first frame on the execution stack at a step 403. In preferred embodiments, the programming language of the first function is the Java programming language. Each Java thread has associated with it thread local storage so in these preferred embodiments, the local storage is the thread local storage for the thread that is executing the first and second functions. Additionally, the stack pointer and the frame pointer to the first frame are stored in the thread local storage.
At a step 405, the system stores a second frame on the execution stack for the second function written in another programming language. As an example, the other programming language may be C++programming language, Pascal, FORTRAN, assembly, and the like.
When the second function calls a third function written in the programming language of the first function, the system stores a data block (or entry frame) on the execution stack that includes the pointer or pointers to the first frame on the execution stack at a step 407. The pointer or pointers that were stored in local storage at step 403 are copied into the data block that is pushed on the execution stack above the second frame for the second function. The data block provides a mechanism for traversing the execution stack around or through the second frame on the execution stack. Although the process shown in
At a step 409, the system stores a third frame on the execution stack for the third function written in the programming language of the first function. Accordingly, the execution stack now stores frames for functions written in multiple programming language and includes mechanisms for traversing the execution stack through the frames. In order to further illustrate the process shown in
As shown in
An entry frame 457 is shown on the execution stack which stores, among other things, a LAST_JAVA_SP and a LAST_JAVA_FP that are pointers to a previous Java frame 459 on the execution stack. An external frame 461 is shown on the execution stack between entry frame 457 and Java frame 459. The external frame or frames may be for functions written in languages other than the Java programming language. As shown, the entry frame is a data block that includes at least one pointer around the external frame.
In the timeline of executing the program that has generated the execution stack shown in
Subsequently, the function corresponding to external frame 461 calls a Java function. In response to calling the Java function, the system pushes entry frame 457 onto the execution stack and stores therein the at least one pointer to Java frame 459 that was stored in local storage, which in this case is the LAST_JAVA_SP and the LAST_JAVA_FP. The function corresponding to Java frame 455 then calls a Java function corresponding to Java frame 453.
In order to more clearly understand the present invention, there are four distinct actions that will be described in reference to the execution stack of FIG. 7. As shown, the system may enter external code from Java code meaning that a Java function has called an external function written in another programming language. Additionally, the system may enter Java code from external code. As the Java function corresponding to Java frame 455 returns, the system exits Java code to external code and as the external function corresponding to external frame 461 returns, the system exits external code to Java code. The following will describe each of these four processes in more detail.
We will start with a Java function calling an external function.
The system then calls the external code at a step 503. At this point, the system will push an external frame for the external function on the execution stack. Before calling the external code, the system pushes the return address for the Java function on the execution stack before pushing the external frame on the top of the execution stack. Once in external code, the external function may call a Java function or call another external function that calls a Java function.
We have described a Java function calling an external function. Now, we will describe an external function calling a Java function.
At a step 555, the system clears the LAST_JAVA_SP and LAST_JAVA_FP stored in thread local storage. These pointers in the thread local storage may be cleared by setting their values equal to zero or any other way known to those of ordinary skill in the art. In preferred embodiments, the pointers are set equal to zero so that the pointers may be checked to determine whether Java code or external code is currently running on the system (e.g., nonzero=external and zero=Java).
In conventional systems, resources for native methods are typically allocated when the native methods are called. Oftentimes, a Java function will call multiple native methods so the conventional resource allocation results in multiple allocation and deallocation of resources. With embodiments of the invention, resources are allocated for native methods when a Java function is entered so that these resources are available to all the native methods that the Java function may call. Additionally, resources may be allocated for native methods once when the Java function is entered and deallocated once when the Java function returns thereby increasing the efficiency of resource allocation/deallocation.
At a step 557, the system allocates resources for native methods and stores the resources in thread local storage. The system then calls the Java code at a step 559.
After a Java function that was called by an external function returns, execution will continue with the external function that called the Java function.
The system deallocates resources for native methods at a step 603. In preferred embodiments, the resources are stored in thread local storage after they are allocated. At a step 605, the system returns to external code that is typically designated by a return address on the execution stack.
Once the external function that was called by a Java function returns, execution will resume in the Java function that called the external function.
The system returns to Java code at a step 653. The system returns to Java code by setting the program counter to the return address that was pushed on the execution stack once the external function was called.
The above has shown how embodiments of the present invention provide an implementation of an execution stack that stores frames for functions written in multiple programming languages. Although the description has focused on functions for the Java programming language, the present invention is not limited to any specific programming language. The invention may be advantageously applied to systems that execute programs utilizing functions written in multiple programming languages. By allowing the system to traverse the execution stack and more efficiently allocate resources, programs may be executed more efficiently.
Exceptions are signals that indicate something out of the ordinary has happened. For example, an exception may indicate that the system has run out of memory or that the end-of-file of a file has been reached. Some exceptions indicate unrecoverable situations (e.g., out of memory) and some exceptions indicate recoverable situations (e.g., end-of-file).
When an exception is generated, a Java run time system typically searches for an exception handler for that exception. The search starts within the function in which the exception was thrown and then propagates through the functions on the execution stack. If an exception handler is found, the exception handler catches the exception and takes the appropriate action that may include throwing another exception.
As an example, we will describe an embodiment where the Java virtual machine is written in the C++programming language. Accordingly, the execution stack will include C++frames and Java frames. With embodiments of the invention, exceptions may be propagated through the different frames on the execution stack. Although a particular embodiment is described to illustrate the invention, the invention is not limited to any particular language or configuration.
Conceptually there is a shield 715 between C++frame 703 and Java frame 705. Shield 715 catches C++exceptions that are not handled in C++frame 703 and passes the exception to Java frame 705. It may be necessary to transform the C++exception to a Java exception before the exception is passed on. As shown, there may also be a shield 716 between C++frame 711 and Java frame 713.
An unshield 717 is between Java frame 705 (and entry frame 707) and C++frame 709. Unshield 717 passes Java exceptions that are not handled within Java frame 705 and passes them on to C++frame 709. The execution stack shown in
Steps 805 and the subsequent steps 807, 809, 811, 813, 815, and 817 correspond to shield 715 of FIG. 12. At a step 805, the system catches all the exceptions that were not handled within the C++frame. The system then determines if the caught exception is a Java exception at a step 807. In other words, the system determines if the C++exception may be translated into a Java exception. If the C++exception may not be transformed into a Java exception, the system may issue a bug error message at a step 809 and halt execution.
If the C++exception is a Java exception, the system removes the C++frame from the top of the execution stack at a step 811. The C++frame corresponds to the C++function that was running when the exception was thrown. The system stores the exception and a return address in thread local storage at a step 813. The stored return address may be utilized to generate a Java exception.
At a step 815, the system patches the return address on the execution stack with an address to an exception forwarder. The exception forwarder is external code of a virtual machine function (written in C++or assembly in preferred embodiments) that is responsible for generating a Java exception and jumping to the exception handler for the next Java frame on the execution stack.
At a step 817, the system returns to external code. Now that the return address for Java frame 705 has been patched at step 815 to refer to the exception forwarder, the system will next execute the exception forwarder function which is shown in FIG. 13B.
Utilizing the return address stored in thread local storage, the exception forwarder gets the exception handler routine for the method specified by the return address. After the appropriate exception handler is identified, a jump is performed to the exception handler at a step 855. Accordingly, it has been shown how a C++exception may be translated and handled as a Java exception. The following will describe an exception exiting Java code to external code.
If the Java exception may not be handled by the exception handler for this Java frame, the system removes the Java frame from the execution stack at a step 907. The system then finds the exception handler for the return address stored in the CPU registers at a step 909. At a step 911, the system jumps to the exception handler. The exception handler will be the exception handler for the entry frame.
The embodiments described above has shown that information may be stored in thread local storage in order to implement an execution stack that stores frames for functions written in multiple programming languages.
Resources 1005 are allocated when the system enters a Java function from a function written in another programming language. The resources may then be utilized by any native methods called by the Java function or any subsequent Java functions.
An exception 1007 and a return address 1009 are stored to allow exceptions to pass from a function written in another programming language (e.g., the C++programming language) to a Java function, and vice versa. Other information may also be stored in thread local storage.
While the above is a complete description of preferred embodiments of the invention, there are alternatives, modifications, and equivalents that may be used. It should be evident that the invention is equally applicable by making appropriate modifications to the embodiments described above. For example, the embodiments described have been in reference to a mixed execution stack including Java frames, but the principles of the present invention may be readily applied to other systems and languages. Therefore, the above description should not be taken as limiting the scope of the invention that is defined by the meets and bounds of the impended claims along with their full scope of equivalents.
Bak, Lars, Hölzle, Urs, Griesemer, Robert
Patent | Priority | Assignee | Title |
7574702, | Mar 18 2005 | Microsoft Technology Licensing, LLC | Method and apparatus for hybrid stack walking |
7992138, | Sep 25 2004 | Samsung Electronics Co., Ltd. | Method and apparatus for executing different java methods |
8006071, | Mar 31 2004 | Altera Corporation | Processors operable to allow flexible instruction alignment |
8874881, | Mar 31 2004 | Altera Corporation | Processors operable to allow flexible instruction alignment |
9740488, | Mar 31 2004 | Altera Corporation | Processors operable to allow flexible instruction alignment |
Patent | Priority | Assignee | Title |
4399507, | Jun 30 1981 | IBM Corporation | Instruction address stack in the data memory of an instruction-pipelined processor |
4491912, | Mar 18 1981 | Hitachi, Ltd. | Data processing system with improved microsubroutine facility |
5274817, | Dec 23 1991 | Caterpillar Inc. | Method for executing subroutine calls |
5475822, | Nov 15 1993 | Motorola, Inc. | Data processing system for resuming instruction execution after an interrupt and method therefor |
5574915, | Dec 21 1993 | Apple Inc | Object-oriented booting framework |
5634046, | Sep 30 1994 | Microsoft Technology Licensing, LLC | General purpose use of a stack pointer register |
5740441, | Dec 20 1994 | Oracle America, Inc | Bytecode program interpreter apparatus and method with pre-verification of data type restrictions and object initialization |
5761491, | Apr 15 1996 | SHENZHEN XINGUODU TECHNOLOGY CO , LTD | Data processing system and method for storing and restoring a stack pointer |
5784553, | Feb 12 1996 | Parasoft Corporation | Method and system for generating a computer program test suite using dynamic symbolic execution of JAVA programs |
5822606, | Feb 16 1996 | CUFER ASSET LTD L L C | DSP having a plurality of like processors controlled in parallel by an instruction word, and a control processor also controlled by the instruction word |
5884062, | Aug 28 1997 | Texas Instruments Incorporated | Microprocessor with pipeline status integrity logic for handling multiple stage writeback exceptions |
5884083, | Sep 20 1996 | Open Invention Network, LLC | Computer system to compile non-incremental computer source code to execute within an incremental type computer system |
5925123, | Jan 24 1996 | Oracle America, Inc | Processor for executing instruction sets received from a network or from a local memory |
5937193, | Nov 27 1996 | Intellectual Ventures II LLC | Circuit arrangement for translating platform-independent instructions for execution on a hardware platform and method thereof |
Executed on | Assignor | Assignee | Conveyance | Frame | Reel | Doc |
Jul 01 2004 | Sun Microsystems, Inc. | (assignment on the face of the patent) | / |
Date | Maintenance Fee Events |
Jul 08 2009 | M1552: Payment of Maintenance Fee, 8th Year, Large Entity. |
Dec 04 2013 | M1553: Payment of Maintenance Fee, 12th Year, Large Entity. |
Date | Maintenance Schedule |
Mar 13 2010 | 4 years fee payment window open |
Sep 13 2010 | 6 months grace period start (w surcharge) |
Mar 13 2011 | patent expiry (for year 4) |
Mar 13 2013 | 2 years to revive unintentionally abandoned end. (for year 4) |
Mar 13 2014 | 8 years fee payment window open |
Sep 13 2014 | 6 months grace period start (w surcharge) |
Mar 13 2015 | patent expiry (for year 8) |
Mar 13 2017 | 2 years to revive unintentionally abandoned end. (for year 8) |
Mar 13 2018 | 12 years fee payment window open |
Sep 13 2018 | 6 months grace period start (w surcharge) |
Mar 13 2019 | patent expiry (for year 12) |
Mar 13 2021 | 2 years to revive unintentionally abandoned end. (for year 12) |