RISC

Compilers and interpreters are systems-software programs which are used to implement high-level languages; they facilitate the running of high-level language programs on a particular computer, even though the computer can only directly execute programs written in its own, low-level, machine code. Each compiler, or interpreter, implements only one high-level language, and so a computer system will usually have several of them, so that programs in several different high-level languages can be executed.

The existing tools of deductive verification allow us to successfully prove the correctness of functions written in high-level languages such as C or Java. However, this may not be enough for critical software because even fully verified code cannot guarantee the correct generation of machine code by the compiler. At the moment, developers of such systems have to accept the compiler correctness assumption, which, however, is extremely undesirable, but inevitable due to the lack of full-fledged systems of formal verification of machine code. It is also worth noting that the verification of machine code by a person directly is an extremely time-consuming task due to the high complexity and large amounts of machine code. One of the approaches to simplify the verification of machine code is automatic deductive verification reusing the formal specification of the high-level language function. The formal specification of the function consists of the specification of the pre- and postcondition, as well as loop invariants, which specify conditions that are satified at each iteration of the loop. When compiling a program into machine code, pre- and postconditions are preserved, which, however, cannot be said about loop invariants. This fact is one of the main problems of automatic verification of machine code with loops. Another important problem is that high-level function variables often have ‘projections' to both registers and memory at the machine code level, and the verification procedure requires that invariants be described for each variable, and therefore the missing invariants must be generated. This paper presents an approach to solving these problems, based on the analysis of the control flow graph, and intelligent search of the locations of variables.

Most programmers at Texas Instruments feel that writing in a high-level language (HLL) is one effective way to cut costs and that this is particularly true of a language like Pascal, which lends itself to top-down structuring. When our programmers compare writing in Pascal with writing in native microprocessor assembly language, they find that programmer efficiency increases by a factor of 2.5 to 3 and that software development and maintenance time, after the problem has been analyzed, is reduced by a factor of 2. The switch from machine code to Pascal increases productivity for three reasons: Each program high-level statement creates several machine instructions that permit the programmer to solve the problem at an abstract level rather than deal in machine code. A structured HLL like Pascal allows problems to be solved the way the natural thought processes work-from the top down. Because Pascal is easier to read, it is easier to modify.

This thesis presents research to build and evaluate embedding of a textual form of state machines into high-level programming languages. The work entailed adding state machine syntax and code generation to the Umple model-oriented programming technology. The added concepts include states, transitions, actions, and composite states as found in the Unified Modeling Language (UML). This approach allows software developers to take advantage of the modeling abstractions in their textual environments, without sacrificing the value added of visual modeling. Our efforts in developing state machines in Umple followed a test-driven approach to ensure high quality and usability of the technology. We have also developed a syntax-directed editor for Umple, similar to those available to other high-level programming languages. We conducted a grounded theory study of Umple users and used the findings iteratively to guide our experimental development. Finally, we conducted a controlled experiment to evaluate the effectiveness of our approach. By enhancing the code to be almost as expressive as the model, we further support model-code duality; the notion that both model and code are two faces for the same coin. Systems can be and should be equally-well specified textually and diagrammatically. Such duality will benefit both modelers and coders alike. Our work suggests that code enhanced with state machine modeling abstractions is semantically equivalent to visual state machine models. The flow of the thesis is as follows; the research hypothesis and questions are presented in “Chapter 1: Introduction”. The background is explored in “Chapter 2: Background”. “Chapter 3: Syntax and semantics of simple state machines” and “Chapter 4: Syntax and semantics of composite state machines” investigate simple and composite state machines in Umple, respectively. “Chapter 5: Implementation of composite state machines” presents the approach we adopt for the implementation of composite state machines that avoids explosion of the amount of generated code. From this point on, the thesis presents empirical work. A grounded theory study is presented in “Chapter 6: A Grounded theory study of Umple”, followed by a controlled experiment in “Chapter 7: Experimentation”. These two chapters constitute our validation and evaluation of Umple research. Related and future work is presented in “Chapter 8: Related work”.

