EMPL(ID:717/emp001)Microprogramming languageExtensible Microprogramming Language. An early object-oriented microprogramming language with PL/I-like syntax. Extensions include datatype definitions and operators. Never fully implemented. Structures: Related languages
References: EMPL (Extensible microprqgramming language) EMPL dates from 1976, it was developed by David DeWitt at the University of Michigan. Design goals. Four goals are stated: I) "The language must facilitate writing programs ...; 2) It "should be readable, so as to facilitate the task of redesigning a program"...; 3) It "should be machine independent so that programs written in it are portable"; 4) It "should be possible to compile the language into very efficient microcode for a variety of microprogrammable computers". Primitives. A small Set of basic operators is included: addition, subtraction (both one- and two-complement);unary minus, multiplication, division, logical;and, or, exclusive or and the "'logical negation of these three, negation, shift, rotate, and the standard relational operators. There are no primitives for~reading from ,or writing to main memory. The user can declare additional operators. Such a declaration should always have a body expressing the operation in terms of built-in or previously declared operations; but if the machine has a special microoperation for it, this can be specified as well. (Machine testable conditions could be handled by the same mechanism if an operator is allowed to yield a value of type "logical"; this is not explicitly stated however.) This mechanism allows a user to tailor the set of operators to the available hardware, while retaining a certain degree of machine independence: if a certain microoperation is not available, the body of the operator will be compiled statement-by-statement (but see the remarks on implementation below). Variables. Variables in EMPL are not machine registers. All variables are global, in order to avoid procedure calling overhead. Parallelism. Programs are specified completely sequentially. There are no provisions in the language to facilitate detection of parallelism. Control Structure. The language provides both procedure declarations (without formal parameters) and operator declarations (with an arbitrary number of formal parameters). Only simple variables and constants are allowed as actual parameters. Statement forms provided are assignment, call and return, if-then-else, while-do and goto. Expressions are not allowed to contain more than one operator. Datatypes and datastructures. The only basic datatype is the integer. A concept akin to the SIMULA class, called an extension statement, is used for data-structuring. It allows the user to define a new datatype with associated fields (of a previously declared type)~ an initialization statement, and associated operators. Fields can be referenced only from the operators declared within the extension statement; they cannot be selected from outside the class. This is consistent with the view that primarily those datatypes which are hardware supported, are declared in an extension statement. No difference is made in the language between variables residing in registers and variables residing in main memory. As there are no explicitstatements for memory references , it is not clear how an EMFL-program can for example read instruction operands from main memory. Implementation. EMPL has not been fully implemented. A sketch of a two-pass compiler is contained in. The first pass translates the source text to a sequence of microoperations, without allocating resources. The second pass allocates resources and composes microinstructlons; this pass has been completed and is described in [9]. It is hard to judge whether the results of a complete compiler would meet efficiency requirements. Some possible problems are: In the proposed implementation, a call to an operator which is not hardware supported is textually replaced by the statements that form its body. This is undoubtedly done to avoid parameter passing. If the operator mechanism is heavily used, this will lead to an increase in the size of the produced code. - I doubt whether the control statements are sophisticated enough to allow optimal mlcroinstructlon sequencing. There is neither a case-construct nor a cascaded conditional stateient (if tl then sl elif t2 then s2 ... ere). Multiway branches will therefore be hard to utilize. Conclusions From all mlcroprogramming languages considered in this survey, EMPL most closely resembles a conventional high level language. By grouping all operations on objects of a single datatype in a class, program modularity and portability are improved. The way in which the user may invoke specific microoperations is elegant. The specification of a machine dependent microoperation" in an operator body guarantees a certain degree of machine independence while retaining the chance to produce reasonably efficient code. Viewing classes mainly as a way to extend the language with datatypes and operations that are supported by specific mlcrooperations, is unnecessarily restrictive. It has caused useful constructs like field selection to he excluded from the language - compare the EMPL fields for example with the tuples of S*. It has also lead to an inefficient implementation scheme for classes and associated operators that are not hardware supported. The desira- Bility of a case-construct has been mentioned already. The integer as basic datatype does not seem to be the best possible choice (again compare with S*). in Proceedings of the 13th International Symposium on Microarchitecture Springs, Colorado, United States 1980 view details |