JP2795309B2 - Code addition method for profiler - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a profiler code addition method, and more particularly to a method of adding a profiler code to a shared object referred to by a dynamically linked executable program (hereinafter referred to as a "dynamic link executable program"). It relates to a method for adding a profiler code. The profiler is a program for analyzing the performance of an execution object.

[0002]

2. Description of the Related Art Conventionally, in order to collect performance data of an executable program generated by a C compiler or the like, a profiler executable program obtained by adding a profiler code to an original executable program is executed as follows. Had been

(1) From the text of an executable program, the program is divided into blocks that can be entered only from the beginning and can be exited only from the end, and output an equivalent program including an instruction for counting the execution of each block. I do.

(2) When the executable program is dynamically linked, when the created profiler executable program is executed and jumps into a shared object referenced by the original executable program, the return address is stored and the return is performed. So that the process after it arrives can be continued.

(3) In addition to the above, when another function of the executable program is called before jumping into the shared object and returning, so that all functions of the executable program can be measured. Also jump into the new text being created.

The prior art is disclosed in JP-A-64-3
There is a “program trace method” disclosed in Japanese Patent No. 5637. This method converts the code of an object program itself, embeds an interrupt instruction for a monitor call, and traces a program when an interrupt occurs, thereby enabling performance measurement only with the object program of the program to be measured.

[0007]

In the above-described conventional method, the performance data can be analyzed even if the target executable program is statically linked or dynamically linked. In this case, there is a problem that the performance data for the shared object cannot be analyzed because the profiler code is not added to the shared object referred to by the profiler.

In the "program trace method" disclosed in Japanese Patent Application Laid-Open No. 64-35637, a program trace method capable of measuring the performance only by preparing an object is provided. The problem is similar to that of the present invention. However, in order to embed an interrupt instruction of a monitor call only for an object whose performance is to be measured, if an object to be generated is dynamically linked, the object refers to the object. There has been a problem that a program trace cannot be performed on a shared object when an interrupt occurs.

In view of the above, it is an object of the present invention to obtain information on a shared object referred to by an object generated by a general compiler by dynamic link, and execute a shared object executed based on the information. It is another object of the present invention to provide a profiler code addition method that adds a profiler code for recording data indicating an operation of an object, and makes it easier to analyze and improve the execution performance of an executable program.

[0010]

According to the profiler code addition method of the present invention, a shared object name referred to by a dynamic link executable program is extracted from dynamic link information held by the dynamic link executable program, and is extracted. A shared object input means for inputting a target shared object, a function prologue of the shared object, a virtual address on a text section existing in a data section,
Relocation information extracting means for extracting relocation information from an instruction code for obtaining a text address with reference to GOT and a GOT to create a relocation information table;
A profiler shared object generating means for generating a profiler shared object having the same function as the shared object and adding a profiler code, and updating necessary instruction code or data content by referring to the relocation information table; Having.

[0011]

Next, the present invention will be described in detail with reference to the drawings.

[0012]

FIG. 1 is a block diagram showing the configuration of a profiler code addition system according to an embodiment of the present invention. The method for adding a profiler code according to the present embodiment includes a shared object 1 and a dynamic link executable program 2.
, A shared object input means 3, a relocation information extracting means 4, a relocation information table 5, a profiler shared object generating means 6, and a profiler shared object program 7.

In the dynamic link system which is a premise of the present invention, a text address at the time of execution can be represented by a relative value from an address of a global offset table (hereinafter abbreviated as GOT). Also, a function address, which is a fixed value determined when the shared object 1 or the dynamic link executable program 2 is created, and GOT
The GOT address at the time of execution is calculated by adding the relative value to the address and the address to which the function is actually allocated at the beginning of each function of the shared object 1 or the dynamic link executable program 2 at the time of execution. , A global pointer gp to which the value is set. Therefore, the global pointer gp is
It has a unique value within shared object 1 and has an address that is the starting point of shared object 1. The GOT address is used as the starting point of the shared object 1 because the shared object 1 has a characteristic that the instruction code is position-independent and is loaded with an address that may change for each process. The presence information such as functions in the shared object 1 is GOT
The reason for this is that inconsistencies do not occur in function access at the time of execution, and this contributes to improvement in the access efficiency of functions.