For many compiled languages, source-level types are erased very early in the compilation process. As a result, further compiler passes may convert type-safe source into type-unsafe machine code. Type-unsafe idioms in the original source and type-unsafe optimizations mean that type information in a stripped binary is essentially nonexistent. The problem of recovering high-level types by performing type inference over stripped machine code is called type reconstruction, and offers a useful capability in support of reverse engineering and decompilation. In this paper, we motivate and develop a novel type system and algorithm for machine-code type inference. The features of this type system were developed by surveying a wide collection of common source- and machine-code idioms, building a catalog of challenging cases for type reconstruction. We found that these idioms place a sophisticated set of requirements on the type system, inducing features such as recursively-constrained polymorphic types. Many of the features we identify are often seen only in expressive and powerful type systems used by high-level functional languages. Using these type-system features as a guideline, we have developed Retypd: a novel static type-inference algorithm for machine code that supports recursive types, polymorphism, and subtyping. Retypd yields more accurate inferred types than existing algorithms, while also enabling new capabilities such as reconstruction of pointer const annotations with 98% recall. Retypd can operate on weaker program representations than the current state of the art, removing the need for high-quality points-to information that may be impractical to compute.

For many compiled languages, source-level types are erased very early in the compilation process. As a result, further compiler passes may convert type-safe source into type-unsafe machine code. Type-unsafe idioms in the original source and type-unsafe optimizations mean that type information in a stripped binary is essentially nonexistent. The problem of recovering high-level types by performing type inference over stripped machine code is called type reconstruction, and offers a useful capability in support of reverse engineering and decompilation. In this paper, we motivate and develop a novel type system and algorithm for machine-code type inference. The features of this type system were developed by surveying a wide collection of common source- and machine-code idioms, building a catalog of challenging cases for type reconstruction. We found that these idioms place a sophisticated set of requirements on the type system, inducing features such as recursively-constrained polymorphic types. Many of the features we identify are often seen only in expressive and powerful type systems used by high-level functional languages. Using these type-system features as a guideline, we have developed Retypd: a novel static type-inference algorithm for machine code that supports recursive types, polymorphism, and subtyping. Retypd yields more accurate inferred types than existing algorithms, while also enabling new capabilities such as reconstruction of pointer const annotations with 98% recall. Retypd can operate on weaker program representations than the current state of the art, removing the need for high-quality points-to information that may be impractical to compute.

Many signal processing systems, particularly in the multimedia and telecom domains, are synthesized to execute data-dominated applications. Their behavior is described in a high-level programming language, where the code is typically organized in sequences of loop nests and the main data structures are multidimensional arrays. Since data transfer and storage have a significant impact on both the system performance and the major cost parameters--power consumption and chip area, the designer must spend a significant effort during the system development process on the exploration of the memory subsystem in order to achieve a cost-optimized design. This paper presents a memory allocation methodology for multidimensional signal processing applications, focusing on the problem of efficiently mapping the multidimensional signals from the algorithmic specification into the physical memory. In a first phase, two previous mapping models are implemented within a common theoretical framework, which is advantageous from both the point of view of computational efficiency and the amount of allocated data storage. Different from all the previous mapping models that aim to optimize the memory sharing between the elements of a same array (creating separate windows in the physical memory for distinct arrays), this proposed mapping model exploit--in a second phase--the possibility of memory sharing between the elements of different arrays. As a consequence, this signal assignment approach yields significant savings in the amount of data storage resulted after mapping.

One use of performance measurement techniques is in the study of operational characteristics of programs written in high-level programming languages. Information derived from such studies can be used to construct benchmark programs and synthetic workloads, <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">1,2</sup> detect inefficiencies in programming language implementation, and suggest possible improvements in the design of computers. <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">3,9,10</sup> Our main interest is in the latter area: the discovery of primitive operations, implied by the semantics of a programming language, that can be added to the firmware or hardware of a computer to improve overall system performance. These computer architecture optimization techniques have been applied in several studies <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">3,9</sup> and have been used commercially to design efficient pseudo machines for the Burroughs B1700. <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">10,12</sup>

