JP2013080406A - Compilation device, information processing system, compilation method, compilation program, and storage medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a compilation device which collects information about variables and functions and generates output command to be outputted as debug information as one aspect.SOLUTION: A syntax semantic analysis part 32 generates an execution program including a debug information output command 341 which is a command to output debug information generated by analyzing program elements of an output target of an output instruction on the basis of structured data 33 showing a structure of a source program 2, when the source program 2 of a compilation processing target includes an embedded debug instruction row 21 which is the output instruction of the debug information. An optimization part 35, a code generation part 36, and a linker 38 generate an execution program including a debug information output command 41 which is a command to determine execution propriety of the execution program, as a result of compilation processing of the source program 2.

Description

  The present invention relates to a compiling device, an information processing system, a compiling method, a compiling program, and a recording medium.

  There are roughly three methods for debugging an execution program generated by a compiler. There are three types of debugging: debugging with a debugger, debugging with a memory leak or memory access error detection tool, and debugging with debugging code.

  In the case of debugging with a debugger, an execution program in which an option for instructing generation of debug information is specified by a translation option at the time of compiling the execution program. The debug information is information for the user to debug the execution program. The generated execution program is interactive using a debugger such as GDB. In other words, the execution program is debugged when the user inputs a debug command to operate the execution program.

  In the case of debugging with a memory leak or memory access error detection tool or the like, an execution program in which a library of tools necessary for detection is combined is generated when the execution program is generated. When the generated execution program is executed, when there is a memory leak or a memory access error, a detection message such as a memory leak or a memory access error is output. The user uses the detection message to debug the execution program.

  In the case of debugging with debugging code, the user himself / herself writes the debugging code at a location where the source program is to be debugged. For example, the user himself / herself examines the source program to be debugged in detail, extracts variables and passing messages required for debugging, and specifically describes the extracted variables and passing messages in the output function. As a result, variables necessary for debugging, passing messages, and the like are output by executing the execution program.

  In the compiling device, a code optimizing unit that translates a source program into an optimized machine language instruction sequence based on an instruction to the compiling device for optimizing the machine language instruction sequence, and the instruction An optimization hint information description detection unit that detects from within, an error checkpoint detection unit that detects a position on the machine language instruction sequence that can determine whether or not the instruction is illegal based on the detected instruction; Optimization hint description for generating optimization hint information description debug information including a description position of the instruction in the source program, the position, and information necessary for determining whether the instruction is invalid It has been proposed to include a debug information generation unit.

  In the debugging method, the compiler outputs a comparison interrupt instruction in which an identifier for specifying a test item is added to a normal comparison instruction. During debugging processing, the compiler supports the identifier by executing this comparison interrupt instruction. For example, in the case of an array subscript access check, a comparison interrupt instruction consisting of a comparison condition between the subscript and the upper limit value of the array declaration is embedded in the inspection target part of the source program (intermediate text). When the comparison condition is satisfied, it is determined that there is an access violation of the subscript and an interrupt to the error processing library is generated, and a high-speed debugging method using this comparison interrupt instruction and detailed debugging that outputs detailed error information It has been proposed to use the method together.

JP 2006-155386 A JP-A-11-259334

  Debugging by the debugger is a full set of debugging in which functions are interrupted, stepped, variable values are displayed and values are changed. For this reason, an execution program that includes debugging information that is unnecessary for debugging is required, and an external tool such as GDB is indispensable. Further, when the program to be debugged is a large-scale program, a long-time program, or a highly parallel program, the burden on the user is too great and interactive debugging has a limit.

  In addition, debugging using a detection tool or the like such as a memory leak or a memory access error has a main purpose of detecting an error relating to the memory. For this reason, it is necessary to combine the library of the error detection tool with the execution program. In addition, due to the problem of execution performance, the execution program used for debugging cannot be actually used as it is in the computer that is the execution device. For this reason, it is necessary to generate an execution program that is actually operated separately from the execution program used for debugging.

  Further, in debugging with debugging code, the user himself / herself incorporates debugging code into a portion of the execution program to be debugged. For this reason, the burden of the user who codes the code for debugging is very large. For example, the user himself / herself analyzes and extracts the variable value, file name, function name, line number, etc. that the user wants to output and analyzes the source program to be debugged. There is a need to. In addition, an execution program including debugging code cannot be used as it is in a computer that is actually an execution device. For this reason, it is necessary to generate an execution program that is actually operated separately from the execution program used for debugging. Alternatively, in an execution program that is actually operated including debug code, the user needs to control execution of the debug code by a runtime option, an environment variable, or the like.

  An object of one aspect of the present invention is to suppress an increase in load due to the addition of debugging code.

  According to one aspect, the disclosed compiling device includes a first generation unit and a second generation unit. The first generation unit analyzes the program element that is the output target of the output instruction based on the structured data that represents the structure of the source program when the output instruction of the debug information is included in the source program to be compiled. An execution program including an instruction for outputting the generated debug information is generated. The second generation unit generates an execution program including an instruction for determining whether or not the execution program can be executed as a result of compiling the source program.

  According to one aspect of the disclosed compiling apparatus, an increase in load due to the addition of debug code can be suppressed.

