US 6,477,702 B1Grant
Bytecode program interpreter apparatus and method with pre-verification of data type restrictions and object initialization
Issue Date:2002-11-05
•172 Claims
•11 Drawing Sheets
Abstract
A program interpreter for computer programs written in a bytecode language, which uses a restricted set of data type specific bytecodes. The interpreter, prior to executing any bytecode program, executes a bytecode program verifier procedure that verifies the integrity of a specified program by identifying any bytecode instruction that would process data of the wrong type for such a bytecode and any bytecode instruction sequences in the specified program that would cause underflow or overflow of the operand stack. If the program verifier finds any instructions that violate predefined stack usage and data type usage restrictions, execution of the program by the interpreter is prevented. After pre-processing of the program by the verifier, if no program faults were found, the interpreter executes the program without performing operand stack overflow and underflow checks and without performing data type checks on operands stored in operand stack. As a result, program execution speed is greatly improved.
Metadata
Assignee
- Sun Microsystems, Inc.
Inventors
- Frank Yellin
- James A. Gosling
Application Information
Application Number:US 09/711,053
Filing Date:2000-11-09
Priority Date:1994-12-20
Art Unit:7
Classifications
IPC:
G06F 945
Field of Search:
717126
Patent Drawings (11 sheets)
Description
[0002] This application is a continuation of patent application Ser. No. 09/454,821, filed Dec. 6, 1999, which was a continuation of patent application Ser. No. 09/046,719, filed Mar. 24, 1998, now U.S. Pat. No. 5,999,731, which was a continuation of patent application Ser. No. 08/575,291, filed Dec. 20, 1995, now U.S. Pat. No. 5,740,441, which was a continuation-in-part of patent application Ser. No. S/N 08/360,202, filed Dec. 20, 1994, now U.S. Pat. No. 5,748,964.
[0003] The present invention relates generally to the use of computer software on multiple computer platforms which use distinct underlying machine instruction sets, and more specifically to an program verifier and method that verify the integrity of computer software obtained from a network server or other source.
BACKGROUND OF THE INVENTION
[0004] Referring to FIG. 1, in a networked computer system 100, a first computer 102 may download a computer program 103 residing on a second computer 104. In this example, the first user node 102 will typically be a user workstation (often called a client) having a central processing unit 106, a user interface 108, memory 110 (e.g., random access memory and disk memory) for storing an operating system 112, programs, documents and other data, and a communications interface 114 for connecting to a computer network 120 such as the Internet, a local area network or a wide area network. The computers 102 and 104 are often called “nodes on the network” or “network nodes”.
[0005] The second computer 104 will often be a network server, but may be a second user workstation, and typically would contain the same basic array of computer components as the first computer.
[0006] In the prior art (unlike the system shown in FIG. 1), after the first computer 102 downloads a copy of a computer program 103 from the second computer 104, there are essentially no standardized tools available to help the user of the first computer 102 to verify the integrity of the downloaded program 103. In particular, unless the first computer user studies the source code of the downloaded program, it is virtually impossible using prior art tools to determine whether the downloaded program 103 will underflow or overflow its stack, or whether the downloaded program 103 will violate files and other resources on the user's computer.
[0007] A second issue with regard to downloading computer software from one computer to another concerns transferring computer software between computer platforms which use distinct underlying machine instruction sets. There are some prior art examples of platform independent computer programs and platform independent computer programming languages. What the prior art lacks are reliable and automated software verification tools for enabling recipients of such software to verify the integrity of transferred platform independent computer software obtained from a network server or other source.
SUMMARY OF THE INVENTION
[0008] The present invention verifies the integrity of computer programs written in a bytecode language, commercialized as the JAVA bytecode language, which uses a restricted set of data type specific bytecodes. All the available source code bytecodes in the language either (A) are stack data consuming bytecodes that have associated data type restrictions as to the types of data that can be processed by each such bytecode, (B) do not utilize stack data but affect the stack by either adding data of known data type to the stack or by removing data from the stack without regard to data type, or (C) neither use stack data nor add data to the stack.
[0009] The present invention provides a verifier tool and method for identifying, prior to execution of a bytecode program, any instruction sequence that attempts to process data of the wrong type for such a bytecode or if the execution of any bytecode instructions in the specified program would cause underflow or overflow of the operand stack, and to prevent the use of such a program.
[0010] The bytecode program verifier of the present invention includes a virtual operand stack for temporarily storing stack information indicative of data stored in a program operand stack during the actual execution a specified bytecode program. The verifier processes the specified program using data flow analysis, processing each bytecode instruction of the program whose stack and register input status map is affected by another instruction processed by the verifier. A stack and register input status map is generated for every analyzed bytecode instruction, and when an instruction is a successor to multiple other instructions, its status map is generated by merging the status maps created during the processing of each of the predecessor instructions. The verifier also compares the stack and register status map information with data type restrictions associated with each bytecode instruction so as to determine if the operand stack or registers during program execution would contain data inconsistent with the data type restrictions of the bytecode instruction, and also determines if any bytecode instructions in the specified program would cause underflow or overflow of the operand stack.
[0011] The merger of stack and register status maps requires special handling for the instructions associated with exception handlers and the instructions associated with subroutine calls (including “finally” instruction blocks that are executed via a subroutine call whenever a protected code block is exited).
[0012] After pre-processing of the program by the verifier, if no program faults were found, a bytecode program interpreter executes the program without performing operand stack overflow and underflow checks and without performing data type checks on operands stored in operand stack. As a result, program execution speed is greatly improved.
BRIEF DESCRIPTION OF THE DRAWINGS
[0013] The accompanying drawings, which are incorporated in and form a part of this specification, illustrate embodiments of the invention and, together with the description, serve to explain the principles of the invention, wherein:
[0014] FIG. 1 is a block diagram of a computer system incorporating a preferred embodiment of the present invention.
[0015] FIG. 2 is a block diagram of the data structure for an object in a preferred embodiment of the present invention.
[0016] FIG. 3 is a block diagram of the data structures maintained by a bytecode verifier during verification of a bytecode program in accordance with the present invention.
[0017] FIGS. 4A-4G represents flow charts of the bytecode program verification process in the preferred embodiment of the present invention.
[0018] FIG. 5 represents a flow chart of the class loader and bytecode program interpreter process in the preferred embodiment of the present invention.
DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0019] Reference will now be made in detail to the preferred embodiments of the invention, examples of which are illustrated in the accompanying drawings. While the invention will be described in conjunction with the preferred embodiments, it will be understood that they are not intended to limit the invention to those embodiments. On the contrary, the invention is intended to cover alternatives, modifications and equivalents, which may be included within the spirit and scope of the invention as defined by the appended claims.
[0020] Referring now to a distributed computer system 100 as shown in FIG. 1, there is shown a distributed computer system 100 having multiple client computers 102 and multiple server computers 104. In the preferred embodiment, each client computer 102 is connected to the servers 104 via the Internet 120, although other types of communication connections could be used. While most client computers are desktop computers, such as Sun workstations, IBM compatible computers and Macintosh computers, virtually any type of computer can be a client computer. In the preferred embodiment, each client computer includes a CPU 106, a user interface 108, memory 110, and a communications interface 114. Memory 110 stores:
[0021] an operating system 112;
[0022] an Internet communications manager program 116;
[0023] a bytecode program verifier 120 for verifying whether or not a specified program satisfies certain predefined integrity criteria;
[0024] a bytecode program interpreter 122 for executing application programs;
[0025] a class loader 124, which loads object classes into a user's address space and utilizes the bytecode program verifier to verify the integrity of the methods associated with each loaded object class;
[0026] at least one class repository 126, for locally storing object classes 128 in use and/or available for use by user's of the computer 102;
[0027] at least one object repository 130 for storing objects 132, which are instances of objects of the object classes stored in the object repository 126.
[0028] In the preferred embodiment the operating system 112 is an object oriented multitasking operating system that supports multiple threads of execution within each defined address space.
[0029] The bytecode program verifier 120 includes a snapshot array 140, a status array 142, and other data structures that will be described in more detail below.
[0030] The class loader 124 is typically invoked when a user first initiates execution of a procedure, requiring that an object of the appropriate object class be generated. The class loader 124 loads in the appropriate object class and calls the bytecode program verifier 120 to verify the integrity of all the bytecode programs in the loaded object class. If all the methods are successfully verified an object instance of the object class is generated, and the bytecode interpreter 122 is invoked to execute the user requested procedure, which is typically called a method. If the procedure requested by the user is not a bytecode program and if execution of the non-bytecode program is allowed (which is outside the scope of the present document), the program is executed by a compiled program executer (not shown).
[0031] The class loader is also invoked whenever an executing bytecode program encounters a call to an object method for an object class that has not yet been loaded into the user's address space. Once again the class loader 124 loads in the appropriate object class and calls the bytecode program verifier 120 to verify the integrity of all the bytecode programs in the loaded object class. In many situations the object class will be loaded from a remotely located computer, such as one of the servers 104 shown in FIG. 1. If all the methods in the loaded object class are successfully verified, an object instance of the object class is generated, and the bytecode interpreter 122 is invoked to execute the called object method.
[0032] FIG. 2 shows the data structure 200 in a preferred embodiment of the present invention for an object A-01 of class A. An object of object class A has an object handle 202 that includes a pointer 204 to the methods for the object and a pointer 206 to a data array 208 for the object.
[0033] The pointer 204 to the object's methods is actually an indirect pointer to the methods of the associated object class. More particularly, the method pointer 204 points to the Virtual Function Table (VFT) 210 for the object's object class. Each object class has a VFT 210 that includes (A) pointers 212 to each of the methods 214 of the object class, (B) one or more pointers 215 to methods 216 associated with superclasses of class A, and (C) a pointer 217 to a special Class Object 218.
[0034] Referring to FIGS. 1 and 2, in the preferred embodiment, the methods in an object class to be loaded are bytecode programs, which when interpreted will result in a series of executable instructions. A listing of all the source code bytecode instructions in the JAVA instruction set is provided in Table 1. The JAVA bytecode instruction set is characterized by bytecode instructions that are data type specific. Specifically, the JAVA instruction set distinguishes the same basic operation on different primitive data types by designating separate opcodes. Accordingly, a plurality of bytecodes are included within the instruction set to perform the same basic function (for example to add two numbers), with each such bytecode being used to process only data of a corresponding distinct data type. In addition, the JAVA instruction set is notable for instructions not included. For instance, there are no instructions in the JAVA bytecode language for converting numbers into object references. These restrictions on the JAVA bytecode instruction set help to ensure that any bytecode program which utilizes data in a manner consistent with the data type specific instructions in the JAVA instruction set will not violate the integrity of a users computer system.
[0035] In the preferred embodiment, the available data types are integer, long integer, single precision floating point, double precision floating point, handles (sometimes herein called objects or object references), and return addresses (pointers to virtual machine code). Additional data types are arrays of integers, arrays of long integers, arrays of single precision floating point numbers, arrays of double precision floating point numbers, arrays of handles, arrays of booleans, arrays of bytes (8-bit integers), arrays of short integers (16 bit signed integer), and arrays of unicode characters.
[0036] The “handle” data type includes a virtually unlimited number of data subtypes because each handle data type includes an object class specification as part of the data type. In addition, constants used in programs are also data typed, with the available constant data types in the preferred embodiment comprising the data types mentioned above, plus class, fieldref, methodref, string, and Asciz, all of which represent two or more bytes having a specific purpose.
[0037] The few bytecodes that are data type independent perform stack manipulation functions such as (A) duplicating one or more words on the stack and placing them at specific locations within the stack, thereby producing more stack items of known data type, or (B) clearing one or more items from the stack. A few other data type independent bytecodes do not utilize any words on the stack and leave the stack unchanged, or add words to the stack without utilizing any of the words previously on the stack. These bytecodes do not have any data type restrictions with regard to the stack contents prior to their execution, and all but a few modify the stack's contents and thus affect the program verification process.
[0038] The second computer node 104, assumed here to be configured as a file or other information server, includes a central processing unit 150, a user interface 156, memory 154, and a other communication interface 158 that connects the second computer node to the computer communication network 120. Memory 154 stores programs 103, 164, 166 for execution by the processor 150 and/or distribution to other computer nodes.
[0039] The first and second computer nodes 102 and 104 may utilize different computer platforms and operating systems 112, 160 such that object code programs executed on either one of the two computer nodes cannot be executed on the other. For instance, the server node 104 might be a Sun Microsystems computer using a Unix operating system while the user workstation node 102 may be an IBM compatible computer using an 80486 microprocessor and a Microsoft DOS operating system. Furthermore, other user workstations coupled to the same network and utilizing the same server 104 might use a variety of different computer platforms and a variety of operating systems.
[0040] In the past, a server 104 used for distributing software on a network having computers of many types would store distinct libraries of software for each of the distinct computer platform types (e.g., Unix, Windows, DOS, Macintosh, etc.). Thus, different versions of the same computer program might be stored in each of the libraries. However, using the present invention, many computer programs could be distributed by such a server using just a single, bytecode version of the program.
[0041] The bytecode verifier 120 is an executable program which verifies operand data type compatibility and proper stack manipulations in a specified bytecode (source) program 214 prior to the execution of the bytecode program by the processor 106 under the control of the bytecode interpreter 122. Each bytecode program has an associated verification status value that is True if the program's integrity is verified by the bytecode verifier 120, and it otherwise set to False.
[0042] During normal execution of programs using languages other than the Java bytecode language, the interpreter must continually monitor the operand stack for overflows (i.e., adding more data to the stack than the stack can store) and underflows (i.e., attempting to pop data off the stack when the stack is empty). Such stack monitoring must normally be performed for all instructions that change the stack's status (which includes most all instructions). For many programs, stack monitoring instructions executed by the interpreter account for approximately 80% of the execution time of an interpreted computed program.
[0043] For many purposes, particularly the integrity of downloaded computer programs, the Internet is a “hostile environment.” A downloaded bytecode program may contain errors involving the data types of operands not matching the data type restrictions of the instructions using those operands, which may cause the program to be fail during execution. Even worse, a bytecode program might attempt to create object references (e.g., by loading a computed number into the operand stack and then attempting to use the computed number as an object handle) and to thereby breach the security and/or integrity of the user's computer.
[0044] Use of the bytecode verifier 120 in accordance with the present invention enables verification of a bytecode program's integrity and allows the use of an interpreter 122 which does not execute the usual stack monitoring instructions during program execution, thereby greatly accelerating the program interpretation process.
The Bytecode Program Verifier
[0045] Referring now to FIG. 3, the bytecode program verifier 120 (often called the “verifier”) uses a few temporary data structures to store information it needs while verifying a specified bytecode program 300. In particular, the verifier 120 uses a set of data structures 142 for representing current stack and register status information, and a snapshot data structure 140 for representing the status of the virtual stack and registers just prior to the execution of each instruction in the program being verified. The current status data structures 142 include: a stack size indicator, herein called the stack counter 301, a virtual stack 302 that indicates the data types of all items in the virtual operand stack, a virtual register array 304 that indicates the data types of all items in the virtual registers, and a “jsr” bit vector array 306 that stores zero or more bit vectors associated with the zero or more subroutine calls required to reach the instruction currently being processed.
[0046] The stack counter 301, which indicates the number of stack elements that are currently in use (i.e., at the point in the method associated with the instruction currently being analyzed), is updated by the verifier 120 as it keeps track of the virtual stack manipulations so as to reflect the current number of virtual stack entries.
[0047] The virtual stack 302 stores data type information regarding each datum that will be stored by the bytecode program 300 in the virtual operand stack during actual execution of the program. In the preferred embodiment, the virtual stack 302 is used in the same way as a regular stack, except that instead of storing actual data and constants, the virtual stack 302 stores a data type indicator value for each datum that will be stored in the operand stack during actual execution of the program. Thus, for instance, if during actual execution the stack were to store three values:
[0048] HandleToObjectA
[0049] 5
[0050] 1
[0051] the corresponding virtual stack entries will be
[0052] R;Class A;initialized
[0053] I
[0054] I
[0055] where “R” in the virtual stack indicates an object reference, “Class A”indicates that class or type of the referenced object is “A”, “initialized” indicates that the referenced object is an initialized object, and each “I” in the virtual stack indicates an integer. Furthermore, the stack counter 301 in this example would store a value of 3, corresponding to three values being stored in the virtual stack 302.
[0056] Data of each possible data type is assigned a corresponding virtual stack marker value, for instance: integer (I), long integer (L), single precision floating point number (F), double precision floating point number (D), byte (B), short (S), and object reference (R). The marker value for an object reference includes a value (e.g., “Class A”) indicating the object type and a flag indicating if the object has been initialized. If this is an object that has been created by the current method, but has not yet been initialized, the marker value for the object reference also indicates the program location of the instruction that created the object instance being referenced.
[0057] The virtual register array 304 serves the same basic function as the virtual stack 302. That is, it is used to store data type information for registers used by the specified bytecode program. Since data is often transferred by programs between registers and the operand stack, the bytecode instructions performing such data transfers and otherwise using registers can be checked to ensure that the data values in the registers accessed by each bytecode instruction are consistent with the data type usage restrictions on those bytecode instructions.
[0058] The structure and use of the jsr bit vector array 306 will be described below in the discussion of the handling of subroutine jumps and returns.
[0059] While processing the specified bytecode program, for each datum that would be popped off the stack for processing by a bytecode instruction, the verifier pops off the same number of data type values off the virtual stack 302 and compares the data type values with the data type requirements of the bytecode. For each datum that would be pushed onto the stack by a bytecode instruction, the verifier pushes onto the virtual stack a corresponding data type value.
[0060] One aspect of program verification in accordance with present invention is verification that the number of the operands in the virtual stack 302 is identical every time a particular instruction is executed, and that the data types of operands in the virtual stack are compatible. If a particular bytecode instruction can be immediately preceded in execution by two or more different instructions, then the status of the virtual stack immediately after processing of each of those different predecessor instructions must be compared. Usually, at least one of the different preceding instructions will be a conditional or unconditional jump or branch instruction. A corollary of the above “stack consistency” requirement is that each program loop must not result in a net addition or reduction in the number of operands stored in the operand stack.
[0061] The stack snapshot array 140 is used to store “snapshots” of the stack counter 301, virtual stack 302, virtual register array 304 and jsr bit vector array 306. A separate snapshot 310 is stored for every instruction in the bytecode program. Each stored stack snapshot includes a “changed” flag 320, a stack counter 321, a stack status array 322, a register status array 324 and a variable length jsr bit vector array 326. The jsr bit vector array 326 is empty except for instructions that can only be reached via one or more jsr instructions.
[0062] The changed flag 320 is used to determine which instructions require further processing by the verifier, as will be explained below. The stack counter 321, stack status array 322, register status array 324, and jsr bit vector array 326 are based on the values stored in the data structures 301, 302, 304 and 306 at corresponding points in the verification process.
[0063] The snapshot storage structure 140 furthermore stores instruction addresses 328 (e.g., the absolute or relative address of each target instruction). Instruction addresses 328 are used by the verifier to make sure that no jump or branch instruction has a target that falls in the middle of a bytecode instruction.
[0064] As was described previously, the bytecode program 300 includes a plurality of data type specific instructions, each of which is evaluated by the verifier 120 of the present invention.
[0065] Referring now to FIGS. 4A-4F, and Table 2, the execution of the bytecode verifier program 120 will be described in detail. Table 2 lists a pseudocode representation of the verifier program. The pseudocode used in Table 2 utilizes universal computer language conventions. While the pseudocode employed here has been invented solely for the purposes of this description, it is designed to be easily understandable by any computer programmer skilled in the art.
[0066] As shown in FIG. 4A, a selected class file containing one or more bytecode methods is loaded (350) into the bytecode verifier 120 for processing. The verifier first performs a number of “non-bytecode” based tests (352) on the loaded class, including verifying:
[0067] the class file's format;
[0068] that the class is not a subclass of a “final” class;
[0069] that no method in the class overrides a “final” method in a superclass;
[0070] that each class, other than “Object,” has a superclass; and
[0071] that each class reference, field reference and method reference in the constant pool has a legal name, class and type signature
[0072] If any of these initial verification tests fail, an appropriate error message is displayed or printed, and the verification procedure exits with an abort return code (354).
[0073] Next, the verification procedure checks to see if all bytecode methods have been verified (356). If so, the procedure exits with a success return code (358). Otherwise, it selects a next bytecode method in the loaded object class file that requires verification (360).
[0074] The code for each method includes the following information:
[0075] the maximum stack space needed by the method;
[0076] the maximum number of registers used by the method;
[0077] the actual bytecodes for executing the method;
[0078] a table of exception handlers.
[0079] Each entry in the exception handlers tables gives a start and end offset into the bytecodes, an exception type, and the offset of a handler for the exception. The entry indicates that if an exception of the indicated type occurs within the code indicated by the starting and ending offsets, a handler for the exception will be found at the given handler offset.
[0080] After selecting a method to verify, the verifier initializes a number of data structures (362), including the stack counter 301, virtual stack 302, virtual register array 304, jsr bit vector array 306, and the snapshot array 140. The snapshot array is initialized as follows. The snapshot for the first instruction of the method is initialized to indicate that the stack is empty and the registers are empty except for data types indicated by the method's type signature, which indicates the initial contents of the registers. The snapshots for all other instructions are initialized to indicate that the instruction has not yet been visited.
[0081] In addition, the “changed” bit for the first instruction of the program is set, and a flag called VerificationSuccess is set to True (364). If the VerificationSuccess flag is still set to True when the verification procedure is finished (368), that indicates that the integrity of the method has been verified. If the VerificationSuccess flag is set to False when the verification procedure is finished, the method's integrity has not been verified, and therefore an error message is displayed or printed, and the verification procedure exits with an abort return code (354).
[0082] After these initial steps, a data flow analysis is performed on the selected method (366). The details of the data flow analysis, which forms the main part of the verification procedure, is discussed below with reference to FIG. 4B.
[0083] In summary, the verification procedure processes each method of the loaded class file until either all the bytecode methods are successfully verified, or the verification of any one of the methods fails.
Data Flow Analysis of Method
[0084] Referring to FIG. 4B and the corresponding portion of Table 2, the data flow analysis of the selected method is completed (382) when there are no instructions whose changed bit is set (380). Detection of any stack or register usage error during the analysis causes the VerificationSuccess flag to set to False and for the analysis to be stopped (382).
[0085] If there is at least one instruction whose changed bit is set (380), the procedure selects a next instruction whose changed bit is set (384). Any instruction whose changed bit is set can be selected.
[0086] The analysis of the selected instruction begins with the pre-existing snapshot for the selected instruction being loaded into the stack counter, virtual stack and the virtual register array, and jsr bit vector array, respectively (386). In addition, the changed bit for the selected instruction is turned off (386).
[0087] Next, the effect of the selected instruction on the stack and registers is emulated (388). More particularly, four types of “actions” performed by bytecode instructions are emulated and checked for integrity: stack pops, stack pushes, reading data from registers and writing data to registers. The detailed steps of this emulation process are described next with reference to FIGS. 4C-4G.
[0088] Referring to FIG. 4C, if the selected instruction pops data from the stack (450), the stack counter 301 is inspected (452) to determine whether there is sufficient data in the stack to satisfy the data pop requirements of the instruction. If the operand stack has insufficient data (452) for the current instruction, that is called a stack underflow, in which case an error signal or message is generated (454) identifying the place in the program that the stack underflow was detected. In addition, the verifier will then set a VerificationSuccess flag to False and abort (456) the verification process.
[0089] If no stack underflow condition is detected, the verifier will compare (458) the data type code information previously stored in the virtual stack with the data type requirements (if any) of the currently selected instruction. For example, if the opcode of the instruction being analyzed calls for an integer add of a value popped from the stack, the verifier will compare the operand information of the item in the virtual stack which is being popped to make sure that is of the proper data type, namely integer. If the comparison results in a match, then the verifier deletes (460) the information from the virtual stack associated with the entry being popped and updates the stack counter 301 to reflect the number of entries popped from the virtual stack 302.
[0090] If a mismatch is detected (458) between the stored operand information in the popped entry of the virtual stack 302 and the data type requirements of the currently selected instruction, then a message is generated (462) identifying the place in the bytecode program where the mismatch occurred. The verifier will then set the VerificationSuccess flag to False and abort (456) the verification process. This completes the stack pop verification process.
[0091] Referring to FIG. 4D, if the currently selected instruction pushes data onto the stack (470), the stack counter is inspected (472) to determine whether there is sufficient room in the stack to store the data the selected instruction will push onto the stack. If the operand stack has insufficient room to store the data to be pushed onto the stack by the current instruction (472), that is called a stack overflow, in which case an error signal or message is generated (474) identifying the place in the program that the stack underflow was detected. In addition, the verifier will then set the VerificationSuccess flag to False and abort (476) the verification process.
[0092] If no stack overflow condition is detected, the verifier will add (478) an entry to the virtual stack indicating the type of data (operand) which is to be pushed onto the operand stack (during the actual execution of the program) for each datum to be pushed onto the stack by the currently selected instruction. This information is derived from the data type specific opcodes utilized in the bytecode program of the preferred embodiment of the present invention, the prior contents of the stack and the prior contents of the registers. The verifier also updates the stack counter 301 to reflect the added entry or entries in the virtual stack 302. This completes the stack push verification process.
[0093] Referring to FIG. 4E, if the currently selected instruction reads data from a register (510), the verifier will compare (512) the data type code information previously stored in the corresponding virtual register with the data type requirements (if any) of the currently selected instruction . For object handles, data type checking takes into account object class inheritance (i.e., a method that operates on an object of a specified class will can also operate on an object of any subclass of the specified class). If a mismatch is detected (512) between the data type information stored in the virtual register and the data type requirements of the currently selected instruction, then a message is generated (514) identifying t he place in the bytecode program where the mismatch occurred. The verifier will then set the VerificationSuccess flag to False and abort (516) the verification process.
[0094] The verifier also checks to see if the register accessed by the currently selected instruction has a register number higher than the maximum register number for the method being verified (518). If so, a message is generated (514) identifying the place in the bytecode program where the register access error occurred. The verifier will then set the VerificationSuccess flag to False and abort (516) the verification process.
[0095] If the currently selected instruction does not read data from a register (510) or the data type comparison at step 512 results in a match and the registered accessed is within the range of register numbers used by the method being verified (518), then the verifier continues processing the currently selected instruction at step 520.
[0096] Referring to FIG. 4F, if the currently selected instruction stores data into a register (520), then the data type associated with the selected bytecode instruction is stored in the virtual register (522).
[0097] The verifier also checks to see if the register(s) to be written by the currently selected instruction has(have) a register number higher than the maximum register number for the method being verified (523). If so, an error message is generated (526) identifying the place in the bytecode program where the register access error occurred. The verifier will then set the VerificationSuccess flag to False and abort (528) the verification process.
[0098] In addition, the instruction emulation procedure updates the jsr bit vector array 306 as follows. The jsr bit vector array 306 includes a separate bit vector for each subroutine level. Thus, if the current instruction is in a subroutine nested four levels deep, there will be four active jsr bit vectors in the array 306. If the current instruction is in a subroutine that is the target of a jsr instruction (i.e., a jump to subroutine instruction), for each subroutine level applicable to the current instruction, the corresponding jsr bit vector is updated to indicate the register(s) accessed or modified by the current instruction (540, FIG. 4G). The set of “marked” registers in each jsr bit vector can only be increased, not decreased, by step 540.
[0099] At this point the procedure for emulating one instruction is complete.
[0100] Referring back now to FIG. 4B, if the instruction emulation resulted in the detection of an error, the verification process is halted (382). Otherwise, the next step (390) is to determine the selected instruction's set of successor instructions. The “successor instructions” are defined to be all instructions that might be executed next after the currently selected instruction. The set of all successor instructions, includes:
[0101] (A) the next instruction in the method, if the current instruction is not an unconditional goto, a return, or a throw;
[0102] (B) the target of a conditional or unconditional branch;
[0103] (C) all exception handlers for this instruction; and
[0104] (D) when the current instruction is a subroutine return instruction, the instructions immediately following all jsr's that target the called subroutine.
[0105] It is noted that the last instruction of most exception handlers is a “goto” instruction. More generally, the successor instruction for the end of an exception handler is simply the successor instruction for the last instruction of the exception handler.
[0106] As part of the successor instruction determination process, the verifier also checks to see if the program can simply fall off the current instruction (i.e., without having a legal next instruction. If so, this is a fatal error and the VerificationSuccess flag is set to False and the verification procedure is terminated (382).
SnapShot Merger
[0107] After the successor instruction determination step (390), the verifier next merges the current stack counter 301, virtual stack 302, virtual register array 304 and jsr bit vector arrays 304 into the SnapShots of each of the successor instructions (392). This merger is performed separately for each successor instruction. There are a number of “special” cases requiring special handling of the status and snapshot merger process.
[0108] For instance, if a successor instruction is an exception handler, the Stack Status portion of the SnapShot of the successor instruction is defined to contain a single object of the exception type indicated by the exception handler information (i.e, the stored data type for the first virtual stack element indicates the object type of the exception handler), and furthermore the stack counter of the SnapShot of the successor instruction is set to a value of 1.
[0109] If the SnapShot for a successor instruction indicates that it has never before been “visited” (i.e., it is empty), the stack counter 301, virtual stack 302, virtual register array 304 and jsr bit vector array 306 are copied into the SnapShot for the successor instruction.
[0110] Otherwise, when the instruction has been visited before, the snapshot merger is handled as follows. If the stack counter in the Status Array does not match the stack counter in the existing SnapShot, or the two stacks are not identical with regard to data types, except for differently typed object handles, the VerificationSuccess flag is set to False and the verification process is aborted. Otherwise, the virtual stack 302 and virtual register array 304 values are merged into the values of the successor instruction's existing SnapShot as follows.
[0111] If two corresponding virtual stack elements or two corresponding virtual register elements contain different object handles, the specified data type for the stack or register element in the snapshot is replaced with the closest common ancestor (i.e., superclass) of the two handle types. If two corresponding virtual register elements contain different data types (other than handles), the data type for the register element in the updated SnapShot is denoted as “unknown” (i.e., unusable). If two corresponding stack elements contain different data types (other than handles), that is flagged by the verifier as an error.
[0112] However, if the successor instruction is the instruction immediately after a “jsr” instruction and the current instruction is a “ret” instruction the above rules for merging virtual register status information are replaced with the following rule:
[0113] 1) for any register that the corresponding jsr bit vector (i.e., the jsr bit vector for the current instruction that corresponds to the successor jsr instruction) indicates that the subroutine has accessed or modified, update the successor instruction's virtual register SnapShot data to use the data type of the virtual register at the time of the return (i.e., use the virtual register data type information in the corresponding element of the virtual register array 304);
[0114] 2) for all other registers, update the successor instruction's virtual register SnapShot data to use the data type of the register at the time of the preceding jsr instruction (i.e., copy the virtual register data type information from the corresponding element of the virtual register array in the preceding jsr's instruction's SnapShot).
[0115] The snapshot merger procedure also copies the current jsr bit vectors 306 into the SnapShot of the successor instructions only to the extent that those successor instructions are inside the same subroutines as the current instruction.
[0116] Finally, after the merger of the current verification status information into the SnapShot of each successor instruction has been performed, the changed bit for the successor instruction is set only if the merging of the virtual stack and register verification status values caused any change to the successor instruction's SnapShot (394).
[0117] Thus, the analysis of each selected instruction can cause the changed bit of one or more other instructions to be set. The data flow analysis continues until there are no instructions whose changed bit is set (380). Due to the fact that some instructions are the successor instructions for multiple other instructions, many instructions may be analyzed two or more times by the data flow analysis procedure before the data flow analysis of the method is completed.
Verification Considerations For Exception Handlers
[0118] An exception handler is a routine that protects a specified set of program code, called a protected code block. The exception handler is executed whenever the applicable exception gets thrown during execution of the corresponding protected code.
[0119] As indicated above, the Stack Status portion of the SnapShot for the first instruction of the exception handler contains a single object of the exception type indicated by the exception handler information (i.e, the stored data type for the first virtual stack element indicates the object type of the exception handler), and further more the stack counter of the SnapShot of the instruction is set to a value of 1.
[0120] The virtual register information of the SnapShot for the exception handler's first instruction contains data type values only for registers whose use is consistent throughout the protected code, and contains “unknown” indicators for all other registers used by the protected code.
Verification Considerations for “Finally” Code Blocks
[0121] The following program:
[0122] try {
[0123] startFaucet( );
[0124] waterLawn( );
[0125] } finally {
[0126] stopFaucet( )
[0127] }
[0128] ensures that the faucet is turned off, even if an exception occurs while starting the faucet or watering the lawn. The code inside the bracket after the word “try” is called the protected code. The code inside the brackets after the word “finally” is called the cleanup code. The cleanup code is guaranteed to be executed, even if the protected code does a “return” out of the function, or contains a break or continue to code outside the try/finally code, or experiences an exception.
[0129] In the Java bytecode language, the “finally” construct is implemented using the exception handling facilities, together with a “jsr” (jump to subroutine) instruction and “ret” (return from subroutine) instruction. The cleanup code is implemented as a subroutine. When it is called, the top item on the stack will be the return address; this return address is saved in a register. A “ret” is placed at the end of the cleanup code to return to whatever code called the cleanup.
[0130] To implement the “finally” feature, a special exception handler is set up for the protected code which catches all exceptions. This exception handler: (1) saves any exception that occurs in a register, (2) executes a “jsr” to the cleanup code, and (3) upon return from the cleanup code, re-throws the exception.
[0131] If the protected code has a “return” instruction that when executed will cause a jump to code outside the protected code, the interpreter performs the following steps to execute that instruction: (1) it saves the return value (if any) in a register, (2) executes a “jsr” to the cleanup code, and (3) upon return from the cleanup code, returns the value saved in the register.
[0132] Breaks or continue instructions inside the protected code that go outside the protected code are compiled into bytecodes that include a “jsr” to the cleanup code before performing the associated “goto” function. In addition, there must be a “jsr” instruction at the end of the protected code.
[0133] The jsr bit vector array and corresponding SnapShot data, as discussed above, enable the successful verification of bytecode programs that contain “finally” constructs. Due to the provision of multiple jsr bit vectors, even multiply-nested cleanup code can be verified.
Verification Considerations for New Object Formation and Initialization
[0134] Creating a usable object in the bytecode interpreter is a multi-step process. A typical bytecode sequence for creating and initializing an object, and leaving it on top of the stack is:
| new <myClass> | /* | allocate uninitialized space /* |
| dup | /* | duplicate object on the stack */ |
[0135] The myClass initialization method, myClass.<init>, sees the newly initialized object as its argument in register 0. It must either call an alternative myClass initialization method or call the initialization method of a superclass of the object before it is allowed to do anything else with the object.
[0136] To prevent the use of uninitialized objects, and to prevent objects from being initialized more than once, the bytecode verifier pushes a special data type on the stack as the result of the opcode “new”:
[0137] R;ObjClass;uninitialized;creationstep
[0138] The instruction number (denoted above as “creationstep”) needs to be stored as part of the special data type since there may be multiple instances of a not-yet initialized data type in existence at one time.
[0139] This special data type indicates the instruction in which the object was created and the class type of the uninitialized object created. When an initialization method is called on that object, all occurrences of the special type on the virtual stack and in the virtual registers (i.e., all virtual stack and virtual registers that have the identical data type, including the identical object creation instruction) are replaced by the appropriate, initialized data type:
[0140] R;ObjClass;initialized
[0141] During verification, the special data type for uninitialized objects is an illegal data type for any bytecode instruction to use, except for a call to an object initialization method for the appropriate object class. Thus, the verifier ensures that an uninitialized object cannot be used until it is initialized.
[0142] Similarly, the initialized object data type is an illegal data type for a call to an object initialization method. In this way the verifier ensures that an object is not initialized more than once.
[0143] One special check that the verifier must perform during the data flow analysis is that for every backwards branch, the verifier checks that there are no uninitialized objects on the stack or in a register. See steps 530, 532, 534, 536 in FIG. 4F. In addition, there may not be any uninitialized objects in a register in code protected by an exception handler or a finally code block. See steps 524, 526, 528 in FIG. 4F. Otherwise, a devious piece of code could fool the verifier into thinking it had initialized an object when it had, in fact, initialized an object created in a previous pass through the loop. For example, an exception handler could be used to indirectly perform a backwards branch.
Class Loader and Bytecode Interpreter
[0144] Referring to flow chart in FIG. 5 and Table 3, the execution of the class loader 124 and bytecode interpreter 122 will be described. Table 3 lists a pseudocode representation of the class loader and bytecode interpreter.
[0145] The class loader 124 is typically invoked when a user first initiates execution of a procedure, requiring that an object of the appropriate object class be generated. The class loader 124 loads in the appropriate object class file (560) and calls the bytecode program verifier 120 to verify the integrity of all the bytecode programs in the loaded object class (562). If the verifier returns a “verification failure” value (564), the attempt to execute the specified bytecode program is aborted by the class loader (566).
[0146] If all the methods are successfully verified (564) an object instance of the object class is generated, and the bytecode interpreter 122 is invoked (570) to execute the user requested procedure, which is typically called a method. The bytecode interpreter of the present invention does not perform (and does not need to perform) any operand stack overflow and underflow checking during program execution and also does not perform any data type checking for data stored in the operand stack during program execution. These conventional stack overflow, underflow and data type checking operations can be skipped by the present invention because the verifier has already verified that errors of these types will not be encountered during program execution.
[0147] The program interpreter of the present invention is especially efficient for execution of bytecode programs having instruction loops that are executed many times, because the operand stack checking instructions are executed only once for each bytecode in each such instruction loop in the present invention. In contrast, during execution of a program by a conventional interpreter, the interpreter must continually monitor the operand stack for overflows (i.e., adding more data to the stack than the stack can store) and underflows (i.e., attempting to pop data off the stack when the stack is empty). Such stack monitoring must normally be performed for all instructions that change the stack's status (which includes most all instructions). For many programs, stack monitoring instructions executed by the interpreter account for approximately 80% of the execution time of an interpreted computed program. As a result, the interpreter of the present invention will often execute programs at two to ten times the speed of a conventional program interpreter running on the same computer.
Alternate Embodiments
[0148] The foregoing descriptions of specific embodiments of the present invention have been presented for purposes of illustration and description. They are not intended to be exhaustive or to limit the invention to the precise forms disclosed, and obviously many modifications and variations are possible in light of the above teaching. The embodiments were chosen and described 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 and various embodiments 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 and their equivalents.
| TABLE 1 |
|---|
| BYTECODES IN JAVA LANGUAGE |
| TABLE 2 |
|---|
| Pseudocode for JAVA Bytecode Verifier |
| TABLE 3 |
|---|
| Pseudocode for Bytecode Class Loader and Interpreter |
Claims
What is claimed is:
1. A method, comprising:
selectively connecting a computer system via a network to a sending computer to receive from the sending computer a program formed of low-level, stack-oriented, program code;
verifying prior to execution that when an instruction of the program is executed that can be executed along more than one execution path, a number of operands on a stack when arriving at that instruction during execution is identical regardless of the execution path taken to arrive at the instruction, and a type state of the stack when arriving at the instruction during execution of a first execution path that includes the instruction is compatible with a type state of the stack when arriving at the instruction during execution of all other execution paths that include the instruction; and
executing the verified program.
2. The method of claim 1, wherein the verifying includes confirming prior to execution of the program that the number of operands on the stack when arriving at the instruction that can be executed along more than one execution path is identical for all execution paths that include the instruction, even when the stack is not empty prior to execution of the instruction.
3. The method of claim 1, wherein the verifying includes confirming prior to execution of the program that execution of any loop in the program will not result in a net addition or deletion of operands on the stack.
4. The method of claim 1, wherein when the program is executed no check is made for overflow and underflow of the stack.
5. The method of claim 1, wherein t he verifying includes verifying prior to execution that when a loop of the program is executed, immediately before and after each iteration of the loop, a number of operands an the s tack is identical, even when the stack is not empty, and a type state of the stack remains compatible with an initial type state of the stack regardless of how many times the loop is executed.
6. The method of claim 1, wherein the executing includes executing the program without performing a check during execution of the program that corresponds to a check performed by the verifying.
7. The method of claim 1, wherein each instruction of the program comprises one or more bytecodes, and wherein the verifying includes determining whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
8. The method of claim 1, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne; iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<l>, ldc1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, lstore_n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
9. The method of claim 1, wherein the verifying includes certifying that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
10. The method of claim 1, wherein the verifying includes using a virtual stack to track the type state of the stack.
11. The method of claim 1, wherein the verifying includes using an array of virtual local variables to track a type state of local variables used by the program.
12. A computer system, comprising:
means for selectively connecting the computer system via a network to a sending computer to receive from the sending computer a program formed of low-level, stack-oriented, program code;
memory for storing the program;
a data processing unit for executing programs stored in the memory;
a program verifier, stored in the memory and executed by the data processing unit, the program verifier including instructions for verifying prior to execution that when an instruction of the program is executed that can be executed along more than one execution path, a number of operands on a stack when arriving at that instruction during execution is identical regardless of the execution path taken to arrive at the instruction, and a type state of the stack when arriving at the instruction during execution of a first execution path that includes the instruction is compatible with a type state of the stack when arriving at the instruction during execution of all other execution paths that include the instruction; and
a program execution module for executing the verified program.
13. The computer system of claim 12, wherein the verifying instructions include instructions for confirming prior to execution of the program that the number of operands on the stack when arriving at the instruction that can be executed along more than one execution path is identical for all execution paths that include the instruction, even when the stack is not empty prior to execution of the instruction.
14. The computer system of claim 12, wherein the verifying instructions include instructions for confirming prior to execution of the program that execution of any loop in the program will not result in a net addition or deletion of operands on the stack.
15. The computer system of claim 12, wherein the program execution module does not check for overflow and underflow of the stack when executing the verified program.
16. The computer system of claim 12, wherein the verifying instructions include instructions for verifying prior to execution that when a loop of the program is executed, immediately before and after each iteration of the loop, a number of operands on the stack is identical, even when the stack is not empty, and a type state of the stack remains compatible with an initial type state of the stack regardless of how many times the loop is executed.
17. The computer system of claim 12, wherein the program execution module includes instructions for executing the program with out performing a check during execution of the pro gram that corresponds to a check performed by the program verifier.
18. The computer system of claim 12, wherein each instruction of the program comprises one or more bytecodes, and wherein the program verifier includes instructions for determining whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
19. The computer system of claim 12, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<1>, lda1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, Istore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
20. The computer system of claim 12, wherein the program verifier includes instructions for certifying that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
21. The computer system of claim 12, wherein the program verifier includes instructions using a virtual stack to track the type state of the stack.
22. The computer system of claim 12, wherein the program verifier includes instructions using an array of virtual local variables to track a type state of local variables used by the program.
23. A computer program product for use in conjunction with a computer system, the computer program product comprising a computer readable storage medium and a computer program mechanism embedded therein, the computer program mechanism comprising:
a program verifier, for analyzing a program formed of low-level, stack-oriented, program code; the program verifier including instructions for verifying prior to execution of the program that when an instruction of the program is executed that can be executed along more than one execution path, a number of operands on a stack when arriving at that instruction during execution is identical regardless of the execution path taken to arrive at the instruction, and a type state of the stack when arriving at the instruction during execution of a first execution path that includes the instruction is compatible with a type state of the stack when arriving at the instruction during execution of all other execution paths that include the instruction; and
a program execution module for executing the verified program.
24. The computer program product of claim 23, wherein the verifying instructions include instructions for confirming prior to execution of the program that the number of operands on the stack when arriving at the instruction that can be executed along more than one execution path is identical for all execution paths that include the instruction, even when the stack is not empty prior to execution of the instruction.
25. The computer program product of claim 23, wherein the verifying instructions include instructions for confirming prior to execution of the program that execution of any loop in the program will not result in a net addition or deletion of operands on the stack.
26. The computer program product of claim 23, wherein the program execution module does not check for overflow and underflow of the stack when executing the verified program.
27. The computer program product of claim 23, wherein the verifying instructions include instructions for verifying prior to execution that when a loop of the program is executed, immediately before and after each iteration of the loop, a number of operands on the stack is identical, even when the stack is not empty, and a type associated with each of the operands on the stack is compatible regardless of how many times the loop is executed.
28. The computer program product of claim 23, wherein the program execution module includes instructions for executing the program without performing a check during execution of the program that corresponds to a check performed by the program verifier.
29. The computer program product of claim 23, wherein each instruction of the program comprises one or more bytecodes, and wherein the program verifier includes instructions for determining whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
30. The computer program product of claim 23, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<1>, ldc1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, lstore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
31. The computer program product of claim 23, wherein the program verifier includes instructions for certifying that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
32. The computer program product of claim 23, wherein the program verifier includes instructions using a virtual stack to track the type state of the stack.
33. The computer program product of claim 23, wherein the program verifier includes instructions using an array of virtual local variables to track a type state of local variables used by the program.
34. A method comprising:
providing a program formed of low-level, stack-oriented, program code; and
making the program available to a computer system via a network;
wherein after the computer system accesses the program, the computer system verifies prior to execution of the program that when an instruction of the program is executed that can be executed along more than one execution path, a number of operands on a stack when arriving at that instruction during execution is identical regardless of the execution path taken to arrive at the instruction, and a type state of the stack when arriving at the instruction during execution of a first execution path that includes the instruction is compatible with a type state of the stack when arriving at the instruction during execution of all other execution paths that include the instruction.
35. The method of claim 34, wherein the computer system confirms prior to execution of the program that the number of operands on the stack when arriving at the instruction that can be executed along more than one execution path is identical for all execution paths that include the instruction, even when the stack is not empty prior to execution of the instruction.
36. The method of claim 34, wherein the computer system confirms prior to execution of the program that execution of any loop in the program will not result in a net addition or deletion of operands on the stack.
37. The method of claim 34, wherein the computer system confirms prior to execution of the program that when a loop of the program is executed, immediately before and after each iteration of the loop, a number of operands on the stack is identical, even when the stack is not empty, and a type associated with each of the operands on the stack is compatible regardless of how many times the loop is executed.
38. The method of claim 34, including executing the program without performing a check during execution of the program that corresponds to a check performed by the computer system prior to execution of the program.
39. The method of claim 34, wherein each instruction of the program comprises one or more bytecodes, and wherein the computer system determines prior to execution of the program whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
40. The method of claim 34, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst-null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<1>, ldc1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, lstore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
41. The method of claim 34, wherein the computer system, prior to execution of the program, verifies that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
42. The method of claim 34, wherein the computer system, prior to execution of the program, uses a virtual stack to track the type state of the stack during execution of the program.
43. The method of claim 34, wherein the computer system, prior to execution of the program, uses an array of virtual local variables to track a type state of local variables used during execution of the program.
44. A computer system, comprising:
memory for storing a program formed of low-level, stack-oriented, program code;
a data processing unit for executing programs stored in the memory;
a program verifier, stored in the memory and executed by the data processing unit, the program verifier including instructions for verifying, prior to execution, that when an instruction of the program is executed that can be executed along more than one execution path, a number of operands on a stack when arriving at that instruction during execution is identical regardless of the execution path taken to arrive at the instruction, and a type state of the stack when arriving at the instruction during execution of a first execution path that includes the instruction is compatible with a type state of the stack when arriving at the instruction during execution of all other execution paths that include the instruction.
45. The computer system of claim 44, wherein the verifying instructions include instructions for confirming prior to execution of the program that the number of operands on the stack when arriving at the instruction that can be executed along more than one execution path is identical for all execution paths that include the instruction, even when the stack is not empty prior to execution of the instruction.
46. The computer system of claim 44, wherein the verifying instructions include instructions for confirming prior to execution of the program that execution of any loop in the program will not result in a net addition or deletion of operands on the stack.
47. The computer system of claim 44, wherein the verifying instructions include instructions for verifying prior to execution that when a loop of the program is executed, immediately before and after each iteration of the loop, a number of operands on the stack is identical, even when the stack is not empty, and a type associated with each of the operands on the stack is compatible regardless of how many times the loop is executed.
48. The computer system of claim 44, including a program execution module having instructions for executing the program without performing a check during execution of the program that corresponds to a check performed by the program verifier.
49. The computer system of claim 44, wherein each instruction of the program comprises one or more bytecodes, and wherein the program verifier includes instructions for determining whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
50. The computer system of claim 44, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<1>, ldc1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, lstore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
51. The computer system of claim 44, wherein the program verifier includes instructions for certifying that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
52. The computer system of claim 44, wherein the program verifier includes instructions using a virtual stack to track the type state of the stack.
53. The computer system of claim 44, wherein the program verifier includes instructions using an array of virtual local variables to track a type state of local variables used by the program.
54. A computer program product for use in conjunction with a computer system, the computer program product comprising a computer readable storage medium and a computer program mechanism embedded therein, the computer program mechanism comprising:
a program verifier for analyzing a program formed of low-level, stack-oriented, program code, the program verifier including instructions for verifying at run time, prior to execution, that when an instruction of the program is executed that can be executed along more than one execution path, a number of operands on a stack when arriving at that instruction during execution is identical regardless of the execution path taken to arrive at the instruction, and a type state of the stack when arriving at the instruction during execution of a first execution path that includes the instruction is compatible with a type state of the stack when arriving at the instruction during execution of all other execution paths that include the instruction.
55. The computer program product of claim 54, wherein the verifying instructions include instructions for confirming prior to execution of the program that a number of operands on the stack when arriving at the instruction that can be executed along more than one execution path is identical for all execution paths that include the instruction, even when the stack is not empty prior to execution of the instruction.
56. The computer program product of claim 54, wherein the verifying instructions include instructions for confirming prior to execution of the program that execution of any loop in the program will not result in a net addition or deletion of operands on the stack.
57. The computer program product of claim 54, wherein the verifying instructions include instructions for verifying prior to execution that when a loop of the program is executed, immediately before and after each iteration of the loop, a number of operands on the stack is identical, even when the stack is not empty, and a type associated with each of the operands on the stack is compatible regardless of how many times the loop is executed.
58. The computer program product of claim 54, further including a program execution module having instructions for executing the program without performing a check during execution of the program that corresponds to a check performed by the program verifier.
59. The computer program product of claim 54, wherein each instruction of the program comprises one or more bytecodes, and wherein the program verifier includes instructions for determining whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
60. The computer program product of claim 54, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<1>, ldc1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, lstore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
61. The computer program product of claim 54, wherein the program verifier includes instructions for certifying that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
62. The computer program product of claim 54, wherein the program verifier includes instructions using a virtual stack to track the type state of the stack.
63. The computer program product of claim 54, wherein the program verifier includes instructions using an array of virtual local variables to track a type state of local variables used by the program.
64. A method of operating a computer system, comprising:
receiving from a source computer a program formed of low-level, stack-oriented, program code;
verifying at run time, prior to execution, that when an instruction of the program is executed that can be executed along more than one execution path, a number of operands on a stack when arriving at that instruction during execution is identical for all execution paths that include the instruction, and a type state of the stack when arriving at the instruction during execution of a first execution path that includes the instruction is compatible with a type state of the stack when arriving at the instruction during execution of all other execution paths that include the instruction; and
executing the verified program.
65. The method of claim 64, wherein the verifying comprises confirming prior to execution of the program that a number of operands on the stack when arriving at the instruction that can be executed along more than one execution path is identical for all execution paths that include the instruction, even when the stack is not empty prior to execution of the instruction.
66. The method of claim 64, wherein the verifying includes confirming prior to execution of the program that execution of any loop in the program will not result in a net addition or deletion of operands on the stack.
67. The method of claim 64, wherein the verifying includes confirming prior to execution of the program that execution of any loop in the program will not result in a net addition or deletion of operands on the stack.
68. The method of claim 64, wherein the verifying includes verifying prior to execution that when a loop of the program is executed that, immediately before and after each iteration of the loop, a number of operands on the stack is identical, even when the stack is not empty, and a type state of the stack remains compatible with an initial type state of the stack regardless of how many times the loop is executed.
69. The method of claim 64, wherein the executing includes executing the program without performing a check during execution of the program that corresponds to a check performed by the verifying.
70. The method of claim 64, wherein each instruction of the program comprises one or more bytecodes, and wherein the verifying includes determining whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
71. The method of claim 64, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<l>, ldc1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, lstore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
72. The method of claim 64, wherein the verifying includes certifying that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
73. The method of claim 64, wherein the verifying includes using a virtual stack to track the type state of the stack.
74. The method of claim 64, wherein the verifying includes using an array of virtual local variables to track a type state of local variables used by the program.
75. A computer system, comprising:
an interface for receiving a program formed of low-level, stack-oriented, program code;
memory for storing the program;
a data processing unit for executing programs stored in the memory;
a program verifier, stored in the memory and executed by the data processing unit, the program verifier including instructions for verifying prior to execution that when an instruction of the program is executed that can be executed along more than one execution path, a number of operands on a stack when arriving at that instruction during execution is identical regardless of the execution path taken to arrive at the instruction, and a type state of the stack when arriving at the instruction during execution of a first execution path that includes the instruction is compatible with a type state of the stack when arriving at the instruction during execution of all other execution paths that include the instruction; and
a program execution module for executing the verified program.
76. The computer system of claim 75, wherein the verifying instructions include instructions for confirming prior to execution of the program that the number of operands on the stack when arriving at the instruction that can be executed along more than one execution path is identical for all execution paths that include the instruction, even when the stack is not empty prior to execution of the instruction.
77. The computer system of claim 75, wherein the verifying instructions include instructions for confirming prior to execution of the program that execution of any loop in the program will not result in a net addition or deletion of operands on the stack.
78. The computer system of claim 75, wherein the program execution module does not check for overflow and underflow of the stack when executing the verified program.
79. The computer system of claim 75, wherein the verifying instructions include instructions for verifying prior to execution that when a loop of the program is executed, immediately before and after each iteration of the loop, a number of operands on the stack is identical, even when the stack is not empty, and a type state of the stack remains compatible with an initial type state of the stack regardless of how many times the loop is executed.
80. The computer system of claim 75, wherein the program execution module includes instructions for executing the program without performing a check during execution of the program that corresponds to a check performed by the program verifier.
81. The computer system of claim 75, wherein each instruction of the program comprises one or more bytecodes, and wherein the program verifier includes instructions for determining whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
82. The computer system of claim 75, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<l>, ldc1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, lstore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
83. The computer system of claim 75, wherein the program verifier includes instructions for certifying that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
84. The computer system of claim 75, wherein the program verifier includes instructions using a virtual stack to track the type state of the stack.
85. The computer system of claim 75, wherein the program verifier includes instructions using an array of virtual local variables to track a type state of local variables used by the program.
86. The computer system of claim 75, wherein the program is platform independent, and wherein the interface is configured to receive the program from a remote device.
87. The computer system of claim 75, wherein the interface is configured to receive the program from a remote device.
88. A method of operating a computer system, comprising:
providing a program formed of low-level, stack-oriented, program code;
verifying, at run time, that when an instruction of the program is executed that can be executed along more than one execution path, a number of operands on a stack when arriving at that instruction during execution is identical for all execution paths that include the instruction, even when the stack is not empty, and a type state of the stack when arriving at the instruction during execution of a first execution path that includes the instruction is compatible with a type state of the stack when arriving at the instruction during execution of all other execution paths that include the instruction; and
executing the verified program.
89. The method of claim 88, wherein the verifying includes confirming prior to execution of the program that the number of operands on the stack when arriving at the instruction that can be executed along more than one execution path is identical for all execution paths that include the instruction, even when the stack is not empty prior to execution of the instruction.
90. The method of claim 88, wherein the verifying includes confirming prior to execution of the program that execution of any loop in the program will not result in a net addition or deletion of operands on the stack.
91. The method of claim 88, wherein when the program is executed no check is made for overflow and underflow of the stack.
92. The method of claim 88, wherein the verifying includes verifying prior to execution that when a loop of the program is executed, immediately before and after each iteration of the loop, a number of operands on the stack is identical, even when the stack is not empty, and a type state of the stack remains compatible with an initial type state of the stack regardless of how many times the loop is executed.
93. The method of claim 88, wherein the executing includes, when the program has been verified, executing the program without performing a check during execution of the program that corresponds to a check performed during the verifying.
94. The method of claim 88, wherein each instruction of the program comprises one or more bytecodes, and wherein the verifying includes determining whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
95. The method of claim 88, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<l>, ldc1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, lstore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
96. The method of claim 88, wherein the verifying includes certifying that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
97. The method of claim 88, wherein the verifying is performed using a virtual stack to track the type state of the stack.
98. The method of claim 88, wherein the verifying is performed using an array of virtual local variables to track a type state of local variables used by the program.
99. The method of claim 88, wherein the program is platform independent, and wherein the providing includes receiving the program from a remote device.
100. The method of claim 88, wherein the providing includes receiving the program from a remote device.
101. The method of claim 88, wherein the verifying occurs at a point in time prior to execution of the program by the computer system.
102. The computer program product of claim 23, wherein the program is platform independent.
103. A method of operating a computer system, comprising:
receiving a program formed of low-level, stack-oriented, program code from a server over a network;
determining whether the program successfully completed a verification process, wherein the verification process verifies, prior to execution of the program, that when an instruction of the program is executed that can be executed along more than one execution path, a number of operands on a stack when arriving at that instruction during execution is identical for all execution paths that include the instruction regardless of the execution path taken to arrive at the instruction, and a type state of the stack when arriving at the instruction during execution of a first execution path that includes the instruction is compatible with a type state of the stack when arriving at the instruction during execution of all other execution paths that include the instruction; and
executing or aborting execution of the program based on a result of the determination.
104. The method of claim 103, wherein when the program is executed no check is made to verify that when an instruction of the program is executed that can be executed along more than one execution path, a number of operands on a stack when arriving at that instruction is identical regardless of the execution path taken to arrive at the instruction, and no check is made during execution of the program that a type state of the stack when arriving at the instruction during execution of the first execution path is compatible with a type state of the stack when arriving at the instruction during execution of all other execution paths that include the instruction.
105. The method of claim 103, wherein when the program is executed no check is made for overflow and underflow of the stack.
106. The method of claim 103, wherein the executing includes executing the program without performing a check during execution of the program that corresponds to a check performed during the verification process.
107. The method of claim 103, wherein each instruction of the program comprises one or more bytecodes, and wherein the verification process determines whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
108. The method of claim 103, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<l>, ldc1 ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, Ireturn, lshl, lshr, lstore, lstore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
109. A computer system, comprising:
an interface for receiving a program formed of low-level, stack-oriented, program code;
memory for storing the program;
a data processing unit for executing programs stored in the memory;
a first module for determining whether the program successfully completed a verification process, wherein the verification process verifies, prior to execution of the program, that when an instruction of the program is executed that can be executed along more than one execution path, a number of operands on a stack when arriving at that instruction during execution is identical for all execution paths that include the instruction regardless of the execution path taken to arrive at the instruction, and a type state of the stack when arriving at the instruction during execution of a first execution path that includes the instruction is compatible with a type state of the stack when arriving at the instruction during execution of all other execution paths that include the instruction; and
a program execution module for executing or aborting based on a result generated by the first module.
110. The computer system of claim 109, wherein the verification process verifies that the number of operands on the stack when arriving at the instruction that can be executed along more than one execution path is identical for all execution paths that include the instruction, even when the stack is not empty prior to execution of the instruction.
111. The computer system of claim 109, wherein the verification process verifies that execution of any loop in the program will not result in a net addition or deletion of operands on the stack.
112. The computer system of claim 109, wherein the program execution module does not check for overflow and underflow of the stack when executing the verified program.
113. The computer system of claim 109, wherein the verification process verifies that when a loop of the program is executed, immediately before and after each iteration of the loop, a number of operands on the stack is identical, even when the stack is not empty, and a type state of the stack remains compatible with an initial type state of the stack regardless of how many times the loop is executed.
114. The computer system of claim 109, wherein the program execution module includes instructions for executing the program without performing a check during execution of the program that corresponds to a check performed by the program verifier.
115. The computer system of claim 109, wherein each instruction of the program comprises one or more bytecodes, and wherein the verification process determines whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
116. The computer system of claim 109, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<l>, ldc1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, lstore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
117. The computer system of claim 109, wherein the verification process verifies that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
118. A computer program product for use in conjunction with a computer system, the computer program product comprising a computer readable storage medium and a computer program mechanism embedded therein, the computer program mechanism comprising:
a first module for determining whether the program successfully completed a verification process, wherein the verification process verifies, prior to execution of the program, that when an instruction of the program is executed that can be executed along more than one execution path, a number of operands on a stack when arriving at that instruction during execution is identical for all execution paths that include the instruction regardless of the execution path taken to arrive at the instruction, and a type state of the stack when arriving at the instruction during execution of a first execution path that includes the instruction is compatible with a type state of the stack when arriving at the instruction during execution of all other execution paths that include the instruction; and
a program execution module for executing or aborting based on a result generated by the first module.
119. The computer program product of claim 118, wherein the verification process verifies that the number of operands on the stack when arriving at the instruction that can be executed along more than one execution path is identical for all execution paths that include the instruction, even when the stack is not empty prior to execution of the instruction.
120. The computer program product of claim 118, wherein the verification process verifies that execution of any loop in the program will not result in a net addition or deletion of operands on the stack.
121. The computer program product of claim 118, wherein the program execution module does not check for overflow and underflow of the stack when executing the verified program.
122. The computer program product of claim 118, wherein the verification process verifies that when a loop of the program is executed, immediately before and after each iteration of the loop, a number of operands on the stack is identical, even when the stack is not empty, and a type state of the stack remains compatible with an initial type state of the stack regardless of how many times the loop is executed.
123. The computer program product of claim 118, wherein the program execution module includes instructions for executing the program without performing a check during execution of the program that corresponds to a check performed by the program verifier.
124. The computer program product of claim 118, wherein each instruction of the program comprises one or more bytecodes, and wherein the verification process determines whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
125. The computer program product of claim 118, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<l>, ldc1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, lstore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
126. The computer program product of claim 118, wherein the verification process verifies that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
127. A method of operating a computer system, comprising the steps of:
providing a program formed of low-level, stack-oriented, program code;
verifying at run time, prior to execution, that when a loop of the program is executed that, immediately before and after each iteration of the loop, a number of operands on a stack is identical, even when the stack is not empty, and a type state of the stack before a first iteration of the loop is compatible with a type state of the stack after the each iteration of the loop regardless of how many times the loop is executed; and
executing the verified program.
128. The method of claim 127, wherein the executing includes, when the program has been verified, executing the program without performing a check during execution of the program that corresponds to a check performed during the verifying.
129. The method of claim 127, wherein each instruction of the program comprises one or more bytecodes, and wherein the verifying includes determining whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
130. The method of claim 127, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<l>, ldc1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, lstore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
131. The method of claim 127, wherein the verifying includes certifying that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
132. The method of claim 127, wherein the verifying is performed using a virtual stack to track the type state of the stack.
133. The method of claim 127, wherein the verifying is performed using an array of virtual local variables to track a type state of local variables used by the program.
134. The method of claim 127, wherein the program is platform independent, and wherein the providing includes receiving the program from a remote device.
135. The method of claim 127, wherein the providing includes receiving the program from a remote device.
136. A computer system, comprising:
memory for storing a program formed of low-level, stack-oriented, program code;
a data processing unit for executing programs stored in the memory;
a program verifier, stored in the memory and executed by the data processing unit, the program verifier including instructions for verifying prior to execution that when a loop of the program is executed that, immediately before and after each iteration of the loop, a number of operands on a stack is identical, even when the stack is not empty, and a type state of the stack before a first iteration of the loop is compatible with a type state of the stack after the each iteration of the loop regardless of how many times the loop is executed; and
a program execution module for executing the verified program.
137. The computer system of claim 136, including a program execution module for executing the program, when the program has been verified by the program verifier, without performing a check during execution of the program that corresponds to a check performed by the program verifier.
138. The computer system of claim 136, wherein each instruction of the program comprises one or more bytecodes, and wherein the program verifier includes instructions for determining whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
139. The computer system of claim 136, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<l>, ldc1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, lstore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
140. The computer system of claim 136, wherein the program verifier includes instructions for certifying that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
141. The computer system of claim 136, wherein the program verifier includes instructions using a virtual stack to track the type state of the stack.
142. The computer system of claim 136, wherein the program verifier includes instructions using an array of virtual local variables to track a type state of local variables used by the program.
143. A computer program product for use in conjunction with a computer system, the computer program product comprising a computer readable storage medium and a computer program mechanism embedded therein, the computer program mechanism comprising:
a program verifier, for analyzing a program formed of low-level, stack-oriented, program code; the program verifier including instructions for verifying prior to execution of the program that when a loop of the program is executed that, immediately before and after each iteration of the loop, a number of operands on a stack is identical, even when the stack is not empty, and a type state of the stack before a first iteration of the loop is compatible with a type state of the stack after the each iteration of the loop regardless of how many times the loop is executed; and
a program execution module for executing the verified program.
144. The computer program product of claim 143, including a program execution module for executing the program, when the program has been verified by the program verifier, without performing a check during execution of the program that corresponds to a check performed by the program verifier.
145. The computer program product of claim 143, wherein each instruction of the program comprises one or more bytecodes, and wherein the program verifier includes instructions for determining whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
146. The computer program product of claim 143, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst <f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<l>, ldc1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, lstore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
147. The computer program product of claim 143, wherein the program verifier includes instructions for certifying that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
148. The computer program product of claim 143, wherein the program verifier includes instructions using a virtual stack to track the type state of the stack.
149. The computer program product of claim 143, wherein the program verifier includes instructions using an array of virtual local variables to track a type state of local variables used by the program.
150. A method of operating a computer system, comprising:
receiving a program formed of low-level, stack-oriented, program code from a server over a network;
determining whether the program successfully completed a verification process, wherein the verification process verifies, prior to execution of the program, that when a loop of the program is executed that, immediately before and after each iteration of the loop, a number of operands on a stack is identical and a type state of the stack before a first iteration of the loop is compatible with a type state of the stack after the each iteration of the loop regardless of how many times the loop is executed; and
executing or aborting execution of the program based on a result of the determination.
151. The method of claim 150, wherein when the program is executed no check is made to verify that when a loop of the program is executed that, immediately before and after each iteration of the loop, a number of operands on the stack is identical and no check is made to verify that a type state of the stack before a first iteration of the loop is compatible with a type state of the stack after the each iteration of the loop regardless of how many times the loop is executed.
152. The method of claim 150, wherein each instruction of the program comprises one or more bytecodes, and wherein the verification process determines whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
153. The method of claim 150, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<l>, ldc1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, lstore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
154. The method of claim 150, wherein the verification process certifies that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
155. The method of claim 150, wherein the verification process uses a virtual stack to track the type state of the stack.
156. The method of claim 150, wherein the verification process uses an array of virtual local variables to track a type state of local variables used by the program.
157. The method of claim 127, wherein the program is platform independent, and wherein the providing includes receiving the program from a remote device.
158. The method of claim 127, wherein the providing includes receiving the program from a remote device.
159. A computer system, comprising:
an interface for receiving a program formed of low-level, stack-oriented, program code;
memory for storing the program;
a data processing unit for executing programs stored in the memory;
a first module for determining whether the program successfully completed a verification process, wherein the verification process verifies, prior to execution of the program, that when a loop of the program is executed that, immediately before and after each iteration of the loop, a number of operands on a stack is identical, even when the stack is not empty, and a type state of the stack before a first iteration of the loop is compatible with a type state of the stack after the each iteration of the loop regardless of how many times the loop is executed; and
a program execution module for executing or aborting execution of the program based on a result of the determination.
160. The computer system of claim 159, wherein the program execution module is configured to execute the program without checking to verify that when a loop of the program is executed that, immediately before and after each iteration of the loop, a number of operands on the stack is identical and without checking to verify that a type state of the stack before a first iteration of the loop is compatible with a type state of the stack after the each iteration of the loop regardless of how many times the loop is executed.
161. The computer system of claim 159, wherein each instruction of the program comprises one or more bytecodes, and wherein the verification process determines whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
162. The computer system of claim 159, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<1>, ldc1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, lstore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
163. The computer system of claim 159, wherein the verification process certifies that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
164. The computer system of claim 159, wherein the verification process uses a virtual stack to track the type state of the stack.
165. The computer system of claim 159, wherein the verification process uses an array of virtual local variables to track a type state of local variables used by the program.
166. A computer program product for use in conjunction with a computer system, the computer program product comprising a computer readable storage medium and a computer program mechanism embedded therein, the computer program mechanism comprising:
a first module for determining whether the program successfully completed a verification process, wherein the verification process verifies, prior to execution of the program, that when a loop of the program is executed that, immediately before and after each iteration of the loop, a number of operands on a stack is identical, even when the stack is not empty, and a type state of the stack before a first iteration of the loop is compatible with a type state of the stack after the each iteration of the loop regardless of how many times the loop is executed; and
a program execution module for executing or aborting execution of the program based on a result of the determination.
167. The computer program product of claim 166, wherein the program execution module is configured to execute the program without checking to verify that when a loop of the program is executed that, immediately before and after each iteration of the loop, a number of operands on the stack is identical and without checking to verify that a type state of the stack before a first iteration of the loop is compatible with a type state of the stack after the each iteration of the loop regardless of how many times the loop is executed.
168. The computer program product of claim 166, wherein each instruction of the program comprises one or more bytecodes, and wherein the verification process determines whether execution of any bytecoded instruction in the program would violate predetermined data type restrictions for that instruction.
169. The computer program product of claim 166, wherein at least one instruction of the program comprises one or more bytecodes that represent an operation on a specific data type and is selected from the group consisting of: aaload, aastore, aconst_null, aload, areturn, arraylength, astore, astore_<n>, athrow, bipush, breakpoint, catchsetup, catchteardown, checkcast, df2, d2i, d2l, dadd, daload, dastore, dcmpg, dcmpl, dconst_<d>, ddiv, dload, dload_<d>, dmod, dmul, dneg, dreturn, dstore, dstore_<n>, dsub, dup, dup2, dup2_x1, dup2_x2, dup_x1, dup_—x2, f2d, f2i, f2l, fadd, faload, fastore, fempg, fempl, fconst_<f>, fdiv, fload, fload_<n>, fmod, fmul, fneg, freturn, fstore, fstore_<n>, fsub, gatfield, getstatic, goto, i2d, i2f, i2l, iadd, iaload, iand, iastore, iconst_<n>, iconst_m1, idiv, if_acmpeq, if_acmpne, if_icmpeq, if_icmpge, if_icmpgt, if_icmple, if_icmplt, if_icmpne, ifeq, ifge, ifgt, ifle, iflt, ifne, iinc, iload, iload_<n>, imod, imul, ineg, instanceof, int2byte, int2char, invokeinterface, invokemethod, invokesuper, ior, ireturn, ishl, Ishr, istore, istore_<n>, isub, iushr, ixor, jsr, 12d, 12f, 12i, ladd, laload, land, lastore, lcmp, lconst_<l>, ldc1, ldc2, ldc2w, ldiv, lload, lload_<n>, lmod, lmul, lneg, lookupswitch, lor, lreturn, lshl, lshr, lstore, lstore_<n>, lsub, lushr, lxor, monitorenter, monitorexit, new, newarray, newfromname, nop, pop, pop2, putfield, putstatic, ret, return, saload, sastore, siaload, siastore, sipush, tableswitch, and verifystack.
170. The computer program product of claim 166, wherein the verification process certifies that the program complies with a stack non-overflow constraint and a stack non-underflow constraint.
171. The computer program product of claim 166, wherein the verification process uses a virtual stack to track the type state of the stack.
172. The computer program product of claim 166, wherein the verification process uses an array of virtual local variables to track a type state of local variables used by the program.
Patent Citations (27)
| Patent | Date | Inventor | Cited By |
|---|---|---|---|
| US3878513(A) | 1975-04-01 | Werner | Applicant |
| US4521851(A) | 1985-06-01 | Trubisky et al. | Applicant |
| US4524416(A) | 1985-06-01 | Stanley et al. | Applicant |
| US4622013(A) | 1986-11-01 | Cerchio | Applicant |
| US4742215(A) | 1988-05-01 | Daughters et al. | Applicant |
| US5165465(A) | 1992-11-01 | Kenet | Applicant |
| US5179734(A) | 1993-01-01 | Candy et al. | Applicant |
| US5187799(A) | 1993-02-01 | McAuley et al. | Applicant |
| US5220522(A) | 1993-06-01 | Wilson et al. | Applicant |
| US5283864(A) | 1994-02-01 | Knowlton | Applicant |
| US5307499(A) | 1994-04-01 | Yin | Applicant |
| US5347632(A) | 1994-09-01 | Filepp et al. | Applicant |
| US5422992(A) | 1995-06-01 | Motoyama et al. | Applicant |
| US5446875(A) | 1995-08-01 | Ogisu et al. | Applicant |
| US5450575(A) | 1995-09-01 | Sites | Applicant |
| US5590329(A) | 1996-12-01 | Goodnow, II et al. | Applicant |
| US5640503(A) | 1997-06-01 | Alpert et al. | Examiner |
| US5668999(A) | 1997-09-01 | Gosling | Examiner |
| US5740441(A) | 1998-04-01 | Yellin et al. | Examiner |
| US5748964(A) | 1998-05-01 | Gosling | Examiner |
| US5925125(A) | 1999-07-01 | Alpert et al. | Examiner |
| US5978574(A) | 1999-11-01 | Sharma | Examiner |
| US5999731(A) | 1999-12-01 | Yellin et al. | Examiner |
| US6075940(A) | 2000-06-01 | Gosling | Examiner |
| US6247171(B1) | 2001-06-01 | Yellin et al. | Examiner |
| EP424056 | 1990-10-01 | Applicant | |
| EP718764 | 1995-12-01 | Applicant |
Non-Patent Literature (76)
- Mili et al., A system for Classifying Program Verification . . . , 1984, IEEE, p. 499-509.Applicant
- Gumb, R., A First Course in Program Verification . . . 1989, ACM, p. 146-150.Applicant
- Kamikawai et al., A Critical Path System, 1981, IEEE, p. 118-123.Applicant
- Adobe Systems Inc., “PostScript Language Reference Manual Second Edition,” 1990, pp. 23-143.Applicant
- Ahamed et al., “An Application of Name Based Addressing to Low Level Distributed Algorithms,” Jan. 1985, IEEE Transactions On Software Engineering, vol. SE-11, No. 1, p59.Applicant
- Almes et al., “The Eden System: A Technical Review,” Jan. 1985, IEEE Transactions On Software Engineering, vol SE-11, No. 1, pp. 43-58.Applicant
- Almes, Guy. T, “Integration and Distribution in the Eden System,” Department of Computer Science, University of Washington Seattle, Technical Report 83-01-02, Jan. 19, 1983, pp. 1-18.Applicant
- Almes, Guy. T, “The Evolution of the Eden Invocation Mechanism,” Department of Computer Science, University of Washington Seattle, Technical Report 83-01-03, Jan. 19, 1983, pp. 1-14.Applicant
- Almes, Guy. T, “Eden Project Proposal,” Department of Computer Science, University of Washington Seattle, Technical Report 80-10-01, Oct. 1980, pp. i-ii.Applicant
- Almes et al., “Research in Integrated Distributed Computing,” Department of Computer Science, University of Washington Seattle, Oct. 1979 pp. 1-42.Applicant
- Almes et al., “The Eden System: A Technical Review,” Department of Computer Science, University of Washington Seattle, Technical Report 83-10-05, Oct. 1983, pp. 1-25.Applicant
- Almes et al., “Edmas: An Object-Oriented Locally Distributed Mail System,” Department of Computer Science, FR-35 University of Washington Seattle, Technical Report 84-08-03, Dec. 13, 1984, pp. 1-19.Applicant
- Almes et al., “Edmas: A Locally Distributed Mail System,” Department of Computer Science, University of Washington Seattle, Technical Report 83-07-01, Jul. 7, 1983, pp. 1-17.Applicant
- Auerbach et al., “High-Level Language Support for Programming Distributed Systems,” IEEE Transactions On Software Engineering, 1992, p. 320.Applicant
- Bertz, David., “Drool Over A Little Language That Sports Multiple Inheritance,” Dr. Dobb's Journal, v18, n11,p74(4), Oct. 1993.Applicant
- Bertz, David., Your Own Tiny Object-Oriented Language: C++? Smalltalk? What About Bob? (An interpreter formed from C++ and Lisp) Dr. Dobb's Journal, Sep., 1991, v16, n9, p26(8).Applicant
- Bertz, David., “Embedded Languages : ExTalk Allows Users To Extend The Capabilities Of Your Application Programs,” BYTE Nov., 1988; p. 419-423; vol. 13No. 12.Applicant
- Black et al., “A Language For Distributed Programming” Department of Computer Science, University of Washington, Technical Report 86-02-03, Feb. 1986, p 10.Applicant
- Black, Andrew P., “The Eden Programming Language,” Department of Computer Science, FR-35 University of Washington Seattle, Technical Report 85-09-01, Sep. 1985, pp. 1-19.Applicant
- Black, Andrew P., “Supporting Distributed Applications: Experience With Eden,” University of Washington Seattle, Presentation at Tenth ACM Symposium on Operating System Principles, Sep. 1985, pp. 1-14.Applicant
- Black et al., “Distribution and Abstract Types in Emerald,” Department of Computer Science, University of Washington Seattle, Technical Report 85-08-05, Aug. 1985, pp. 1-10.Applicant
- Black et al., “Distribution and Abstract Types in Emerald,” IEEE Transactions On Software Engineering, Vol SE-13 No. 1 Jan. 1987, pp. 65-76.Applicant
- Black et al., “The Eden Project: A Final Report,” Department of Computer Science, University of Washington Seattle, Technical Report 86-11-01, pp. 1-28.Applicant
- Black et al., Distribution and Abstract Types In Emerald, University of Washington Seattle, Technical Report 86-02-04, pp. 1-189.Applicant
- Black et al., “Object Structure in the Emerald System,” University of Washington Seattle, Technical Report 86-04-03, pp. 1-9.Applicant
- Black, Andrew P. , “Supporting Distributed Applications: Experience With Eden,” Department of Computer Science, University of Washington Seattle, Technical Report 85-03-02, Mar. 1985, pp. 1-21.Applicant
- Cardelli, L., “The Amber Machine,” Proceedings Of The Thirteenth Spring School Of The LITP Proceedings, 1986, pp. 48-70.Applicant
- Chambers, Craig., “An Efficient Implementation on SELF, A Dynamically-Typed Object Oreinted Language Based On Prototypes,” Conference Proceedings, Special Issue of SIGPLAN Notices, vol. 24, No.: 10, Oct. 1989.Applicant
- Chung et al., “A “Tiny” Pascal Compiler Part 1: The P-Code Interpreter,” BYTE Publications, Sep. 1978, pp. 58-65, 148-155.Applicant
- Chung et al., “A “Tiny” Pascal Pascal Compiler Part 2: The P-Compiler,” BYTE Publications, Sep. 1978, pp. 34-52.Applicant
- Duff, Charles B., “Designing An Efficient Language,” BYTE, Aug. 1986, p 211.Applicant
- Franks, Neville., “Adding An Extension Language To Your Software: The Little Language/Application Interface,” Dr. Dobb's Journal, Sep. 1991, v16, n9, p34(6).Applicant
- Goldberg et al., “Smalltalk-80 The Language and its Implementation,” Xerox Palo Alto Research Center pp 1-707.Applicant
- Gosling et al., “The Java Language Environment A White Paper,” The Java Language Environment, Sun Microsystems, Oct. 1995, pp. 1-84.Applicant
- Gosling, James., “Java Intermediate Bytecodes” ACM SIGPLAN Workshop On Intermediate Representations (IR '95), Jan. 1995, San Francisco, ACM SIGPLAN Notices, vol. 30, No. 3, Mar. 1995 pp. 111-118.Applicant
- Gosling, James., “System And Method For Pre-Verification Of Stack Usage In ByteCode Program Loops”, US Application Ser. No.: 08/359,882, Filed Dec. 20, 1994 pp 1-38 Fig 1-5.Applicant
- Gosling, James., “Bytecode Program Interpreter Apparatus And Method With Pre-Verification Of Data Type Restrictions”, US Application Ser. No.: 08/360,202, Filed Dec. 21, 1994 pp 1-41.Applicant
- Guibas et al., “Compilation and Delayed Evaluation in APL,” Fifth Annual ACM Symposium On Principles Of Programming Languages, Jan. 23-25, 1978, 1-8.Applicant
- Guttman et al., “The VLISP Verified Scheme System,” LISP And Symbolic Computation: An International Journal, 8, 1995, pp. 33-110.Applicant
- Grimaud et al., “FACADE: A Typed Intermediate Language Dedicated To Smart Cards,” Software Engineering Notes, Association For Computing Machinery. New York, US, vol. 24, No. 6, Sep. 6, 1999, pp. 476-493.Applicant
- Holman et al., “The Eden Shared Calendar System,” Department of Computer Science, FR-35, University of Washington Seattle, Technical Report 85-05-02, Jun. 22, 1985, pp. 1-14.Applicant
- Hutchison, Norman C., “An Object Based Language for Distributed Programming,” University of Washington, Dissertation for Doctor of Philosophy, 1987, pp. 1-103.Applicant
- Hsu, Felix Shamson., “Reimplementing Remote Procedure Calls,” University of Washington, Masters Thesis, 1985, pp. 1-76.Applicant
- Johnston, Robert L., “The Dynamic Incremental Compiler of APL/3000,” Association of Computing Machinery , May 30-Jun. 1, 1979, vol. 9 No. 4-Part 1, pp. 82-87.Applicant
- Jul et al., “Fine-Grained Mobility in the Emerald System,” University of Washington, ACM Transactions On Computer Systems, vol. 6, No. 1., Feb. 1988, pp. 109-133.Applicant
- Jul, Eric., “Object Mobility in a Distributed Object Oriented System,” University of Washington, Dissertation for Doctor Of Philosophy, 1989, pp. 1-154.Applicant
- Kinchin, Corinna., “Postscript: P.S. it's a programming language too!” EXE, v6,n1, Jun. 1991, p66(5).Applicant
- King, James C., “A Program Verifier,” IBM Thomas J. Watson Research Center. Yorktown Heights, New York 10598, USA.Applicant
- Korfhage et al., “Hermes Language Experiences,” Software-Practice and Experience, vol. 25(4), Apr. 1995, p. 389.Applicant
- Krasner, Glen., “Smalltalk-80 Bits of History, Words of Advice,” Xerox Palo Alto Research Center, 1983, pp. 1-343.Applicant
- Lazowska et al., “The Architecture of the Eden System,” Proceedings of the Eighth Symposium On Operating System Principles, Dec. 14-16, 1981, Asilomar Conference, Pacific Grove, California, Dec. 1981, vol. 15, No. 5.Applicant
- McDaniel, Gene., “An Analysis of a Mesa Instruction Set,” Association for Computing Machinery, Xerox Palo Alto Research Center, May 1982.Applicant
- Mitchell et al., “Mesa Language Manual,” Xerox Palo Alto Research Center, Palo Alto, California pp. 1-147.Applicant
- Perrott et al., “A Supercomputer Program Development System,” Software-Practice and Experience, Oct. 1987, vol. 17 (10), pp. 663.Applicant
- Pier, Kenneth A., “A Retrospective on the Dorado, A High-Performance Personal Computer,” Association for Computing Machinery, Xerox Palo Alto Research Center, 1983, pp. 252-269.Applicant
- Pu, Calton., “Replication and Nested Transactions in the Eden Distributed System.,” University of Washington, Department of Computer Science, Dissertation for Doctor of Philosophy, 1986, pp. 1-179.Applicant
- Proudfoot, Andrew Blaine., “Replects: Data Repliation in the Eden System,” University of Washington, Department of Computer Science, Technical Report No. TR-85-12-04, pp. 1-154.Applicant
- Rose et al., “Lightweight ByteCode Verification”, Extended Abstract For FUJ'98, Sep. 21, 1998, pp 1-23.Applicant
- Schauer, von. H., “Architektur und Implementierung eines PASCAL-Systems fur Mikrocomputer,” Elektronische Rechenanlagen, vol. 24 (1982), Jun., No. 3, pp. 108.Applicant
- “A Postscript Backgrounder,” Seybold Report on Desktop Publishing, vol. 5, No. 7, Mar. 4, 1991 p. 9(1).Applicant
- Strom et al., “NIL: An Integrated Language and System For Distributed Programming,” Association for Computing Machinery, 1983, p. 73.Applicant
- Strom et al., “Extending Typestate Checking Using Conditional Liveness Analysis.” IEEE Transactions On Software Engineering, vol. 19, No. 5, May 1993, pp. 478.Applicant
- Thompson, Ken., “Regular Expression Search Algorithm,” Communications of the ACM, vol. 11, No. 6, Jun. 1968, pp. 419-422.Applicant
- Unagar et al., “Object, Message, and Performance: How They Coexist In Self,” Computer, vol. 25 No. 10, Oct. 1, 1992, pp. 53-64.Applicant
- Wright et al., “A Practical Soft Type System for Scheme,” LISP 94, Jun. 1994, Orlando, Florida, pp 250-262.Applicant
- Yellin, Dan., “Do Programmers Need Seat Belts?” ACM SIGPLAN Debates (1996), pp 5.Applicant
- Ken Thompson, “Regular Expression Search Algorithm,” Communications of the ACM, Jun., 1968, vol. 11, No. 6, pp. 419-422.Applicant
- Kin-Man Chung and Herbert Yuen, “A ‘Tiny’ Pascal Compiler; Part 1: The P-Code Interpreter,” BYTE Publications, Inc., Sep. 1978.Applicant
- Kin-Man Chung and Herbert Yuen, “A ‘Tiny’ Pascal Compiler; Part 2: The P-Compiler,” BYTE Publications, Inc., Oct. 1978.Applicant
- Gene McDaniel, “An Analysis of a Mesa Instruction Set,” Association for Computing Machinery, May 1982.Applicant
- Kenneth A. Pier, “A Retrospective on the Dorado, a High-Performance Personal Computer,” IEEE Computer Society, 10th Annual Intl. Symposium on Computer Architecture, 1983, pp. 252-269.Applicant
- James G. Mitchell, et al., “Mesa Language Manual,” Xerox Corporation, Palo Alto Research Center.Applicant
- Kaoru Takahashi et al., Validating Network Protocols Using a Flexible Verifier, IEEE, 1994, p. 811-817.Applicant
- Timothy Shih et al., “An Automated Design Specification and Verification Tool for Systolic Architectures”, IEEE, 1992, pp. 6-17.Applicant
- Douglas A. Stuart, “Implementing a Verifier for Real-Time Systems”, IEEE 1990, pp 62-71.Applicant
- Farn Wang et al., “A Verifier for Distributed Real-Time Systems with Bounded Integer Variables”, IEEE 1993, pp 135-151.Applicant