US5748964A
Expired / Lapsed
US
⏱️ 0.0 years remaining
Bytecode program interpreter apparatus and method with pre-verification of data type restrictions
Assignee: Sun Microsystems Inc
•
Filing: 1994-12-20
•
Granted: 1998-05-05
•
Expires: 2014-12-20
Abstract
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.
Inventors
- 👤 James A. Gosling
Bibliographic Details
Application Number
—
Jurisdiction
US
Data Source
google_patents
Last Synchronized
2026-10-30 00:23
CPC Classifications
G; G06; G06F; G06F9/00; G06F9/06; G06F9/44; G06F9/455; G06F9/45504; G06F9/45508; G06F11/00; G06F11/36; G06F11/3604; G06F11/3612; G06F21/00; G06F21/50; G06F21/51; G06F21/52; G06F21/55; G06F21/56; G06F21/566; G06F9/445; G06F9/44589
Claims Analysis
Total Claims: 22
Claim 1
Independent Claim
326 words
A method of operating a computer system, the steps of the method comprising: (A) storing a program in a memory, the program including a sequence of bytecodes, where each of a multiplicity of said bytecodes each represents an operation on data of a specific data type; said each bytecode having associated data type restrictions on the data type of data to be manipulated by said each bytecode; (B) prior to execution of said program, preprocessing said program by determining whether execution of any bytecode in said program would violate said data type restrictions for that bytecode and generating a program fault signal when execution of any bytecode in said program would violate the data type restrictions for that bytecode; (C) when said preprocessing of said program results in the generation of no program fault signals, enabling execution of said program; (D) when said preprocessing of said program results in the generation of a program fault, preventing execution of said program; and (E) when execution of said bytecode program has been enabled, executing said bytecode program without performing data type checks on operands stored in said operand stack during execution of said bytecode program; said bytecode program including at least one execution loop; said step (B) including determining the state of a virtual stack associated with said program before and after execution of each said bytecode in the program, said virtual stack state storing data type values for operands that would be stored in an operand stack during execution of said program; and determining whether execution of any loop in said program would result in a net addition or deletion of operands to said operand stack, and for generating a program fault signal when execution of any loop in said program would produce a net addition or deletion of operands to said operand stack; and said executing step including executing said bytecode program without performing operand stack underflow and overflow checks during execution of said bytecode program.
Claim 2
Independent Claim
326 words
A method of operating a computer system, the steps of the method comprising: (A) storing a program in a memory, the program including a sequence of bytecodes, where each of a multiplicity of said bytecodes each represents an operation on data of a specific data type; said each bytecode having associated data type restrictions on the data type of data to be manipulated by said each bytecode; (B) prior to execution of said program, preprocessing said program by determining whether execution of any bytecode in said program would violate said data type restrictions for that bytecode and generating a program fault signal when execution of any bytecode in said program would violate the data type restrictions for that bytecode; (C) when said preprocessing of said program results in the generation of no program fault signals, enabling execution of said program; (D) when said preprocessing of said program results in the generation of a program fault, preventing execution of said program; and (E) when execution of said bytecode program has been enabled, executing said bytecode program without performing data type checks on operands stored in said operand stack during execution of said bytecode program; said bytecode program including at least one execution loop; said step (B) including determining the state of a virtual stack associated with said program before and after execution of each said bytecode in the program, said virtual stack state storing data type values for operands that would be stored in an operand stack during execution of said program; and determining whether execution of any loop in said program would result in a net addition or deletion of operands to said operand stack, and for generating a program fault signal when execution of any loop in said program would produce a net addition or deletion of operands to said operand stack; and said executing step including executing said bytecode program without performing operand stack underflow and overflow checks during execution of said bytecode program.
Claim 3
Independent Claim
301 words
A method of operating a computer system, the steps of the method comprising: (A) storing a program in a memory, the program including a sequence of bytecodes, where each of a multiplicity of said bytecodes each represents an operation on data of a specific data type; said each bytecode having associated data type restrictions on the data type of data to be manipulated by said each bytecode; (B) prior to execution of said program, preprocessing said program by determining whether execution of any bytecode in said program would violate said data type restrictions for that bytecode and generating a program fault signal when execution of any bytecode in said program would violate the data type restrictions for that bytecode; (C) when said preprocessing of said program results in the generation of no program fault signals, enabling execution of said program; (D) when said preprocessing of said program results in the generation of a program fault, preventing execution of said program; and (E) when execution of said bytecode program has been enabled, executing said bytecode program without performing data type checks on operands stored in said operand stack during execution of said bytecode program; said bytecode program including a plurality of jump/branch bytecodes; said step (B) including determining, whenever two or more bytecodes in said program comprise jumps/branches to an identical location in said program, whether the states of a virtual stack are identical prior to execution of each of said jump/branches, said virtual stack state storing data type values for operands that would be stored in an operand stack during execution of said program, and for generating a program fault signal if said virtual stack states are not identical; and said executing step (E) including executing said bytecode program without performing operand stack status checks during execution of said bytecode program.
Claim 4
Independent Claim
301 words
A method of operating a computer system, the steps of the method comprising: (A) storing a program in a memory, the program including a sequence of bytecodes, where each of a multiplicity of said bytecodes each represents an operation on data of a specific data type; said each bytecode having associated data type restrictions on the data type of data to be manipulated by said each bytecode; (B) prior to execution of said program, preprocessing said program by determining whether execution of any bytecode in said program would violate said data type restrictions for that bytecode and generating a program fault signal when execution of any bytecode in said program would violate the data type restrictions for that bytecode; (C) when said preprocessing of said program results in the generation of no program fault signals, enabling execution of said program; (D) when said preprocessing of said program results in the generation of a program fault, preventing execution of said program; and (E) when execution of said bytecode program has been enabled, executing said bytecode program without performing data type checks on operands stored in said operand stack during execution of said bytecode program; said bytecode program including a plurality of jump/branch bytecodes; said step (B) including determining, whenever two or more bytecodes in said program comprise jumps/branches to an identical location in said program, whether the states of a virtual stack are identical prior to execution of each of said jump/branches, said virtual stack state storing data type values for operands that would be stored in an operand stack during execution of said program, and for generating a program fault signal if said virtual stack states are not identical; and said executing step (E) including executing said bytecode program without performing operand stack status checks during execution of said bytecode program.
Claim 5
Independent Claim
204 words
A method of operating a computer system, the steps of the method comprising: (A) storing a program in a memory, said program including a sequence of bytecodes, including a plurality of jump/branch bytecodes; (B) prior to execution of said program, preprocessing said program by: determining the state of a virtual stack associated with said program before and after execution of each said bytecode in the program, said virtual stack state storing data type values for operands that would be stored in an operand stack during execution of said program; and determining, whenever two or more bytecodes in said program comprise jumps/branches to an identical location in said program, whether the states of the virtual stack are identical prior to execution of each of said jump/branches, and generating a program fault signal if said virtual stack states are not identical; (C) when said preprocessing of said program results in the generation of no program fault signals, enabling execution of said program; (D) when said preprocessing of said program results in the generation of a program fault, preventing execution of said program; and (E) when execution of said program has been enabled, executing said program without performing operand stack status checks during execution of said program.
Claim 6
Independent Claim
204 words
A method of operating a computer system, the steps of the method comprising: (A) storing a program in a memory, said program including a sequence of bytecodes, including a plurality of jump/branch bytecodes; (B) prior to execution of said program, preprocessing said program by: determining the state of a virtual stack associated with said program before and after execution of each said bytecode in the program, said virtual stack state storing data type values for operands that would be stored in an operand stack during execution of said program; and determining, whenever two or more bytecodes in said program comprise jumps/branches to an identical location in said program, whether the states of the virtual stack are identical prior to execution of each of said jump/branches, and generating a program fault signal if said virtual stack states are not identical; (C) when said preprocessing of said program results in the generation of no program fault signals, enabling execution of said program; (D) when said preprocessing of said program results in the generation of a program fault, preventing execution of said program; and (E) when execution of said program has been enabled, executing said program without performing operand stack status checks during execution of said program.
Claim 7
Dependent Claim
59 words
The method of claim 3, said step (B) including determining, whether execution of any loop in said program would result in a net addition or deletion of operands to said operand stack and generating a program fault signal when execution of any loop in said program would produce a net addition or deletion of operands to said operand stack.
Claim 8
Independent Claim
215 words
A method of operating a computer system, the steps of the method comprising: (A) storing a program in a memory, the program including a sequence of bytecodes, including a plurality of jump/branch bytecodes; said program including at least one execution loop; (B) prior to execution of said program, preprocessing said program by determining the state of a virtual stack associated with said program before and after execution of each said bytecode in the program, said virtual stack state storing data type values for operands that would be stored in an operand stack during execution of said program; and determining whether execution of any loop in said program would result in a net addition or deletion of operands to said operand stack and generating a program fault signal when execution of any loop in said program would produce a net addition or deletion of operands to said operand stack; (C) when said preprocessing of said program results in the generation of no program fault signals, enabling execution of said program; (D) when said preprocessing of said program results in the generation of a program fault, preventing execution of said program; and (E) when execution of said program has been enabled, executing said program without performing operand stack underflow and overflow checks during execution of said program.
Claim 9
Independent Claim
215 words
A method of operating a computer system, the steps of the method comprising: (A) storing a program in a memory, the program including a sequence of bytecodes, including a plurality of jump/branch bytecodes; said program including at least one execution loop; (B) prior to execution of said program, preprocessing said program by determining the state of a virtual stack associated with said program before and after execution of each said bytecode in the program, said virtual stack state storing data type values for operands that would be stored in an operand stack during execution of said program; and determining whether execution of any loop in said program would result in a net addition or deletion of operands to said operand stack and generating a program fault signal when execution of any loop in said program would produce a net addition or deletion of operands to said operand stack; (C) when said preprocessing of said program results in the generation of no program fault signals, enabling execution of said program; (D) when said preprocessing of said program results in the generation of a program fault, preventing execution of said program; and (E) when execution of said program has been enabled, executing said program without performing operand stack underflow and overflow checks during execution of said program.
Claim 10
Dependent Claim
222 words
A computer system, comprising: memory for storing a bytecode program, the bytecode program including a sequence of bytecodes, where each of a multiplicity of said bytecodes (A) represents an operation on data of a specific data type, and, (B) has associated data type restrictions on the data type of data to be manipulated by that bytecode; a data processing unit for executing programs stored in said memory; a bytecode program verifier, stored in said memory, said bytecode program verifier including data type testing instructions for determining whether execution of any bytecode in said program would violate said data type restrictions for that bytecode and generating a program fault signal when execution of any bytecode in said program would violate the data type restrictions for that bytecode; program execution enabling instructions that enable execution of said bytecode program only after processing said bytecode program by said bytecode program verifier generates no program fault signals; and a bytecode program interpreter, coupled to said program execution enabling instructions, for executing said bytecode program after processing of said bytecode program by said bytecode program verifier and after said program execution enabling instructions enable execution of said bytecode program by said bytecode program interpreter; said bytecode program interpreter including instructions for executing said bytecode program without performing data type checks on operands stored in an operand stack.
Claim 11
Dependent Claim
222 words
A computer system, comprising: memory for storing a bytecode program, the bytecode program including a sequence of bytecodes, where each of a multiplicity of said bytecodes (A) represents an operation on data of a specific data type, and, (B) has associated data type restrictions on the data type of data to be manipulated by that bytecode; a data processing unit for executing programs stored in said memory; a bytecode program verifier, stored in said memory, said bytecode program verifier including data type testing instructions for determining whether execution of any bytecode in said program would violate said data type restrictions for that bytecode and generating a program fault signal when execution of any bytecode in said program would violate the data type restrictions for that bytecode; program execution enabling instructions that enable execution of said bytecode program only after processing said bytecode program by said bytecode program verifier generates no program fault signals; and a bytecode program interpreter, coupled to said program execution enabling instructions, for executing said bytecode program after processing of said bytecode program by said bytecode program verifier and after said program execution enabling instructions enable execution of said bytecode program by said bytecode program interpreter; said bytecode program interpreter including instructions for executing said bytecode program without performing data type checks on operands stored in an operand stack.
Claim 12
Dependent Claim
170 words
The computer system of claim 6, said bytecode program verifier including stack status tracking instructions for determining the state of a virtual stack associated with said bytecode program before and after execution of each said bytecode in the bytecode program, said virtual stack state storing data type values for operands that would be stored in an operand stack during execution of said bytecode program; stack overflow/underflow testing instructions for determining (A) whether execution of said bytecode program would result in an operand stack underflow or overflow, and (B) whether execution of any loop in said bytecode program would result in a net addition or deletion of operands to said operand stack, and for generating a program fault signal when execution of any loop in said bytecode program would produce a net addition or deletion of operands to said operand stack; and said executing instructions of said bytecode program interpreter including instructions for executing said bytecode program without performing operand stack underflow and overflow checks during execution of said bytecode program.
Claim 13
Dependent Claim
119 words
The computer system of claim 6, said bytecode program verifier including jump/branch inspection instructions for determining, whenever two or more bytecodes in said bytecode program comprise jumps/branches to an identical location in said bytecode program, whether the states of a virtual stack are identical prior to execution of each of said jump/branches, said virtual stack state storing data type values for operands that would be stored in an operand stack during execution of said bytecode program, and for generating a program fault signal if said virtual stack states are not identical; and said executing instructions of said bytecode program interpreter including instructions for executing said bytecode program without performing operand stack status checks during execution of said bytecode program.
Claim 14
Dependent Claim
242 words
A computer system, comprising: memory for storing a bytecode program, the bytecode program including a sequence of bytecodes, including a plurality of jump/branch bytecodes; a data processing unit for executing programs stored in said memory; a bytecode program verifier, stored in said memory, said bytecode program verifier including: stack status tracking instructions for determining the state of a virtual stack associated with said program before and after execution of each said bytecode in the program, said virtual stack state storing data type values for operands that would be stored in an operand stack during execution of said program; jump/branch inspection instructions for determining, whenever two or more bytecodes in said program comprise jumps/branches to an identical location in said program, whether the states of the virtual stack are identical prior to execution of each of said jump/branches, and for generating a program fault signal if said virtual stack states are not identical; program execution enabling instructions that enable execution of said bytecode program only after processing said bytecode program by said bytecode program verifier generates no program fault signals; and a bytecode program interpreter, coupled to said program execution enabling instructions, for executing said bytecode program after processing of said bytecode program by said bytecode program verifier and after said program execution enabling instructions enable execution of said bytecode program by said bytecode program interpreter; said bytecode program interpreter including instructions for executing said bytecode program without performing operand stack status checks.
Claim 15
Dependent Claim
242 words
A computer system, comprising: memory for storing a bytecode program, the bytecode program including a sequence of bytecodes, including a plurality of jump/branch bytecodes; a data processing unit for executing programs stored in said memory; a bytecode program verifier, stored in said memory, said bytecode program verifier including: stack status tracking instructions for determining the state of a virtual stack associated with said program before and after execution of each said bytecode in the program, said virtual stack state storing data type values for operands that would be stored in an operand stack during execution of said program; jump/branch inspection instructions for determining, whenever two or more bytecodes in said program comprise jumps/branches to an identical location in said program, whether the states of the virtual stack are identical prior to execution of each of said jump/branches, and for generating a program fault signal if said virtual stack states are not identical; program execution enabling instructions that enable execution of said bytecode program only after processing said bytecode program by said bytecode program verifier generates no program fault signals; and a bytecode program interpreter, coupled to said program execution enabling instructions, for executing said bytecode program after processing of said bytecode program by said bytecode program verifier and after said program execution enabling instructions enable execution of said bytecode program by said bytecode program interpreter; said bytecode program interpreter including instructions for executing said bytecode program without performing operand stack status checks.
Claim 16
Dependent Claim
87 words
The computer system of claim 9, said bytecode program verifier including stack overflow/underflow testing instructions for determining (A) whether execution of said bytecode program would result in an operand stack underflow or overflow, and (B) whether execution of any loop in said bytecode program would result in a net addition or deletion of operands to said operand stack, and for generating a program fault signal when execution of any loop in said bytecode program would produce a net addition or deletion of operands to said operand stack.
Claim 17
Dependent Claim
269 words
A computer system, comprising: memory for storing a bytecode program, the bytecode program including a sequence of bytecodes, including a plurality of jump/branch bytecodes; said program including at least one execution loop; a data processing unit for executing programs stored in said memory; a bytecode program verifier, stored in said memory, said bytecode program verifier including: stack status tracking instructions for determining the state of a virtual stack associated with said program before and after execution of each said bytecode in the program, said virtual stack state storing data type values for operands that would be stored in an operand stack during execution of said program; stack overflow/underflow testing instructions for determining (A) whether execution of said program would result in an operand stack underflow or overflow, and (B) whether execution of any loop in said program would result in a net addition or deletion of operands to said operand stack and generating a program fault signal when execution of any loop in said program would produce a net addition or deletion of operands to said operand stack; program execution enabling instructions that enables execution of said bytecode program only after processing said bytecode program by said bytecode program verifier generates no program fault signals; and a bytecode program interpreter, coupled to said bytecode program execution enabling instructions, for executing said bytecode program after processing of said bytecode program by said bytecode program verifier and after said program execution enabling instructions enable execution of said bytecode program by said bytecode program interpreter; said bytecode program interpreter including instructions for executing said bytecode program without performing operand stack overflow/underflow checks.
Claim 18
Dependent Claim
269 words
A computer system, comprising: memory for storing a bytecode program, the bytecode program including a sequence of bytecodes, including a plurality of jump/branch bytecodes; said program including at least one execution loop; a data processing unit for executing programs stored in said memory; a bytecode program verifier, stored in said memory, said bytecode program verifier including: stack status tracking instructions for determining the state of a virtual stack associated with said program before and after execution of each said bytecode in the program, said virtual stack state storing data type values for operands that would be stored in an operand stack during execution of said program; stack overflow/underflow testing instructions for determining (A) whether execution of said program would result in an operand stack underflow or overflow, and (B) whether execution of any loop in said program would result in a net addition or deletion of operands to said operand stack and generating a program fault signal when execution of any loop in said program would produce a net addition or deletion of operands to said operand stack; program execution enabling instructions that enables execution of said bytecode program only after processing said bytecode program by said bytecode program verifier generates no program fault signals; and a bytecode program interpreter, coupled to said bytecode program execution enabling instructions, for executing said bytecode program after processing of said bytecode program by said bytecode program verifier and after said program execution enabling instructions enable execution of said bytecode program by said bytecode program interpreter; said bytecode program interpreter including instructions for executing said bytecode program without performing operand stack overflow/underflow checks.
Claim 19
Dependent Claim
217 words
A computer readable media storing programs executable by a processor, the programs stored on the computer readable media comprising: a bytecode program verifier for analyzing a bytecode program, the bytecode program including a sequence of bytecodes, where each of a multiplicity of the bytecodes (A) represents an operation on data of a specific data type, and (B) has associated data type restrictions on the data type of data to be manipulated by that bytecode; the bytecode program verifier including data type testing instructions for determining whether execution of any bytecode in the bytecode program would violate the data type restrictions for that bytecode and generating a program fault signal when execution of any bytecode in the bytecode program would violate the data type restrictions for that bytecode; program execution enabling instructions that enable execution of the bytecode program only after processing of the bytecode program by the bytecode program verifier generates no program fault signals; and a bytecode program interpreter for executing the bytecode program after processing of the bytecode program by the bytecode program verifier and after the program execution enabling instructions enable execution of the bytecode program by the bytecode program interpreter; the bytecode program interpreter including instructions for executing the bytecode program without performing data type checks on operands stored in an operand stack.
Claim 20
Dependent Claim
217 words
A computer readable media storing programs executable by a processor, the programs stored on the computer readable media comprising: a bytecode program verifier for analyzing a bytecode program, the bytecode program including a sequence of bytecodes, where each of a multiplicity of the bytecodes (A) represents an operation on data of a specific data type, and (B) has associated data type restrictions on the data type of data to be manipulated by that bytecode; the bytecode program verifier including data type testing instructions for determining whether execution of any bytecode in the bytecode program would violate the data type restrictions for that bytecode and generating a program fault signal when execution of any bytecode in the bytecode program would violate the data type restrictions for that bytecode; program execution enabling instructions that enable execution of the bytecode program only after processing of the bytecode program by the bytecode program verifier generates no program fault signals; and a bytecode program interpreter for executing the bytecode program after processing of the bytecode program by the bytecode program verifier and after the program execution enabling instructions enable execution of the bytecode program by the bytecode program interpreter; the bytecode program interpreter including instructions for executing the bytecode program without performing data type checks on operands stored in an operand stack.
Claim 21
Dependent Claim
170 words
The computer readable media of claim 12, the bytecode program verifier including: stack status tracking instructions for determining the state of a virtual stack associated with the bytecode program before and after execution of each bytecode in the bytecode program, the virtual stack state storing data type values for operands that would be stored in an operand stack during execution of the bytecode program; stack overflow/underflow testing instructions for determining (A) whether execution of the bytecode program would result in an operand stack underflow or overflow, and (B) whether execution of any loop in the bytecode program would result in a net addition or deletion of operands to the operand stack, and for generating a program fault signal when execution of any loop in the bytecode program would produce a net addition or deletion of operands to the operand stack; and the executing instructions of the bytecode program interpreter including instructions for executing the bytecode program without performing operand stack underflow and overflow checks during execution of the bytecode program.
Claim 22
Dependent Claim
120 words
The computer readable media of claim 12, the bytecode program verifier including jump/branch inspection instructions for determining, whenever two or more bytecodes in the bytecode program comprise jumps/branches to an identical location in the bytecode program, whether the states of a virtual stack are identical prior to execution of each of the jump/branches, the virtual stack state storing data type values for operands that would be stored in an operand stack during execution of the bytecode program, and for generating a program fault signal if the virtual stack states are not identical; and the executing instructions of the bytecode program interpreter including instructions for executing the bytecode program without performing operand stack status checks during execution of the bytecode program.
References Cited (Backward Citations)
US3878513A
Cited
US4524416A
Cited
US4521851A
Cited
US5446875A
Cited
EP0424056A2
Cited
US5422992A
Cited
EP0718764A2
Cited
USPTO Annuity & Maintenance Windows
| Annuity Stage | Window Opens | Payment Deadline | Surcharge Period Until | Estimated Fee | Status |
|---|---|---|---|---|---|
| 3.5 Years (Year 4) | 2001-05-04 | 2001-11-03 | 2002-05-05 | $2000.00 | Window Closed / Lapsed |
| 7.5 Years (Year 8) | 2005-05-04 | 2005-11-03 | 2006-05-05 | $3760.00 | Window Closed / Lapsed |
| 11.5 Years (Year 12) | 2009-05-04 | 2009-11-03 | 2010-05-05 | $7700.00 | Window Closed / Lapsed |