Assembly Language Programming Research Articles

The design and implementation of a certifying compiler

This paper presents the design and implementation of a compiler that translates programs written in a type-safe subset of the C programming language into highly optimized DEC Alpha assembly language programs, and a certifier that automatically checks the type safety and memory safety of any assembly language program produced by the compiler. The result of the certifier is either a formal proof of type safety or a counterexample pointing to a potential violation of the type system by the target program. The ensemble of the compiler and the certifier is called a certifying compiler .Several advantages of certifying compilation over previous approaches can be claimed. The notion of a certifying compiler is significantly easier to employ than a formal compiler verification, in part because it is generally easier to verify the correctness of the result of a computation than to prove the correctness of the computation itself. Also, the approach can be applied even to highly optimizing compilers, as demonstrated by the fact that our compiler generates target code, for a range of realistic C programs, which is competitive with both the cc and gcc compilers with all optimizations enabled. The certifier also drastically improves the effectiveness of compiler testing because, for each test case, it statically signals compilation errors that might otherwise require many executions to detect. Finally, this approach is a practical way to produce the safety proofs for a Proof-Carrying Code system, and thus may be useful in a system for safe mobile code.

A tale of assembly

The author takes us back to the days when assembly language programming was still a large part of the computing scene with a story of how the user group Share influenced IBM on assembly languages just when the company had decided to concentrate on the new high-level languages.

Introducing computer concepts by simulating a simple computer

The simulated computer consists of (1) main memory, (2) a register known as the accumulator, (3) a central processing unit (CPU), and (4) an instruction counter. This computer recognizes 8 op codes (Halt, Load, Store, Add, Subtract, Read, Write, and Branch On Zero). The computer is simulated by creating a program in Pascal or C++. This program simulates the execution of programs written by students, such as adding two numbers and printing their sum. Student programs are written in machine language and executed by the simulated computer. Students can write programs in assembly language, compile them by hand, and then test them by running them on the simulated computer. This example has been helpful in teaching students what a computer is and what computers can do.

Loose ends

Loose ends

Mechatronics instruction in the Mechanical Engineering curriculum at Georgia Tech

The increasing use of microcontrollers and microprocessors in a wide variety of consumer and commercial products, laboratory test instruments and equipment, and industrial applications has created a need for Mechatronics education in all engineering disciplines. The subject of Mechatronics is broad, encompassing, and interdisciplinary. How to teach Mechatronics in the various Engineering disciplines is still an open area for discussion. This presentation focuses on the way Mechatronics is taught in George Woodruff School of Mechanical Engineering at Georgia Tech. The courses are structured to teach students design at the micro-chip level, and to teach them how to write assembly language programs for measurement and control. They learn by hands-on experience with interfacing sensors, actuators, and passive and active devices with microprocessors and microcomputers in laboratory exercises. The class includes a final group project and a group class lecture. Each group of three students is required to complete a design project that integrates hardware and software design with electronic interfacing design and mechanical systems analysis. Several such projects and all the laboratory exercises are presented.

A visual simulator for a simple machine and assembly language

We present a package which provides a visually oriented simulation of the execution of machine and assembly language programs on a simple computer. The programs are written for HyperCard running on Apple Macintosh computers. They are suitable for in-class demonstrations and various types of in-class or out of class assignments.

The S‐Machine: An Alternative Approach to Teaching Assembler Programming

The demand for assembler language programmers has dropped dramatically over the past 20 years with the advent of structured programming languages and the accessibility of hardware features from high‐level languages. Nevertheless, a course in assembler language programming is often the first, and sometimes the only, introduction a student has to a machine's hardware. For this reason alone, assembler language programming courses should not be removed from a curriculum; instead, they should be kept and taught in conjunction with modern software engineering practices. This article describes an alternative approach to teaching assembler language programming. Whereas the students are still introduced to a machine and its assembler language, they are required to write several low‐level library routines they used in introductory courses (such as ACM CS1 and CS2). Furthermore, the S‐Machine's support software allows students to study the internals of an assembler, a librarian, and a linker.

Design and VLSI implementation of an address generation coprocessor

Most applications of general purpose VLSI processors are developed using high level languages. In these languages, information is generally handled in a structured form. Compilers generate a considerable amount of code to navigate through the data structures and considerable processing time is spent performing address calculations required to access the data structures. An alternative to software address generation, a hardware memory reconfiguring unit or an address generation coprocessor is presented. To demonstrate the VLSI feasibility of the designed device, it is implemented in VLSI using the Octtool suite of tools. The tools used and the implementation procedure are described. VLSI design aspects such as regularity, modularity, scalability, etc. are discussed. The performance of the device is evaluated using assembly language programs that implement popular signal processing algorithms such as convolution, correlation, FFT and matrix multiplication. A system with the address generation unit exhibits a speed up of between approximately 1.5 and 2.5.