It is a figure which shows an example of the information processing system containing a compilation apparatus. It is a figure which shows an example of an embedded debugging instruction | indication line. It is a figure which shows an example of a source program. It is a figure which shows an example of structured data. It is a figure which shows an example of debug information output. It is a figure which shows an example of a hardware structure of a compiling apparatus. It is a compilation processing flow.

  FIG. 1 is a diagram illustrating an example of an information processing system including a compiling device.

  The information processing system includes a generation device 1, a compilation device 3, and an execution device 5. The generating device 1 is a computer that generates a source program 2 to be compiled by a user. The compiling device 3 is a computer that generates an execution program 4 by compiling the source program 2. The execution program 4 is a program in the execution format of the source program 2. The execution device 5 is a computer that obtains a program execution result output 6 by executing the execution program 4. The program execution result output 6 is a result of executing the execution program 4.

  The generation apparatus 1 transmits the generated source program 2 to the compilation apparatus 3 via, for example, a network. The compiling device 3 stores the received source program 2 in a storage device, reads the stored source program 2, compiles it, and generates an execution program 4.

  The compiling device 3 stores the generated execution program 4 in a storage device, reads the stored execution program 4, and transmits the read execution program 4 to the execution device 5 via a network, for example. The execution device 5 stores the received execution program 4 in a storage device, and reads and executes the stored execution program 4.

  The compiling device 3 includes a compiler 31, a linker 38, and a library 39. The compiler 31 includes a syntax and semantic analysis unit 32, an optimization unit 35, and a code generation unit 36. The compiler 31 generates structured data 33, an intermediate program 34, and an object program 37 based on the source program 2.

  In the compiler 31 of the compiling device 3, the syntax and semantic analysis unit 32 reads the source program 2 from the storage device and analyzes the source program 2 before generating the intermediate program 34, thereby generating structured data 33. Specifically, the syntax and semantic analysis unit 32 generates structured data 33 by executing syntax analysis processing and semantic analysis processing for the source program 2. The structured data 33 may be generated by a computer other than the compiling device 3 and input to the compiling device 3. The structured data 33 is stored in a storage device.

  The source program 2 created by the user includes, for example, a plurality of source codes input by coding and one or a plurality of embedded debug instruction lines 21. The embedded debug instruction line 21 is an instruction to output debug information. Specifically, the embedded debug instruction line 21 is a code that is written in the source program 2 by being described by the user, and is a code that instructs collection and output of debug information. The embedded debug instruction line 21 is a code different from the source code, and is a code that is not normally used as the source code, and is predetermined. The collection and output of debug information is actually instructed to the execution device 5 that executes the execution program 4. In other words, the collection and output of actual debug information is executed by the execution device 5 executing the execution program 4.

  The syntax and semantic analysis unit 32 is a first generation unit that generates the intermediate program 34 by analyzing the source program 2. Specifically, the syntax and semantic analysis unit 32 generates an intermediate program 34 by executing syntax analysis processing and semantic analysis processing for the source program 2. The intermediate program 34 is described by an intermediate code. Therefore, the syntax and semantic analysis unit 32 includes a code generation unit that executes a code generation process for generating an intermediate code. The intermediate program 34 is stored in a storage device. From the viewpoint that the intermediate program 34 is a program generated from the source program 2, it can also be considered as a form of an execution program.

  In practice, the structured data 33 and the intermediate program 34 are generated by a single syntax analysis process and semantic analysis process. In other words, the structured data 33 may be generated based on the syntax analysis process.

  In the generation of the intermediate program 34, when the embedded debug instruction line 21 is included in the source program 2, the syntax and semantic analysis unit 32 generates the intermediate program 34 including the debug information output instruction 341 corresponding to the embedded debug instruction line 21. . The debug information output instruction 341 is based on the structured data 33 representing the structure of the source program 2, and is a program element that is an output target instructed by the embedded debug instruction line 21, in other words, a program instructed by the embedded debug instruction line 21. Generated by parsing elements. The debug information output instruction 341 is an instruction for outputting debug information, and is described in an intermediate code. The program element includes, for example, a statement or expression to be debugged, a variable or function used in the statement or expression to be debugged, a function to be debugged, a dummy argument in the function to be debugged, as described later. External variables or static variables to be debugged.

  The optimization unit 35 optimizes the intermediate program 34 and passes the optimized intermediate program 34 obtained by the optimization process to the code generation unit 36. When the intermediate program 34 includes the debug information output instruction 341, the debug information output instruction 341 is also optimized.

  The code generation unit 36 generates an object program 37 by generating an object code based on the optimized intermediate program 34. The object program 37 is described in object code. When the intermediate program 34 includes the debug information output instruction 341, the object program 37 includes the debug information output instruction 371. The debug information output instruction 371 is an instruction for outputting debug information, and is generated based on the optimized debug information output instruction 341.

  The linker 38 generates the execution program 4 by linking the object program 37 and the library 39 specified in the object program 37. The execution program 4 is an execution format program described in executable code. When the object program 37 includes the debug information output instruction 371, the execution program 4 includes the debug information output instruction 41. The debug information output instruction 41 is generated based on the debug information output instruction 371. In other words, when the source program 2 includes the embedded debug instruction line 21, the execution program 4 includes the debug information output instruction 41 generated based on the embedded debug instruction line 21.

  The debug information output instruction 41 is an instruction for instructing collection and output of debug information, but is not executed by the debugger but executed by the execution device 5. In other words, the debug information output instruction 41 is an instruction for instructing the execution apparatus 5 to collect and output debug information, in other words, debug and output of the debug result. The embedded debug instruction line 21 is an instruction for generating a debug information output instruction 41, in other words, an instruction for instructing collection and output of debug information to the execution device 5. In addition, by executing the debug information output instruction 41, debugging and a debugging result are output. Based on the output debug and the debug result, it is determined whether or not the execution program is actually executable. Therefore, it can be said that the debug information output instruction 41 is an instruction for determining whether or not the execution program can be executed.

  As described above, the execution program 4 including the debug information output instruction 41 is generated from the intermediate program 34. In other words, the optimization unit 35, the code generation unit 36, and the linker 38 are the second generation unit that generates the execution program 4 based on the intermediate program 34.

  The execution device 5 obtains a program execution result output 6 of the execution program 4 by executing the execution program 4. In executing the execution program 4, the execution device 5 executes the debug information output instruction 41 in the same manner as other instructions without being aware of the collection and output of debug information.

  When the execution program 4 includes the debug information output instruction 41, the program execution result output 6 includes the debug information output 61. The program execution result output 6 excluding the debug information output 61 is a result of executing a portion excluding the debug information output instruction 41 of the execution program 4. The debug information output 61 is a result of debugging one or more predetermined portions in the execution program 4.

  As described above, the execution device 5 executes the execution program 4, thereby executing the program execution result output 6 of the execution program 4 and the debug information output 61 of the execution program 4 obtained by executing the debug information output instruction 41. And generate

  The program execution result output 6 is output as one file, for example. The debug information output 61 may be output to a separate file independent of the program execution result output 6 file.

  FIG. 2 is a diagram illustrating an example of an embedded debug instruction line.

  As the embedded debug instruction line 21, a pragma command “#pragma” is used as shown in FIG. The pragma command is a command defined in the C ++ language standard and the C language standard, and is a command passed to the compiler. Therefore, by using the pragma command, the operation of the compiler 31 can be controlled without affecting the source program 2.

  As shown in FIG. 2A, there are three types of embedded debug instruction lines 21: “statement”, “parameter”, and “global”. Thereby, it is possible to instruct collection and output of debug information for almost all program elements of the source program 2.

  The built-in debug instruction line 21 whose type is “statement” is used when the user wants to output debug information about variables and functions used in statements and expressions. In other words, the embedded debug instruction line 21 of the type “statement” is to be debugged, in other words, a statement or expression to be debugged is specified, and a variable or function used in the specified statement or expression. This is an instruction to instruct debugging.

  When the type of the embedded debug instruction line 21 is “statement”, the syntax and semantic analysis unit 32 uses the variable or the variable used in the specified sentence or expression as the debug information output instruction 341 corresponding to the embedded debug instruction line 21. A function is extracted from the source program 2 and an instruction for collecting information about the extracted variable or function is generated.

  The debug information output instruction 371 and the debug information output instruction 41 generated based on the debug information output instruction 341 are the same instructions as the debug information output instruction 341. The same applies when the type of the embedded debug instruction line 21 is “parameter” or “global”.

  The built-in debug instruction line 21 whose type is “statement” is described in a format such as “#pragma builtin_debug statement [variable list]” as shown in FIG. The built-in debug instruction line “#pragma builtin_debug statement [variable list]” is incorporated, for example, immediately before the statement or expression to be debugged. As a result, the statement or expression to be debugged, and further the variable or function described in the statement or expression to be debugged are specified. The debug information output instruction 41 generated from the built-in debug instruction line “#pragma builtin_debug statement [variable list]” collects information on variables and functions described in the specified statement or expression from the source program 2 and debugs them. Output as information.

  For example, when the source program 2 is described in the C ++ language, information on member functions, constructors, operator functions, and template functions is collected and output as debug information. When the built-in debug instruction line “#pragma builtin_debug statement [variable list]” specifies a block statement, all of it is used in one or more statements or one or more expressions contained in the specified block statement Debug information such as variables and functions is output.

  The built-in debug instruction line 21 of the type “parameter” is used when the user wants to output debug information about a function dummy argument. In other words, the built-in debug instruction line 21 of the type “parameter” is an instruction that designates a function to be debugged and instructs debugging of a dummy argument in the designated function.

  When the type of the embedded debug instruction line 21 is “parameter”, the syntax / semantic analysis unit 32 extracts, from the source program 2, the dummy argument in the specified function as the debug information output instruction 341 corresponding to the embedded debug instruction line 21. Then, an instruction for collecting information on the extracted dummy argument is generated.

  The built-in debug instruction line 21 of the type “parameter” is described in a format such as “#pragma builtin_debug parameter [variable list]” as shown in FIG. The built-in debug instruction line “#pragma builtin_debug parameter [variable list]” is, for example, incorporated at the head of a function to be debugged. As a result, the function to be debugged and further the dummy argument in the function to be debugged are specified. By using the debug information output instruction 41 generated from the built-in debug instruction line “#pragma builtin_debug parameter [variable list]”, information on the dummy argument is collected and output as debug information.

  The embedded debug instruction line 21 of the type “global” is used when the user wants to output debug information about an external variable or a static variable. In other words, the built-in debug instruction line 21 of the type “global” is an instruction that designates an external variable or static variable to be debugged and instructs debugging of the designated external variable or static variable. .

  When the type of the embedded debug instruction line 21 is “global”, the syntax / semantic analyzer 32 uses the specified external variable or static variable as the source program 2 as the debug information output instruction 341 corresponding to the embedded debug instruction line 21. And an instruction for collecting information about the extracted external variable or static variable.

  The built-in debug instruction line 21 of the type “global” is described in a format such as “#pragma builtin_debug global [variable list]” as shown in FIG. The built-in debug instruction line “#pragma builtin_debug global [variable list]” specifies, for example, an external variable or a static variable that is visible from the built-in position. The variables declared in the line before the built-in debug instruction line “#pragma builtin_debug global [variable list]” are visible to the compiler 31. Thereby, a visible external variable or static variable to be debugged is designated. The debug information output instruction 41 generated from the built-in debug instruction line “#pragma builtin_debug global [variable list]” collects visible external variables or static variables from the built-in position and outputs them as debug information.

  In the embedded debug instruction line 21, “variable list” can be designated as shown in FIG. In “variable list”, a variable is specified by one identifier. Alternatively, in “variable list”, “variable list” can be further described after one identifier for designating a variable. Thereby, a plurality of variables can be specified.

  When “variable list” is specified, only the debug information of the variable specified by “variable list” is generated by executing the debug information output instruction 41 generated from the embedded debug instruction line 21 by the execution device 5. Is done. The designation of “variable list” can be omitted. When the “variable list” is not designated, the execution of the debug information output instruction 41 generated from the embedded debug instruction line 21 by the execution device 5 causes a variable or function determined by the embedded position of the embedded debug instruction line 21. Debug information is generated.

  For example, when “variable list” is specified in the embedded debug instruction line 21 of the type “statement”, only the debug information of the variable or function specified in the “variable list” is output. When “variable list” is specified in the built-in debug instruction line 21 whose type is “parameter”, only the debug information of the dummy argument specified in “variable list” is output. When “variable list” is specified in the built-in debug instruction line 21 whose type is “global”, only the debug information of the external variable or static variable specified in “variable list” is output.

  Actually, in any type of embedded debug instruction line 21, in addition to the debug information described above, the file name, the current function name, and the line number are output together. The file name, current function name, and line number may not be output.

  FIG. 3 is a diagram illustrating an example of a source program.

  For example, the source program 2 is described in a high-level program language such as C ++ language or C language which is an object-oriented language. For example, the source program 2 includes three types of built-in debug instruction lines 21. Specifically, the 19th, 24th, and 27th lines each include an embedded debug instruction line 21. Since the embedded debug instruction line 21 can be embedded in the source program 2 in this way, the developer who knows the source program 2 can easily use it, and the embedded debug instruction line 21 is used for route testing. Can also be used.

  As shown in FIG. 3, the number of embedded debug instruction lines 21 included in one source program 2 may be one or plural. The number of embedded debug instruction lines 21 is determined according to the number of debug targets.

  In the source program 2 in FIG. 3, the leftmost number represents the number of lines in the source program 2. The name of the source program 2 is “sample.cc”, for example.

  The embedded debug instruction line 21 is an instruction that is executed in a predetermined compiling device 3 and that does not generate an error and is not executed in a compiling device other than the predetermined compiling device 3. Specifically, the portability of the source program 2 can be ensured by using the pragma command “#pragma” as the embedded debug instruction line 21. In other words, even if the source program 2 is compiled by a compiler other than the compiler 31, no error occurs.

  The embedded debug instruction line 21 is a position in the source program 2 that specifies a statement or expression to be debugged, a position that has a predetermined relationship with the sentence or expression, and a position that specifies a function to be debugged. A position that is in a predetermined relationship with the function, or a position that specifies an external variable or static variable to be debugged, and has a predetermined relationship with the external variable or static variable. It is included in a certain position. The position of the embedded debug instruction line 21 will be described later.

  Therefore, in the source program 2, the position where the embedded debug instruction line 21 is described, in other words, the position where the embedded debug instruction line 21 is embedded is determined by the user when the source program 2 is coded. In other words, the position where the embedded debug instruction line 21 is incorporated is determined by the user according to the position of the debug target portion. As a result, the user can debug only the portion of the source program 2 that is the debug target.

  The embedded debug instruction line “#pragma builtin_debug parameter” on line 19 is the embedded debug instruction line 21 of the type “parameter”. As described above, the built-in debug instruction line 21 of the type “parameter” designates a function to be debugged and instructs to debug a dummy argument in the designated function. On the other hand, the built-in debug instruction line “#pragma builtin_debug parameter” on the 19th line is specified at the top position in the function func starting on the 17th line. Accordingly, it can be said that the built-in debug instruction line “#pragma builtin_debug parameter” on the 19th line is a debug information output instruction that specifies the function func on the 17th line and instructs the debugging of the formal parameter param of the function func. .

  The embedded debug instruction line “#pragma builtin_debug global” on line 24 is the embedded debug instruction line 21 of the type “global”. As described above, the built-in debug instruction line 21 of the type “global” designates an external variable or static variable to be debugged, and instructs to debug the designated external variable or static variable. On the other hand, from the built-in debug instruction line “#pragma builtin_debug global” on the 24th line, “int data = 10” on the second line and “int data = 20” on the fifth line are visible. Therefore, the embedded debug instruction line “#pragma builtin_debug global” on the 24th line is “data = 10” on the 2nd line which is a visible external variable or static variable included in the source program 2 and “data” on the 5th line. It can be said that this is a debug information output instruction instructing debugging of “= 20”.

  The embedded debug instruction line “#pragma builtin_debug statement” on line 27 is the embedded debug instruction line 21 of the type “statement”. As described above, the built-in debug instruction line 21 of the type “statement” designates a statement or expression to be debugged, and instructs to debug a variable or function used in the designated sentence or expression. On the other hand, the built-in debug instruction line “#pragma builtin_debug statement” on the 27th line is incorporated immediately before “ret = clsobj + data;” on the 28th line. Therefore, it can be said that the built-in debug instruction line “#pragma builtin_debug statement” on the 27th line is a debug information output instruction that instructs debugging of “ret = clsobj + data;” on the 28th line.

  As described above, since the syntax and semantic analysis unit 32 of the compiler 31 generates code for outputting debug information, the user does not need to code or compile the debug source program 2. In addition, when the variables to be debugged increase as a result of the change in the source program 2, the user does not need to recode the source program 2 and only increases the number of debug targets by recompiling the source program 2. Debug information corresponding to can be output. Furthermore, any source program 2 that can be compiled and any statement or expression can output debug information.

  FIG. 4 is a diagram illustrating an example of structured data.

  The syntactic and semantic analysis unit 32 of the compiler 31 generates structured data 33 shown in FIG. 4 from the source program 2 shown in FIG. 3 based on the syntax analysis processing.

  Specifically, the syntax and semantic analysis unit 32 extracts a compile unit “CompileUnit” “sample.cc” based on the name “sample.cc” of the source program 2. “CompileUnit” is the highest hierarchy in the data structure of the source program 2.

  Further, the syntax and semantic analysis unit 32 extracts a name space, a class type, a using statement, a function, and the like as a hierarchy one level lower than “CompileUnit”.

  Specifically, as a hierarchy one level below “CompileUnit”, first, “Namespace” named “NS1” is based on “namespace NS1 {” on the first line and “};” on the third line. Extracted.

  Further, the syntax and semantic analysis unit 32 extracts variables and the like as a hierarchy one level lower than “Namespace”. Specifically, “int data = 10;” on the second line is surrounded by “{}” in “Namespace” “NS1”. Therefore, based on “int data = 10;”, “Variable” “data = 10” is extracted as a hierarchy one level lower than “Namespace” “NS1”.

  Similarly, “Namespace” of “NS2” is extracted based on “namespace NS2 {” on the fourth line and “};” on the sixth line as a hierarchy one level lower than “CompileUnit”. Also, based on “int data = 20;” on the fifth line, “Variable” of “data = 20” is extracted as a hierarchy one level lower than “Namespace” of “NS2”.

  Next, “Type” “CLS” is extracted based on “class CLS {” on the eighth line and “};” on the thirteenth line as a hierarchy one level lower than “CompileUnit”.

  Further, the syntax and semantic analysis unit 32 extracts a variable or the like as a hierarchy one level lower than “Type” such as a class. Specifically, “int mem;” on line 10 and “int operator + (int i) ....;” on line 11 are “{}” in “Type” of “CLS”. Surrounded by Therefore, based on “int mem;” on the 10th line, “Member” “mem” is extracted as a layer one level lower than “Type” “CLS”. Also, based on “int operator + (int i) ....;” on the 11th line, “Member” “operator + (int)” is one level lower than “Type” “CLS”. Is extracted. The 10th and 11th lines are data members or member functions in the class, and are extracted as a hierarchical structure. The 9th and 12th lines are keywords in the class and are not extracted as a hierarchical structure but ignored.

  Next, “using namespace” “NS1” is extracted based on “using namespace NS1;” on the 15th line as a hierarchy one level lower than “CompileUnit”.

  Next, based on “int func (int param)” on the 17th line, “{” on the 18th line, and “}” on the 31st line, “func (int "Function") is extracted. The 19th to 31st lines are surrounded by “{}” in “Function” called “func (int)”. Accordingly, the 19th to 31st lines are extracted as a lower hierarchy of “Function” called “func (int)”.

  Further, the syntax and semantic analysis unit 32 extracts a parameter, a pragma command, a variable, a sentence, an expression, or the like as a lower hierarchy of the function.

  Specifically, in the “Function” “func (int)”, based on the “int func (int param)” on the 17th line, the hierarchy one level lower than the “Function” “func (int)” As a result, “Parameter” “param” is extracted. Also, based on “#pragma builtin_debug parameter” on the 19th line, “Pragma” “builtin_debug parameter” is extracted as a layer one level lower than “Function” “func (int)”. Therefore, the pragma command is the same as the parameter or variable in the function Function from the viewpoint of the data structure.

  Also, based on “CLS clsobj;” on the 21st line, “Variable” “clsobj” is extracted as a hierarchy one level lower than “Function” “func (int)”. In addition, based on “int ret = 0;” on the 22nd line, “Variable” “ret” is extracted as a layer one level lower than “Function” “func (int)”. Also, based on “#pragma builtin_debug global” on the 24th line, “Pragma” “builtin_debug global” is extracted as a layer one level lower than “Function” “func (int)”.

  Also, based on “if (param && data) {” on the 26th line and “}” on the 29th line, “if (param && data) "is extracted. The 27th to 28th lines are surrounded by “{}” in “Statement” “if (param && data)”. Accordingly, the 27th to 28th lines are extracted as a lower hierarchy of “Statement” of “if (param && data)”.

  Furthermore, in the “Statement” “if (param && data)”, based on “ret = clsobj + data;” on the 28th line, it is one level lower than the “Statement” “if (param && data)”. As a hierarchy, “Statement” “ret = clsobj + data” is extracted.

  Also, “Pragma” “builtin_debug statement” is extracted based on “#pragma builtin_debug statement” on the 27th line. The “#pragma builtin_debug statement” on the 27th line is a debug instruction line for “ret = clsobj + data;” on the 28th line, and is therefore one level below the 28th line. Therefore, in the 27th and 28th lines, the upper and lower positions of the lines are reversed from the upper and lower positions of the hierarchy.

  Furthermore, since the source program 2 is an object-oriented language, the syntax and semantic analysis unit 32 extracts a relationship between the layers and associates the extracted layers.

  Specifically, since “ret” included in the hierarchy “ret = clsobj + data;” generated from the 28th line has the same name, it is “ret” generated from the 22nd line. Therefore, in order to structurally express that “ret” included in the hierarchy generated from the 28th line is “ret” generated from the 22nd line, as shown by a dotted line in FIG. “Ret” included in the hierarchy generated from the eyes is associated with “ret” generated from the 22nd line. Similarly, “clsobj” included in the hierarchy generated from the 28th line and “clsobj” generated from the 21st line are associated with each other as shown by a dotted line in FIG.

  Further, “+” included in the hierarchy generated from the 28th line is an operator that defines addition. The data member or member function related to addition in the class is “operator + (int)” generated from the 11th line. Therefore, “+” included in the hierarchy generated from the 28th line and “operator + (int)” generated from the 11th line are associated with each other as shown by a dotted line in FIG.

  Also, because the “namespace” named “NS1” is declared to be used in the using statement on the 15th line, “data” included in the hierarchy generated from the 28th line is “Namespace” named “NS1”. “Data = 10” in “Variable”, in other words, “data = 10” generated from the second line. Therefore, “data” included in the hierarchy generated from the 28th line and “data = 10” generated from the 2nd line are associated with each other as shown by a dotted line in FIG.

  The structured data 33 shown in FIG. 4 is obtained from the source program 2 shown in FIG. 3 by the syntax analysis processing by the syntax semantic analysis unit 32 as described above.

  FIG. 5 is a diagram illustrating an example of debug information output.

  The execution device 5 executes the execution program 4 generated from the source program 2 shown in FIG. 3, and obtains a program execution result output 6 shown in FIG. The program execution result output 6 includes a debug information output 61.

  In the program execution result output 6, the first and second lines are the results of executing the portion of the execution program 4 excluding the debug information output instruction 41. The third to twelfth lines are the debug information output 61 and are the results of executing the debug information output instruction 41.

  In the program execution result output 6, whether or not the debug information output 61 is output when the execution program 4 is executed is controlled by an environment variable, in other words, a flag. The value of the flag is specified by the user, for example, in the source program 2 when the source program 2 is generated. Prior to the compilation process of the source program 2, a flag value may be designated.

  When the flag value is “0”, the syntax / semantic analysis unit 32 does not compile the embedded debug instruction line 21 included in the source program 2. Accordingly, the intermediate program 34 does not include the debug information output instruction 341, the execution program 4 does not include the debug information output instruction 41, and the execution apparatus 5 does not output the debug information output 61. The syntax and semantic analysis unit 32 compiles the embedded debug instruction line 21 included in the source program 2 when the value of the flag is “1”. Therefore, the intermediate program 34 includes the debug information output instruction 341, the execution program 4 includes the debug information output instruction 41, and the execution apparatus 5 outputs the debug information output 61.

  Thus, whether or not debug information is output can be controlled when the execution program 4 is executed. Therefore, the source program 2 including the embedded debug instruction line 21 that is a code for debugging can be used in actual operation only by changing the flag value from “1” to “0”. The influence on the execution speed during operation can be reduced.

  The value of the flag is output at the end of the first line in the program execution result output 6, for example. In FIG. 5, since the flag value is “1”, the program execution result output 6 is output in a state including the debug information output 61. Thereby, the user can know whether or not the part other than the program execution result output 6 included in the program execution result output 6 is the debug information output 61, and can know the debug result.

  In the second line of the program execution result output 6, the name of the output destination file of the program execution result output 6 is output. In other words, the result of executing the portion of the execution program 4 excluding the debug information output instruction 41 is output to a file “a.out”.

  The syntax and semantic analysis unit 32 executes a first analysis process for analyzing the embedded debug instruction line 21, executes a second analysis process for analyzing the instruction target of the embedded debug instruction line 21, and executes the first and second analysis processes. A debug information output instruction 341 is generated based on the analysis processing.

  For example, in the debug information output 61, the third to fourth lines are the results of executing the debug information output instruction 41 generated from the 19th built-in debug instruction line “#pragma builtin_debug parameter” in the source program 2. . Specifically, debug information of the dummy argument param of the function func on the 17th line of the source program 2 is output.

  The syntax and semantic analysis unit 32 analyzes that the built-in debug instruction line “#pragma builtin_debug parameter” is described in the 19th line, and further, based on this analysis, as described above with reference to FIG. The function func on the 17th line is specified, and it is analyzed that the debugging of the formal parameter param of the function func is instructed.

  Therefore, based on the above analysis, the syntax and semantic analysis unit 32 obtains all information about the formal parameter param of the function func on the 17th line from the built-in debug instruction line “#pragma builtin_debug parameter” on the 19th line. 2 generates a debug information output instruction 341 that is collected from the inside and output. Thus, the execution program 4 includes a debug information output instruction 41 that collects and outputs information about the dummy argument param of the function func on the 17th line.

  The execution device 5 collects information on the dummy argument param of the function func on the 17th line by executing the debug information output instruction 41 generated from the built-in debug instruction line “#pragma builtin_debug parameter” on the 19th line. And output as debug information.

  Next, in the debug information output 61, the 5th to 7th lines are the results of executing the debug information output instruction 41 generated from the built-in debug instruction line “#pragma builtin_debug global” of the 24th line in the source program 2. is there. Specifically, debug information of visible external variables or static variables “data = 10” and “data = 10” in the second and fifth lines of the source program 2 is output.

  The syntax and semantic analysis unit 32 analyzes that the embedded debug instruction line “#pragma builtin_debug global” is described in the 24th line, and further, based on this analysis, as described above with reference to FIG. Then, it is analyzed that the instruction is for instructing debugging of “data = 10” on the second line and “data = 10” on the fifth line, which are visible external variables or static variables.

  Therefore, based on the above analysis, the syntax-separation analysis unit 32 starts the visible external variable or static variable “data” in the second and fifth lines from the built-in debug instruction line “#pragma builtin_debug global” on the 24th line. = 10 ”and“ data = 10 ”are generated from the source program 2 to collect and output a debug information output instruction 341 for output. As a result, the execution program 4 collects and outputs information about the visible external variables or static variables “data = 10” and “data = 10” on the second and fifth lines, and outputs the debug information output instruction 41. Is included.

  The execution device 5 executes the debug information output instruction 41 generated from the built-in debug instruction line “#pragma builtin_debug global” on the 24th line, thereby making visible external variables or static variables on the 2nd line and the 5th line. Information on “data = 10” and “data = 10” is collected and output as debug information.

  Next, in the debug information output 61, the 8th to 12th lines are the results of executing the debug information output instruction 41 generated from the 27th built-in debug instruction line “#pragma builtin_debug statement” in the source program 2. is there. Specifically, debug information of “ret = clsobj + data;” on line 28 of the source program 2 is output.

  The syntax and semantic analysis unit 32 analyzes that the built-in debug instruction line “#pragma builtin_debug statement” is described in the 27th line, and further, based on this analysis, as described above with reference to FIG. , Line 28, “ret = clsobj + data;” is analyzed to be an instruction instructing debugging.

  Therefore, based on the above analysis, the syntax-semantic analysis unit 32 obtains all information about “ret = clsobj + data;” on the 28th line from the built-in debug instruction line “#pragma builtin_debug statement” on the 27th line. A debug information output instruction 341 that is collected from the inside of the source program 2 and output is generated. Thus, the execution program 4 includes a debug information output instruction 41 that collects and outputs information about “ret = clsobj + data;” on the 28th line.

  In generating the debug information output instruction 341, the syntax and semantic analysis unit 32 further refers to the structured data 33. As a result, the syntax and semantic analysis unit 32 sets “ret = clsobj + data;” to be debugged as a variable “data” on the second line, an operator function “CLS :: operator + (int)” on the eleventh line, It is known that the variable “clsobj” on the 21st line and the variable “ret” on the 22nd line are associated with each other. Therefore, the syntax and semantic analysis unit 32 not only collects and outputs the information “ret = clsobj + data;” on the 28th line as the debug information output instruction 341 but also adds the variable “ret”. , A command for collecting and outputting information on the variable “clsobj”, the variable “data”, and the operator function “CLS :: operator + (int)”.

  The execution unit 5 executes the debug information output instruction 41 generated from the built-in debug instruction line “#pragma builtin_debug statement” on the 27th line, thereby obtaining information on “ret = clsobj + data;” on the 28th line. Collect and output as debug information.

  At this time, debug information of the variable “clsobj”, the variable “ret”, and the variable “data” used in “ret = clsobj + data;” on the 28th line of the source program 2 is output. Here, since the variable “clsobj” is a class type, a class name is displayed. The variable “data” is defined in both “Namespace” “NS1” and “Namespace” “NS2”, but it is defined in “Namespace” “NS1” by using statement on the 15th line. Indicates that the data is referenced. “CLS :: operator + (int)” on the 12th line indicates that the operator function declared in the CLS class is used. This is because the addition operation of “clsobj + data” actually uses the operator function “CLS :: operator + (int)”, in other words, is called.

  It should be noted that only debug information based on a specific embedded debug instruction line 21 may be output among a plurality of embedded debug instruction lines 21 included in the source program 2. In this case, for example, a control function interface is provided, and in the function, for example, “char builtin_debug_table [] = {“ test.c: 17 ”,“ test.c: 26 ”}; And the line number are specified as the initial value of the specified array, so that only the debug information for the specific embedded debug instruction line 21 can be output.

  As described above, since the execution device 5 outputs debug information by executing the debug information output instruction 41, the debug information is collected and output without using any debugging external tool or debug library. be able to. Further, since the compiling device 3 generates the debug information output instruction 41, the user does not need to code the debug information output instruction 41.

  Further, for example, when the source program 2 is a program described in the C ++ language, the user can analyze the identifier resolution result, the function overload / override resolution result, and the analysis result in the compiler 31 of the expression described in the source program 2. And the resolution result can be known as debug information. For example, the identifier resolution result indicates which namespace identifier is referred to. The function overload / override resolution result includes, for example, an operator operator. The expression described in the source program 2 includes, for example, a template function.

  FIG. 6 is a diagram illustrating an example of a hardware configuration of the compiling device.

  The CPU 101 controls the compiling device 3 according to a control program stored in the ROM 102. The CPU 101 executes a compile program on the RAM 103, which is a main memory, for example. As a result, the compiler 31 and the linker 38 are realized. The compile program is stored in, for example, a recording medium 109 such as a CD-ROM or DVD, input from the recording medium 109 to the hard disk 106, and loaded from the hard disk 106 to the RAM 103 via the CD-ROM drive, DVD drive, or the like.

  The program and data storage unit is provided in the hard disk 106, for example, and stores the source program 2, structured data 33, intermediate program 34, object program 37, library 39, and execution program 4. In other words, the program and data are stored in the hard disk 106, for example. For example, the library 39 is stored in a recording medium 109 such as a CD-ROM or DVD, and is input from the recording medium 109 to the hard disk 106 via a CD-ROM drive or DVD drive, and from the hard disk 106 to the RAM 103 as necessary. Loaded and processed by linker 38. The structured data 33, the intermediate program 34, the object program 37, and the execution program 4 are generated by the compiler 31 or the linker 38.

  The input device 104 is a keyboard, for example, and may include a mouse or the like. The output device 105 is a display, for example, and may include an output device such as a printer. The CPU 101, ROM 102, RAM 103, input device 104, output device 105, hard disk 106, and network connection unit 107 are connected to each other via a bus 108.

  The network connection unit 107 is, for example, a transmission / reception device, is connected to the network, and is connected to other computers, for example, the generation device 1 and the execution device 5 via the network. As a result, the compiling device 3 communicates with the generation device 1 and the execution device 5. For example, the source program 2 is input to the hard disk 106 from the generation apparatus 1 via the network, loaded from the hard disk 106 to the RAM 103 as necessary, and processed by the compiler 31 and the linker 38. The execution program 4 is transmitted from the compiling device 3 to the execution device 5 via the network and executed.

  FIG. 7 shows a compile processing flow executed by the compiler 31, and particularly shows a processing flow for generating an intermediate program including a debug information output instruction from a source program.

  In the compiling device 3, when the compiler 31 reads the source program 2 (step S1), the syntax / semantic analysis unit 32 executes the lexical analysis processing of the read source program 2 (step S2), and the result of the lexical analysis processing is obtained. Based on the read source program 2, syntax analysis processing and semantic analysis processing are executed (step S3). The structured data 33 of the source program 2 is generated by the syntax analysis process and the semantic analysis process.

  The syntax and semantic analysis unit 32 extracts the code one line at a time from the top of the source program 2, and determines whether or not the embedded debug instruction line 21 is specified in the extracted line (step S4). When the embedded debug instruction line 21 is not designated (No at Step S4), the syntax and semantic analysis unit 32 repeats Step S3.

  If the embedded debug instruction line 21 is designated (Yes in step S4), the syntax-separation analyzer 32 determines whether the type of the embedded debug instruction line 21 is “statement”, “parameter”, or “global”. Is determined (step S5).

  Next, the syntax and semantic analysis unit 32 determines whether or not “variable list” is specified in the embedded debug instruction line 21 and, if so, whether or not the variable is declared. Is inspected (step S6).

  On the other hand, if “variable list” is not specified in the embedded debug instruction line 21 in step S6, the syntax and semantic analysis unit 32 specifies in the source program 2 based on the position where the embedded debug instruction line 21 is specified. The checked variables and functions are checked (step S7).

  Next, the syntax and semantic analysis unit 32 generates an instruction for collecting and outputting variable and function debugging information, and also generates an information output instruction for a file name, a function name, and a line number (step S8).

  Next, the syntax and semantic analysis unit 32 generates a debug information output instruction 341 that is an intermediate code of the embedded debug instruction line 21 by using the environment variable shown in FIG. 5, in other words, the flag as a determination condition (step S9). ).

  Next, the syntax and semantic analysis unit 32 determines whether or not the processing of all lines in the source program 2 has been completed (step S10). If all the lines have not been processed (No at Step S10), the syntax and semantic analysis unit 32 repeats Step S3. When all the lines have been processed (Yes in step S10), the syntax and semantic analysis unit 32 ends the process.

  As will be understood from the above description, the following embodiments are grasped.

