WO1990003610A1 - Agencement pour le partage d'un code generique dans un systeme de traitement de donnees numeriques - Google Patents

Agencement pour le partage d'un code generique dans un systeme de traitement de donnees numeriques Download PDF

Info

Publication number
WO1990003610A1
WO1990003610A1 PCT/US1989/004098 US8904098W WO9003610A1 WO 1990003610 A1 WO1990003610 A1 WO 1990003610A1 US 8904098 W US8904098 W US 8904098W WO 9003610 A1 WO9003610 A1 WO 9003610A1
Authority
WO
WIPO (PCT)
Prior art keywords
sharable
instantiation
generic
program structure
program
Prior art date
Application number
PCT/US1989/004098
Other languages
English (en)
Inventor
Ronald F. Brender
Bevin R. Brett
Original Assignee
Digital Equipment Corporation
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Digital Equipment Corporation filed Critical Digital Equipment Corporation
Priority to JP1510377A priority Critical patent/JPH0731606B2/ja
Priority to EP89911161A priority patent/EP0390900B1/fr
Priority to DE68926956T priority patent/DE68926956T2/de
Publication of WO1990003610A1 publication Critical patent/WO1990003610A1/fr

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/40—Transformation of program code
    • G06F8/41—Compilation
    • G06F8/44—Encoding
    • G06F8/447—Target code generation