CPU Sim a computer simulator for use in an introductory computer organization-architecture class

CPU SIM is an interactive low-level computer simulation package that runs on the Macintosh computer. Users of the package specify the details of the CPU to be simulated, including the register, i/o channels, main memory, the microinstruction set, machine instructions, and assembly language instructions. User can then create machine or assembly language programs using the built-in text editor and assembler and can run their programs in the simulator. It is possible to step through the execution of a program one machine instruction at a time. Also, users may choose to edit the contents of any component and then continue execution. The main window displays the state of the machine at every step. CPU Sim was chosen as “Best Engineering Software (Computer Science)” in the 1993 EDUCOM Higher Education Software and Curriculum Innovation Awards Program. It is currently being sold by Intellimation.

Visual BASIC for DOS: building scientific and technical applications

The VBDOS language elements of the BASIC language writing subroutines in VBDOS compiling and debugging in VBDOS using Visual BASIC forms in VBDOS other visual controls screen graphics in VBDOS programming the PC's serial port elements of assembly language programming.

Design and implementation of efficient IIR notch filters with quantization error feedback

Straightforward methods for the design of digital notch filters are presented. The design method is based on setting a zero of the filter at a notch frequency and placing a pole in its neighborhood such that the notch width is narrow enough while keeping the group delay of the filter sufficiently flat. A technique for efficient and well-behaved implementation with fixed-point signal processors is advanced, based on the use of quantization error feedback for roundoff noise reduction. The design approach is illustrated with numerical examples, and an assembly-language program for the family of TMS320 signal processors is provided. >

Incorporating probabilistic reasoning in a reactive program debugging system

The authors are developing a system that takes a novel approach to the reactive analysis of assembly language programs that have abnormally terminated. The Dump Analysis and Consulting System (Daacs) integrates traditional compiler design, heuristic and logic-based techniques for program understanding, and probabilistic reasoning for diagnostic inference. Implemented as a belief network, the reasoner controls inference and works with incomplete and uncertain data to produce a ranked list of plausible (sometimes certain) diagnoses and supporting evidence. The use of a belief network allows diagnosis to continue past that which can be proven with certainty. Daacs determines an error's exact cause when possible. When it cannot establish the true cause with certainty, it provides plausible diagnoses and supporting evidence. The Sabre Computer Services Realtime Coverage group analyzes and resolves program errors in American Airlines' Sabre reservation system. The system executes on IBM mainframes running the Transaction Processing Facility operating system, and the programs are primarily written in assembly language. The use of Daacs for analyzing these programs is discussed. >

ASSEMBLY LANGUAGE PROGRAMMING FOR THE 1860

The structure of the i860 is reviewed briefly. The code generation strategies used by compilers and assembly language programmers are compared. The problems associated with generating efficient code for the i860 are highlighted and a case study from QCD is used to demonstrate these points. Timing results for the case study are presented.

An interactive tutorial system for MC68000 assembly language using HyperCard

Assembly language programming of the Motorola MC68000 microprocessor is taught to post-graduate students in the department of Computer Science at Queens University of Belfast in a course entitled "Microcomputer Architecture and Programming". Due to the large number and complexity of the 68000's instructions an interactive tutorial system was developed, using HyperCard and HyperTalk, to enhance existing teaching methods. The system, although aimed at courses teaching MC68000 programming, would be a useful introduction to low level programming theory on courses teaching computer architecture or assembly language programming.

Book review of DOS 5: A developer’s guide

