JPH05224944A - Alignment matching method - Google Patents

Abstract

PURPOSE:To diagnose a fact that an alignment exception is generated, and to automatically avoid it by setting an exception avoiding code to a generated part by detecting a part in which a model conversion is performed by a data reference executed by a pointer. CONSTITUTION:When an alignment control part 1 recognizes a source code, a model conversion detecting means 2 executes a collection of model converting information for specifying a model conversion performing part of a pointer on the source code (S1). Thereafter, an alignment determining means 3 recognizes collected model converting information (S2), and determines a pair of alignments (S3). An alignment relation deciding means 4 decides whether an alignment exception is generated or not from a relation of the alignment determined by the alignment determining means 3 (S4). In the case where the alignment exception is generated, it is outputted by using a display and a printer, etc.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an alignment matching method capable of avoiding the occurrence of an alignment exception due to type conversion described in source code when compiling the source code into object code.

[0002]

2. Description of the Related Art In a computer, in order to realize high-speed processing, there is a constraint that data must be arranged at a specific boundary (area) according to the data type (data length). There is something. Such a constraint is called an alignment constraint.

For example, integer type data of one word length (32 bits) has a half word length (1
Data of 6-bit integer type data is arranged on a half-word boundary (16-bit data area). As for the data arrangement, when the compiler translates the source code, the boundary is determined according to the type of data referred to in the source code, and the data is arranged at the boundary that does not violate the alignment constraint.

Now, in a source code written in a high-level programming language that has a pointer type such as C language and allows type conversion between pointers, the data referred to by the pointer tries to reference. Then, it is not always arranged on the boundary according to the type of data (variable). That is, it is assumed that a variable declared for data on a half word boundary refers to data on a word boundary in addition to referring to data on a half word boundary by a pointer. If you refer to data with different boundaries, an alignment exception will occur.

FIG. 2 shows a first explanatory diagram related to the alignment exception. In the source code shown in the figure, the variables i and * ip are arranged on word boundaries, and the array C is arranged on byte boundaries. However, in line L1, since the address of the character array C is assigned to the integer pointer ip, the integer data referred to by the pointer ip is arranged at the byte boundary instead of the word boundary. Become. After that, if the integer type data assigned by the pointer ip in the line L2 is treated as being on a word boundary, an alignment exception occurs. That is, when the line L2 is executed, an alignment exception will occur.

In general, in order to avoid the occurrence of such an alignment exception, the coding for aligning the alignment is performed on the source code. FIG. 3 shows a second explanatory diagram related to the alignment exception. As shown in the figure, prepare a work variable w and
In 3, the value to be assigned to the variable * ip is assigned to the variable w. After that, in line L4, the data of one word length is copied from the address indicated by the variable w to the address indicated by the pointer ip.

Now, a specific description of the copying described with reference to FIG. 3 will be given with reference to FIGS. 4 and 5. FIG. 4 is an explanatory diagram related to an alignment exception when referring to data. For example, the object code corresponding to the source code that refers to the data by the pointer p requires only one instruction. However, in order to avoid an alignment exception, when referencing a value via a work variable, data is copied to the work variable in byte units, and a series of processes such as reference to the work variable are performed. The above requires 9 instructions.

FIG. 5 is an explanatory diagram related to an alignment exception at the time of storing data. Similar to FIG. 4, the object code corresponding to the source code for storing the data by the pointer p needs only one instruction. However, in order to avoid the alignment exception, the value to be stored is assigned to the work variable, and then the data is copied in bytes from the work variable to the address pointed to by pointer p. Then 9 instructions are required.

[0009]

Now, in order to find a data reference point that is an alignment exception, a method of visually tracing the source code, a method of detecting a point of abnormal execution by actually executing it, or the like is used. Is taken.
In the case of a method such as tracing or actually executing it, a great amount of time is spent, and there is a problem that it is extremely difficult to completely avoid omission of discovery. Further, when the compiler sets the avoidance code for avoiding the alignment exception for all pointer references on the source code, there is a problem that the execution efficiency is significantly reduced due to the increase in the number of instructions. The present invention has been made paying attention to the above points, and it is possible to detect a location where an alignment exception occurs without tracing or execution, and to set the avoidance code to avoid the alignment exception. It is an object of the present invention to provide an alignment matching method that can be minimized.

[0010]

According to the alignment matching method of the present invention, when compiling a source code into an object code, basic data having a predetermined alignment and modified data having another alignment are set. When there is an instruction for performing a type conversion between the two, the pair of pointers that point to the position of each of the data is detected, and one of the pointers that points to the basic data causes the alignment of the basic data and the modified data. The other pointer that points to recognizing the alignment of the modified data and diagnosing that the alignment exception occurs due to the type conversion when the alignments of the two are different. Further, the compiler recognizes a compiler directive included in the source code for specifying the location where the alignment exception occurs, sets an exception avoidance code at the location where the alignment exception occurs, and automatically avoids the occurrence of the alignment exception.

[0011]

According to this method, the location where the type conversion is performed by referring to the data by the pointer is detected, and in the case of the type conversion in which the alignment is different, it is diagnosed that an alignment exception due to the type conversion occurs. Also, the compiler directive for identifying the location of the alignment exception on the source code is recognized, and the exception avoidance code is set at the location identified by the compiler directive to automatically avoid the occurrence of the alignment exception.

[0012]

DESCRIPTION OF THE PREFERRED EMBODIMENTS FIG. 1 shows a conceptual diagram of a compiler according to the present invention. In order to implement the present invention, the compiler is provided with the alignment control unit 1. The alignment control unit 1 is provided with a type conversion detecting unit 2, an alignment determining unit 3, and an alignment relationship determining unit 4.

The type conversion detector 2 retrieves pointer type conversion information from the source code and stores the position. The alignment determining means 3 includes the type conversion detecting section 2
To determine the alignment of the type conversion information stored by. The alignment relationship determination means 4 determines whether or not the pair of alignments determined by the alignment determination means 3 causes an alignment exception.

When the alignment control section 1 recognizes the source code, the type conversion detecting means 2 collects the type conversion information for specifying the type conversion execution point of the pointer on the source code (step S1). Then, the alignment determination means 3 recognizes the collected type conversion information (step S2), and determines a pair of alignment (step S3).

The alignment relationship determining means 4 determines whether or not an alignment exception occurs based on the alignment relationship determined by the alignment determining means 3.
Alignment restrictions tend to become looser in the order of word boundaries, half-word boundaries, and byte boundaries. Therefore, due to this regulatory relationship, in the case of data reference to a more restrictive one, it is determined that an alignment exception will occur, and the process proceeds to step S5.

In step S5, a report in which the type conversion execution point to be determined is the location of the alignment exception on the source code is output using a display, a printer or the like (not shown). After that, the alignment control unit 1
Determines whether or not there is any other type conversion information detected by the type conversion detection means 2 (step S6). If the result is YES, the process proceeds to step S2, and if the result is NO, the process is terminated. .. If it is determined in step S4 that the alignment exception does not occur, the process proceeds to step S6.

The present invention will now be described in detail with reference to the drawings starting from FIG. FIG. 6 is a conceptual diagram of the source code. In the source code shown in the figure, line L5
The type conversion of the pointer occurs along with the execution of L9. These lines are collected by the type conversion detecting means 2 and the alignment is determined by the alignment determining means.

Line L5 is a process for substituting the pointer q1 at the half word boundary into the pointer p1 which is referred to as the word boundary. Line L6 is a process of substituting the pointer p1 of the word boundary for the pointer q1 which is referred to as the half word boundary. Row L7
Is a half-word boundary pointer q2 and a word boundary pointer P2
Is the process of substituting into.

Line L8 is a process for substituting a structure containing a member of a half word boundary into a structure containing a member of a word boundary. Line L9 is a process of substituting a structure including a member of a word boundary into a structure including a member of a half word boundary.

The operation of the alignment relation determining means 4 for each row having the above configuration will be described with reference to FIG. FIG. 7 is a process explanatory diagram according to the present invention. When the type conversion detecting unit 2 collects the type conversion information 71, the alignment determining unit 3 determines the alignment 72 based on the declaration part of each pointer.

The alignment relation judging means 4 analyzes the correlation of the alignment determined by the alignment determining means 3, that is, the degree of regulation, judges the presence / absence 73 of the alignment exception, and reports the judgment result. Become. When determining the alignment of the structure, the alignment determining means 3 adopts the alignment of the member having the strongest regulation as the alignment of the structure. With the above procedure, the presence or absence of an alignment exception is analyzed at the pointer type conversion location.

Next, a second embodiment of the present invention will be described. FIG. 8 is a first source code example according to the second embodiment of the present invention. In order to realize the second embodiment, the source code includes in advance a compiler directive for notifying the compiler of the location where the alignment exception occurs. The compiler directive starts with "#pragma" (line L10), and in this case, indicates the corresponding instruction for the pointer p.

In this case, since the type conversion relating to the pointer p is performed in the line L11, the compiler directive is activated for this line L11. Specifically, the object code (exception avoidance code for avoiding an alignment exception) for fetching data in units of bytes described above with reference to FIG. 5 is generated for the line L11.

The compiler directive can be specified not only for a local identifier but also for a wide area, for example, for a structure. FIG. 9 shows a second source code example according to the second embodiment of the present invention. In the figure. Line L13
Is a compiler directive for the type definition (line L14), and line 15 is a compiler directive for the tag name (structure of line L16). Also, line L17 is an example description of an architecture that employs half-word length alignment.

FIG. 10 shows a conceptual diagram of a compiler according to the second embodiment of the present invention. The syntactic and semantic analysis unit 11 analyzes the source code SC and recognizes the compiler directive.
When the syntactic and semantic analysis unit 11 recognizes the compiler directive,
Recognize the access type. This access type is, for example, in the case of byte access to the pointer p shown in FIG.
The symbol table 12 including the access type 12a, the symbol 12b, and the position 12c is generated.

When the processing by the syntactic and semantic analysis unit 11 is completed, the intermediate word generation unit 13 is activated, and the intermediate word 1 in which the exception avoidance code is set for the portion designated by the symbol table 12.
4 is generated. The exception avoidance code is added with the information of the instruction 14a indicating the purpose of setting and the symbol 14b for specifying the target. Finally, in the code generator 15, the intermediate language 14 is the object code O.
Converted to C.

By executing the object code OC, the byte unit is taken out (stored) at the location where the compiler is specified in the source code. According to the second embodiment described above, the exception avoidance code can be automatically set at a desired location.

[0028]

According to the alignment matching method of the present invention, it is possible to accurately grasp only the place where the alignment exception occurs without tracing or executing the source code, and to reduce the work man-hour. Since the number of places where the exception avoidance code is set can be kept to a necessary minimum, it is possible to avoid a decrease in operation efficiency due to an increase in the number of instructions.

[Brief description of drawings]

FIG. 1 is a conceptual diagram of a compiler according to the present invention.

FIG. 2 is a first explanatory diagram related to an alignment exception.

FIG. 3 is a second explanatory diagram related to an alignment exception.

FIG. 4 is an explanatory diagram related to an alignment exception when referring to data.

FIG. 5 is an explanatory diagram related to an alignment exception when storing data.

FIG. 6 is a conceptual diagram of source code.

FIG. 7 is an explanatory diagram of processing according to the present invention.

FIG. 8 is a first source code example according to the second embodiment of the present invention.

FIG. 9 is a second source code example according to the second embodiment of the present invention.

FIG. 10 is a conceptual diagram of a compiler according to a second embodiment of the present invention.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 Alignment control unit 2 Type conversion detection means 3 Alignment determination means 4 Alignment relationship determination means

Claims (2)

[Claims] 1. When compiling source code into object code, there are instructions for performing type conversion between basic data having a predetermined alignment and transformation data having another alignment. In this case, a pair of pointers pointing to the position of each of the data is detected, the one pointer pointing to the basic data causes the alignment of the basic data, and the other pointer pointing to the modified data causes the alignment of the modified data. Is recognized, and if the alignments of the two are different, it is diagnosed that the alignment exception due to the type conversion occurs. 2. A compiler is included in the source code, recognizes a compiler directive for identifying a location where an alignment exception occurs, sets an exception avoidance code at the location, and automatically generates the alignment exception. The alignment matching method according to claim 1, wherein the alignment matching method is avoided.