(Additional remark 1) When the output instruction | indication of debug information is included in the source program of a compilation process target, the program element which is the output object of the said output instruction | indication is analyzed based on the structured data showing the structure of the said source program A first generation unit that generates an execution program including an instruction for outputting debug information generated by:
A compiling apparatus comprising: a second generation unit that generates an execution program including an instruction for determining whether or not the execution program can be executed as a result of compiling the source program.

(Supplementary Note 2) The first generation unit executes a first analysis process for analyzing the output instruction, executes a second analysis process for analyzing an instruction target of the output instruction, and performs the first and second The compiling device according to appendix 1, wherein the debug information output instruction is generated based on the analysis processing of No. 2.

(Supplementary note 3) The compiling device according to supplementary note 1, wherein the first generation unit generates the structured data by analyzing the source program prior to generation of the execution program.

(Supplementary Note 4) The output instruction is an instruction that is executed in a predetermined compiling device, and is an instruction that does not generate an error and is not executed in a compiling device other than the predetermined compiling device. The compiling device according to Supplementary Note 1, which is characterized.

(Additional remark 5) The said output instruction | indication is the position which designates the sentence or expression which is a debug object in the said source program, Comprising: The position which has a predetermined relationship with respect to the said sentence or expression, The function which is a debug object A position that is designated and has a predetermined relationship with respect to the function, or a position that designates an external variable or static variable to be debugged and that is designated in advance with respect to the external variable or static variable. The compiling device according to appendix 1, wherein the compiling device is included in a position having a predetermined relationship.