the aim of this work is an improvement of previous work on greenhouse monitoring using smart sensors network, hardware and software design is presented to control and monitoring greenhouse parameters such as: air temperature, humidity and CO2 gas emission then providing irrigation, ventilation and enrichment of the sol with appropriate chemical products. The smart nodes for WSAN (wireless sensor and actuators network) transfer the data to and from a Laptop via a wireless transmission hardware agent, a simulation based on fuzzy logic controller is provided in order to make smart decision. As a result; the command devices, fans, vapor injectors and heaters will changed to reach the requested condition. A friendly Graphic user interface using high level language was developed to carry out the monitoring tasks. The control algorithms is used to receive data that includes the set points and issuing signals to activate the appropriate devices to get the appropriate condition. The system performance was tested by installing four smart actuators and sensors in the greenhouse.

No application programmer writes machine-language programs–i.e., strings of ones and zeroes. That primitive pursuit has long been reserved for those few who create the very first modules of a software system for new hardware. Instead, programmers make use of a wide spectrum of symbolic programming languages, ranging from assembly code to high-level languages such as Fortran, Cobol, and the Algol family. Every programming language has semantics which define some abstract machine. For the assembly-language programmer this machine bears a great resemblance to the actual hardware on which the program will be interpreted, but even here the programmer will frequently use system-defined subroutines or macros which represent extensions of the base hardware facilities. The high-level language programmer's abstract machine reflects the control mechanisms and data structures characteristic of the language. The Fortran programmer, for example, can think in terms of multidimensional array structures, DO loops, subprogram facilities, and so on. In principle he need never be concerned with the manner in which his abstract Fortran machine is to be realized by a particular hardware and software system. The user of a modern electronic hand calculator needs no knowledge of the works inside the box, and a modern high-level language system should present to its users an equally consistent environment, completely defined in terms of the syntax and semantics of the source language.

Ada is a high-level programming language; it provides abstract constructs that allow programs to be constructed easily and safely. However, it is recognised that one of the intended application areas for Ada is the production of embedded systems. Often these (and other) systems require the programmer to become more concerned with the implementation, and efficient manipulation, of these abstract program entities. Ada resolves this conflict in two ways:

Poster detailing project to design a compiler for a simple stack based computer (SSBC) which will take high level language with object oriented features, such as C++, and compile it into SSBC machine code. This shows that object oriented programming can be achieved on a stack based computer with a limited instruction set.

The problems of compiler construction have largely been solved for COBOL '74, but a remaining fundamental consideration in a commercial environment is the cost of compiler development. This can be reduced by the use of portable software, but the cost of porting to a new system remains significant. In the microprocessor system market, two approaches have been followed. The first is to produce software for a virtual machine environment and simulate this on real hardware be means of an interpreter. Most software, including language processors and large parts of the operating system, can be transferred almost unchanged to a new processor. Nearly all commercial software for microprocessors has been developed on this basis. The alternative approach is to produce software which, by virtue of certain characteristics, can be made to be portable to new real machine environments, provided the appropriate high level language compiler is available. We have developed an ANS COBOL 74 compiler for microprocessors using this second approach [1]. Since the compiler compiles COBOL at a level approaching level 2 in the main modules to the true machine code of the target machine, the same approach becomes available to the applications programmer. As far as can be established, this work is unique. Both compiler and object code interface directly to the machine environment. No interpreter is required for their execution. The compiler system runs on, and generates code for, three machines. In addition, since the compiler is written in a high level language, portable cross compilers are available.

A Transpiler is a set of tools that take the source code developed in a high-level programming language (source language), and after a transpilation process, it generates a translated source code written in another programming language (target language), that is syntactically equivalent. In this paper, it is presented a new approach for software architecture design, which uses a Transpiler (Haxe) as a programming language and as a generator of the business logic and service layer. The goal is that software developers write the business logic only once and transpile it to equivalent server layers for C#, Java, and PHP, making them reusable and runnable on several platforms. An experimental prototype was developed to test the idea (published on GitHub with the codename “Cornerstone”), that implements a benchmark to compare when running on different Operating Systems and Application Servers combinations. A single web interface is developed, using HTML, CSS, Javascript, and XML-HttpRequest, which connect to any of the transpiled services regardless of the deployment platform. Cloud instances were used to assure comparability. Preliminary results were obtained and analyzed to show the concept validity and which platform combination provided the highest performance.

A LISP interpreter for the 8080: Van Buer, DDr Dobbs Journal Vol 3 (Nov – Dec 1978) pp 4–11