In the dynamic link system which is a premise of the present invention, the GOT has an absolute virtual address. The absolute virtual address means that when the dynamic link executable program 2 is executed, a segment on the file of the dynamic link executable program 2 is logically copied to a segment on the virtual memory, but the process is executed normally. And the address at which the segment must be allocated when the program is created. From this absolute virtual address, a text address at the time of execution can be uniquely represented by a relative value to the text address before copying. The GOT address is obtained by adding the text address of the function in the function prologue in the instruction description section (text section) and the relative value to the GOT defined by the instruction code of the function prologue. It has a unique value in the target shared object 1 or the target dynamic link executable program 2. That value also becomes the value of the global pointer gp.

FIG. 2 is a diagram showing the relocation information extracting means 4 in detail. Relocation information extraction means 4
Is composed of a function prologue detection section 41, a data text address detection section 42, and a GOT reference text address detection section 43.

Referring to FIG. 3, shared object 1
Is an object header that mainly collects information for interpreting an object file, a segment, a program header that collects information necessary for the system to load an execution program, a text section, a dynamic section, a symbol table, and the like. , A data segment including a data section, GOT, and the like, and a section information header table. The instruction description section of the text section includes a function prologue and a GOT reference instruction code. In some cases, the data section includes a data section in which the virtual address itself in the text section is data. For example, exceptionally, there is a program that writes the address of a static function to the initial value, and when compiling such a program to generate an executable program, the virtual address itself is automatically written in the data section. is there.

Referring to FIG. 4, the GOT has, as part of a data segment, several entries whose contents are all absolute virtual addresses. Since the instruction code of the shared object 1 is a position-independent instruction code that cannot include an absolute virtual address, the GOT having the absolute virtual address breaks the sharing between the position-independent instruction code and the runtime program text. No addressing is possible. This GOT includes two logical entries, and the first half of the GOT is a local entry and the second half is an external entry. They are all composed of absolute virtual addresses. The local entry includes a special function entry address and a base address (start address of a text segment) in the target object, and is used for relocation when the base address of the shared object 1 is different from its default base address. Shall be. The external entry contains the absolute virtual address of a symbol that is not defined in the target object. The GOT reference is a reference with offset of the global pointer gp using a local entry.

Referring to FIG. 5, the dynamic link executable program 2 includes an object header, a program header, a text segment including a text section and a dynamic section, a data segment including a data section and a GOT, and section information. And a header table. The dynamic section includes dynamic link information in which a shared object name is described.

Referring to FIG. 6, the relocation information table 5 includes type, address, and info.
A plurality of pieces of relocation information consisting of a “mation” are stored. There are three types of function prologue, virtual address and GOT reference. Further, the meaning indicated by information changes depending on the type of type. That is, if type is a function prologue,
information is the value of the global pointer gp−
In the case of a function address (address) or a virtual address, the contents of the area on the data section indicated by the corresponding address, that is, the virtual address itself, and in the case of GOT reference, the target text address indicated by the instruction code with GOT reference Respectively.

Referring to FIG. 7, the profiler shared object 7 includes an object header, a program header, a text segment including a text section, a dynamic section, etc., a data section, and a G section.
The data segment includes an OT and other data segments, a new text segment including a profiler code addition text section, a map table, and the like, and a section information header table. The new instruction description section of the new text section (profiler code addition text section) includes a profiler code (call count), a function prolog including an updated part, and a GOT reference instruction code including an updated part. It is. Also,
The data section includes an updated portion of the virtual address in the text section. Further, a profiler text address corresponding to each instruction code of the original text section is written in the map table for each word.

FIG. 8 is a diagram showing the contents of the symbol table which is always present in the text segment of the shared object 1. The symbol table stores a plurality of pieces of symbol information including Index, symbol value, size, type, attribute, existing section, and name. For a symbol whose symbol type is that of a function and exists in the text section, the symbol value held by each becomes the function entry address for each function.

Referring to FIG. 9, the processing of the shared object input means 3 includes a dynamic link executable program input step S31, a shared object reference determination step S32, and a shared object name extraction step S3.
3, a shared object open step S34, and a shared object open completion determination step S35.