(Additional remark 6) The said output instruction | indication is the instruction | indication which designates the debug about the variable or the function which designates the sentence or expression which is a debug object, and is used in the designated said sentence or expression. 5. The compiling device according to 5.

(Additional remark 7) The said 1st production | generation part extracted and extracted the variable or function used in the said sentence or expression designated from the said source program as the said debug information output instruction corresponding to the said output instruction | indication The compiling device according to appendix 6, wherein an instruction for collecting information on the variable or function is generated.

(Supplementary note 8) The compiling device according to supplementary note 5, wherein the output instruction is an instruction that designates a function to be debugged, and instructs to debug a dummy argument in the designated function.

(Supplementary Note 9) The first generation unit extracts a dummy argument in the function specified from the source program as the debug information output instruction corresponding to the output instruction, and stores information on the extracted dummy argument. The compiling device according to appendix 8, wherein the instruction to be collected is generated.

(Additional remark 10) The said output instruction | indication is the instruction | indication which designates the external variable or static variable which is a debug object, and instruct | indicates the debugging about the designated external variable or static variable. The compiling device described.

(Supplementary Note 11) The first generation unit extracts the external variable or static variable designated from the source program as the debug information output instruction corresponding to the output instruction, and extracts the external variable or static variable extracted. 13. The compiling device according to appendix 10, wherein an instruction for collecting information on a static variable is generated.

(Supplementary Note 12) The source program is described in C ++ language or C language, which is an object-oriented language, and the output instruction is a standard of the C ++ language and a pragma command defined as a command passed to a compiler in the C language. The compiling device according to appendix 1, wherein there is a compiling device.

(Supplementary note 13) a compiling device that generates an execution program by compiling a source program;
An information processing system including an execution device that executes the execution program,
The compiling device is:
Debug generated by analyzing a program element that is the output target of the output instruction based on structured data representing the structure of the source program when the source program to be compiled includes an instruction to output debug information A first generation unit that generates an execution program including an instruction for outputting information;
A second generation unit that generates an execution program including an instruction for determining whether or not the execution program can be executed as a compile processing result of the source program, and the execution device executes the execution program by executing the execution program An information processing system for generating a program execution result and debug information of the execution program obtained by executing the debug information output instruction.

(Supplementary note 14) When a debug information output instruction is included in a compile processing target source program, analyzing a program element that is the output target of the output instruction based on structured data representing the structure of the source program Generate an execution program that includes instructions to output debug information generated by
An execution program including an instruction for determining whether or not the execution program can be executed is generated as a compilation processing result of the source program.

(Supplementary note 15) A compiling program for generating an execution program by compiling a source program,
The compile program is stored in a computer.
Debug generated by analyzing a program element that is the output target of the output instruction based on structured data representing the structure of the source program when the source program to be compiled includes an instruction to output debug information A first generation process for generating an execution program including an instruction for outputting information;
A compile program, wherein a second generation process for generating an execution program including an instruction for determining whether or not the execution program can be executed is executed as a compile process result of the source program.