Definitions

  • the invention relates generally to the field of digital data processing systems, and more specifically to compilers which generate machine-executable code from a high-level language.
  • Programs detailing the operations to be performed by a digital data processing system, or computer are in the form of a series of instructions.
  • the computer performs one or more operations, as defined by an operation code portion of the instruction, on data which is identified, either explicitly or implicitly, in the instruction.
  • machine language In machine language, all of the instructions are in the form of sequences of Is and Os, which form a binary code that the computers could interpret and use *
  • a program is also -2- in the form of a sequence of instructions which the computer will process, but the operation code portion is in the form of a mnemonic abbreviation for the operation to occur, and the data to be processed by the instruction is typically identified by a variable name which represents the data's storage location in the computer.
  • An assembler program processes the assembly language program to produce a machine language program which the computer can execute. Since the instructions use mnemonic abbreviations, variable names and/or storage locations, programming using assembly language was greatly simplified over machine language programming.
  • assembly language programming made programming less confusing than machine language programming, it was very time-consuming since the programmer had to specify each and every operation to be performed by the computer to solve a problem.
  • the programmer could not limit his attention to the desired high-level arithmetic and logical operations to be performed by the computer in the processing the algorithm, but instead had to be aware of the operations that the computer would perform in connection with each instruction.
  • High-level languages were developed to remedy this. High-level languages freed the programmer from having to know the details of operation of the computer, and instead allowed him to concentrate on the algorithms themselves.
  • a compiler program processed the high-level language program to provide a machine-language program which could be executed by the computer, and as a result the compiler program effectively shielded the programmer from the computer.
  • programs written in high-level languages may typically be executed, after compilation, on diverse computers which typically can * not be done with programs written in assembly language or machine language. * " A problem with programs written in a high-level language, however, is that they are often somewhat slower than programs written in assembly language which accomplish the same results, and also they can take up much more memory.
  • some high-level languages permit a programmer to define certain sequences of operations or characteristics as a named generic program structure, called a generic package, generic procedure or generic function, and then use the generic structures elsewhere in the program -4- as they are needed merely by invoking the name and identifying, as parameters, the data to be used in forming the specific structure or performing the specific operations set forth in the previously-defined generic program structure.
  • This permits the programmer to use the program structure which has been previously defined, while at the same time avoiding repeating the program structure or sequence throughout the program.
  • the use of a generic program structure or sequence at a specific location in a program is termed an "instantiation" of the generic program structure or sequence, since it is a specific instance of the structure or sequence, using specific types o ' data, and so forth.
  • a single instance of the code sequence is generated which is used at each instantiation of the generic program structure or sequence.
  • the code sequence forming the instantiation must be sufficiently general as to be able to handle any of several types of data passed by way of the parameters which may be identified in the various instantiations. Since the code sequence must be able to handle very general situations, its generality may, in turn, adversely effect performance when the program is run.
  • the invention provides a new and improved system for facilitating code sharing- among instantiations of a generic program structure.
  • the invention provides a new and improved compiler system which maintains a library of -6- sharable program structures generated in response to instantiations of a generic program structure, along with characteristics of parameters which were used in generating the sharable program structure.
  • the compiler In response to an instantiation of a generic program structure, the compiler generates information relating to the characteristics of each parameter which are used in connection with the instantiation. The compiler then compares those characteristics to the characteristics associated with the sharable program structures in the library. If the library contains a sharable program structure the characteristics of whose parameters compare satisfactorily to the characteristics of the corresponding parameters, that sharable program structure is used in connection with further operations in connection with the instantiation.
  • the library does not contain such a sharable program structure, one is generated and stored in the library, along with characteristics of the parameters used in its generation, for use in sharing with later instantiations.
  • the just-generated sharable program structure is used in further operations in connection with the instantiation. -7-
  • the new compiler system provides several benefits. By basing sharing determinations on the actual characteristics and usage of the parameters, and by generating code based on those characteristics and usages, the run-time performance of the code can be improved over code that is generated by existing compilers to handle all possible instantiations as in the past.
  • the degree of sharing will be less than such compilers, resulting in somewhat larger object programs, they will be smaller than object programs in which all instantiations of generic program structures are expanded inline and no sharing is used.
  • Fig. 1 is a general functional block diagram illustrating the invention
  • FIGs. 2A through 2C depict a flow diagram illustrating the operation of the invention depicted in Fig. 1; and _ _
  • FIG. 3 and 4 depict diagrams of data structures useful in understanding the invention depicted in Fig. 1 and the operations depicted in Figs. 2A through 2C.
  • the invention provides a new and improved system, particularly comprising a compiler, for compiling high-level languages used in programming a digital data processing system which facilitates the declaration and use of a program structure or sequence (generally identified as a
  • the Ada programming language accommodates three types of generic program structures, namely, generic procedures, generic functions and generic packages.
  • procedures and functions provide program structures which define named sequences of operations
  • packages provide program structures which allow the specification of named groups of logically related entities or objects, which are then used in the program by reference to the name.
  • Generic procedures and functions provide generic program structures which may -9- be instantiated in the program to provide specific sequences of operations by reference to the name of the generic procedure or function in connection with particular parameters.
  • generic packages provide generic program structures which may be instantiated in the program to provide a specification of a named group of logically related entities or objects by reference to the name of the generic package in connection with particular parameters.
  • each generic program structure includes a generic declaration followed by a generic body.
  • the generic declaration provides a name for the generic program structure and identifies the parameters.
  • the generic declaration also identifies the entities or objects which form the group identified by the package's name.
  • the generic body of a generic program structure identifies the sequence of operations which are to be performed in connection with execution of the program structure.
  • entities or objects which are declared in the generic declaration may be computed in relation to a sequence of operations defined in the generic body.
  • the generic declaration and generic body portions of a -10- generic program structure may be separately set forth in a program, and, indeed, may be separately compiled, and are linked to provide an object program which may be executed by the computer.
  • the generic declaration identifies the generic program structure as being available for use later in the program, regardless of whether the generic body has been provided.
  • the generic body may be provided separately. When the generic body is provided, it is used in connection with generation of instantiations of the generic program structure set forth in the program.
  • This illustrative generic program structure provides a -11- generic program structure, named SWAP, that can be used to create instances comprising non-generic procedures which, in turn, can be used to swap the values of two variables.
  • "T" represents a formal data type, which is also a formal parameter of the generic program structure.
  • an actual parameter representing an actual data type, is specified when the generic program structure is used to create the instance.
  • Formal type "T” is identified in the generic declaration as "private" to indicate that only certain operations may be performed in connection with variables of that type within the generic structure; consequently, a wide class of actual types can be used as an actual parameter in an instantiation to correspond to this formal data type.
  • the illustrative generic program structure. can be used to create instances comprising non-generic procedures.
  • an instantiation as a procedure, may itself include formal parameters for which corresponding actual parameters must be provided when the procedure is called.
  • the formal parameters for the instantiation are variables X and 3610
  • variables representing formal parameters of an instantiation may be identified as input parameters, that is, parameters whose values are provided by the containing program, by use of the designation "in”.
  • variables representing formal parameters of an instantiation may be identified as output parameters, that is, parameters whose values are used by the containing program, by use of the designation "out”.
  • a variable whose value is both provided by the containing program and used by the containing program is identified by the designation "in out”.
  • a generic program structure includes a declaration portion which identifies the structure as generic and identifies the parameters, and a body portion which defines a sequence operations in connection with the parameters, which are of the formal private type T.
  • the generic program structure can be thereafter instantiated in the program for use in connection with fixed point or integer data by the following: -13- procedure SWAP_INT is new SWAP(INTEGER) ; which creates, as an instance, a procedure named SWAP_INT which can swap integer data, that is, data having a data type named INTEGER.
  • procedure SWAP_FLOAT is new SWAP(FLOAT) ; which creates, as an instance, a procedure named SWAP_FLOAT which can swap floating point data, that is, data having a data type named FLOAT.
  • the generic program structure thus is instantiated by identifying the generic program ' structure by its name, which in this case is SWAP.
  • parameters may be specified in the instantiation which are specific to the instantiation.
  • the compiler In creating an instantiation of the generic program structure, the compiler generates code which enables the operations defined by the generic program structure to be performed on the values identified by the input parameters and which provides as output values in response thereto which may be used in the portion of the program following the instantiation.
  • the compiler performs syntactic analysis in connection with the instantiation, to verify that the instantiation is correctly specified syntactically, and semantic analysis to verify that the instantiation is correctly specified semantically.
  • syntactic analysis the compiler attempts to recognize both the individual words and the sequence of words used in the instantiation to verify, among other things, that the words define operations which it recognizes.
  • semantic analysis the compiler performs a number of checks, including the verification that the actual parameters defined in the instantiation are consistent with the formal parameters defined in the generic declaration portion of the generic program structure.
  • the compiler maintains a compilation library 12 in which it stores, among other information used during the compilation, for each generic program structure, sharable units of compiled program code which may be shared among instantiations.
  • Each sharable unit includes, for each formal parameter in the generic program structure, a representative actual parameter which contains information as to the properties of the associated formal parameter -15- which were used in connection with generating the compiled program code for the sharable unit.
  • each record 14 comprises a sharable unit comprising a sharable declaration 15, which is associated with the structure's generic declaration.
  • each record 14 may include one or more sharable units comprising sharable bodies 16(1) through 16(N) (generally identified by reference numeral 16) associated with the generic program structure's generic body.
  • the sharable body portion of the generic program structure may be provided separately, and until it is provided the record 14 will not contain any sharable bodies 16.
  • Each sharable declaration 15 is associated with • compiled program code relating to the generic declaration portion of the generic program structure compiled in connection with representative actual parameters which detail characteristics of the parameters that were used in generating the compiled program code.
  • declaration portion of a generic procedure or generic 03610
  • the compiled program code associated with a sharable declaration 15 may, for example, comprise code which indicates the instantiation of the generic procedure or generic function at the location in the program.
  • the compiled program code may comprise code used to specify a named group of logically related entities or objects at the location in the program.
  • each sharable body 16 is associated with compiled program code enabling the performance of the operations defined by the generic body compiled in connection with a set of representative actual parameters, which also detail characteristics of the parameters that were used in generating the compiled program code associated with the sharable body 16.
  • a generic program structure may be associated with one or more records 14.
  • a generic program structure may be associated with multiple records 14 if the various instantiations of the generic program structure require creation of multiple sharable declarations 15.
  • each sharable declaration 15 and sharable body 16 includes, for each formal parameter in the generic program structure, a representative actual parameter which includes such information as the characteristics used in connection with its compilation.
  • a sharable declaration 15 or sharable body 16 generated for one instantiation may be used for a second instantiation if the characteristics of the actual parameters of the second instantiation correspond to the characteristics which were used in generating the sharable declaration 15 or sharable body 16, respectively, which were recorded in the representative actual parameters of the sharable declaration 15 and sharable body 16.
  • the characteristics of the representative actual parameters which are used in compiling a sharable declaration 15 in response to an instantiation provide a limitation on the use of the sharable declaration 15 in connection with other instantiations.
  • the characteristics of the representative actual parameters which are used in compiling a sharable body 16 in response to an instantiation of a generic program structure provide a limitation on the sharing of a sharable body 16 in connection with other instantiations of the generic program structure.
  • the compiler first attempts to locate a record 14 which contains a sharable declaration 15 which it can use in connection with the instantiation.
  • the compiler bases its selection of a record 14 on the characteristics of the instantiation's actual parameters and those recorded in the representative actual parameters of the sharable declaration 15 in the record.
  • the compiler determines, based on the characteristics of the actual parameters of the particular instantiation being compiled, and the characteristics recorded in the representative actual parameters of the sharable declaration in the records 14, that no records 14 contain sharable declarations that may be used for the instantiation, it creates a new record 14, including a new sharable declaration 15, and links -it in the library 12.
  • the sharable declaration 15 includes representative actual parameters that identify characteristics that were used in compiling the sharable declaration 15.
  • the new sharable declaration is available for that instantiation, and also for sharing with subsequent instantiations of the generic program structure.
  • the compiler locates a record 14 which contains a sharable declaration 15 which it can use in connection with compiling an instantiation 10, and if the record contains sharable bodies 16, it attempts to locate a sharable body which it can use in connection with the instantiation. In doing this, it compares the characteristics of the instantiation's actual parameters with the characteristics recorded in the representative actual parameters of each of the sharable bodies 16. If the record 14 contains a sharable body 16 whose representative actual parameters contain characteristics that compare satisfactorily with the characteristics of the actual parameters associated with the instantiation 10, the compiler uses that sharable body 16 in connection with compilation of the instantiation 10.
  • the compiler determines, based on the characteristics of the actual parameters of the particular instantiation being compiled, and the characteristics recorded in the representative actual parameters of the sharable bodies 16 in the record 14, that -20- none of the sharable bodies 16 in the record 14 may be used for the instantiation, it compiles a new sharable body 16 and links it to the sharable declaration 15, including representative actual parameters, each identifying the characteristics of the corresponding actual parameter that were used in compiling the sharable body 16.
  • the new sharable body 16 is thus available for that instantiation, and also for sharing with subsequent instantiations of the generic program structure.
  • a number of characteristics may be references in connection with the actual parameters of an instantiation 10 and the representative actual parameters of a sharable declaration 15 or sharable body 16 in determining whether a sharable declaration 15 or sharable body 16 may be used for -21- the instantiation 10.
  • the detail of the characteristics may vary from very specific to somewhat general. If the characteristics are specific, sharable declarations 15 and sharable bodies 16 are less likely to be shared, but the compiled program code 1 for the sharable declaration 15 and sharable body 16 need 1 not be general so as to handle the general characteristics.
  • sharable declarations 15 and sharable bodies 16 are more likely to be shared but the compiled program code therefor will be general enough to handle the more general characteristics.
  • Illustrative characteristics include, for example, whether the data represented by the representative actual parameters are fixed or floating, that is, whether the data are of type INTEGER or FLOAT, whether the data are byte, word, longword, single or double precision, whether the data are aligned by bit, byte or other boundaries, whether the data are arithmetic, string data, numerical ranges and so forth.
  • the new compiler thus enhances sharing of declarations and bodies by basing sharing decisions on characteristics of the actual parameters associated with an instantiation and the declarations and code that are actually used during compilation of an instantiation, which are reflected in the characteristics recorded in the representative actual parameters in the sharable declarations 15 and sharable bodies 16.
  • prior arrangements which allowed sharing, only formal parameters were used in determining whether sharing was permitted.
  • compilation of an instantiation required either that all possible characteristics of the actual parameters be taken into account in generating the code, or that sharing be restricted.
  • the compiler generated code for each instantiation which eliminated problems relating to generality of the compiled code, but effectively precluding sharing and unduly increased the amount of code generated.
  • the general functions of the new compiler are divided into a front end whose operations depend upon the language of the source progra , and a back end whose operations depend upon the program code which is recognizable by the particular computer which is to execute the program.
  • the front end performs lexical and syntactic analysis on the source program to identify the sequential high-level language instructions and determine that each is correctly stated within the context of the rules of the high-level language, static semantic analysis which, in part, verifies whether the sequences of instructions are properly stated, and generates an intermediate code.
  • the back end from the intermediate code, generates an object code program which includes instructions recognizable by the computer'which is to execute the program.
  • source programs are written in modules which may be separately compiled, and linked by ⁇ arlinker (which is typically not part of the compiler) to form a complete program which may be executed by the computer.
  • the front end identifies sequences of one or more source program instructions which it processes as a unit.
  • the front end iteratively processes the source program instruction sequences to determine whether they form or contain a generic program structure or element thereof, such as a generic declaration or generic body (step 100, Fig. 2A) . If so, it links the generic program structure in the library 12 (step 101, Fig. 2A) .
  • the front end determines, in step 100 that a source program instruction sequence does not form or contain a generic program structure, it sequences to step 102.
  • the front end determines whether the source program instruction sequence forms an instantiation of a generic program structure. If not, it sequences to step 103 and proceeds to compile the source program instruction sequence using conventional compilation techniques. '
  • the front end determines in step 102 that the source program instruction sequence forms or contains an instantiation, it sequences to step 104, in which it generates an instantiation specification and an instance generator and links them into the compilation library 12 (step 104) .
  • the instantiation specification identifies the generic program structure being instantiated and the parameters, and the instance generator includes an instantiation map 25 (Fig. 3) .
  • SWAP_INT is new SWAP(INTEGER) ; to: procedure SWAP_INT is new SWAP(INTEGER) ; [1] procedure SWAP_INT (X, Y: in out INTEGER) ; + ⁇ where the formal parameters for SWAP_INT [2] result from copy substitution from the j generic declaration, replacing generic
  • procedure SWAP_INT (X, Y: in out INTEGER) is separate; [4] which indicates that the operations performed in response to the procedure call are separately provided, in this case an instance generator unit, and creating the instance generator as follows: separate (PROC) [5] procedure SWAP_INT (X, Y: in out INTEGER) is —+
  • the instantiation map 25 contains fields for much of the information which is used in completing compilation of the instance generator 20. Not all of the fields receive information when the instance generator 20 is generated; some of the information in the fields is provided later during completion of the instance generator 20.
  • the general structure of an instantiation map 25 is depicted in Fig. 3. With reference to Fig. 3, the instantiation map 25 includes a number of fields for pointers to the formal and actual parameters, the generic declaration and body, which is also linked in the compilation library 12, and the record 14 associated with the generic program structure and sharable declaration 15 and sharable body 16 which has been selected to be used in connection with compilation of the instantiation.
  • the instantiation map includes two fields related to the parameters of the generic program structure and the instantiation.
  • a FORMAL_CV field 30 contains a pointer to a formals counted vector.
  • the formals counted vector in turn, ' includes a first entry whose contents indicate the number of additional entries in the vector, with each of the additional entries comprising a pointer to a formal parameter in the generic program structure.
  • An ACTUAL_CV field 31 contains a pointer to an actuals counted vector, which in turn includes a first entry whose contents indicate the number of additional entries in the vector, with each of the additional entries containing a pointer to an actual parameter.
  • Each of the sequential entries in the counted vector pointed to by the contents of the ACTUAL_CV field 31 corresponds to the sequential entry in the counted vector pointed to by the contents of the FORMAL_CV field 30.
  • the instantiation map 25 also includes a number of other pointer fields which point to the various portions of the instance generator with which the instantiation map 25 is associated.
  • the contents of a INST_DECL_POINTER instantiation declaration pointer field 32 points to an instantiation declaration associated with the instantiation map 25.
  • the contents of a BODY_DECL_POINTER body declaration pointer 34 points to a specification declaration associated with the instantiation map 25.
  • the contents of a BODY_TEMPL_POINTER body template pointer field 35 points to a body declaration.
  • the instantiation map 25 also includes several pointer fields to the generic program structure related to the instantiation and to context information.
  • the contents of a GEN_DECL_POINTER generic declaration pointer field 33 points to the generic declaration portion of the generic program structure.
  • the generic program structure may be declared and used elsewhere in a program without initially providing the body or details of operations. If this occurs, the contents of a STUB_DECL field 37 provides a location into which a pointer to a compilation unit for the bodyor details of operations may be inserted.
  • the last pointer in the instantiation map 25 is a SHAR_UNIT_POINTER sharable unit pointer field 40 into which the compiler loads a pointer identifying the location of a sharable declaration 15 or sharable body 16.
  • the SHAR_UNIT_POINTER sharable unit pointer field 40 may point to a sharable unit which has previously been generated, or -29- it may point to a sharable unit which is being generated in response to the instance generator and which may be later used in connection with other instance generators.
  • the instantiation map 25 includes several flags, including an INST_GEN instantiation generator flag 41, a TEMPL_IS_INCOMPL body is incomplete flag 42, a SHAR_BODY sharable body flag 43 and an IMP_INST_GEN implicit instance generator flag 44.
  • the conditions of the INST_GEN instantiation generator flag 41 and SHAR_BODY sharable body flag 43 indicate whether the instantiation map 25 is part of an instance generator.
  • the generic program structure may be declared without initially providing a generic body, and the condition of the TEMPL_IS_INCOMPL template is incomplete flag 42 is used during compilation to indicate whether the generic body has been provided.
  • the front end identifies actual parameters associated with the instantiation (step 105) , which are recorded by the ACTUALS_CV actuals counted vector in the instantiation map 25 associated with the instantiation, and passes the instance generator, including the instantiation map to the back end.
  • the back end Upon receiving the instance generator, the back end proceeds to determine if the compilation library 12 contains any sharable declarations 15 that can be used for the instantiation (step 106, Fig. 2A) . In this operation, the back end obtains from the compilation library 12 the identification of records 14 associated with the generic program structure being instantiated, and searches through their sharable ' declarations 15 to identify one which can be used in connection with the instantiation.
  • the back end identifies a sharable declaration 15 which may be used in connection with compilation of the instantiation (step 106) by comparing characteristics of the representative actual parameters which were used in generating the sharable declaration with the characteristics of the actual parameters in the declaration of the instantiation which were supplied by the back end.
  • the back end returns to the front end either the identification of a sharable declaration the characteristics of whose representative actual parameters match the characteristics of the actual parameters of the instantiation, or alternatively an indication that no such sharable declaration 15 exists (step 107) .
  • the subsequent operations of the front end are determined by whether or not the back end returns the identification of a sharable declaration 15 which is to be used in connection with the compilation of the instantiation. If the back end does not, in step 107, return the identification of a sharable declaration 15, the front end proceeds with the creation of a sharable ' declaration 15 (step 110, Fig. 2B) using the generic declaration, the instance generator, and the actual parameters of the instantiation. As part of this process, the front end creates representative actual parameters and includes them as part of the sharable unit. At this point in the compilation, the representative actual parameters reflect only the properties of the generic formal parameters associated with the generic declaration, except that each also contains a pointer to the corresponding actual parameter associated with the instantiation.
  • the front end then suspends compilation of the source program instruction sequence that contains the instantiation and passes the newly created sharable unit to the back end to complete processing and code generation for the sharable unit.
  • the back end updates the representative actual parameters to reflect characteristics of the actual parameters that it found to be needed and which it used during generation of the object code.
  • the back end When the back end is finished, it eliminates, from the representative actual parameters, the pointers to the actual parameters of the instantiation, so that the sharable unit becomes independent of the instantiation.
  • the 'back end then links the sharable unit in the compilation library 12 in a new record associated with the generic program structure (step 111) , completing the creation of the sharable unit.
  • the front end then resumes processing of the source program instruction sequence that includes the instantiation.
  • the newly-created sharable declaration 15 is then identified as the sharable declaration to be used in connection with the compilation of the instantiation by inserting a pointer to it in the SHAR__UNIT_POINTER sharable unit pointer field 40 of the instantiation map 25 of the instance generator associated with the instantiation.
  • the structure of a sharable declaration 15 is depicted in Fig. 4. It will be appreciated that the structure of a sharable declaration 15 is similar to the structure of an instantiation.
  • the sharable declaration includes a DECL_HEAD declaration head node 50 which points to an INST_DECL instantiation declaration node 51, an SPEC_DECL specification declaration node 52 and a B0DY_DECL body declaration node 53.
  • the INST__DECL instantiation declaration node 51 points to ⁇ the instance generator which resulted in creation of the sharable declaration 15.
  • the SPEC_DECL specification declaration node 52 and B0DY_DECL body declaration node 53 point to the generic specification and generic body in the generic program structure.
  • the BODY_DECL body declaration node 53 also points to the various sharable bodies 1.6 created in response to the generic body of the generic program structure when it is provided. As noted above, the generic body may be provided separately of the generic declaration.
  • the DECL_HEAD declaration head node 50 also includes an IS_SHARED flag 54 which is conditioned to indicate that the sharable declaration 15 can be shared.
  • -34- node 50 also includes a pointer 55 to a buffer 56 which contains the representative actual parameters which were used in connection with creation of the sharable declaration
  • the order of the sequence of representative actual i parameters in buffer 56 is the same as the order of the formal parameters in the declaration of the generic program structure. While the back-end is generating the object code, it accumulates, in the buffer 56, the information identifying the characteristics of the representative actual parameters which it used in the code generation.
  • the representative actual parameter may include such information as the data representation, the alignment and the size.
  • the alignment information indicates whether the parameter is to be aligned on a bit, byte or word boundary.
  • the size information may indicate, for example, whether the parameter represents a single element or value, or an array of values, and the number of bytes required to represent each value.
  • each representative actual parameter also includes information specific to the data type of the parameter, as indicated by the formal parameters.
  • the representative actual parameter includes such information as whether the parameter is represented as an arithmetic progression, and, if so, identifies how the first element is represented and the spacing between values of the elements of the progression.
  • the representative actual parameter identifies the number of bytes required to represent each element of the progression.
  • the representative actual parameter identifies the smallest value and a delta value. If the data type is PRIVATE, the representative actual parameter provides such information as how an object of the type is to be initialized, how objects are to be compared for equality, constraints, and whether the actual is a composite type or an array type. If the formal parameter is a formal object, the representative actual parameter may also include such information as the location of the actual parameter, whether the object is stored in biased, or otherwise encoded form, and constraints on the formal object. it will be appreciated that the number of types of usage information that is selected governs the degree of sharing which can be accomplished. Each type of usage information which is provided reflects a factor that is used -36- in code required for the instantiation.
  • step 107 if the back end has located a suitable sharable declaration for the instantiation, or following step 111 (Fig. 2B) , the front end generates code in the intermediate language to be used at the site of the instantiation in the generated code sequence (step 112, Fig. 2B) .
  • the front end then performs a merge operation in which it merges information from the sharable declaration 15 into the intermediate language code at the instantiation site (step 113). Thereafter, it performs an allocation operation for an activation record to allocate run-time space for the instantiation (step 114) . Since the size of the activation record may not be determined until link -time, a link-time symbol is used to allocate the activation record, which may be replaced by the -37- linker in a conventional manner with code to allocate the run-time space for the instantiation.
  • the front end determines whether the generic body for the generic program structure has been provided or modified since the last compilation. If the generic body has not been provided or modified, the front end returns to step 100 (Fig. 2A) to process the next source program code sequence. On the other hand, if the generic body has been provided, the front end proceeds to complete the instance generator for the instantiation (step 114) , by completing the instantiation map associated with the instantiation. In completing the instance generator, the front end first initiates location or generation of a sharable body 16 in the record 14 associated with the sharable declaration 15 selected for the sharable declaration of the generic program
  • the sharable body 16 has a structure similar to that shown in Fig. 4 in connection with a sharable declaration 15, including the representative actual parameters and associated characteristics identifying the usage information used .in generating the sharable body 16.
  • the operations performed in connection with location or creation of the sharable body 16 namely, steps 117 and 120 through 122, Fig. 2C) are similar to those described above in connection with location or creation of the sharable declaration 15.
  • the front end proceeds to complete the instance generator associated with the instantiation (step 123) .
  • An incomplete instance generator is identified by the TEMPL_IS_INCOMPL body is incomplete flag having the appropriate condition.
  • the instantiation pointers associated with the generic body identify the " various instantiations associated therewith.
  • each instance generator pointed to is completed in order.
  • the address of the activation record in the compilation library 12 is then determined.
  • the result is then passed to the back-end for code generation of the instantiation in a conventional manner using the pointers in the instantiation map 25.
  • the generic body may later be modified. If that occurs, the completed instance generator may be modified to reflect the modifications to the generic body.
  • a number of characteristics of the representative actual parameters can be used in determining whether a previously-generated sharable declaration 15 or sharable body 16 can be used in connection with a particular instantiation.
  • the degree of detail serves to determine the degree of sharing which can be accommodated.
  • various matching rules may be used in determining whether characteristics of the representative actual parameters of a sharable declaration 15 would permit sharing.
  • the characteristics of the instantiation's actual"parameters and sharable declaration's representative actual parameters may be required to be the same if the representative actual parameters are a variable or a constant.
  • a matching rule may require the size of the instantiation's array to correspond to the size of the sharable declaration's array. It will be appreciated that other matching rules may also be used.
  • the new compiler provides several benefits. For example, by basing determinations of whether a declaration or body can be shared in an instantiati ⁇ n on the actual characteristics and usage of the parameters, and by generating code for the declaration and body based on those characteristics and usages, the run-time performance of the code can be improved over code generated by prior compilers to handle all possible instantiations as in the past.
  • the degree of sharing will be less than such prior compilers, resulting in somewhat larger object programs, they will be smaller than object programs in which all instantiations of generic program structures are expanded inline and no sharing is used.