Referring to FIG. 10, the processing of the relocation information extracting means 4 includes a shared object extraction completion determining step S44, a shared object symbol table reading step S45, a function and text section symbol determining step S46, and a relocation information table. , Writing symbol information next NULL determination step S48, shared object data segment reading step S49, text section virtual address determination step S4a, and relocation information table writing preparation step S4b.
Read data next NULL determination step S4c, and shared object text section read step S4
d, instruction code GOT reference determination step S4e, and relocation information table writing preparation step S4f.
And read instruction code next NULL determination step S4g
And relocation information table writing processing step S
4h and an extracted shared object number increment step S4i.

Referring to FIG. 11, the processing of the profiler shared object generation means 6 includes a generation profiler shared object number determination step S61, a shared object text section reading step S62, a minimum block head determination step S63, an original instruction Code memory writing step S64, profiler code addition / original instruction code memory writing step S65, relocation information table reading step S66, and corresponding instruction code and data section updating step S67
Reading relocation information next NULL determination step S68, writing the memory contents to the profiler code addition text section S69, copying the shared object structure to the profiler shared object S6a, and incrementing the generated profiler shared object number S6b.

Next, the operation of the profiler code addition system of the embodiment constructed as described above will be described.

First, the shared object input means 3 inputs the dynamic link executable program 2 whose performance is to be measured on a command line (step S3).
1) It is verified whether or not the dynamic link executable program 2 refers to the shared object 1 based on whether or not there is a dynamic section containing dynamic link information in the input dynamic link executable program 2 ( Step S32). If the dynamic link executable program 2 does not refer to the shared object 1, the shared object input means 3 immediately terminates the processing. If the dynamic link executable program 2 refers to the shared object 1, the shared object input means 3 extracts all the shared object names from the dynamic link information in the dynamic section (step S33), and changes the shared object name. Each extracted shared object 1
Is opened (step S34). Subsequently, the shared object input unit 3 compares the number of the opened shared objects 1 with the number of the extracted shared objects 1 (step S35).
If the number of shared objects 1 is smaller than the number of extracted shared objects 1, control is returned to step S34 to open the next shared object 1, and if the number of opened shared objects 1 is equal to or greater than the number of extracted shared objects 1, After the processing is completed, control is passed to the relocation information extracting means 4.

Next, the relocation information extracting means 4
As long as the number of shared objects 1 used for extracting the relocation information is smaller than the number of opened shared objects 1 obtained by the shared object input means 3, it is determined that the processes of steps S45 to S4i are repeatedly performed. (Step S44).

First, the function prologue detection unit 41 reads a symbol table included in the input shared object 1 one symbol information at a time (step S4).
5) For the read symbol information, the type is a function "F
It is checked whether or not the symbol is “UNC” and the existing section is a text section (step S 46). Only the symbol information that satisfies this condition is written in the relocation information table 5. 41 stores the symbol information in the memory so that the symbol information can be collectively written to the relocation information table 5 before the next shared object 1 is input (step S47). It is checked whether all the symbol information has been read (step S4).
8) If still remaining, steps S45 to S48
Are repeated, and when the processing is completed, the control is transferred to the data text address detecting section 42.

The data text address detection unit 42
Before reading the data of the data section in the data segment of the shared object 1, the minimum address and the maximum address of the text section of the shared object 1 are stored. Next, the data text address detection unit 42 reads the data section one word at a time (step S49), and the content is larger than the stored minimum address and smaller than the stored maximum address, that is, the virtual address on the text section. Are detected (yes in step S4a), and only the data that satisfies the condition is stored in the relocation information table 5.
(Step S4)
b). Further, the data text address detection unit 42
In order to update the corresponding data segment area, it is necessary to store the location where the corresponding text address is stored, and record the corresponding virtual address on the data segment. This is because the profiler shared object 7 executes the text in the new text segment, not the text segment. Subsequently, the data text address detection unit 42 checks whether or not all the data in the data segment has been read (step S4c).
49 to 4c are repeatedly performed.
The control is transferred to the OT reference text address detection unit 43.

