CN112579091A - Instruction compiling method and device, compiler and computing equipment - Google Patents
Instruction compiling method and device, compiler and computing equipment Download PDFInfo
- Publication number
- CN112579091A CN112579091A CN201910931185.0A CN201910931185A CN112579091A CN 112579091 A CN112579091 A CN 112579091A CN 201910931185 A CN201910931185 A CN 201910931185A CN 112579091 A CN112579091 A CN 112579091A
- Authority
- CN
- China
- Prior art keywords
- constant pool
- instruction
- constant
- information
- instructions
- 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
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
Abstract
The embodiment of the invention discloses an instruction compiling method, which comprises the following steps: traversing a compiled object containing a plurality of instructions to search the compiled object for instructions comprising constants; updating constant pool information according to the searched instruction and the constants contained in the searched instruction, wherein the constant pool information at least comprises each searched instruction and the constants contained in the searched instruction; determining the position of the constant pool in the compiled object according to the position information of the instruction in the constant pool information; and generating a constant pool at the determined constant pool position, the constant pool comprising one or more constants in the constant pool information. The embodiment of the invention also discloses a corresponding instruction compiling device, a computing device and a storage medium.
Description
Technical Field
The present invention relates to the field of compiling technologies, and in particular, to an instruction compiling method and apparatus, a compiler, and a computing device.
Background
Processors such as CPUs or DSPs each have a specialized machine language, that is, a set of machine instructions that the processor can directly recognize and execute. In order for these processors to execute source code expressed in a high-level language (such as C), the high-level language must be translated into a machine language that the processors can recognize and execute. Generally, a compiler may be used to convert source code expressed in a high-level language into object code expressed in a machine language. The translated target code has the same function as the source code, and finally the processor obtains the function to be realized by the source code by executing the target code.
Modern compilers typically include a compilation phase, an assembly phase, and a linking phase. The compiling stage mainly translates a high-level language into an assembly language, the assembly stage mainly translates the assembly language into a machine language, and the linking stage mainly merges a plurality of files expressed in the machine language into a final executable program.
In source code, there will typically be some instructions that include constants. The constant (const) is a deterministic value used in programs that can be determined at the assembly stage. For such instructions including constants, the compiler adopts the following processing modes in the compiling process: first, the constant is directly encoded into the instruction. The constants and the instructions are stored together, and a storage space is not separately opened up. This approach is usually used when the constant value is small, and occupies a large code space, and the code density is low. And secondly, storing the constants in a constant pool, and acquiring the constants from the constant pool by adopting a memory reading instruction. A constant pool (constant pool) is a block of memory in a code segment that holds constant data rather than executable code. Compilers typically store constant data in each code segment during the assembly phase by placing a constant pool at the end of the code segment. But this may conflict with the jump table controlling the execution order of the instructions.
Therefore, a more advanced instruction compiling scheme is needed to increase the code density and solve the problem of conflict with the jump table.
Disclosure of Invention
To this end, embodiments of the present invention provide an instruction compiling method, apparatus, compiler and computing device, so as to solve or at least alleviate the above problems.
According to an aspect of an embodiment of the present invention, there is provided an instruction compiling method including: traversing a compiled object containing a plurality of instructions to search the compiled object for instructions comprising constants; updating constant pool information according to the searched instruction and the constants contained in the searched instruction, wherein the constant pool information at least comprises each searched instruction and the constants contained in the searched instruction; determining the position of the constant pool in the compiled object according to the position information of the instruction in the constant pool information; and generating a constant pool at the determined constant pool position, wherein the constant pool comprises one or more constants in the constant pool information.
Optionally, in the method according to an embodiment of the present invention, the step of determining the constant pool position in the compiled object according to the position information of the instruction in the constant pool information includes: positions that do not change the instruction execution order are selected as constant pool positions.
Optionally, in the method according to the embodiment of the present invention, the position where the execution order of the instructions is not changed includes at least one of: the object returns to a location after the instruction, a location after the unconditional jump instruction.
Optionally, in the method according to an embodiment of the present invention, the step of determining, according to position information of an instruction in the constant pool information, a constant pool position in the compiled object further includes: creating an unconditional jump instruction; and taking the position after the unconditional jump instruction as the constant pool position to generate a constant pool, and jumping to the first instruction after the constant pool by the unconditional jump instruction.
Optionally, in the method according to the embodiment of the present invention, the method further includes: after the constant pool is generated at the determined constant pool position, the constant pool information is updated based on the constants contained in the constant pool.
Optionally, in a method according to an embodiment of the invention, the constant pool comprises constants contained by instructions preceding the constant pool position.
Optionally, in a method according to an embodiment of the invention, the constant pool comprises constants comprised by instructions preceding and following the constant pool position.
Optionally, in the method according to the embodiment of the present invention, none of the offsets between the constant in the constant pool and the instruction including the constant exceeds the offset constraint range of the instruction including the constant.
Optionally, in the method according to the embodiment of the present invention, the method is performed during compiling each compiled object, where after one compiled object is compiled, constant pool information corresponding to the compiled object is used as constant pool information of a next compiled object.
Optionally, in a method according to an embodiment of the present invention, the compiled object is a function.
Optionally, in the method according to the embodiment of the present invention, the method further includes: and in the case that the constant pool information is not empty, repeating the steps of determining the constant pool position in the compiled object and generating the constant pool at the determined constant pool position.
According to another aspect of the embodiments of the present invention, there is provided an instruction compiling apparatus including: the instruction traversing module is suitable for traversing a compiling object containing a plurality of instructions so as to search the compiling object for the instructions comprising the constants; the constant pool updating module is suitable for updating the constant pool information according to the searched instruction and the constants contained in the searched instruction, and the constant pool information at least comprises each searched instruction and the constants contained in the searched instruction; the position determining module is suitable for determining the position of the constant pool in the compiled object according to the position information of the instruction in the constant pool information; and the constant pool generating module is suitable for generating a constant pool at the determined constant pool position, wherein the constant pool comprises one or more constants in the constant pool information.
Optionally, in the apparatus according to an embodiment of the present invention, the position determination module is adapted to select a position that does not change the instruction execution order as the constant pool position.
Optionally, in an apparatus according to an embodiment of the present invention, the location determining module is adapted to create an unconditional jump instruction; and taking the position after the unconditional jump instruction as the constant pool position to generate a constant pool, and jumping to the first instruction after the constant pool by the unconditional jump instruction.
Optionally, in the apparatus according to an embodiment of the present invention, the constant pool updating module is further adapted to update the constant pool information based on constants contained in the constant pool after the constant pool is generated at the determined constant pool position.
Optionally, in the apparatus according to the embodiment of the present invention, the apparatus is adapted to compile each compiled object, where after one compiled object is compiled, constant pool information corresponding to the compiled object is used as constant pool information of a next compiled object.
Optionally, in the apparatus according to an embodiment of the present invention, in a case that the constant pool information is not empty, the position determining module is further adapted to repeat the above step of determining the constant pool position in the compiled object, and the constant pool generating module is further adapted to repeat the step of generating the constant pool at the determined constant pool position.
According to another aspect of an embodiment of the present invention, there is provided a compiler including: a compiling unit adapted to convert the source file into an intermediate file, the intermediate file comprising a plurality of compiled objects; optimizing the intermediate file; converting the optimized intermediate file into an assembly file; the compiling unit further comprises an instruction compiling device according to the embodiment of the invention, and the instruction compiling device is suitable for generating a constant pool for the instruction comprising the constant in the compiled object so as to optimize the intermediate file.
According to another aspect of an embodiment of the present invention, there is provided a computing device including: one or more processors; a memory; and one or more programs, wherein the one or more programs are stored in the memory and configured to be executed by the one or more processors, the one or more programs including instructions for performing the instruction compilation method according to the embodiment of the present invention.
According to a further aspect of embodiments of the present invention, there is provided a computer-readable storage medium storing one or more programs, the one or more programs comprising instructions, which when executed by a computing device, cause the computing device to perform an instruction compiling method according to embodiments of the present invention.
According to the instruction compiling scheme of the embodiment of the invention, the constant pool is generated in the compiling stage, so that an additional mechanism is not required to be configured to solve the conflict with the jump table, and an optimization space (for example, optimization related to switch-case statement) is provided for the optimization of code density. The constant is obtained from the constant pool by using the memory reading instruction, so that sharing of part of the constant can be realized, and the code density is improved. In addition, constant pool sharing among functions can be realized through the transfer of constant pool information, and the code density is further improved.
The foregoing description is only an overview of the technical solutions of the embodiments of the present invention, and the embodiments of the present invention can be implemented according to the content of the description in order to make the technical means of the embodiments of the present invention more clearly understood, and the detailed description of the embodiments of the present invention is provided below in order to make the foregoing and other objects, features, and advantages of the embodiments of the present invention more clearly understandable.
Drawings
To the accomplishment of the foregoing and related ends, certain illustrative aspects are described herein in connection with the following description and the annexed drawings, which are indicative of various ways in which the principles disclosed herein may be practiced, and all aspects and equivalents thereof are intended to be within the scope of the claimed subject matter. The above and other objects, features and advantages of the present disclosure will become more apparent from the following detailed description read in conjunction with the accompanying drawings. Throughout this disclosure, like reference numerals generally refer to like parts or elements.
FIG. 1 shows a schematic diagram of a compiler 100 according to one embodiment of the present invention;
FIG. 2 shows a schematic diagram of a compiling unit 120 according to one embodiment of the invention;
FIG. 3 shows a schematic diagram of a computing device 300, according to one embodiment of the invention;
FIG. 4 illustrates a flow diagram of an instruction compilation method 400 according to one embodiment of the invention;
FIG. 5 is a diagram illustrating the execution of an instruction compilation method 400 in a plurality of compiled objects according to one embodiment of the invention;
FIG. 6 is a diagram illustrating an assembly file that is output after compilation by the instruction compilation method 400 according to one embodiment of the invention;
FIG. 7 is a diagram illustrating an instruction translator 700 according to one embodiment of the present invention; and
FIG. 8 shows a flow diagram of an instruction compilation method 800 according to another embodiment of the invention.
Detailed Description
Exemplary embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. While exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be embodied in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the disclosure to those skilled in the art.
FIG. 1 shows a schematic diagram of a compiler 100 according to one embodiment of the present invention. Compiler 100 is capable of compiling source code into code that can be executed by a processor. As shown in fig. 1, the compiler 100 may include a compiling unit 110, an assembling unit 120, and a linking unit 130.
The compiling unit 110 may convert an input source file into an assembly file. The source files are expressed in a high-level language such as C language, C + + language, and the assembly files are expressed in an assembly language. Next, the assembly unit 120 connected to the compiling unit 110 converts the assembly file into a binary file expressed in a machine language that can be understood by a processor. Finally, a linking unit 130 connected to the assembling unit 120 may combine a plurality of binary files and convert the combined binary files into a program that can be executed by a processor.
In some embodiments, as shown in fig. 2, compiling unit 110 may further include a compiling front end 112, at least one optimizer 114, and a compiling back end 116.
Compile front end 112 may convert the source files into intermediate files. An intermediate file is some kind of Intermediate Representation (IR) of the source file, representing the semantic and syntactic structure of the source file. Next, an optimizer (PASS)114 coupled to the compilation front-end 112 may optimize the intermediate file. The compilation back-end 115, coupled to the optimizer 114, may then convert the optimized intermediate file into an assembly file.
According to an embodiment of the present invention, one of the optimizers 114 may include an instruction compiling apparatus 700. The intermediate file may generally include a plurality of compiled objects, and the instruction compiling apparatus 700 may generate a constant pool for an instruction including a constant in the compiled object in a compiling stage (i.e., a stage of translating a high-level language into an assembly language), thereby implementing optimization of the intermediate file. The compiling unit 110 compiles the compilation object using the compilation object as a compilation unit. That is, the compiling unit 110 compiles the source file of the next compiled object after outputting the assembler instruction of one compiled object. The compiled object may generally be a function.
In one embodiment, the optimizer in which the instruction compiling apparatus 700 is located is typically located after the other optimizers. This means that the optimizer in which the instruction compiling apparatus 700 is located optimizes the intermediate file after the other optimizers optimize the intermediate file. Thus, after the other optimization processes are completed, the optimizer of the instruction compiling apparatus 700 can predict the assembly instructions obtained after the intermediate file is converted more accurately, and calculate the length of each IR expression more accurately.
Furthermore, those skilled in the art will appreciate that the optimization in compiler 100 is mostly focused on the compilation stage. Since the compilation stage uses the compiled object as the compilation unit, such optimization is usually for a single compiled object and cannot be optimized for the entire program. Thus, in some embodiments, the linking unit 120 may also include at least one Link-time optimization (LTO) 122, which Link-time optimizer 122 may optimize during the linking phase. Therefore, according to the embodiment of the present invention, one of the link time optimizers 122 described above may also include the instruction compiling apparatus 700.
In an embodiment according to the present invention, each component in the compiler 100, in particular, the instruction compiling apparatus 700, may be implemented by the computing device 300 as described below.
FIG. 3 shows a schematic diagram of a computing device 300, according to one embodiment of the invention. As shown in FIG. 3, in a basic configuration 302, a computing device 300 typically includes a system memory 306 and one or more processors 304. A memory bus 308 may be used for communication between the processor 304 and the system memory 306.
Depending on the desired configuration, the processor 304 may be any type of processor, including but not limited to: a microprocessor (μ P), a microcontroller (μ C), a Digital Signal Processor (DSP), or any combination thereof. The processor 304 may include one or more levels of cache, such as a level one cache 310 and a level two cache 312, a processor core 314, and registers 316. The example processor core 314 may include an Arithmetic Logic Unit (ALU), a Floating Point Unit (FPU), a digital signal processing core (DSP core), or any combination thereof. The example memory controller 318 may be used with the processor 304, or in some implementations the memory controller 318 may be an internal part of the processor 304.
Depending on the desired configuration, system memory 306 may be any type of memory, including but not limited to: volatile memory (such as RAM), non-volatile memory (such as ROM, flash memory, etc.), or any combination thereof. System memory 306 may include an operating system 320, one or more applications 322, and program data 324. In some implementations, the application 322 can be arranged to execute instructions on the operating system with the program data 324 by one or more processors 304.
The computing device 300 may also include an interface bus 340 that facilitates communication from various interface devices (e.g., output devices 342, peripheral interfaces 344, and communication devices 346) to the basic configuration 302 via the bus/interface controller 330. The example output devices 342 include a graphics processing unit 348 and an audio processing unit 350. They may be configured to facilitate communications with various external devices, such as a display or speakers, via one or more a/V ports 352. Example peripheral interfaces 344 may include a serial interface controller 354 and a parallel interface controller 356, which may be configured to facilitate communication with external devices such as input devices (e.g., keyboard, mouse, pen, voice input device, touch input device) or other peripherals (e.g., printer, scanner, etc.) via one or more I/O ports 358. An example communication device 346 can include a network controller 360, which can be arranged to facilitate communications with one or more other computing devices 362 over a network communication link via one or more communication ports 364.
A network communication link may be one example of a communication medium. Communication media may typically be embodied by computer readable instructions, data structures, program modules, and may include any information delivery media, such as carrier waves or other transport mechanisms, in a modulated data signal. A "modulated data signal" may be a signal that has one or more of its data set or its changes made in such a manner as to encode information in the signal. By way of non-limiting example, communication media may include wired media such as a wired network or private-wired network, and various wireless media such as acoustic, Radio Frequency (RF), microwave, Infrared (IR), or other wireless media. The term computer readable media as used herein may include both storage media and communication media.
Computing device 300 may be implemented as a server, such as a database server, an application server, a WEB server, and the like, or as a personal computer including both desktop and notebook computer configurations. Of course, computing device 300 may also be implemented as part of a small-sized portable (or mobile) electronic device.
In an embodiment according to the invention, the computing device 300 is implemented as an instruction compiling apparatus 700 and is configured to execute an instruction compiling method 400/800 according to an embodiment of the invention. The application 322 of the computing device 300 includes a plurality of instructions for executing the instruction compiling method 400/800 according to the embodiment of the invention, and the program data 324 may also store the configuration data of the compiler 100 and the like. The applications 322 of the computing device 300 may also include other applications processed by the instruction compiling apparatus 700, or other applications that call the instruction compiling apparatus 700 during execution. By executing the instruction compiling method 400/800 by the instruction compiling apparatus 700, the code density can be increased, and the storage space occupied by the codes of the applications can be reduced, so that the power consumption of the processor 304 for processing the applications is smaller.
FIG. 4 shows a flow diagram of an instruction compilation method 400 according to one embodiment of the invention. As shown in fig. 4, the instruction compiling method 400 can be executed in the instruction compiling apparatus 700 and starts with step S410.
In step S410, a compiled object containing a plurality of instructions is traversed to find an instruction including a constant in the compiled object. Those skilled in the art will appreciate that traversal from an instruction executed first to an instruction executed later is typically performed in instruction execution order.
Wherein the constant is a fixed value that does not change during execution of the program. In C language, constants may include integer constants, floating point constants, string constants, and the like. In assembly languages and machine languages, the constant may be more widely contained, and may include, for example, addresses of functions and variables, and the like. The following are two examples of instructions that include constants in the machine instruction set of a processor:
movi r0，2
lrw r0, [ label ], [ label ] stores the address of a variable.
Then, in step S420, the constant pool information is updated according to the searched instruction and the constant included in the searched instruction. Specifically, the searched instruction and the constant included in the searched instruction may be recorded in the constant pool information.
The constant pool information may include at least each found instruction and its contained constant. It is understood that the constant pool information includes instructions that are ordered in a manner consistent with the order in which the instructions of the compiled objects are executed.
In some embodiments, the constant pool information may include location information of the located instruction including the constant, and the location information of the instruction may include at least an address of the instruction and an offset constraint range of the instruction. Wherein the offset constraint range of the instruction may include a forward offset constraint range and/or a backward offset constraint range of the instruction. The forward offset constraint range includes the maximum minimum offset that the instruction references forward, and the backward offset constraint range includes the maximum minimum offset that the instruction references backward. It should be noted that forward/forward and backward/backward are defined herein in terms of address size, with forward references referring to dereferencing to addresses that are larger and backward references referring to dereferencing to addresses that are smaller.
In particular practice, the constant pool information may generally represent instructions that include constants using the following data structure:
in some embodiments, the constant pool information may include position information of a constant included in an instruction in the constant pool information, and the position information of the constant may include at least an offset of the constant in the constant pool information, that is, an offset from a starting address of the constant pool.
In particular practice, the constant pool information may generally represent constants using the following data structure:
then, in step S430, the constant pool position in the compiled object may be determined according to the position information of the instruction in the constant pool information.
Preferably, a position that does not change the execution order of instructions may be selected as the constant pool position. The position where the execution order of the instructions is not changed may include at least one of the following positions: an object returns a location after an instruction (e.g., a return instruction), a location after an unconditional jump instruction (e.g., a jump instruction).
It should be noted that the preceding and following are defined in the order of execution of the instructions, as opposed to the preceding and following definitions described above. Throughout this document, only the forward references/forward and backward references/backward are defined in terms of address size, and the rest are defined in terms of instruction execution order. Specifically, the instruction execution order is before and the instruction execution order is after. For example, a position before a certain instruction refers to a position in which an instruction execution order precedes a certain instruction, and a position after a certain instruction refers to a position in which an instruction execution position follows a certain instruction.
In some embodiments, a location may be selected to create an unconditional jump instruction, with the location after the unconditional jump instruction as a constant pool location to generate a constant pool. Wherein the unconditional jump instruction jumps to the first instruction after the constant pool. That is, the target address of the unconditional jump instruction is the end address of the constant pool. In this way, it is also ensured that the order of execution of the instructions of the program is not changed.
After determining the constant pool position, a constant pool may be generated at the determined constant pool position in step S440, and the constant pool may include one or more constants in the constant pool information.
In some embodiments, instructions that include constants allow only forward referencing, and the constant pool generated in this case may only include constants that instructions that precede the constant pool location contain. And, the offset between the constant in the constant pool and the instruction including the constant does not exceed the offset constraint range of the instruction including the constant, i.e., the forward offset constraint range.
In other embodiments, instructions that include constants allow both forward and backward references. The constant pool generated in this case may include constants contained by instructions preceding and following the constant pool location. Likewise, none of the offsets between a constant in the constant pool and an instruction that includes the constant exceed the offset constraint range of the instruction that includes the constant. And the offset between the instruction after the constant pool position and the constant included by the instruction does not exceed the forward offset constraint range of the instruction. It will be appreciated that for instructions preceding the constant pool position, whose instruction execution order precedes the constant pool position, their addresses are smaller than the constant addresses contained by the instruction. For instructions after the constant pool position, the execution order of the instructions is after the constant pool position, and the address of the instructions is larger than the constant address contained by the instructions.
According to an embodiment of the present invention, before step S430, it may further be determined whether an offset between an instruction in the constant pool information and a constant included in the instruction in the constant pool information exceeds an offset constraint range of the instruction according to position information of the instruction in the constant pool information and position information of the constant included in the instruction in the constant pool information.
Specifically, the following steps S431 to S43 may be performed on the instructions in the constant pool information one by one:
taking the current instruction as an example, first in step S431, for the current instruction, a constant pool reference position is determined based on the position information of the current instruction. For example, the position after the current instruction may be taken as the constant pool reference position.
Next, assuming that a constant pool is generated at the constant pool reference position, it may be determined whether the offset between the instruction before the constant pool reference position in the constant pool information and the constant included in the instruction exceeds the offset constraint range of the instruction in step S432.
Wherein, the offset between the instruction and the constant contained in the instruction can be calculated according to the determined constant pool reference position, the address of the instruction and the offset of the constant contained in the instruction in the constant pool information.
In some embodiments, the offset between an instruction and its contained constant in the constant pool information may be equal to the offset between the instruction and the constant pool reference location plus the offset of the constant contained by the instruction in the constant pool information.
Specifically, in the case where an instruction including a constant allows only forward referencing, it is naturally possible to determine only whether the offset between an instruction preceding the constant pool reference position in the constant pool information and the constant included in the instruction exceeds the forward offset constraint range of the instruction.
In the case that the instruction including the constant allows forward reference and backward reference, it may be determined whether an offset between an instruction preceding the constant pool reference position in the constant pool information and a constant included in the instruction exceeds a forward offset constraint range of the instruction.
If the offset between the instruction before the constant pool reference position in the constant pool information and the constant contained in the instruction does not exceed the offset constraint range of the instruction, the steps S431 to S432 may be repeated for the next instruction in the constant pool information.
If the offset between the instruction before the constant pool reference position in the constant pool information and the constant contained in the instruction exceeds the offset constraint range of the instruction, the constant pool position may be determined in step S430, and the constant pool may be generated in step S440. Obviously, the constant pool position determined at this time should be located before the constant pool reference position.
After the constant pool is generated, the steps S431 to S432 may be further continued one by one for the instructions following the constant pool position in the constant pool information.
Further, according to an embodiment of the present invention, in the case where the instruction including the constant allows forward reference and backward reference, steps S431 to S432 may be continued on a case-by-case basis for the instruction following the constant pool position in the constant pool information after the constant pool position is determined in step S430 and before the constant pool is generated in step S440. It should be noted that, at this time, the offset between the instruction and the constant contained in the instruction is calculated according to the determined constant pool position (instead of the constant pool reference position), the address of the instruction in the constant pool information, and the offset of the constant contained in the instruction in the constant pool information. For example, the offset between the instruction and the constant contained by the instruction may be equal to the offset between the instruction and the constant pool location plus the offset of the constant contained by the instruction in the constant pool information.
It is to be understood that, at this time, if the offset between the instruction before the constant pool reference position in the constant pool information and the constant included in the instruction before the constant pool reference position in the constant pool information exceeds the forward offset constraint range of the instruction in the constant pool information, it may be determined whether the offset between the instruction and the constant included in the instruction exceeds the backward offset constraint range of the instruction.
If the offset between the instruction and the constant contained by the instruction exceeds the backward offset constraint range of the instruction, a constant pool may be generated in step S440. If not, steps S431 to S432 are performed for the next instruction.
It should be noted that, since the instructions in the constant pool are located in the compiled object, in some embodiments, the above-mentioned process of performing steps S431 to S432 on the instructions in the constant pool information item by item may be included in the process of traversing the compiled object including a plurality of instructions in step S410. That is, in the process of traversing an instruction in a compiled object, when an instruction including a constant is traversed, the above steps S431 to S432 may be performed on the instruction.
Of course, the two processes may be two independent processes, and the present invention is not limited thereto.
Finally, after the constant pool is generated, since the constant pool does not necessarily include all constants in the constant pool information, the constant pool information may also be updated based on the generated constant pool. Specifically, the constants contained in the generated constant pool may be deleted from the constant pool information.
According to the embodiment of the present invention, the instruction compiling method 400 is performed in a compiling stage, and specifically may be performed in a process of compiling each compiled object. After a compiled object is compiled, the constant pool information corresponding to the compiled object can be used as the constant pool information of the next compiled object. By transmitting the constant pool information among the compiled objects, the constant pool can be shared among a plurality of compiled objects, and the code density is greatly improved.
FIG. 5 is a diagram illustrating the execution of an instruction compilation method 400 in a plurality of compiled objects according to one embodiment of the invention. As shown in fig. 5, the compiling unit 110 may compile compiled objects one by one in order. Specifically, the compiling unit 110 compiles a next compiled object after outputting an assembly instruction of one compiled object. In compiling each compiled object, the instruction compiling method 400 according to the embodiment of the invention may be performed on the compiled object.
FIG. 6 is a diagram illustrating an assembly file that is output after compilation by the instruction compilation method 400 according to one embodiment of the invention. The final output assembly file may be as shown in FIG. 6, where an arrow points from the instruction execution that includes the constant to the constant pool const pool where the constant is stored.
Furthermore, according to an embodiment of the present invention, as long as the constant pool information is not empty (the constant pool information further includes a constant), the above steps of determining the constant pool position in the compilation object in step S430 and generating the constant pool in the determined constant pool position in step S440 may be repeated. Of course, according to an embodiment of the present invention, if the constant pool information is still not empty when the last instruction of the last compiled object is compiled, the constant pool including all constants in the constant pool information may be generated after the object return instruction of the compiled object.
Fig. 7 shows a schematic diagram of an instruction compiling apparatus 700 according to an embodiment of the invention. Fig. 7 illustrates the instruction compiling apparatus 500 in a manner of dividing functional modules.
As shown in fig. 7, the instruction compiling apparatus 700 may include an instruction traversal module 710, a constant pool update module 720, a location determination module 730, and a constant pool generation module 740.
The instruction traversal module 710 is adapted to traverse a compiled object containing a plurality of instructions to find an instruction including a constant in the compiled object. The constant pool updating module 720 is connected to the instruction traversing module 710 and is adapted to update the constant pool information according to the searched instruction and the constants contained in the searched instruction. The constant pool information at least comprises each searched instruction and the constant contained in the instruction.
The position determination module 730 is coupled to the constant pool update module 720 and is adapted to determine the constant pool position in the compiled object based on the position information of the instruction in the constant pool information. The constant pool generating module 740 is coupled to the position determining module 730 and is adapted to generate a constant pool at the determined constant pool position, the generated constant pool including one or more constants in the constant pool information. For example, the constant pool may include constants that instructions preceding the constant pool location contain. As another example, the constant pool may include constants that the instructions before and after the constant pool location contain. Of course, none of the offsets between a constant in the constant pool and an instruction that includes the constant exceed the offset constraint range of the instruction that includes the constant.
In some embodiments, the position determination module 730 may select a position that does not change the order of execution of instructions as a constant pool position. In other embodiments, the location determination module 730 may create an unconditional jump instruction with the location after the unconditional jump instruction as a constant pool location to generate a constant pool. The unconditional jump instruction jumps to the first instruction after the constant pool.
According to an embodiment of the invention, the constant pool update module 720 may also update the constant pool information based on the constants contained in the constant pool after the constant pool is generated at the determined constant pool position.
The instruction compiling apparatus 700 is adapted to compile each compiled object, wherein after one compiled object is compiled, the constant pool information corresponding to the compiled object can be used as the constant pool information of the next compiled object. Compiled objects may generally be functions.
Further, as long as the constant pool information is not empty, the position determination module 730 may repeat the above-described step of determining the constant pool position in the compiled object, and the constant pool generation module 740 may repeat the step of generating the constant pool at the determined constant pool position.
For the detailed processing logic and implementation process of each module in the instruction compiling apparatus 700, reference may be made to the related description of the instruction compiling method 400 in conjunction with fig. 1 to fig. 6, and details are not repeated here.
The following further describes an instruction compilation scheme according to an embodiment of the present invention in a more specific embodiment.
FIG. 8 shows a flow diagram of an instruction compilation method 800 according to one embodiment of the invention. As shown in FIG. 8, the instruction compiling method 800 starts in step S810.
In step S810, a compiled object including a plurality of instructions may be traversed to find an instruction including a constant in the compiled object.
In the traversal process, for the currently searched instruction including the constant (i.e., the currently traversed instruction including the constant), in step S820, the constant pool information may be updated according to the currently searched instruction and the constant included in the currently searched instruction, where the constant pool information at least includes each searched instruction and the constant included in the searched instruction.
Next, for the currently searched instruction including the constant, in step S830, it may be determined whether the offset between the instruction in the constant pool information and the constant included in the instruction in the constant pool information exceeds the offset constraint range of the instruction in the constant pool information according to the position information of the instruction in the constant pool information and the position information of the constant included in the instruction in the constant pool information.
Specifically, the constant pool reference position may be determined based on the position information of the currently found instruction including the constant. For example, the position after the currently found instruction including the constant may be used as the constant pool reference position.
If the constant pool is generated at the constant pool reference position, it is then determined whether the offset between the instruction before the constant pool reference position in the constant pool information and the constant contained therein exceeds the offset constraint range of the instruction. Wherein, the offset between the instruction and the constant contained in the instruction can be calculated according to the determined constant pool reference position, the address of the instruction and the offset of the constant contained in the instruction in the constant pool information.
If so, the constant pool position may be determined in step S840 based on the position information of the instruction included in the constant pool information.
Specifically, a position before the currently searched instruction including the constant, which does not change the execution order of the instructions, may be selected as the constant pool position. For example, a position which is located before the currently searched instruction including the constant and is closest to the currently searched instruction including the constant without changing the execution order of the instructions is selected as the constant pool position.
If there is no position before the currently searched instruction including the constant that does not change the execution order of the instructions, before the currently searched instruction including the constant, a position may be selected to create an unconditional jump instruction, and a position after the unconditional jump instruction is used as a constant pool position to generate a constant pool. The unconditional jump instruction jumps to the first instruction after the generated constant pool.
After determining the constant pool position, a constant pool may be generated at the determined constant pool position in step S850, and the constant pool may include constants in the constant pool information that precede the constant pool position. Meanwhile, the constant pool information may be updated based on the generated constant pool, traversal may be performed again from the instruction after the position of the constant pool, and the steps S820 to S850 may be performed on the traversed instruction including the constant.
If it is assumed that a constant pool is generated at the constant pool reference position, and the offset between the instruction before the constant pool reference position in the constant pool information and the constant contained in the constant pool information does not exceed the offset constraint range of the instruction, then the traversal may be continued, and the steps S820 to S850 described above are performed on the traversed instruction including the constant.
For the detailed processing logic and implementation procedure of each step in the instruction compiling method 800, reference may be made to the related description of the instruction compiling method 400 in conjunction with fig. 1 to fig. 6, and details are not repeated here.
In summary, according to the instruction compiling scheme of the embodiment of the invention, the constant pool is generated in the compiling stage, no additional mechanism is required to be configured to solve the conflict with the jump table, and an optimization space (for example, optimization about switch-case statement) is provided for the optimization of the code density. The constant is obtained from the constant pool by using the memory reading instruction, so that sharing of part of the constant can be realized, and the code density is improved.
In addition, constant pool sharing among functions can be realized through the transfer of constant pool information, and the code density is further improved.
In particular, for smart devices such as IoT (Internet of Things) devices and AIoT (artificial intelligence Internet of Things) devices, as well as embedded systems, code density directly affects their memory size and power consumption. Those skilled in the art will appreciate that too much memory will not only impact the overall cost of the smart device/embedded system, but will also increase complexity. By adopting the instruction compiling method provided by the embodiment of the invention, the code density can be greatly improved, so that the requirement on a memory is reduced, the overall cost of the intelligent equipment/embedded system is reduced, and the complexity of the intelligent equipment/embedded system is avoided being increased. At the same time, increasing code density also helps to reduce power consumption of smart devices/embedded systems.
The technical effect of the instruction compiling scheme according to the embodiment of the present invention is described below by a specific code example.
The following is an example of a source file expressed in the C language:
wherein x-y in function func1 and x-z in function func2 are both instructions that include constants.
The intermediate file generated by compiling it by the GCC compiler is as follows:
here, the instruction "(set (reg/f: SI 2 a2) (symbol _ ref: SI (" x "))", "(set (reg/f: SI 1 a1) (symbol _ ref: SI (" y "))") is an instruction including a constant, and corresponds to "x ═ y". Instructions "(set (reg/f: SI 2 a2[211]) (symbol _ ref: SI (" x "))", "(set (reg/f: SI 1 a1[213]) (symbol _ ref: SI (" z "))") are instructions that include constants, and correspond to "x ═ z".
These four instructions require a constant pool to be generated to hold the addresses of the variables x, y, z.
The intermediate file obtained by optimizing the instruction compiling method 400/800 according to the embodiment of the present invention is as follows:
the end of the intermediate file, i.e., after the function return instruction of the function func2, generates the following constant pool in which the addresses of the variables x, y, and z are stored:
and the offset between the address of x, y and z in the constant pool and the corresponding instruction does not exceed the offset constraint range of the corresponding instruction. Also, the address of variable x in the constant pool is referenced by two functions (func1 and func2), shared.
The final output assembly file may be as follows:
.align 2
.global func1
.type func1,@function
func1:
func2:
.align 2
# constant pool
.LCP0:
Obviously, the code fragment contains only one constant pool:
.LCP0:
if the existing instruction compiling method is adopted, the output assembly file is as follows:
.global func1
.type func1,@function
func1:
.align 2
# constant pool
.LCP0:
func2:
.align 2
# constant pool
.LCP1:
.long x
.long z
.size func2,.-func2
Obviously, if the existing instruction compilation method is adopted, the functions fun1 and fun2 will generate respective constant pools. Wherein, the constant pool corresponding to the function fun1 is:
.LCP0:
the constant pool for function fun2 is:
.LCP1:
.long x
.long z
.size func2,.-func2
the code segment comprises two constant pools, and compared with the code segment output after the instruction compiling method according to the embodiment of the invention is adopted, one more constant pool is provided. Therefore, the volume of the code segment output by adopting the existing instruction compiling method is increased, the occupied storage space is increased, and the code density is correspondingly reduced. Also, the address of variable x is stored in two constant pools, not shared, which also reduces code density.
The various techniques described herein may be implemented in connection with hardware or software or, alternatively, with a combination of both. Thus, the methods and apparatus of embodiments of the present invention, or certain aspects or portions thereof, may take the form of program code (i.e., instructions) embodied in tangible media, such as removable hard drives, U.S. disks, floppy disks, CD-ROMs, or any other machine-readable storage medium, wherein, when the program is loaded into and executed by a machine, such as a computer, the machine becomes an apparatus for practicing embodiments of the invention.
In the case of program code execution on programmable computers, the computing device will generally include a processor, a storage medium readable by the processor (including volatile and non-volatile memory and/or storage elements), at least one input device, and at least one output device. Wherein the memory is configured to store program code; the processor is configured to perform the methods of embodiments of the present invention according to instructions in the program code stored in the memory.
By way of example, and not limitation, readable media may comprise readable storage media and communication media. Readable storage media store information such as computer readable instructions, data structures, program modules or other data. Communication media typically embodies computer readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media. Combinations of any of the above are also included within the scope of readable media.
In the description provided herein, algorithms and displays are not inherently related to any particular computer, virtual system, or other apparatus. Various general purpose systems may also be used with examples of embodiments of the invention. The required structure for constructing such a system will be apparent from the description above. In addition, embodiments of the present invention are not directed to any particular programming language. It is appreciated that a variety of programming languages may be used to implement the teachings of embodiments of the present invention as described herein, and any descriptions of specific languages are provided above to disclose the best modes of embodiments of the invention.
In the description provided herein, numerous specific details are set forth. It is understood, however, that embodiments of the invention may be practiced without these specific details. In some instances, well-known methods, structures and techniques have not been shown in detail in order not to obscure an understanding of this description.
Similarly, it should be appreciated that in the foregoing description of exemplary embodiments of the invention, various features of the embodiments of the invention are sometimes grouped together in a single embodiment, figure, or description thereof for the purpose of streamlining the disclosure and aiding in the understanding of one or more of the various inventive aspects. However, the disclosed method should not be interpreted as reflecting an intention that: that is, the claimed embodiments of the invention require more features than are expressly recited in each claim. Rather, as the following claims reflect, inventive aspects lie in less than all features of a single foregoing disclosed embodiment. Thus, the claims following the detailed description are hereby expressly incorporated into this detailed description, with each claim standing on its own as a separate embodiment of an embodiment of this invention.
Those skilled in the art will appreciate that the modules or units or components of the devices in the examples disclosed herein may be arranged in a device as described in this embodiment or alternatively may be located in one or more devices different from the devices in this example. The modules in the foregoing examples may be combined into one module or may be further divided into multiple sub-modules.
Those skilled in the art will appreciate that the modules in the device in an embodiment may be adaptively changed and disposed in one or more devices different from the embodiment. The modules or units or components of the embodiments may be combined into one module or unit or component, and furthermore they may be divided into a plurality of sub-modules or sub-units or sub-components. All of the features disclosed in this specification (including any accompanying claims, abstract and drawings), and all of the processes or elements of any method or apparatus so disclosed, may be combined in any combination, except combinations where at least some of such features and/or processes or elements are mutually exclusive. Each feature disclosed in this specification (including any accompanying claims, abstract and drawings) may be replaced by alternative features serving the same, equivalent or similar purpose, unless expressly stated otherwise.
Furthermore, those skilled in the art will appreciate that while some embodiments described herein include some features included in other embodiments, rather than other features, combinations of features of different embodiments are meant to be within the scope of and form different embodiments of the invention. For example, in the following claims, any of the claimed embodiments may be used in any combination.
Furthermore, some of the above embodiments are described herein as a method or combination of elements of a method that can be performed by a processor of a computer system or by other means for performing the functions described above. A processor having the necessary instructions for carrying out the method or method elements described above thus forms a means for carrying out the method or method elements. Furthermore, the elements of the apparatus embodiments described herein are examples of the following apparatus: the apparatus is used to implement the functions performed by the elements for the purpose of carrying out the invention.
As used herein, unless otherwise specified the use of the ordinal adjectives "first", "second", "third", etc., to describe a common object, merely indicate that different instances of like objects are being referred to, and are not intended to imply that the objects so described must be in a given sequence, either temporally, spatially, in ranking, or in any other manner.
While embodiments of the invention have been described with respect to a limited number of embodiments, those skilled in the art, having benefit of this description, will appreciate that other embodiments can be devised which do not depart from the scope of the embodiments of the invention as described herein. Furthermore, it should be noted that the language used in the specification has been principally selected for readability and instructional purposes, and may not have been selected to delineate or circumscribe the inventive embodiments. Accordingly, many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the appended claims. The present embodiments are disclosed by way of illustration and not limitation, the scope of embodiments of the invention being defined by the appended claims.
Claims (22)
1. An instruction compilation method comprising:
traversing a compiled object containing a plurality of instructions to find an instruction containing a constant in the compiled object;
updating constant pool information according to the searched instruction and the constants contained in the searched instruction, wherein the constant pool information at least comprises each searched instruction and the constants contained in the searched instruction;
determining the position of the constant pool in the compiled object according to the position information of the instruction in the constant pool information; and
generating a constant pool at the determined constant pool position, the constant pool comprising one or more constants in the constant pool information.
2. The method of claim 1, wherein determining the constant pool location in the compiled object based on location information of instructions in the constant pool information comprises:
and selecting a position which does not change the execution sequence of the instructions as the constant pool position.
3. The method of claim 2, wherein the locations that do not change the order of execution of the instructions comprise at least one of: the object returns to a location after the instruction, a location after the unconditional jump instruction.
4. The method of claim 1, wherein determining a constant pool location in the compiled object based on location information of instructions in the constant pool information further comprises:
creating an unconditional jump instruction;
and taking the position after the unconditional jump instruction as the position of the constant pool to generate the constant pool, wherein the unconditional jump instruction jumps to the first instruction after the constant pool.
5. The method of any of claims 1-4, further comprising:
after generating a constant pool at the determined constant pool position, updating the constant pool information based on constants contained in the constant pool.
6. The method of any of claims 1-5, wherein the constant pool includes constants contained by instructions preceding the constant pool position.
7. The method of any of claims 1-5, wherein the constant pool includes constants contained by instructions preceding and following the constant pool position.
8. The method of claim 6 or 7, wherein none of the offsets between a constant in the constant pool and an instruction that includes the constant exceed an offset constraint range of an instruction that includes the constant.
9. The method according to any one of claims 1 to 8, wherein the method is performed during the compilation of each compiled object, and when the compilation of one compiled object is finished, the constant pool information corresponding to the compiled object is used as the constant pool information of the next compiled object.
10. The method of any of claims 1-9, wherein the compiled object is a function.
11. The method of any of claims 1-10, further comprising:
and under the condition that the constant pool information is not empty, repeating the steps of determining the constant pool position in the compiled object and generating the constant pool at the determined constant pool position.
12. An instruction compiling apparatus comprising:
the instruction traversing module is suitable for traversing a compiled object containing a plurality of instructions so as to search the compiled object for the instructions comprising the constants;
the constant pool updating module is suitable for updating constant pool information according to the searched instructions and constants contained in the searched instructions, and the constant pool information at least comprises each searched instruction and the constants contained in the searched instruction;
the position determining module is suitable for determining the position of the constant pool in the compiled object according to the position information of the instruction in the constant pool information; and
a constant pool generating module adapted to generate a constant pool at the determined constant pool position, the constant pool including one or more constants in the constant pool information.
13. The apparatus of claim 12, wherein the position determination module is adapted to select a position that does not change instruction execution order as the constant pool position.
14. The apparatus of claim 12, wherein the location determination module is adapted to create an unconditional jump instruction; and taking the position after the unconditional jump instruction as the position of the constant pool to generate the constant pool, wherein the unconditional jump instruction jumps to the first instruction after the constant pool.
15. The apparatus of any of claims 12-14, wherein the constant pool update module is further adapted to update the constant pool information based on constants contained in the constant pool after the constant pool is generated at the determined constant pool location.
16. The apparatus according to any of claims 12-15, said apparatus being adapted to compile each compiled object, wherein when compiling one compiled object is finished, the constant pool information corresponding to the compiled object is used as the constant pool information of the next compiled object.
17. The apparatus of any of claims 12-16, wherein the compiled object is a function.
18. The apparatus according to any of claims 12-17, wherein the position determining module is further adapted to repeat the step of determining the constant pool position in the compiled object if the constant pool information is not empty, and the constant pool generating module is further adapted to repeat the step of generating the constant pool at the determined constant pool position.
19. A compiler, comprising:
a compilation unit adapted to convert a source file into an intermediate file, the intermediate file comprising a plurality of compiled objects; optimizing the intermediate file; converting the optimized intermediate file into an assembly file; wherein
The compilation unit further comprises an instruction compilation device according to claim 11, the instruction compilation device being adapted to generate a constant pool for instructions comprising constants in the compiled object to optimize the intermediate file.
20. The compiler of claim 19, further comprising:
an assembly unit adapted to convert the assembly file into a binary file;
and a link unit which merges the plurality of binary files into a program.
21. A computing device, comprising:
one or more processors;
a memory; and
one or more programs, wherein the one or more programs are stored in the memory and configured to be executed by the one or more processors, the one or more programs comprising instructions for performing any of the methods of claims 1-11.
22. A computer readable storage medium storing one or more programs, the one or more programs comprising instructions, which when executed by a computing device, cause the computing device to perform any of the methods of claims 1-11.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910931185.0A CN112579091A (en) | 2019-09-29 | 2019-09-29 | Instruction compiling method and device, compiler and computing equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910931185.0A CN112579091A (en) | 2019-09-29 | 2019-09-29 | Instruction compiling method and device, compiler and computing equipment |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN112579091A true CN112579091A (en) | 2021-03-30 |
Family
ID=75110570
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910931185.0A Pending CN112579091A (en) | 2019-09-29 | 2019-09-29 | Instruction compiling method and device, compiler and computing equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112579091A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114237612A (en) * | 2021-12-03 | 2022-03-25 | 龙芯中科技术股份有限公司 | Program code compiling method, program code compiling device, electronic equipment and storage medium |
-
2019
- 2019-09-29 CN CN201910931185.0A patent/CN112579091A/en active Pending
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114237612A (en) * | 2021-12-03 | 2022-03-25 | 龙芯中科技术股份有限公司 | Program code compiling method, program code compiling device, electronic equipment and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| KR101731742B1 (en) | Combined branch target and predicate prediction | |
| Goossens et al. | Embedded software in real-time signal processing systems: Design technologies | |
| JP3896087B2 (en) | Compiler device and compiling method | |
| US8561040B2 (en) | One-pass compilation of virtual instructions | |
| US5778212A (en) | Interprocedural analysis user interface | |
| US7823139B2 (en) | Method and system for translating programming languages | |
| US8250551B2 (en) | Refining tail call optimizations at link-time | |
| WO2007016808A1 (en) | A compiling and translating method and apparatus | |
| CN114816417B (en) | Cross compiling method, device, computing equipment and storage medium | |
| CN114721720B (en) | Instruction set extension method and device, electronic equipment and storage medium | |
| JP2007094731A (en) | Compiler apparatus | |
| US11599478B2 (en) | Reduced instructions to generate global variable addresses | |
| KR20170014613A (en) | Electronic Device, Compilation Method, and Computer Readable Recording Medium | |
| CN114924810A (en) | Heterogeneous program execution method and device, computing device and readable storage medium | |
| US8539458B2 (en) | Transforming addressing alignment during code generation | |
| Araujo et al. | Challenges in code generation for embedded processors | |
| JP2006107338A (en) | Program processor | |
| CN112579091A (en) | Instruction compiling method and device, compiler and computing equipment | |
| Sias et al. | Enhancing loop buffering of media and telecommunications applications using low-overhead predication | |
| JP4768984B2 (en) | Compiling method, compiling program, and compiling device | |
| KR20160070965A (en) | Compiler | |
| US20080104372A1 (en) | Method, apparatus and computer program for executing a program | |
| CN114385180A (en) | Data processing method, device and equipment and computer storage medium | |
| US20120089823A1 (en) | Processing apparatus, compiling apparatus, and dynamic conditional branch processing method | |
| JPH11242599A (en) | Computer program |
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 |