CN112631722A - Byte code instruction set simplifying method and system - Google Patents
Byte code instruction set simplifying method and system Download PDFInfo
- Publication number
- CN112631722A CN112631722A CN202011550106.0A CN202011550106A CN112631722A CN 112631722 A CN112631722 A CN 112631722A CN 202011550106 A CN202011550106 A CN 202011550106A CN 112631722 A CN112631722 A CN 112631722A
- Authority
- CN
- China
- Prior art keywords
- static
- constant pool
- sub
- instruction
- domain
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 315
- 230000003068 static effect Effects 0.000 claims description 325
- 238000005056 compaction Methods 0.000 claims description 13
- 230000009467 reduction Effects 0.000 claims description 10
- 238000012163 sequencing technique Methods 0.000 claims description 2
- 238000010586 diagram Methods 0.000 description 6
- 238000006243 chemical reaction Methods 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 230000008569 process Effects 0.000 description 2
- 238000004458 analytical method Methods 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 230000008676 import Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45504—Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The invention discloses a method and a system for simplifying a bytecode instruction set, wherein the simplifying method comprises the following steps: s100, dividing a constant pool into a plurality of corresponding sub-constant pools based on different reference types; s200, counting the occurrence frequency of the instruction corresponding to each reference type based on the number of references of each reference type, and putting the instructions into corresponding sub-constant pools in a sequence from high to low, wherein the constant pool index of the instruction corresponding to each reference type is the index of the sub-constant pool corresponding to each reference type; and S300, generating a corresponding instruction of the single-byte constant pool index based on the generation condition of the instruction corresponding to each reference type. The invention can simplify the byte code of the virtual machine, reduce the storage space of the byte code and improve the execution performance of the byte code.
Description
Technical Field
The invention relates to a virtual machine instruction set, in particular to a byte code instruction set simplifying method and system.
Background
The virtual machine is an abstract computer generated by a software application program or an instruction sequence executed by a processor, the virtual machine can execute an instruction set supported by the virtual machine, the instruction set comprises an operand stack-based instruction set and a register-based instruction set, the instruction set of the Java Card virtual machine is based on the operand stack, and the instruction set of the Dalvik virtual machine is based on the register. The bytecode generated by adopting the instruction set of the existing Dalvik virtual machine occupies a large storage space and has good execution performance, while the bytecode generated by adopting the instruction set of the Java Card virtual machine occupies a small storage space, but has general execution performance, so that in order to meet higher performance requirements, a method for simplifying instructions needs to be designed urgently, so that the storage space can be saved, the execution performance can be improved, and the method is suitable for the two types of instruction sets.
Disclosure of Invention
Aiming at the defects in the prior art, the invention aims to provide a bytecode instruction set reduction method and a bytecode instruction set reduction system, which can reduce the bytecode of a virtual machine, reduce the storage space of the bytecode and improve the execution performance of the bytecode.
In order to achieve the purpose, the technical scheme adopted by the invention is as follows:
a byte code instruction set reduction method is suitable for an operand stack-based and register-based instruction set, and comprises the following steps:
s100, dividing a constant pool into a plurality of corresponding sub-constant pools based on different reference types;
s200, counting the occurrence frequency of the instruction corresponding to each reference type based on the number of references of each reference type, and putting the instructions into corresponding sub-constant pools in a sequence from high to low, wherein the constant pool index of the instruction corresponding to each reference type is the index of the sub-constant pool corresponding to each reference type;
and S300, generating a corresponding instruction of the single-byte constant pool index based on the generation condition of the instruction corresponding to each reference type.
Further, as described above for the compaction method, the reference type includes a reference of a class, a reference of a static method, a reference of a virtual method, a reference of a super method, a reference of a static domain, and a reference of an instance domain, and the plurality of child constant pools include: the sub-constant pool of the class, the sub-constant pool of the static method, the sub-constant pool of the virtual method, the sub-constant pool of the super method, the sub-constant pool of the static domain, and the sub-constant pool of the instance domain.
Further, in the above simplifying method, S200 includes:
if the number of the references of the instance domain exceeds 256, counting the occurrence times of the access instructions of the instance domain of the reference type, and putting the access instructions into the sub-constant pool of the instance domain according to the sequence of the times from high to low, otherwise, directly putting the access instructions into the sub-constant pool of the instance domain;
if the number of the references of the static domain exceeds 256, counting the times of the static domain access instructions of the reference types in the package, and putting the static domain access instructions into the sub-constant pool of the static domain from high to low, otherwise, directly putting the static domain access instructions into the sub-constant pool of the static domain;
if the number of the references of the virtual method exceeds 256, counting the occurrence frequency of each virtual method calling instruction, and putting the virtual method calling instructions into a sub-constant pool of the virtual method according to the sequence of the frequency from high to low, otherwise, directly putting the virtual method calling instructions into the sub-constant pool of the virtual method;
if the number of the references of the static method exceeds 256, firstly counting the number of times of static method instructions in the calling library package, preferentially putting the static method instructions into the sub-constant pool of the static method according to the sequence of the times from high to low, then counting the number of times of the static method instructions in each calling package, and putting the static method instructions into the sub-constant pool of the static method according to the sequence of the times from high to low, otherwise, directly putting the static method instructions into the sub-constant pool of the static method.
Further, as for the above reduction method, the counting the number of times of occurrence of static domain access instructions of a reference type in a package, and placing the static domain access instructions into the sub-constant pool of the static domain in order from high to low, includes:
and counting the occurrence times of static domain access instructions of the reference types in the packet, and preferentially placing the static domain access instructions at the front end of the sub-constant pool of the static domain according to the order of the times from high to low.
Further, in the above simplifying method, S300 includes:
if the constant pool index of an instance domain access instruction is in a byte range, generating a corresponding instance domain access instruction of a single-byte constant pool index;
if the constant pool index of a static domain access instruction is in a byte range and belongs to the static domain access instruction of the intra-packet reference type, generating a corresponding static domain access instruction of a single-byte constant pool index;
and if the constant pool index of one virtual method calling instruction is in a byte range, generating the corresponding virtual method calling instruction with the single-byte constant pool index.
Further, in the above simplifying method, S300 further includes:
generating a common library package static method list based on the called statistical times of each library package static method in a large number of applications, and putting the common library package static method list into a configuration file, wherein the number of the static methods in the common library package static method list is within 256 and the static methods have complete Java method names;
if the constant pool index of a library package static method calling instruction is in a byte range, inquiring the configuration file, and determining whether the library package static method called by the library package static method calling instruction exists in the common library package static method list;
and if the library package static method is confirmed to exist in the common library package static method list, generating a library package static method calling instruction of a corresponding single-byte constant pool index.
Further, according to the above simplification method, the generating a list of commonly used library package static methods into a configuration file based on the statistical number of times that each library package static method is called in a large number of applications includes:
and sequencing the called statistical times of each library package static method from high to low, if the number of all the library package static methods exceeds 256, putting the first 256 library package static methods into the list of the common library package static methods, and if the number of all the library package static methods is within 256, directly putting all the library package static methods into the list of the common library package static methods.
A bytecode instruction set compaction system adapted for operand stack-based and register-based instruction sets, the compaction system comprising:
the constant pool dividing module is used for dividing the constant pool into a plurality of corresponding sub constant pools based on different reference types;
the constant pool component generation module is used for counting the occurrence frequency of the instruction corresponding to each reference type based on the number of references of each reference type and putting the instructions into the corresponding sub constant pools in the sequence from high to low, wherein the constant pool index of the instruction corresponding to each reference type is the index of the sub constant pool corresponding to each reference type;
and the instruction generating module is used for generating the instruction of the corresponding single-byte constant pool index based on the generating condition of the instruction corresponding to each reference type.
Further, as described above for the compaction system, the reference type includes a reference of a class, a reference of a static method, a reference of a virtual method, a reference of a super method, a reference of a static domain, and a reference of an instance domain, and the plurality of child constant pools include: the sub-constant pool of the class, the sub-constant pool of the static method, the sub-constant pool of the virtual method, the sub-constant pool of the super method, the sub-constant pool of the static domain, and the sub-constant pool of the instance domain.
Further, as for the compacting system described above, the constant pool component generation module is specifically configured to:
if the number of the references of the instance domain exceeds 256, counting the occurrence times of the access instructions of the instance domain of each acquired reference type, and putting the access instructions into the sub-constant pool of the instance domain according to the sequence of the times from high to low, otherwise, directly putting the access instructions into the sub-constant pool of the instance domain;
if the number of the references of the static domain exceeds 256, counting the times of the static domain access instructions of the reference types in the package, and putting the static domain access instructions into the sub-constant pool of the static domain from high to low, otherwise, directly putting the static domain access instructions into the sub-constant pool of the static domain;
if the number of the references of the virtual method exceeds 256, counting the occurrence frequency of each virtual method calling instruction, and putting the virtual method calling instructions into a sub-constant pool of the virtual method according to the sequence of the frequency from high to low, otherwise, directly putting the virtual method calling instructions into the sub-constant pool of the virtual method;
if the number of the references of the static method exceeds 256, firstly counting the number of times of static method instructions in the calling library package, preferentially putting the static method instructions into the sub-constant pool of the static method according to the sequence of the times from high to low, then counting the number of times of the static method instructions in each calling package, and putting the static method instructions into the sub-constant pool of the static method according to the sequence of the times from high to low, otherwise, directly putting the static method instructions into the sub-constant pool of the static method.
The invention has the beneficial effects that: the method is simultaneously suitable for an operand stack-based and register-based virtual machine instruction set, and the frequency of the instruction of a domain of a certain method call and access reference type is counted before the instruction is generated; dividing the constant pool into a plurality of sub-constant pools, wherein each sub-constant pool preferentially places references appearing at high frequency; the instruction of the high-frequency access instance domain adopts a single-byte constant pool index; the virtual method calling instruction of high-frequency access adopts a single-byte constant pool index; the instruction for accessing the static domain at high frequency adopts a single-byte constant pool index; the high-frequency access library packet static method calling instruction adopts a single-byte constant pool index; by the design, the size of the byte code of the method can be effectively reduced under the condition of not using a plurality of operation codes.
Drawings
Fig. 1 is a schematic structural diagram of a constant pool provided in an embodiment of the present invention;
FIG. 2 is a diagram illustrating a usage of a single-byte static domain constant pool index according to an embodiment of the present invention;
FIG. 3 is a diagram illustrating a library static method invocation using a single-byte static method constant pool index (before parsing) according to an embodiment of the present invention;
FIG. 4 is a diagram illustrating a library package static method invocation according to the usage of a single-byte static method constant pool index (after parsing) provided in the embodiment of the present invention;
FIG. 5 is a diagram illustrating in-package and library package static method invocation in another usage of a single-byte static method constant pool index (after parsing) provided in the embodiment of the present invention;
FIG. 6 is a flowchart illustrating a method for reducing a bytecode instruction set according to an embodiment of the invention;
fig. 7 is a schematic structural diagram of a bytecode instruction set reduction system according to an embodiment of the present invention.
Detailed Description
The invention is described in further detail below with reference to the drawings and the detailed description.
Noun interpretation
Constant pool: the virtual machine instruction set accesses the symbol references stored in the constant pool through the constant pool index, wherein the symbol references comprise classes (interfaces), static domains, static methods, instance domains, virtual methods and super methods.
In the bag: the byte code generating program is converted by taking a Java packet as a unit, the packet refers to a Java packet to be converted, and the Java packet is imported into (import) library packet.
Library package: java packages can be imported by other Java packages, and the Java Card API is realized in a Java library mode and can be referred by classes in other packages. A package-defined java class (within a package) may invoke methods of classes provided in the library package.
The method of the invention is simultaneously suitable for a Java Card virtual machine thought instruction set, a Dalvik virtual machine instruction set and a TGoMOS virtual machine instruction set, and the method of the invention is explained by the TGoMOS virtual machine instruction set. The TGoMOS virtual machine instruction set, a reduced instruction set of micro-operating system bytecodes, includes six instructions.
The first instruction consists of an operation code, and the operation code contains parameter information of the first instruction in a hidden way; the first instructions include: instructions that imply both operands and register numbers into the opcode; instructions that imply register numbers into the opcodes; instructions to imply constant operands into opcodes; an array member access instruction for hiding the member type of the array member into the operation code; the type and parameters of the method call are implicit to the instruction in the opcode.
The second instruction is a high-frequency instruction with multiple instruction formats; the second instructions include: common arithmetic operation instructions having a plurality of operation formats; an array member access instruction in a 4-bit register format is adopted; an array creating instruction for hiding the member type of the array member into the operation code; based on the equal and unequal comparison results, branch instructions having multiple instruction formats.
A third instruction, wherein the third instruction comprises instructions with different instruction formats based on different parameter numbers; the third instructions include: based on different parameter numbers, static method call instructions with different instruction formats; virtual method call instructions with different instruction formats based on different parameter numbers; based on the number of different parameters, private instance method call instructions with different instruction formats.
The fourth instruction comprises an instruction of a common data type and an instruction of an uncommon data type, wherein the instruction of the common data type has a plurality of instruction formats, and the instruction of the uncommon data type has one instruction format; instructions of common data types include instructions of short data types, and instructions of less common data types include instructions of int data types.
A fifth instruction, the fifth instruction being an instruction having a single-byte constant pool index; the fifth instructions include: a static method call instruction with a single-byte constant pool index; a virtual method call instruction with a single-byte constant pool index; a static domain access instruction with a single-byte constant pool index; example Domain Access instructions with a one-byte constant pool index.
And the sixth instruction is a macro instruction. The sixth instruction includes: the method comprises the steps of converting a formed macro instruction based on a static method calling instruction and merging a plurality of instructions to form the macro instruction.
The seventh instruction is an instruction other than the first six types of instructions.
The implementation of the present invention includes the following four parts.
Design of constant pool component in loadable and executable file format
1. Put together the same reference type, forming a pool of 6 sub-constants. There are 6 reference types: 1) a class reference; 2) static method references; 3) virtual method quote; 4) super method quote; 5) a static domain reference; 6) instance domain references. Putting each reference type together to form a sub-constant pool, specifically, putting all the class reference types together to form a class sub-constant pool, putting all the static method reference types together to form a static method sub-constant pool, putting all the virtual method reference types together to form a virtual method sub-constant pool, putting all the super method reference types together to form a super method sub-constant pool, putting all the static domain reference types together to form a static domain sub-constant pool, and putting all the instance domain reference types together to form an instance domain sub-constant pool.
2. If the reference of each sub-constant pool exceeds 256, the references of a specific type are preferentially put into the sub-constant pool according to the order of the use frequency from high to low.
3. The constant pool index in the instruction is the index of the corresponding sub-constant pool. Some instructions use constant pool indices, and different instructions use different types of constant pool indices. For example, the instance domain access instruction includes an instance domain sub-constant pool index operand, and a corresponding instance domain reference can be queried in the instance domain sub-constant pool through the instance domain sub-constant pool index.
Compared with the design of an undifferentiated constant sub-pool, if the size of the whole constant pool exceeds 256, the index of a specific constant pool is easy to exceed the range represented by one single byte, and by splitting the constant pool into 6 constant sub-pools, the index of each constant pool entry basically does not exceed the range of 1 byte.
FIG. 1 illustrates a constant pool implementation, where the constant pool includes 6 sub-constant pools, where each sub-constant pool has no requirement on the order of the constant pool, and where the method of accessing the sub-constant pool (i.e., the way in which the offset and size of each sub-constant pool is recorded) has no requirement.
Second, instruction set design
In the TGoMO virtual machine instruction set, a byte of an opcode can specify the operation type of an instruction, whether an operand is required and the operand type, whether an operation result is returned, and the like. Some of the instructions need to access the constant pool (e.g., the fifth instruction), and therefore the instructions include corresponding constant pool index operands. The constant pool index of an instruction may be one or two bytes long, and the length of the constant pool index in the instruction depends on two conditions: 1) the size of the index that a particular reference is in the corresponding sub-constant pool; 2) the specific reference is the length in bytes needed after constant pool parsing. If a single-byte index can be adopted for a common instruction, the length of the byte code of the method can be obviously reduced, and if the instruction of the constant pool index of the single byte is used for N times, N bytes can be saved compared with the instruction using the 2-byte index. By applying a large number of analyses of the conversion results, it was found that the following instructions occur relatively frequently:
1. instance domain access instructions of a reference type;
2. static domain access instructions of a reference type defined in the package;
3. static method call instructions in the library package;
4. and calling the instruction by the virtual method.
By the design of the constant pool component in the loadable and executable file format, the common reference index can be ensured not to exceed one byte, and the analyzed result can be stored by the one-byte index through other methods adopted by the virtual machine. Table 1 shows instructions that may employ a single byte index, including the function of the instruction and the conditions applicable to use.
TABLE 1
| Instructions | Function(s) | Using single byte index instructions |
| Invoke static | Invoking static methods | Static method in library package |
| Invoke virtual | Invoking virtual methods | Is not particularly limited |
| Get Static | Accessing static domains | Reference type field |
| Get Field | Accessing instance domains | Reference type field |
Prior to generating the instruction, a resolution of the index is required, i.e. a process when the application is installed into the virtual machine. The method comprises the following specific steps:
1. instance Domain reference types
The sub-constant pool of the instance domain is resolved to an index of the instance domain references, each class numbered individually starting with 0. Condition of using single-byte constant pool index of instance domain references: the value of the index referenced by this instance field is in the range of one byte representation, i.e., 0 to 255. The single-byte constant pool index referenced by the instance domain can meet common application scenes, 256 words can be addressed by 1 byte, basic types of a bootean type, a byte type and a short type respectively occupy one word, a reference type occupies one word, and basic variables of an int type occupy 2 words. A word is an abstract storage unit defined by a virtual machine specification, one word must be large enough to contain the next byte, short, reference and return address data types, and two words can contain the next int type.
2. Static domain reference types
The index of the static domain reference is resolved to an offset of the static domain mirror. The static domains of all classes declared in one Java package are put together to form a static domain mirror. Static domain images are single byte offset and static domains of reference types are placed in front of the images, so that static domains of frequently accessed reference types can be addressed by single byte offset. Fig. 2 shows a usage of a single-byte static domain constant pool index, where a sequence number 20 indicates an offset of a static domain mirror in a static domain access instruction (the static domain sub-constant pool index is replaced after being resolved), and a sequence number 21 indicates the static domain mirror.
3. Virtual method referencing
The index referenced by the virtual method is resolved into an index of a virtual method table of each class, and the virtual method table is divided into a public (protection) type virtual method table and a package visible virtual method table. The virtual method calling instruction of the TGoMOS virtual machine instruction set clearly specifies the number of parameters of the method, and the number of the parameters called by the virtual method does not need to be analyzed from the virtual method sub-constant pool index.
4. Static method referencing
And calling static methods of the library package by the executable file of the TGoMOS virtual machine, wherein the static methods are static methods in the mask library package, and the analyzed result is the global reference table index of the static methods. The common static method reference needs to be added to the front end of the global reference table (the range that is accessible by 1 byte), so that the sub-constant pool reference of the static method can be resolved into a single-byte global reference table index.
FIG. 3 illustrates one use of a one-byte static method constant pool index (before parsing), calling a static method of a library package. The sequence number 32 represents the content referenced by the child constant pool of the library package static method, including a package index, and may be used to query the specified mask package information, including an Export component; sequence number 35 represents an Export component of the specified packet, and byte code position information of the Method can be obtained by querying the Export component through the Class index and the Method index. Sequence number 34 indicates the method component of the designated packet, including the bytecode specifying the method, etc.
FIG. 4 illustrates one use of a one-byte static method constant pool index (after parsing), library package static method invocation. Sequence number 40 represents the index of the global reference table in the static method call instruction (resolved and replaced by the constant pool index). The sequence number 41 indicates an entry of the global reference table, including an index of the packet and an offset of a method component for specifying the packet, and a common static method needs to be preferentially put in a header of the global reference table during byte code conversion, that is, the index is in a range of 0 to 255. Sequence number 42 indicates the location of the static method bytecode.
FIG. 5 shows another use of the one-byte static method constant pool index (after parsing), intra-package, library-package static method invocation. Sequence number 51 indicates an offset table of the method in the high-frequency call packet, that is, the offset of the common method is put into a table, and when the constant pool is analyzed, the index of the corresponding method of the table is replaced. Sequence number 52 represents a global reference table index table of the library packet method called at high frequency, that is, the global reference table index of the common method is put into a table, and when the constant pool is analyzed, the index of the corresponding method of the table is replaced. Sequence number 53 exemplarily represents a method component and sequence number 54 exemplarily represents a global reference table.
One-byte indexed versions of instructions, such as Invvirtual, getstattic-o, getfield-o, invstatic, may be provided for instructions that occur frequently by the above-described method. For other instructions that are used relatively frequently, instructions that provide a single byte index may also be considered if the increase in execution performance and demand on RAM is not a concern. Instructions that provide a single byte index may not be considered for instructions that are used relatively infrequently. By the method, the size of the byte code can be effectively reduced under the condition of not using a plurality of operation codes.
Third, conversion implementation process
1. Generating constant pool components
The constant pool component consists of 6 sub-constant pools, namely a class sub-constant pool, a static method sub-constant pool, a virtual method sub-constant pool, a super method sub-constant pool, a static domain sub-constant pool and an instance domain sub-constant pool.
And if the number of the references of the instance domain exceeds 256, counting the occurrence times of the instructions of the instance domain of each reference type, and putting the instructions into the instance domain sub-constant pool according to the sequence of the times from top to bottom, otherwise, not requiring the sequence.
And if the number of the references of the virtual methods exceeds 256, counting the times of calling instructions of each virtual method, and putting the virtual method into a virtual method sub-constant pool according to the sequence of the times from top to bottom, otherwise, having no requirement on the sequence.
And if the number of the references of the static domain exceeds 256, counting the occurrence times of the instructions of the static domain of the reference type in the package, and putting the instructions into the static domain sub-constant pool according to the sequence of the times from top to bottom, otherwise, having no requirement on the sequence.
And if the number of the references of the static method exceeds 256, counting the times of calling instructions of the static method of each library package, and putting the instructions into a static method sub-constant pool according to the sequence of the times from top to bottom, otherwise, having no requirement on the sequence.
Through the operation, the index value of the constant pool reference of the following high-frequency occurring instruction is ensured not to exceed the range of one byte. High frequency instructions, namely an instance domain access instruction getfield-o for obtaining a reference type, a static domain access instruction getstattic-o for obtaining a reference type, a virtual method call instruction invvirtual, and a static method call instruction invstatic.
2. Generating static domain components
Counting the frequency of the occurrence of the instructions of the static domain of each reference type, and preferentially placing the instructions at the front end of the static domain region according to the sequence of the frequency from high to low.
3. Generation method component
The method mainly refers to a static method calling instruction, and the instruction of a single-byte constant pool index is only suitable for calling a common mask to a static method in a library package of a virtual machine system. The generation conditions are as follows: 1) a list of common static methods in a configuration file specified library package needs to be provided, the number of the common static methods cannot exceed 256, and each row in the list comprises a complete name of one static method; 2) the constant pool index of the static method does not exceed 256; 3) when generating executable file, generating static method calling instruction, it needs to inquire the configuration file, if the called method is in the list, it generates single-byte constant pool index instruction.
4. Generating instructions to access static domains
The instruction with the constant pool index of one byte is only suitable for accessing the reference type static field in the packet, and the constant pool index is in the range which can be represented by one byte.
5. Generating instructions to access instance domains
The generation condition of the single-byte constant pool index instruction, namely obtaining the instance field of the reference type, is that the value of the constant pool index does not exceed 1 byte.
6. Generating instructions to access virtual methods
The generation condition of the single-byte constant pool index instruction, i.e., the value of the constant pool index, does not exceed 1 byte.
7. Generation of mask-to-device library packages
A list of common static methods in a configuration file specified library package needs to be provided, the number of the common static methods cannot exceed 256, and each row in the list comprises a complete name of one static method; the implementation must make all the methods in this list accessible through a one byte index.
Four, virtual machine implementation
In the case of the invention, which preferably uses single byte index, the executable file of the virtual machine should implement the following functions: the static method of the mask library packet is called through the single-byte index, the static domain in the packet is called through the single-byte index, the virtual method is called through the single-byte index, and the instance domain is called through the single-byte index.
In addition to the above-described case of using single-byte indexes, the present invention also includes the following cases of using single-byte indexes:
1. the executable file calls a dynamic download library package static method through a single byte index. Meanwhile, the method supports the static methods of the intra-packet and the library packet, the number of the methods does not exceed 128 methods (the method needs to distinguish the intra-packet and the library packet by the highest bit), and the method only supports the static method of the library packet can be 256 methods. A table indexed by the global reference table of the multi-call static method needs to be added. The constant pool is resolved to an index of a table indexed by the global reference table of the static method. And searching the global reference table index of the method through the index, and acquiring the offset of the method and the packet index of the packet of the class to which the method belongs through the global reference table index.
2. The executable calls the in-package static methods (including private instance methods and < init > methods) through a single byte index. Meanwhile, the method supports static methods of intra-packet and library packets, the number of the methods does not exceed 128 methods (the method of distinguishing intra-packet and library packets by the highest bit is needed), and the method only supports the static methods of intra-packet and can be 256 methods. It is necessary to add an offset table for the multi-call static method. The constant pool is resolved to an index of the offset table for the static method. The offset of the method at the method component is found by the index.
Based on the above design thought, the embodiment of the present invention provides a method for simplifying a bytecode instruction set, which is suitable for a Java Card instruction set, a Dalvik instruction set, and the foregoing TGoMOS virtual machine instruction set. The fifth instruction of the TGoMOS virtual machine instruction set includes: a static method call instruction with a single-byte constant pool index; a virtual method call instruction with a single-byte constant pool index; a static domain access instruction with a single-byte constant pool index; example Domain Access instructions with a one-byte constant pool index. The fifth instruction of the TGoMOS virtual machine instruction set can be generated by the compaction method of the invention.
As shown in fig. 6, the compaction method includes the following steps:
s100, dividing a constant pool into a plurality of corresponding sub-constant pools based on different reference types;
the reference type comprises a reference of a class, a reference of a static method, a reference of a virtual method, a reference of a super method, a reference of a static domain and a reference of an instance domain, and the plurality of child constant pools comprise: the method comprises the following steps of (1) class sub-constant pools, static method sub-constant pools, virtual method sub-constant pools, super method sub-constant pools, static domain sub-constant pools and instance domain sub-constant pools;
s200, counting the occurrence frequency of the instruction corresponding to each reference type based on the number of references of each reference type, and putting the instructions into corresponding sub-constant pools in a sequence from high to low, wherein the constant pool index of the instruction corresponding to each reference type is the index of the sub-constant pool corresponding to each reference type;
s200 comprises the following steps:
if the number of the references of the instance domain exceeds 256, counting the occurrence frequency of the access instruction of each instance domain for acquiring the reference type, and putting the access instruction into the sub-constant pool of the instance domain from high to low, otherwise, directly putting the access instruction into the sub-constant pool of the instance domain;
if the number of the references of the static domain exceeds 256, counting the occurrence frequency of each static domain access instruction for acquiring the reference type, and putting the static domain access instructions into the sub-constant pool of the static domain from high to low, otherwise, directly putting the static domain access instructions into the sub-constant pool of the static domain;
specifically, the number of times of occurrence of each static domain access instruction of the get reference type is counted, and the static domain access instruction is preferentially placed at the front end of the sub-constant pool of the static domain from high to low.
If the number of the references of the virtual method exceeds 256, counting the occurrence frequency of each virtual method calling instruction, and putting the virtual method calling instructions into a sub-constant pool of the virtual method according to the sequence of the frequency from high to low, otherwise, directly putting the virtual method calling instructions into the sub-constant pool of the virtual method;
if the number of the references of the static method exceeds 256, counting the number of times of the static method instructions in the calling library package, preferentially putting the static method instructions into the sub-constant pool of the static method according to the sequence of the times from high to low, then counting the number of times of the static method instructions in each calling package, putting the static method instructions into the sub-constant pool of the static method according to the sequence of the times from high to low, or directly putting the static method instructions into the sub-constant pool of the static method.
And S300, generating a corresponding instruction of the single-byte constant pool index based on the generation condition of the instruction corresponding to each reference type.
For an instance domain access instruction, a static domain access instruction, and a virtual method call instruction, generating an instruction of a corresponding single-byte constant pool index, S300 includes:
1) if the constant pool index of an instance domain access instruction is in a byte range, generating a corresponding instance domain access instruction of a single-byte constant pool index;
2) if the constant pool index of a static domain access instruction is in a byte range and belongs to the static domain access instruction of the intra-packet reference type, generating a corresponding static domain access instruction of a single-byte constant pool index;
3) and if the constant pool index of one virtual method calling instruction is in a byte range, generating the corresponding virtual method calling instruction with the single-byte constant pool index.
4) Aiming at a static method call instruction, generating a corresponding instruction of a single-byte constant pool index, wherein the instruction comprises the following steps:
4.1) generating a list of common library package static methods and putting the list into a configuration file based on the called statistical times of each library package static method in a large number of applications, wherein the number of the static methods in the list of the common library package static methods is within 256 and has complete names;
specifically, the statistical times of the calling of each library package static method in a large number of applications are sorted from high to low, if the number of all the library package static methods exceeds 256, the first 256 library package static methods are placed in a list of common library package static methods, and if the number of all the library package static methods is within 256, all the library package static methods are directly placed in a list of common library package static methods.
4.2) if the constant pool index of a library package static method calling instruction is in a byte range, inquiring a configuration file, and determining whether the library package static method corresponding to the library package static method calling instruction exists in a common library package static method list;
4.3) if the library package static method is confirmed to exist in the common library package static method list, generating a library package static method calling instruction of a corresponding single-byte constant pool index.
The invention is simultaneously suitable for a virtual machine instruction set based on an operand stack and a register, generates the frequency of an instruction of counting a certain method call and accessing a reference type domain before the instruction, divides a constant pool into a plurality of sub constant pools, preferentially places references with high frequency in each sub constant pool, places a static method of high-frequency access in the front end of a reference table in advance, places a static domain of high-frequency access in the front end of a static domain mirror image in advance, uses a single-byte constant pool index as the instruction of a high-frequency access example domain, uses a single-byte constant pool index as the virtual method call instruction of high-frequency access, uses a single-byte constant pool index as the instruction of high-frequency access static domain, uses a single-byte constant pool index as the static method call instruction of high-frequency access, by the design, the size of the byte code of the method can be effectively reduced under the condition of not using a plurality of operation codes.
In order to verify the technical effect, the constant pool index of a typical financial application is adopted, and when the sub-constant pool technology is not adopted, the constant pool has 333 items in common, and 77 items of index exceeds 256 ranges. When the sub-constant pool technology is adopted, the number of references of each sub-constant pool does not exceed 256, so that the sub-constant pool index can adopt a single byte. The instruction call for a typical financial application is shown in table 2 below.
TABLE 2
As can be seen from table 2, the size of the bytecode can be reduced by 3261 bytes using the single-byte index. Therefore, the simplification method of the invention can greatly simplify the byte code of the virtual machine, reduce the storage space of the byte code and improve the execution performance of the byte code.
As shown in fig. 7, an embodiment of the present invention further provides a bytecode instruction set reduction system, which is applicable to an operand stack-based and register-based instruction set, and includes:
a constant pool dividing module 100, configured to divide a constant pool into a plurality of corresponding sub-constant pools based on different reference types;
the constant pool component generating module 200 is configured to count the occurrence frequency of the instruction corresponding to each reference type based on the number of references of each reference type, and place the counted instruction into the corresponding sub constant pools in the order from high to low, where a constant pool index of the instruction corresponding to each reference type is an index of the sub constant pool corresponding to each reference type;
the instruction generating module 300 is configured to generate an instruction of a corresponding single-byte constant pool index based on a generation condition of the instruction corresponding to each reference type.
The reference type comprises a reference of a class, a reference of a static method, a reference of a virtual method, a reference of a super method, a reference of a static domain and a reference of an instance domain, and the plurality of child constant pools comprise: the method comprises the following steps of class sub-constant pool, static method sub-constant pool, virtual method sub-constant pool, super method sub-constant pool, static domain sub-constant pool and instance domain sub-constant pool.
The constant pool component generation module 200 is specifically configured to:
if the number of the references of the instance domain exceeds 256, counting the occurrence frequency of the access instruction of each instance domain for acquiring the reference type, and putting the access instruction into the sub-constant pool of the instance domain from high to low, otherwise, directly putting the access instruction into the sub-constant pool of the instance domain;
if the number of the references of the static domain exceeds 256, counting the occurrence frequency of each static domain access instruction for acquiring the reference type, and putting the static domain access instructions into the sub-constant pool of the static domain from high to low, otherwise, directly putting the static domain access instructions into the sub-constant pool of the static domain;
if the number of the references of the virtual method exceeds 256, counting the occurrence frequency of each virtual method calling instruction, and putting the virtual method calling instructions into a sub-constant pool of the virtual method according to the sequence of the frequency from high to low, otherwise, directly putting the virtual method calling instructions into the sub-constant pool of the virtual method;
if the number of the references of the static method exceeds 256, counting the number of times of the static method instructions in the calling library package, preferentially putting the static method instructions into the sub-constant pool of the static method according to the sequence of the times from high to low, then counting the number of times of the static method instructions in each calling package, putting the static method instructions into the sub-constant pool of the static method according to the sequence of the times from high to low, or directly putting the static method instructions into the sub-constant pool of the static method.
In the instruction generating module 300, for the instance domain access instruction, the static domain access instruction, and the virtual method call instruction, an instruction for generating a corresponding single-byte constant pool index includes:
1) if the constant pool index of an instance domain access instruction is in a byte range, generating a corresponding instance domain access instruction of a single-byte constant pool index;
2) if the constant pool index of a static domain access instruction is in a byte range and belongs to the static domain access instruction of the intra-packet reference type, generating a corresponding static domain access instruction of a single-byte constant pool index;
3) and if the constant pool index of one virtual method calling instruction is in a byte range, generating the corresponding virtual method calling instruction with the single-byte constant pool index.
4) Aiming at a static method call instruction, generating a corresponding instruction of a single-byte constant pool index, wherein the instruction comprises the following steps:
4.1) generating a list of common library package static methods based on the called statistical times of each library package static method in a large number of applications, and putting the list into a configuration file, wherein the number of the static methods in the list of the common library package static methods is within 256 and has a complete Java method name;
specifically, the statistical times of the called of each library package static method are sorted from high to low, if the number of all the library package static methods exceeds 256, the first 256 library package static methods are placed in a list of common library package static methods, and if the number of all the library package static methods is within 256, all the library package static methods are directly placed in the list of common library package static methods.
4.2) if the constant pool index of a library package static method calling instruction is in a byte range, inquiring a configuration file, and determining whether the library package static method corresponding to the library package static method calling instruction exists in a common library package static method list;
4.3) if the library package static method is confirmed to exist in the common library package static method list, generating a library package static method calling instruction of a corresponding single-byte constant pool index.
It will be apparent to those skilled in the art that various changes and modifications may be made in the present invention without departing from the spirit and scope of the invention. Thus, if such modifications and variations of the present invention fall within the scope of the claims of the present invention and their equivalents, the present invention is intended to include such modifications and variations.
Claims (10)
1. A bytecode instruction set reduction method applicable to an operand stack-based and register-based instruction set, the reduction method comprising the steps of:
s100, dividing a constant pool into a plurality of corresponding sub-constant pools based on different reference types;
s200, counting the occurrence frequency of the instruction corresponding to each reference type based on the number of references of each reference type, and putting the instructions into corresponding sub-constant pools in a sequence from high to low, wherein the constant pool index of the instruction corresponding to each reference type is the index of the sub-constant pool corresponding to each reference type;
and S300, generating a corresponding instruction of the single-byte constant pool index based on the generation condition of the instruction corresponding to each reference type.
2. The compaction method of claim 1 wherein the reference types include references to classes, static methods, virtual methods, super methods, static domains, and instance domains, and wherein the plurality of child constant pools comprise: the sub-constant pool of the class, the sub-constant pool of the static method, the sub-constant pool of the virtual method, the sub-constant pool of the super method, the sub-constant pool of the static domain, and the sub-constant pool of the instance domain.
3. The compaction method of claim 2, wherein S200 comprises:
if the number of the references of the instance domain exceeds 256, counting the occurrence times of the access instructions of the instance domain of each reference type, and putting the access instructions into the sub-constant pool of the instance domain according to the sequence of the times from high to low, otherwise, directly putting the access instructions into the sub-constant pool of the instance domain;
if the number of the references of the static domain exceeds 256, counting the occurrence times of static domain access instructions of the reference types defined in the package, and putting the static domain access instructions into the sub-constant pool of the static domain from high to low according to the times, otherwise, directly putting the static domain access instructions into the sub-constant pool of the static domain;
if the number of the references of the virtual method exceeds 256, counting the occurrence frequency of each virtual method calling instruction, and putting the virtual method calling instructions into a sub-constant pool of the virtual method according to the sequence of the frequency from high to low, otherwise, directly putting the virtual method calling instructions into the sub-constant pool of the virtual method;
if the number of the references of the static method exceeds 256, firstly counting the number of times of static method instructions in the calling library package, preferentially putting the static method instructions into the sub-constant pool of the static method according to the sequence of the times from high to low, then counting the number of times of the static method instructions in each calling package, and putting the static method instructions into the sub-constant pool of the static method according to the sequence of the times from high to low, otherwise, directly putting the static method instructions into the sub-constant pool of the static method.
4. The compaction method of claim 3, wherein the counting the number of occurrences of static domain access instructions of a reference type in the package is placed into the sub-constant pool of the static domain in order of the number of occurrences from high to low, comprises:
and counting the occurrence times of static domain access instructions of the reference types in the packet, and preferentially placing the static domain access instructions at the front end of the sub-constant pool of the static domain according to the order of the times from high to low.
5. The compaction method of claim 3, wherein S300 comprises:
if the constant pool index of an instance domain access instruction is in a byte range, generating a corresponding instance domain access instruction of a single-byte constant pool index;
if the constant pool index of a static domain access instruction is in a byte range and belongs to the static domain access instruction of the intra-packet reference type, generating a corresponding static domain access instruction of a single-byte constant pool index;
and if the constant pool index of one virtual method calling instruction is in a byte range, generating the corresponding virtual method calling instruction with the single-byte constant pool index.
6. The compaction method of claim 3, wherein S300 further comprises:
generating a common library package static method list and putting the common library package static method list into a configuration file based on the statistics of the called statistics times of each library package static method in a large number of applications, wherein the number of the library package static methods in the common library package static method list is within 256 and has a complete Java method name;
if the constant pool index of a library package static method calling instruction is in a byte range, inquiring the configuration file, and determining whether the library package static method corresponding to the library package static method calling instruction exists in the common library package static method list;
and if the library package static method is confirmed to exist in the common library package static method list, generating a library package static method calling instruction of a corresponding single-byte constant pool index.
7. The compaction method of claim 6, wherein generating a list of commonly used library package static methods into a configuration file based on a statistical number of times each library package static method is invoked in a plurality of applications comprises:
and sequencing the called statistical times of each library package static method in a large number of applications from high to low, if the number of all the library package static methods exceeds 256, putting the first 256 library package static methods into the list of the common library package static methods, and if the number of all the library package static methods is within 256, directly putting all the library package static methods into the list of the common library package static methods.
8. A bytecode instruction set reduction system adapted for operand stack-based and register-based instruction sets, the reduction system comprising:
the constant pool dividing module is used for dividing the constant pool into a plurality of corresponding sub constant pools based on different reference types;
the constant pool component generation module is used for counting the occurrence frequency of the instruction corresponding to each reference type based on the number of references of each reference type and putting the instructions into the corresponding sub constant pools in the sequence from high to low, wherein the constant pool index of the instruction corresponding to each reference type is the index of the sub constant pool corresponding to each reference type;
and the instruction generating module is used for generating the instruction of the corresponding single-byte constant pool index based on the generating condition of the instruction corresponding to each reference type.
9. The compaction system of claim 8 wherein the reference types include references to classes, references to static methods, references to virtual methods, references to super methods, references to static domains, references to instance domains, and wherein the plurality of pools of children constants comprise: the sub-constant pool of the class, the sub-constant pool of the static method, the sub-constant pool of the virtual method, the sub-constant pool of the super method, the sub-constant pool of the static domain, and the sub-constant pool of the instance domain.
10. The streamlining system of claim 9, wherein the constant pool component generation module is specifically configured to:
if the number of the references of the instance domain exceeds 256, counting the occurrence times of the access instructions of the instance domain of each reference type, and putting the access instructions into the sub-constant pool of the instance domain according to the sequence of the times from high to low, otherwise, directly putting the access instructions into the sub-constant pool of the instance domain;
if the number of the references of the static domain exceeds 256, counting the times of the static domain access instructions of the reference types in the package, and putting the static domain access instructions into the sub-constant pool of the static domain from high to low, otherwise, directly putting the static domain access instructions into the sub-constant pool of the static domain;
if the number of the references of the virtual method exceeds 256, counting the occurrence frequency of each virtual method calling instruction, and putting the virtual method calling instructions into a sub-constant pool of the virtual method according to the sequence of the frequency from high to low, otherwise, directly putting the virtual method calling instructions into the sub-constant pool of the virtual method;
if the number of the references of the static method exceeds 256, firstly counting the number of times of static method instructions in the calling library package, preferentially putting the static method instructions into the sub-constant pool of the static method according to the sequence of the times from high to low, then counting the number of times of the static method instructions in each calling package, and putting the static method instructions into the sub-constant pool of the static method according to the sequence of the times from high to low, otherwise, directly putting the static method instructions into the sub-constant pool of the static method.
Priority Applications (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011550106.0A CN112631722A (en) | 2020-12-24 | 2020-12-24 | Byte code instruction set simplifying method and system |
| PCT/CN2021/104737 WO2022134537A1 (en) | 2020-12-24 | 2021-07-06 | Bytecode instruction set reduction method and system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011550106.0A CN112631722A (en) | 2020-12-24 | 2020-12-24 | Byte code instruction set simplifying method and system |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN112631722A true CN112631722A (en) | 2021-04-09 |
Family
ID=75324375
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011550106.0A Pending CN112631722A (en) | 2020-12-24 | 2020-12-24 | Byte code instruction set simplifying method and system |
Country Status (2)
| Country | Link |
|---|---|
| CN (1) | CN112631722A (en) |
| WO (1) | WO2022134537A1 (en) |
Cited By (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113568637A (en) * | 2021-07-14 | 2021-10-29 | 武汉天喻信息产业股份有限公司 | Smart card system package updating management method and device |
| CN113835620A (en) * | 2021-08-13 | 2021-12-24 | 北京握奇智能科技有限公司 | Method and system for improving application execution efficiency of security chip |
| CN114428639A (en) * | 2021-12-24 | 2022-05-03 | 北京握奇数据股份有限公司 | Instruction simplification method and system of byte code instruction set |
| WO2022134537A1 (en) * | 2020-12-24 | 2022-06-30 | 北京握奇数据股份有限公司 | Bytecode instruction set reduction method and system |
| WO2022134538A1 (en) * | 2020-12-24 | 2022-06-30 | 北京握奇数据股份有限公司 | Micro-operating system bytecode reduced instruction set and resource restriction apparatus |
| CN117234590A (en) * | 2023-08-02 | 2023-12-15 | 北京握奇数据股份有限公司 | Instruction set generation method, device, medium and equipment |
| WO2024169376A1 (en) * | 2023-02-17 | 2024-08-22 | 华为技术有限公司 | Compiling method, analyzing method, and apparatus |
Family Cites Families (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1645319A (en) * | 2005-01-20 | 2005-07-27 | 上海交通大学 | Method for optimizing partial evaluating service under network environment |
| KR100809293B1 (en) * | 2006-03-10 | 2008-03-04 | 삼성전자주식회사 | Apparatus and method for managing stacks in virtual machine |
| CN102681821B (en) * | 2011-12-31 | 2014-07-30 | 浙江大学 | Binary tool set designing method based on C-SKY v2 instruction set |
| CN109102807A (en) * | 2018-10-18 | 2018-12-28 | 珠海格力电器股份有限公司 | Personalized voice database creation system, voice recognition control system and terminal |
| CN112631722A (en) * | 2020-12-24 | 2021-04-09 | 北京握奇数据股份有限公司 | Byte code instruction set simplifying method and system |
-
2020
- 2020-12-24 CN CN202011550106.0A patent/CN112631722A/en active Pending
-
2021
- 2021-07-06 WO PCT/CN2021/104737 patent/WO2022134537A1/en active Application Filing
Cited By (10)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2022134537A1 (en) * | 2020-12-24 | 2022-06-30 | 北京握奇数据股份有限公司 | Bytecode instruction set reduction method and system |
| WO2022134538A1 (en) * | 2020-12-24 | 2022-06-30 | 北京握奇数据股份有限公司 | Micro-operating system bytecode reduced instruction set and resource restriction apparatus |
| CN113568637A (en) * | 2021-07-14 | 2021-10-29 | 武汉天喻信息产业股份有限公司 | Smart card system package updating management method and device |
| CN113568637B (en) * | 2021-07-14 | 2024-05-03 | 武汉天喻信息产业股份有限公司 | Method and device for updating and managing smart card system package |
| CN113835620A (en) * | 2021-08-13 | 2021-12-24 | 北京握奇智能科技有限公司 | Method and system for improving application execution efficiency of security chip |
| CN113835620B (en) * | 2021-08-13 | 2024-05-24 | 北京握奇智能科技有限公司 | Method and system for improving execution efficiency of security chip application |
| CN114428639A (en) * | 2021-12-24 | 2022-05-03 | 北京握奇数据股份有限公司 | Instruction simplification method and system of byte code instruction set |
| WO2024169376A1 (en) * | 2023-02-17 | 2024-08-22 | 华为技术有限公司 | Compiling method, analyzing method, and apparatus |
| CN117234590A (en) * | 2023-08-02 | 2023-12-15 | 北京握奇数据股份有限公司 | Instruction set generation method, device, medium and equipment |
| CN117234590B (en) * | 2023-08-02 | 2024-03-29 | 北京握奇数据股份有限公司 | Instruction set generation method, device, medium and equipment |
Also Published As
| Publication number | Publication date |
|---|---|
| WO2022134537A1 (en) | 2022-06-30 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN112631722A (en) | Byte code instruction set simplifying method and system | |
| EP0777177B1 (en) | A method for object-oriented programming using dynamic interfaces | |
| EP3314422B1 (en) | Extending a virtual machine instruction set architecture | |
| US7814047B2 (en) | Direct loading of semistructured data | |
| US8209361B2 (en) | Techniques for efficient and scalable processing of complex sets of XML schemas | |
| US6275830B1 (en) | Compile time variable size paging of constant pools | |
| US20030208498A1 (en) | System and method for enhancing XML schemas | |
| US20200293335A1 (en) | Container-based language runtime loading an isolated method | |
| US7761861B2 (en) | Method for generating interpretable code for storage in a device having limited storage | |
| US20040024729A1 (en) | Method and system for storing sparse data in memory and accessing stored sparse data | |
| JP5011311B2 (en) | Method and mechanism for loading an XML document into memory | |
| US7483876B2 (en) | Flexible access of data stored in a database | |
| EP1678629A2 (en) | Extensible framework for handling different mark up language parsers and generators in a computing device | |
| WO2023029752A1 (en) | Data query method and apparatus, server, and computer-readable storage medium | |
| US7647580B2 (en) | General programming language support for nullable types | |
| CN114428639A (en) | Instruction simplification method and system of byte code instruction set | |
| CN112631724A (en) | Byte code instruction set simplifying method and system | |
| US4454579A (en) | System for performing call and return operations | |
| CN112199556A (en) | Automatic XML Schema file format conversion method, system and related equipment | |
| CN114611500A (en) | Expression processing method and device, electronic equipment and computer readable storage medium | |
| US20210036944A1 (en) | Ranking service implementations for a service interface | |
| US9342581B2 (en) | System to disclose the internal structure of persistent database objects | |
| US7836434B1 (en) | Method and system for analyzing array access to a pointer that is referenced as an array | |
| US7181724B2 (en) | Representation of Java® data types in virtual machines | |
| US6711576B1 (en) | Method and apparatus for implementing compact type signatures in a virtual machine environment |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |