Computer with integrated hierarchical representation (IHR) of program wherein IHR file is available for debugging and optimizing during target execution

• US 5,175,856 A
• Filed: 08/23/1990
• Issued: 12/29/1992
• Est. Priority Date: 06/11/1990
• Status: Expired due to Term

• Current Assignee: Silicon Graphics International Corporation (Hewlett-Packard Enterprise Company)
• Original Assignee: Supercomputer Systems Limited Partnership
• Inventors: Masamitsu, Jon A., Strout, II, Robert E., Chandramouli, Ashok, Van Dyke, Don A., Cramer, Timothy J., Rasbold, James C., O'Hair, Kelly T., Cox, David M., Seberger, David A., O'Gara, Linda J.
• Primary Examiner(s): Lee, Thomas C.
• Assistant Examiner(s): DONAGHUE, LARRY D
• Application Number:
  US07/572,043
• Time in Patent Office: 859 Days
• Field of Search: 395/700, 395/800, 395/500, 364/200 MS File, 364/900 MS File
• US Class Current: 717/151
• CPC Class Codes: G06F 11/3664 Environments for testing or debugging software
• CPC Class Codes: G06F 12/023 Free address space management
• CPC Class Codes: G06F 12/08 in hierarchically structured memory systems, e.g. virtual memory systems
• CPC Class Codes: G06F 12/12 Replacement control
• CPC Class Codes: G06F 8/41 Compilation
• CPC Class Codes: G06F 8/433 Dependency analysis; Data or control flow analysis
• CPC Class Codes: G06F 8/445 Exploiting fine grain parallelism, i.e. parallelism at instruction level run-time instruction scheduling G06F9/3836
• CPC Class Codes: G06F 8/45 Exploiting coarse grain parallelism in compilation, i.e. parallelism between groups of instructions

Abstract

A modular compilation system that utilizes a fully integrated hierarchical representation as a common intermediate representation to compile source code programs written in one or more procedural programming languages into an executable object code file. The structure of the integrated common intermediate representation supports machine-independent optimizations, as well as machine-dependent optimizations, and also supports source-level debugging of the executable object code file. The integrated hierarchical representation (IHR) is language independent and is shared by all of the components of the software development system, including the debugger.

Claims

1. In a computer processor, a computer implemented method for compiling and optimizing a source code file written in one or more high level programming languages to produce an object code file and an integrated hierarchical representation file (the IHR file) for the source code file associated with the object code, both the object code file and the IHR file to be stored as electronic data files in a memory device, the object code file to be executed on a target computer processing system, the method comprising the steps of:

(a) compiling the source code file by performing the steps of;

(a1) for each high level programming language, generating a HiForm (HF) machine independent representation of the high level program language, the HF representation to be stored as part of the IHR file;

(a2) combining the HF representation for each high level programming language into a single HF representation;

(a3) storing the single HF representation as part of the IHR file;

(a4) generating context information and debug information for the source code file using the single HF representation and the source code file; and

(a5) storing the context information and debug information as part of the IHR file;

(b) optimizing the HF representation by performing the steps of;

(b1) in response to a first user-selected option, optimizing the single HF representation to reorganize the single HF representation and generate HF optimization information; and

(b2) storing the HF optimization information as part of the IHR file;

(c) translating the HF representation into a LoForm (LF) representation for the target computer processing system by performing the steps of;

(c1) generating a LoForm (LF) machine dependent, hierarchical representation for the HF representation for the target computer processing system; and

(c2) storing the LF representation as part of the IHR file;

(d) optimizing the LF representation by performing the steps of;

(d1) in response to a second user-selected option, optimizing the LF representation to reorganize the LF representation and generate LF optimization information; and

(d2) storing the LF optimization information as part of the IHR file; and

(e) generating the object code file by performing the steps of;

(e1) generating the object code file based upon the LF representation, including generating object code information;

(e2) storing the object code file in the memory device;

(e3) storing the object code information as part of the IHR file; and

(e4) storing the IHR file in the memory device,

such that the information stored in the IHR file is available during execution of the object code file on the target computer processing system.

2. The method of claim 1 further comprising the steps of:

(f) debugging the object code file by performing the steps of;

(f1) executing the object code file on the target computer processing system;