GOT reference text address detector 43
Reads the text section in the text segment of the input shared object 1 one instruction code at a time from the beginning (step S4d). Next, the GOT reference text address detection unit 43 extracts an instruction code having an instruction operand corresponding to the GOT reference from the instruction codes read one by one (Step S4).
e) When the offset value, which is the instruction operand, matches the GOT address, the program counter at the time of GOT reference, the target text address obtained by GOT reference, and the difference between the value and the GOT address are recorded. .

An instruction code having an instruction operand corresponding to the GOT reference has only the following patterns. However,
x and y represent registers, and zzz and uuu represent arbitrary offsets, respectively.

Lw x, -0xzzz (gp) nop addiy, x, 0xuuu

GOT reference text address detector 43
Detects all that satisfy the conditions of the above instruction patterns. Among them, the G of the detected instruction pattern
Only those whose contents of the offset when referring to the OT (here, the value stored in the x register) matches the GOT address are detected, and the program counter (text address) at that time and the target text obtained by the GOT reference Since the address (here, pointing to the value in the y register) and the target text address obtained above are present in the text section of the text segment, the target text address of the profiler shared object 7 is Since it is necessary to convert the corresponding new text segment into a text address in the profiler code addition text section, the difference between the target text address and the GOT address is recorded in the memory (step S4f).

Subsequently, the GOT reference text address detecting section 43 checks whether or not the data in the text section, that is, all the instruction codes have been read (step S4g), and if there are any remaining, the steps S4d to S4g. Are repeated, and when the process is completed, the process proceeds to step S4h.

Next, the relocation information extracting means 4
Function prologue detection unit 41, data text address detection unit 42, and GOT reference text address detection unit 4
3, the relocation information stored in the memory is written into the relocation information table 5 for updating the target address after the addition of the profiler code (step S4h), and the number of shared objects 1 used for extracting the relocation information is determined. The control is incremented by one (step S4i), and the control returns to step S44.
When the number of shared objects 1 extracted in step S44 becomes equal to or greater than the number of referenced shared objects 1, control is transferred to the profiler shared object generation means 6.

The profiler shared object generating means 6 first repeats the processing of steps S62 to S6b as long as the number of generated profiler shared objects 7 is smaller than the number of all referenced shared objects 1. It is determined (step S61).

Next, the profiler shared object generating means 6 reads the text section contained in the input shared object 1 one instruction code at a time (step S62). At this time, how many instruction codes increase when adding a profiler code is calculated for each instruction code.

Subsequently, the profiler shared object generating means 6 checks whether the read one instruction code is at the head of the smallest block which can be entered only from the beginning and can be escaped only from the end (step). S63) Otherwise, the original instruction code is written into the memory to copy it as it is as the instruction code in the new text segment in the shared object 7 for profiler (step S64). Prior to this, a series of instruction codes to which the profiler code has been added are written into the memory, and the original instruction code is directly used as the profiler shared object 7.
Is written to the memory to be copied as an instruction code in a new text segment in (step S65).

Next, the profiler shared object generating means 6 reads all the relocation information contained in the relocation information table 5 obtained by the relocation information extracting means 4 (step S66), and if the corresponding relocation information exists. The content is updated as necessary for that portion (step S6).
7).

More specifically, if the relocation information read from the relocation information table 5 is a function prologue, the profiler shared object generation means 6 refers to the profiler shared object 7 without any inconsistencies, that is, the source of each function call. In order to show the same operation as that of the shared object 1 of the profiler, the function prologue of the profiled shared object 7 is converted into a function entry of the profiler code corresponding to the function entry address of the shared object 1 detected by the function prologue detection unit 41. The GOT address of the profiler code is calculated from the relative value between the address and the GOT of the profiler code, and the value is used as an instruction code for setting the global pointer gp.

When the profiler shared object 7 is executed, the instruction code in the text section of the new text segment is executed instead of the text segment. Therefore, the profiler code addition text corresponding to the original function prologue is executed. It is necessary to absorb the difference in addresses generated when generating the function prologue in the section. Therefore, the function prolog has the following pattern.

(A) lui gp, 0xzzzz (B) addi gp, gp, 0xuuu (C) addu gp, gp, t9