Landscapes

  • Engineering & Computer Science (AREA)
  • General Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Software Systems (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • Devices For Executing Special Programs (AREA)
  • Stored Programmes (AREA)
  • Communication Control (AREA)

Abstract

Un compilateur gère une bibliothèque de structures de programme partageables générées en réponse à des instanciations d'une structure de programme générique, en combinaison avec les caractéristiques des paramètres utilisés lors de la génération de la structure de programme partageable. En réponse à une instanciation d'une structure de programme générique, le compilateur produit des informations relatives aux caractéristiques et à l'utilisation de chaque paramètre utilisé en combinaison avec l'instanciation. Le compilateur compare ensuite ces informations aux informations correspondantes associées avec les structures de programme partageables dans la bibliothèque. Si cette dernière contient une structure de programme partageable dont les informations sur les paramètres correspondent, cette structure de programme partageable est utilisée en combinaison avec les autres opérations relatives à l'instanciation. Si, d'autre part, la bibliothèque ne contient pas une telle structure de programme partageable, cette structure est générée et enregistrée dans la bibliothèque, avec les caractéristiques des paramètres utilisés lors de sa génération, de manière à pouvoir l'utiliser en la partageant avec d'autres instanciations. En outre, la structure de programme partageable qui vient d'être générée est utilisée dans d'autres opérations relatives à l'instanciation.
PCT/US1989/004098 1988-09-20 1989-09-19 Agencement pour le partage d'un code generique dans un systeme de traitement de donnees numeriques WO1990003610A1 (fr)

Priority Applications (3)

Application Number Priority Date Filing Date Title
JP1510377A JPH0731606B2 (ja) 1988-09-20 1989-09-19 デジタルデータ処理システム用総称コード共用化装置及び方法
EP89911161A EP0390900B1 (fr) 1988-09-20 1989-09-19 Agencement pour le partage d'un code generique dans un systeme de traitement de donnees numeriques
DE68926956T DE68926956T2 (de) 1988-09-20 1989-09-19 Anordnung zur teilung eines generischen kodes für ein digitales datenverarbeitungssystem

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US24697588A 1988-09-20 1988-09-20
US246,975 1988-09-20

Publications (1)

Publication Number Publication Date
WO1990003610A1 true WO1990003610A1 (fr) 1990-04-05

Family

ID=22932994

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/US1989/004098 WO1990003610A1 (fr) 1988-09-20 1989-09-19 Agencement pour le partage d'un code generique dans un systeme de traitement de donnees numeriques

Country Status (7)

Country Link
US (1) US5280617A (fr)
EP (1) EP0390900B1 (fr)
JP (1) JPH0731606B2 (fr)
AT (1) ATE141423T1 (fr)
CA (1) CA1324834C (fr)
DE (1) DE68926956T2 (fr)
WO (1) WO1990003610A1 (fr)

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP0582738A1 (fr) * 1992-08-12 1994-02-16 International Business Machines Corporation Compilateur
FR2823871A1 (fr) * 2001-04-20 2002-10-25 Canon Kk Procede et dispositif de generation du code executable d'un programme d'ordinateur

Families Citing this family (36)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5659753A (en) * 1991-02-27 1997-08-19 Digital Equipment Corporation Interface for symbol table construction in a multilanguage optimizing compiler
DE69216020T2 (de) 1991-03-07 1997-07-10 Digital Equipment Corp Verbessertes fehlersuchsystem und -verfahren, besonders für die fehlersuche in einer multi-architekturumgebung
JPH0778742B2 (ja) * 1992-08-12 1995-08-23 インターナショナル・ビジネス・マシーンズ・コーポレイション コンピユータ・プログラム言語変換装置及びその方法
US6209040B1 (en) * 1992-10-09 2001-03-27 Microsoft Corporation Method and system for interfacing to a type library
JPH06332678A (ja) * 1993-05-18 1994-12-02 Software Kouchiku Kagaku Kenkyusho:Kk 特定業務用プログラムの製造方法
CA2123924A1 (fr) * 1993-06-02 1994-12-03 Charles Douglas Blewett Definition de contextes en programmation a rappel
JPH07319710A (ja) * 1994-05-20 1995-12-08 Matsushita Electric Ind Co Ltd コンパイル処理方法
US5590331A (en) * 1994-12-23 1996-12-31 Sun Microsystems, Inc. Method and apparatus for generating platform-standard object files containing machine-independent code
US5774726A (en) * 1995-04-24 1998-06-30 Sun Microsystems, Inc. System for controlled generation of assembly language instructions using assembly language data types including instruction types in a computer language as input to compiler
US5701489A (en) * 1995-06-06 1997-12-23 International Business Machines Corporation System for partial in-line expansion of procedure calls during program compilation
US5835771A (en) * 1995-06-07 1998-11-10 Rogue Wave Software, Inc. Method and apparatus for generating inline code using template metaprograms
US6112025A (en) * 1996-03-25 2000-08-29 Sun Microsystems, Inc. System and method for dynamic program linking
CA2178898C (fr) * 1996-06-12 2000-02-01 David Joseph Streeter Sequencement d'instanciations de modeles et detection des erreurs dans ces instanciations durant la compilation de programmes c++
US5857070A (en) * 1996-11-22 1999-01-05 Hewlett-Packard Company Method for locating errors in a computer program
US6021273A (en) * 1997-06-30 2000-02-01 Sun Microsystems, Inc. Interpreter generation and implementation utilizing interpreter states and register caching
US6052750A (en) * 1998-01-06 2000-04-18 Sony Corporation Of Japan Home audio/video network for generating default control parameters for devices coupled to the network, and replacing updated control parameters therewith
US6560774B1 (en) * 1999-09-01 2003-05-06 Microsoft Corporation Verifier to check intermediate language
KR100491883B1 (ko) * 2000-12-28 2005-05-31 엘지전자 주식회사 코바 플랫폼을 이용한 동적 데이터베이스 처리방법
CA2355989A1 (fr) * 2001-08-27 2003-02-27 Ibm Canada Limited-Ibm Canada Limitee Code source de compilation
US8136109B1 (en) 2002-04-19 2012-03-13 Tibco Software Inc. Delivery of data and formatting information to allow client-side manipulation
US7353521B1 (en) 2002-10-19 2008-04-01 Borland Software Corporation Object oriented distributed software system with methodology for piggybacked reflective callbacks
US6876314B1 (en) 2004-02-18 2005-04-05 Robocoder Corporation Self-generating automatic code generator
US7440863B2 (en) * 2005-04-29 2008-10-21 Agilent Technologies, Inc. Integrated tool for compliance testing within an enterprise content management system
US7890285B2 (en) * 2005-04-29 2011-02-15 Agilent Technologies, Inc. Scalable integrated tool for compliance testing
US20080243943A1 (en) * 2007-03-27 2008-10-02 Shih-Wei Liao Method and apparatus for efficient execution of interprocedural transactional memory code while maintaining safety
US7685565B1 (en) 2009-03-19 2010-03-23 International Business Machines Corporation Run time reconfiguration of computer instructions
JP2011203960A (ja) * 2010-03-25 2011-10-13 Fujitsu Ltd テンプレートコンパイル方法及びテンプレートコンパイル装置
US8930913B2 (en) 2010-09-28 2015-01-06 Microsoft Corporation Intermediate representation construction for static analysis
US9251554B2 (en) 2012-12-26 2016-02-02 Analog Devices, Inc. Block-based signal processing
US8856748B1 (en) 2013-09-17 2014-10-07 Xamarin Inc. Mobile application testing platform
US8881111B1 (en) 2013-09-17 2014-11-04 Xamarin Inc. Testing user interface responsiveness for mobile applications
US9183020B1 (en) 2014-11-10 2015-11-10 Xamarin Inc. Multi-sized data types for managed code
US9213638B1 (en) 2015-03-24 2015-12-15 Xamarin Inc. Runtime memory management using multiple memory managers
US9201637B1 (en) 2015-03-26 2015-12-01 Xamarin Inc. Managing generic objects across multiple runtime environments
CN110709814A (zh) * 2017-06-02 2020-01-17 三菱电机株式会社 程序代码生成装置和程序代码生成程序
US10572275B2 (en) * 2017-06-15 2020-02-25 Microsoft Technology Licensing, Llc Compatible dictionary layout

Family Cites Families (8)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
IT1059493B (it) * 1976-04-22 1982-05-31 Olivetti & Co Spa Dispositivo per cambiare l ambiente di lavoro di un calcolatore
US4672532A (en) * 1982-06-14 1987-06-09 Tektronix, Inc. Software/hardware integration control system
US4742467A (en) * 1984-05-04 1988-05-03 Analysts International Corporation Automated programming system for machine creation of applications program source code from non-procedural terminal input
US5142681A (en) * 1986-07-07 1992-08-25 International Business Machines Corporation APL-to-Fortran translators
US5179703A (en) * 1987-11-17 1993-01-12 International Business Machines Corporation Dynamically adaptive environment for computer programs
US5051893A (en) * 1988-07-11 1991-09-24 Digital Equipment Corporation System for processing data to facilitate the creation of executable images
US5062039A (en) * 1988-09-07 1991-10-29 International Business Machines Corp. Sharing of workspaces in interactive processing using workspace name tables for linking of workspaces
US5204947A (en) * 1990-10-31 1993-04-20 International Business Machines Corporation Application independent (open) hypermedia enablement services

Non-Patent Citations (3)

* Cited by examiner, † Cited by third party
Title
Ada-Europe / Ada TEC Joint Conference on Ada, Brussels, BE, March 1983, G. BRAY: "Implementation Implications of Ada Generics", pages 9/1-10 see section 3.3 *
Proceedings of the ACM Sigplan '84 Symposium on Compiler Construction Sigplan Notices, Volume 19, No. 6, June 1984, ACM, (US), G. BRAY: "Sharing Code Among Instances of Ada Generics", pages 276-284 see figure 1; section 3 *
Transactions of the Information Processing Society Japan, Volume 27, No. 7, July 1986, S. KOIZUMI: "A Method for Sharing Executable Programs Derived from Generic Units in Ada", pages 671-678 *

Cited By (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP0582738A1 (fr) * 1992-08-12 1994-02-16 International Business Machines Corporation Compilateur
US5414855A (en) * 1992-08-12 1995-05-09 International Business Machines Corporation Language compiler
FR2823871A1 (fr) * 2001-04-20 2002-10-25 Canon Kk Procede et dispositif de generation du code executable d'un programme d'ordinateur

Also Published As

Publication number Publication date
JPH0731606B2 (ja) 1995-04-10
JPH03500463A (ja) 1991-01-31
ATE141423T1 (de) 1996-08-15
US5280617A (en) 1994-01-18
EP0390900B1 (fr) 1996-08-14
DE68926956T2 (de) 1997-03-27
EP0390900A1 (fr) 1990-10-10
CA1324834C (fr) 1993-11-30
DE68926956D1 (de) 1996-09-19

Similar Documents

Publication Publication Date Title
US5280617A (en) Automatic program code generation in a compiler system for an instantiation of a generic program structure and based on formal parameters and characteristics of actual parameters
Dewar et al. Programming by refinement, as exemplified by the SETL representation sublanguage
US6745384B1 (en) Anticipatory optimization with composite folding
Grant et al. DyC: an expressive annotation-directed dynamic compiler for C
US6314562B1 (en) Method and system for anticipatory optimization of computer programs
US5142681A (en) APL-to-Fortran translators
US6002879A (en) Method for performing common subexpression elimination on a rack-N static single assignment language
US5367683A (en) Smart recompilation of performing matchup/difference after code generation
EP0496494A2 (fr) Système d'entretien de software
US20090150864A1 (en) Declarative object identity
EP0529049B1 (fr) Programme compilateur d'optimisation multilangage mettant en oeuvre des gabarits pour l'elaboration d'un code de passe multiple
US5625822A (en) Using sorting to do matchup in smart recompilation
Hoover Alphonse: Incremental computation as a programming abstraction
US5446899A (en) Hint generation in smart recompilation
Poetzsch-Heffter Prototyping realistic programming languages based on formal specifications
US5535392A (en) Using hint generation to cause portions of object files to remain the same
Bergeron et al. Systems programming languages
Uustalu et al. The nut language report
Bringmann A template for code generator development using the IMPACT-I C compiler
Cservenka Design and implementation of dynamic memory management in a reversible object-oriented programming language
Kessler et al. EPIC-a retargetable, highly optimizing Lisp compiler
EP1785848A1 (fr) Procédé et appareil pour la vérification sémantique de code de programme
Qi An implementation of the language lambda prolog organized around higher-order pattern unification
Larsen Lecture Notes for DM565
Hunt Recreating TOP in Golang

Legal Events

Date Code Title Description
AK Designated states

Kind code of ref document: A1

Designated state(s): JP

AL Designated countries for regional patents

Kind code of ref document: A1

Designated state(s): AT BE CH DE FR GB IT LU NL SE

WWE Wipo information: entry into national phase

Ref document number: 1989911161

Country of ref document: EP

WWP Wipo information: published in national office

Ref document number: 1989911161

Country of ref document: EP

WWG Wipo information: grant in national office

Ref document number: 1989911161

Country of ref document: EP