(f2) accessing the IHR file; and

(f3) analysing the information in the stored IHR file to debug the object code file.

3. The method of claim 2 wherein the programming languages include one or more high level language and an assembly language.

4. The method of claim 3 wherein the target computer processing system is a highly parallel multiprocessor system.

5. The method of claim 4 wherein the computer processor for performing steps (a)-(f) and the target computer processing system are comprised of a plurality of computer processors which are networked together.

6. The method of claim 5 wherein the step of debugging the object code file during execution by using the stored IHR file is accomplished in a distributed manner such that a user on one computer processor can debug a source code file executing on another computer processor.

7. In a computer system having a data storage device for storing computer data, wherein data for an integrated hierarchical representation file (IHR file) of a computer program executed on said computer system is stored in a data storage device and implemented on said computer system according to a data structure, said computer system comprising:

one or more computer processors for compiling, optimizing and debugging a source code file for the computer program to produce an object code file to be executed on a target computer processing system, said source code file including a series of high level programming language statements defining operations executed by said target computer processing system;

said data structure for storing data in the data storage device for the IHR tile comprises;

scope node means for storing one or more items of context information which defines one or more scopes within the source code file;

for each scope within the source code file, a plurality of symbol node means, each symbol node means for storing all items of information about a unique named object included in the high level programming language statements of the source code file;

for each scope within the source code file, a plurality of statement node means, each statement node means for storing one or more machine independent, common intermediate statements generated by the computer processor for each of the high level programming language statements included in the source code file;

the statement node means being operably linked to one another in a lexical order;

for each statement node means;

one of more expression node means, each expression node means for storing an operator or operand that together with the other expression node means define the operation indicated by the associated statement node means;

literal node means for storing a value for each constant operated on by the operation indicated by the associated statement node means;

type node means for storing a data type for each named object operated on by the operation indicated by the associated statement node means; and

LoForm node means for storing one or more machine dependent instruction generated for the target computer processing system for each expression node means;

wherein said computer system access said data structure to retrieve said information for compiling, optimizing and debugging said source code file for the computer program to produce said object code file executed on said target computer processing system.

8. The data structure for storing data in the data storage device of claim 7 further comprising:

for each scope within the source code file, block node means for storing the relationships of one or more basic blocks of statement node means in the source code file;

for each basic block, DUDe node means for storing any data dependences between named objects used within the basic block which are defined as variables in the source code file; and

for each scope within the source code file, loop node means for storing the relationships of any loops identified by the statement node means in the source code file,

such that the information contained in the block node means, the DUDe node means and the loop node means is generated by the computer processor as a result of optimizing the statement node means.

9. In a computer processor, a computer implemented method for compiling and optimizing a source code file comprising one or more program modules written in one or more programming languages to produce an object code file to be executed on a target computer processing system and an integrated hierarchical representation file (the IHR file) for the source code file associated with the object code, both the object code file and the IHR file to be stored as data files in a memory device, the method comprising the steps of:

(a) compiling each program module by performing for each program module the steps of;

(a1) generating a HiForm (HF) machine and language independent representation of the program module, the HF representation to be stored as part of the IHR file;

(a2) storing the HF representation as part of the IHR file;

(a3) generating context information and debug information for the source code file using the HF representation of the program module; and

(a4) storing the context information and debug information as part of the IHR file;

(b) optimizing the HF representation for each program module by performing the steps of;

(b1) in response to a first user-selected option, optimizing the HF representations of the program module to reorganize the HF representation and generate HF optimization information; and

(b2) storing HF optimization information as part of the IHR file;

(c) translating the HF representation into a LoForm (LF) representation for the target computer processing system for each program module by performing the steps of;

(c1) generating a LoForm (LF) machine dependent, hierarchical representation for the HF representation of each program module for the target computer processing system; and

(c2) storing the LF representation as part of the IHR file;

(d) optimizing the LF representation by performing the steps of;

(d1) in response to a second user-selected option, optimizing the LF representation of the one or more of the program modules to reorganize and generate LF optimization information; and

(d2) storing LF optimization information as part of the IHR for the source code file; and

(e) generating the object code file of the source code file based upon the LF representation of all of the program modules by performing the steps of;

(e1) generating the object code file based upon the LF representations of all of the program modules, including generating the object code information;