(Supplementary note 16) A recording medium for recording a compile program for generating an execution program by compiling a source program,
The compile program is stored in a computer.
Debug generated by analyzing a program element that is the output target of the output instruction based on structured data representing the structure of the source program when the source program to be compiled includes an instruction to output debug information A first generation process for generating an execution program including an instruction for outputting information;
A recording medium, wherein a second generation process for generating an execution program including an instruction for determining whether or not the execution program can be executed is executed as a compile process result of the source program.

DESCRIPTION OF SYMBOLS 1 Generation apparatus 2 Source program 3 Compile apparatus 4 Execution program 5 Execution apparatus 6 Output of program execution result 31 Compiler 32 Syntax and semantic analysis section 33 Structured data 34 Intermediate program 35 Optimization section 36 Code generation section 37 Object program 38 Linker 39 Library 61 Debug information output

Claims (8)

Debug generated by analyzing a program element that is the output target of the output instruction based on structured data representing the structure of the source program when the source program to be compiled includes an instruction to output debug information A first generation unit that generates an execution program including an instruction for outputting information;
A compiling apparatus comprising: a second generation unit that generates an execution program including an instruction for determining whether or not the execution program can be executed as a result of compiling the source program. The compiling apparatus according to claim 1, wherein the first generation unit generates the structured data by analyzing the source program prior to generation of the execution program. The output instruction is an instruction that is executed in a predetermined compiling device, and is an instruction that does not generate an error and is not executed in a compiling device other than the predetermined compiling device. Item 2. The compiling device according to Item 1. In the source program, the output instruction is a position for designating a statement or expression to be debugged, a position having a predetermined relationship with the sentence or expression, or a position for designating a function to be debugged. A position that is in a predetermined relationship with the function, or a position that specifies an external variable or static variable to be debugged and has a predetermined relationship with the external variable or static variable The compiling device according to claim 1, wherein the compiling device is included in a position in A compiling device for generating an execution program by compiling a source program;
An information processing system including an execution device that executes the execution program,
The compiling device is:
Debug generated by analyzing a program element that is the output target of the output instruction based on structured data representing the structure of the source program when the source program to be compiled includes an instruction to output debug information A first generation unit that generates an execution program including an instruction for outputting information;
A second generation unit that generates an execution program including an instruction for determining whether or not the execution program can be executed as a result of compiling the source program;
The execution device generates the execution result of the execution program and the debug information of the execution program obtained by executing the debug information output instruction by executing the execution program. Processing system. Debug generated by analyzing a program element that is the output target of the output instruction based on structured data representing the structure of the source program when the source program to be compiled includes an instruction to output debug information Generate an execution program that includes instructions to output information,
An execution program including an instruction for determining whether or not the execution program can be executed is generated as a compilation processing result of the source program. A compilation program that generates an execution program by compiling a source program,
The compile program is stored in a computer.
Debug generated by analyzing a program element that is the output target of the output instruction based on structured data representing the structure of the source program when the source program to be compiled includes an instruction to output debug information A first generation process for generating an execution program including an instruction for outputting information;
A compile program, wherein a second generation process for generating an execution program including an instruction for determining whether or not the execution program can be executed is executed as a compile process result of the source program. A recording medium for recording a compile program for generating an execution program by compiling a source program,
The compile program is stored in a computer.
Debug generated by analyzing a program element that is the output target of the output instruction based on structured data representing the structure of the source program when the source program to be compiled includes an instruction to output debug information A first generation process for generating an execution program including an instruction for outputting information;
A recording medium, wherein a second generation process for generating an execution program including an instruction for determining whether or not the execution program can be executed is executed as a compile process result of the source program.

Images