Inf in relocation information table 5
operation (= value of global pointer gp−ad
dress) to update the underlined part,
With the instruction codes of (A) and (B), the relative value of the profiler code to GOT is set to the global pointer gp.
And the result of addition of the contents of the t9 register holding the function entry address of the profiler code with the instruction code of (C) and the contents of the global pointer gp obtained above is newly assigned to the global pointer gp. At this time, the function entry address of the profiler code is calculated using the map table (step S67). That is, the instruction code of (A) to (C) sets the value obtained by combining the relative value of the profiler code with GOT and the function entry address of the profiler code as the global pointer g.
Instruction code to be set in p.

When the type of the relocation information read from the relocation information table 5 is a virtual address on a text section, the profiler shared object generating means 6 prevents the area indicated by the virtual address from being accessed. A virtual address conversion value on the profiler code is calculated from the virtual address on the text section detected by the data text address detection unit 42, and is converted into a data section area in which the original virtual address on the data segment is embedded. Is overwritten (step S67).

More specifically, since the profiler shared object 7 executes the instruction code in the profiler code addition text section of the new text segment, the virtual address on the original text section exists as data during the execution. Accessing a section may result in incorrect operation. For this reason,
When sequentially referring to the relocation information table 5, the profiler shared object generating means 6
If e is a virtual address, it is necessary to write a text address recorded by the data text address detection unit 42 into a text address on the profiler code in a corresponding area in the data section. At this time, the map table and the virtual address on the data segment recorded by the data text address detection unit 42 are used. For example, in the data section:
If the text address “400520” exists, the format in the relocation information table 5
When referring to the "ion", in the data section, "addre"
In the vicinity of the area indicated by ss, “0000000000040”
28232900 400520 00000000]
"000000000282232900 4a0048
"00000000", the text address 4a1800 on the corresponding profiler code is overwritten to the text address 400520 (step S67). Referring to the instruction description section in FIG. 3, the text address “400520” is a virtual address corresponding to the original ninth instruction, and the corresponding ninth virtual address in the map table in FIG. This is because it is "4a0048".