(e2) storing the object code information as part of the IHR file; and

(e3) storing the object code file and the IHR file in the memory device,

such that the information stored in the IHR file is available during execution of the object code file on the target computer processing system.

10. The method of claim 9 wherein the step (e1) includes the steps of:

(e11) generating a module object code file for each of the program modules; and

(e12) linking all of the module object code files into a single object code file.

11. The method of claim 10 wherein both step (c) and step (f2) include the step of inlining procedure calls.

12. The method of claim 9 wherein the IHR file is stored as a graphical structure and steps (c) and (e) include the step of performing graphical reductions on the IHR file.

13. The method of claim 9 wherein the programming languages include one or more high level language and an assembly language.

14. The method of claim 9 wherein the target computer processing system is a highly parallel multiprocessor system.

15. The method of claim 14 wherein the computer processor for performing steps (a)-(g) and the target computer processing system are comprised of a plurality of computer processors which are networked together.

16. In a computer processor, a method for performing source level debugging of an optimized object code file to be executed on a target computer processing system wherein the optimized object code file represents a source code file comprised of one or more program modules written in one or more high level programming languages, the method comprising the steps of:

(a) for each program module, generating a HiForm (HF) machine and language independent representation of the program module, the HF representation to be stored as part of an integrated hierarchical representation file (the IHR file) for the source code file in the form of a set of electronic data files to be stored in the computer processor;

(b) generating context information and debug information for the source code file using the HF representation of the program module and storing the context information and debug information as part of the IHR file;

(c) generating a LoForm (LF) machine dependent, hierarchical representation for the HF representation of each program module and storing the LF representation as part of the IHR file;

(d) generating an object code file based upon the LF representation of the source code file; and

(e) using the IHR file to debug the object code file as it is executed on the target computer processing system.

17. A computer implemented method for electronically organizing and storing data for an integrated hierarchical representation file (the IHR file) of a computer program for use with a compilation system having one or more storage mechanisms for storing data and having one or more computer processors for compiling, optimizing and debugging a source code file for the computer program to produce an object code file to be executed on a target computer processing system, the source code file being stored in the storage mechanism for the compilation system and including a series of high level programming language statements defining operations to be executed by the target computer processing system, the method comprising:

(a) identifying, organizing and storing as part of the IHR file one or more items of context information which defines one or more scopes within the source code file;

each such item of context information designated as a scope node;

(b) for each scope within the source code file, identifying, organizing and storing as part of the IHR file all items of information about each unique named object included in the high level programming language statements of the source code file, each such item of information designated as a symbol node within each scope node;

(c) for each scope within the source code file, identifying, organizing and storing as part of the IHR file one or more machine independent, common intermediate statements generated by the computer processor for each of the high level programming language statements included in the source code file, each such statement designated as a statement node, the statement nodes being operably linked to one another in a lexical order;

(d) for each statement node;

(d1) identifying, organizing and storing as part of the IHR file an operator or operand that together with the other operators or operands define the operation indicated by the associated statement node, each such operator or operand designated as an expression node;

(d2) identifying, organizing and storing as part of the IHR file a value for each constant operated on by the operation indicated by the associated statement node, each such value designated as a literal node;

(d3) identifying, organizing and storing as part of the IHR file a data type for each named object operated on by the operation indicated by the associated statement node, each such data type designated as a type node; and

(e) storing as part of the IHR file one or more machine dependent instruction generated for the target computer processing system for each expression node during the compilation process, each such instruction designated as a LoForm node,

such that the information stored in the IHR file is available during execution of the object code file on the target computer processing system.

18. The method of claim 17 further comprising the steps of using the computer processor to perform an optimization on the source code file, the optimization including the steps of:

(f) for each scope within the source code file, identifying, organizing and storing as part of the IHR file the relationships of one or more basic blocks of statement nodes in the source code file;

such relationships designated as block nodes;

(g) for each basic block, identifying, organizing and storing as part of the IHR file any data dependences between named objects used within the basic block which are defined as variables in the source code file;

such data dependences designated as DUDe nodes; and

(h) for each scope within the source code file, identifying, organizing and storing as part of the IHR file the relationships of any loops identified by the statement nodes in the source code file, such relationships designated as loop nodes.