Correspondence should be addressed to the author at the Department of Psychology, Cleveland State University, Cleveland, OH 44115. Sargent & Shoemaker, 1986), but with some welcome differences. Particularly welcome are the ready-to-compile and ready-to-assemble routines on diskette. In addition, Part III appears to be the first treatment, in a book of this kind, of important advanced features of the 80386, the 80486, and, to some extent, the 80286. The book is written primarily for people who can do some programmingand includesquite a lot of usablesource code in C and in assembly language. In that respect, even Parts I and II differ somewhat from earlier treatments of the same topics. These sections of source code are used as examples in the hard-copy text but are also included on two 5.25-in. diskettes. That is fortunate, because some of the programs serve not only as examples but also as directly usable utilities that can be incorporated into applications with little or no modification. Readers having no prior experience with either C or assembly language programming are not likely to enjoy this book. It clearly is not a good place to start learning to program. On the other hand, the techniques range widely in complexity, so some of them would be easy enough to adapt and use by tinkerers who have only a modest amount of programming experience. The choice of C and assembly language is wise, because these are the languages that would be used in most serious applications. Moreover, some of the applications would be much more difficult and inefficient if programmed in BASIC, for example. Many of the programs can be directly incorporated into some C language applications program, whereas the BASIC demonstration programs in the more chatty books by Goldstein (1989) and Norton (1990) need to be translated if BASIC is not used. The recommended C compilers are Borland Turbo C Version 2.0 or higher, Microsoft C Version 5.0 or higher, or Mix Power C Version 2.0 or higher. The recommended assemblers are Microsoft MASM Version 5.0 or higher and Borland Turbo Assembler Version 1.0 or higher. An assembler is crucial only for the programs presented in chapters 17 and 19, for some in chapter 18, if Turbo C 1.5 or Microsoft C is used, and for a few other small applications scattered in other chapters. The objective in all of the example programs is to take control of and exploit the capabilities of the machine and operating system. All examples actually do something and are not merely fabricated for rhetorical purposes. True, the first two programs (in chapter 4) have modest goals: to send escape sequences to the console or printer and to count the number of spaces in a keyboard command line. These are things that a programmer might need to do in real life, and the techniques used are perhaps cleaner

Book Review: The M68000 Microprocessor Family—fundamentals of assembly language programming and interface design

Book Review: The M68000 Microprocessor Family—fundamentals of assembly language programming and interface design

A multi-disciplinary approach for digital systems design curricula

Historically, Digital Systems Design curricula have focused principally on the hardware design aspects of systems development. At Arizona State University, we have expanded our Digital Systems Design program to include aspects of computer architecture, assembly language programming, and operating systems fundamentals, as well. We feel that this larger focus provides the students with a comprehensive understanding of the overall system development process. In this paper, we discuss our philosophy and examine a course sequence that incorporates this multi-disciplinary approach.

Providing a laboratory for instruction set design

Computer architecture classes do not provide students with laboratory experience in the design of instruction set architectures. Projects that compare designs have not been possible due to a lack of support software. The design and evaluation of a new instruction set requires an assembler, a symbolic debugger, and a statistics gatherer. Every new instruction set requires changes to all three programs. It would be unrealistic to expect that either students or instructor would (re)write such software in order to evaluate each new design. A new, flexible software package called the Instruction Set Testbed (IST) provides for the comparison of instruction set architectures without writing any of the support software. IST's table-driven assembler uses a student-supplied architecture definition to assemble programs. IST's interactive debugger and a statistics gatherer also have access to the architecture definition. This allows symbolic debugging of the assembly language programs and automatic histogramming of instruction usage in the student-defined architecture. IST has been used in both undergraduate and graduate architecture classes to investigate such topics as orthogonality, choice and number of operands, addressing modes, and RISC philosophy.

CASM (Central's Assembly SiMulator): The Advantages of Using a Simulator to Teach Assembly Language

This article describes an assembly language simulator specifically designed as a pedagogical tool. This simulator has the richness of a stack, procedure calls, and indirect addressing, but prods students into good programming habits without many of the inherent, frustrating aspects of assembly language programming. This is accomplished by providing a syntax checking editor, a powerful debugger, a limited instruction set, and strict attention to eradicating the typical mistakes that assembly language, and high‐level language programmers make.

A wide-angle secondary ion probe for organic ion imaging

A secondary ion source has been developed for an organic ion microprobe capable of imaging sampes up to 2 cm in diameter. The source uses a focused 5 keV Cs + ion beam which is rastered across the sample surface, and secondary ions from each point on the sample are collected and formed into a low energy beam to be analyzed by a quadrupole mass filter. Dynamic emittance matching is employed to deflect ions from off-axis points on the sample back onto the mass analyzer axis. Rastering and dynamic emittance matching are rapidly controlled by assembly language programs using an IBM/AT (80286) type computer. A low energy ion monitor was used to tune and evaluate the secondary ion source by providing a magnified cross-sectional image of the ion beam at the source exit aperture. A well-focused and centered secondary ion beam was obtained from each point on the sample, indicating that large-scale dynamic emittance matching with high collection efficiency is possible. Mass resolved images of grids and glycerol samples are shown to demonstrate the performance of the integrated secondary ion source mass analyzer and control system.