Further, when the type of the relocation information read from the relocation information table 5 is a GOT reference, the profiler shared object generating means 6 performs GOT reference for consistent operation in the profiler shared object 7. The original target text address detected by the text address detection unit 43 (of the jump destination address indicated by the jump instruction or the like,
From the corresponding target text address for the profiler (address present in the text section)
A destination address indicated by a jump instruction or the like is calculated, and a difference between the value and the original target text address is calculated.

In many cases, a target text address obtained by referring to the GOT is used as a jump destination address. Therefore, in the profiler shared object 7 that does not use the instruction code in the text section, the operation may be incorrect. Therefore, when the profiler shared object generating means 6 sequentially refers to the relocation information table 5, if the type is a GOT reference,
Based on the target text address recorded by the GOT reference text address detection unit 43, the target text address is converted into a corresponding target text address for profiler by referring to a map table. The difference between the profiler target text address thus obtained and the original target text address is calculated. Next, the profiler shared object generation means 6 adds
By writing a value obtained by adding the difference between the original target text address and the GOT address recorded by the GOT reference text address detection unit 43 into a part of the instruction code that enables the calculation of a new target address, the corresponding instruction code is written. Update. The profiler shared object generating means 6 generates a new text segment in the profiler shared object 7 from the beginning so that the text address obtained by referring to the GOT can operate normally in the profiler shared object 7 without inconsistency. Must be within the range. Therefore,
The original target text address and GO
The difference between the “T difference from the T address” and the previously calculated “difference between the target text address for profiler and the original target text address” is defined as “0xuu”.
The corresponding instruction code is updated by overwriting the "u" part (step S67).

Subsequently, the profiler shared object generating means 6 checks whether or not all instruction codes in the text section have been read (step S68).
The process of S68 is repeated, and when the process is completed, the process proceeds to step S69.

Next, the profiler shared object generation means 6 writes the instruction code stored in the memory in steps S64 and S65 into the profiler code addition text section in the profiler shared object 7 to be generated (step S69). . At this time, a value obtained by converting the increasing instruction code number calculated in step S62 into a virtual address is written in the map table by the same number as the original instruction code number.

Subsequently, the profiler shared object generator 6 converts the structure of the original shared object 1, that is, the object header, program header, text segment, updated data segment, and section information header table into the profiler shared object 7. (Step S6a).

Finally, the profiler shared object generating means 6 increments the number of the generated profiler shared objects 7 by one (step S6b).
Control is returned to step S61, and when the number of profiler shared objects 7 generated in step S61 is equal to or greater than the number of referenced shared objects 1, a series of processes is terminated.

[0052]

As described above, according to the present invention, the provision of the shared object input means, the relocation information extraction means and the profiled shared object generation means has been conventionally performed to enable detailed performance data analysis. Although the executable program is generated by the static link, even when the executable program is generated by the dynamic link, the executable object for the profiler refers to the shared object for the profiler instead of the shared object when the executable program for the profiler is executed. For,
Profiling on shared objects is possible,
There is an effect that more detailed performance data analysis can be performed.

Further, the presence / absence of access to the smallest block that can enter only from the beginning and exit only from the end can be observed as one of the performance evaluations. There is an effect that more efficient profiling can be performed by using an object generated within a normal compilation range, rather than converting an instruction code into a trace function call instruction code.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a configuration of a profiler code addition method according to an embodiment of the present invention.

FIG. 2 is a detailed processing diagram of a relocation information extraction unit in FIG. 1;

FIG. 3 is a diagram showing contents of a shared object in FIG. 1;

FIG. 4 is a diagram showing contents of a global offset table in FIG. 3;

FIG. 5 is a diagram showing the contents of a dynamic link executable program in FIG. 1;

FIG. 6 is a diagram showing contents of a relocation information table in FIG. 1;

FIG. 7 is a diagram showing contents of a profiler shared object in FIG. 1;

FIG. 8 is a diagram showing contents of a symbol table in FIG. 3;

FIG. 9 is a flowchart showing processing of a shared object input unit in FIG. 1;

FIG. 10 is a flowchart showing a process of a relocation information extracting unit in FIG. 1;

FIG. 11 is a flowchart showing a process of a profiler shared object generation unit in FIG. 1;

[Explanation of symbols]

 REFERENCE SIGNS LIST 1 shared object 2 dynamic link executable program 3 shared object input means 4 relocation information extraction means 5 relocation information table 6 profiler shared object generation means 7 profiler shared object 41 function prologue detection unit 42 data text address detection unit 43 GOT reference Text address detector

Claims (3)

(57) [Claims] 1. A shared object input for extracting a shared object name referred to by a dynamic link executable program from dynamic link information of the dynamic link executable program and inputting a target shared object based on the extracted name. Means for extracting relocation information from a function prologue of the shared object, a virtual address on a text section existing in a data section, and an instruction code for obtaining a text address by referring to GOT, and relocation information extraction for creating a relocation information table Means for generating a profiler shared object having a function equivalent to that of the shared object and having a profiler code added thereto, and referring to the relocation information table to obtain a required instruction code. There profiler code additional method characterized by having a shared object generating means for profiler to update the contents of the data. 2. A function prologue detecting unit for detecting symbol information of a function type from a symbol table included in the shared object, a relocation information extracting unit, and a virtual section on a text section from a data segment included in the shared object. A data text address detection unit for detecting an address, and a GOT for detecting an instruction code having an instruction operand corresponding to a GOT reference from a text section included in the shared object
2. The method according to claim 1, further comprising a reference text address detector. 3. The profiler shared object generating means, when the relocation information in the relocation information table is a function prologue, enters the function prologue of the profiler shared object into the function of the shared object detected by the function prologue detection unit. Calculating the GOT address of the profiler code from a relative value between the function input address of the profiler code corresponding to the program address and the GOT of the profiler code, converting the value into an instruction code for setting a global pointer, When the relocation information is a virtual address on a text section, a virtual address on the profiler code is converted from a virtual address on the text section detected by the data text address detection unit. Calculates the value and overwrites it in the data segment where the original virtual address is embedded. If the relocation information in the relocation information table is a GOT reference,
Based on the target text address recorded by the reference text address detection unit, the target text address for the profiler is converted to the corresponding target text address by referring to the map table, and the difference between the target text address for the profiler and the original target text address is calculated. 3. The method according to claim 2, wherein the new target address is updated to an instruction code.