Richard H. Eckhouse

VAX Instruction Encoding

Two features of the architecture of VAX make it an interesting machine to examine. First is the variety of instructions and addressing modes that allow the programmer or compiler to express complicated constructs in only a few machine-language instructions. Second is the instruction encoding that allows these instructions to be represented efficiently in memory. This chapter focuses on the encoding of VAX instructions and operand specifiers in memory. The chapter discusses what an instruction looks like when it is assembled and stored in the memory of a computer. All the VAX addressing modes, except for short literal and branch addressing, use at least one register to specify the operand address. The programmer can specify the register explicitly, or the assembler can use a register to encode the effective address of an operand or a literal. Almost all references on the VAX are position independent. The indexed addressing modes use two registers, one for the index register and one for the specification of the base address of the array. The base address of the array can be specified by using any mode except for literal, indexed, and register.

More VAX Data Types

This chapter presents some data types and instructions that manipulate VAX information units and data types. The chapter examines single-bit and bit-field instructions, string instructions, floating-point instructions, and instructions to convert between data types. The VAX has a number of instructions that test the condition of one bit or that test and modify the bit in a single operation. The chapter shows that the second form is particularly useful for synchronizing several processes. The VAX also has instructions to extract, insert, and compare bit strings up to 32 bits long. The bit string is described by three arguments—its base address, the position of the first byte relative to the base, and the size in bits of the string. While extracting a bit field, the bit string, specified by the position, size, and base operands, is moved right-justified into the longword destination operand.

Instruction and Addressing Fundamentals

This chapter presents simple programming examples and builds on them to demonstrate more advanced techniques. The examples and techniques presented in the chapter are all based on the VAX. The VAX has a complete set of instructions that perform both generic operations on the primitive data types and allow for conversion from one data type to another. Additionally, the VAX provides different instructions for manipulating numeric data types and addresses. VAX has testable results of instruction execution that can be used to determine the effect of an instruction. In this way, one can change the order of execution of a sequence of instructions and cause different instruction streams to be executed for different data. The VAX has a relatively symmetric instruction set for bytes, words, and longword integers. The general instructions can operate on any of these VAX data types. The chapter examines the various addressing techniques used for the VAX and the method of effective address calculation associated with each. Along with the instructions already examined, these techniques are used to demonstrate the solutions to common programming problems.

Advanced Control Structures

This chapter introduces new VAX instructions and describes the procedure-calling facility that permits modular programming and supports high-level languages. The chapter also discusses macro facilities that allow the programmer to extend the instruction set. The chapter discusses generalized subroutine facilities on the VAX and examines additional methods of constructing loops for the VAX. The chapter shows how the Loop and Case instructions provide capabilities similar to those available with high-level languages. It also examines the procedure-calling mechanisms. Although somewhat complex, these mechanisms help to achieve better program structuring. Even more important, the implementation of a procedure call in the architecture creates a standard for VAX language compilers. Therefore, a program can call procedures written in several different languages. The chapter also examines the stack and the useful properties that come with using a stack for linkage.

Analysis of the VAX Instruction Set

This chapter focuses on the analysis of the VAX instruction set. The most common technique to evaluate a VAX architecture is to build an instruction trace program that executes a target program one instruction at a time, collecting interesting data as each target instruction is executed. Such a program can be simplified with proper hardware support. Hardware monitors can be used for measurement. The hardware monitor needs to be faster than the target central processing unit (CPU), because it must both capture and process signals at the same rate at which they are generated. Measurement can be made by modifying the machine itself to collect data. This has been done in some cases with the VAX and is simplified by the fact that the VAX is microcoded. The VAX instruction set is interpreted by a lower-level microprogram executing on the actual hardware. This microprogram can be modified to collect data.

The Program Assembler and Debugger

This chapter focuses on assemblers and debuggers. The assembler translates the assembly language program into binary machine code, just as the compiler translates the high-level source program into binary machine code. The assembler does all the work of remembering the values of symbols and the addresses of data elements. However, unlike the high-level language, each assembly language instruction corresponds to exactly one machine instruction. The VAX assembler performs the clerical task of translating the symbolic assembly language program into the binary machine language program. The chapter discusses the mechanisms utilized by an assembler in performing the translation process. These mechanisms include the location counter, the definition and use of symbols, storage allocation, expression evaluation, and control statements. Debugging assembly language programs can be difficult and frustrating. As in all programming, the most important step is preventing bugs through careful design and reasoning about the program. The chapter discusses the VAX/VMS debugger that can be used with high-level languages and assembly language.

The Support of an Operating System

This chapter examines how an operating system manages the sharing of the processor and memory. The VAX architecture supports the operating system by providing high-level operating system features in the hardware. These features help the operating system to manage the processor. The operating system allows several programs to share the processor, and the VAX hardware provides for the logical program address space and the sharing of memory by several programs. The chapter discusses the VAX mechanisms used for dealing with special conditions—interrupts and exceptions. The existence of exceptions and interrupts reduces the work required of the processor. The software does not have to constantly check for special conditions, completion of device operations, or erroneous arithmetic results. Instead, the hardware automatically reports the occurrence and prioritizes its servicing.

Computer Structures and the VAX

This chapter discusses the basic elements of a computer. An assembly language programmer must understand the instruction–execution process, the addressing of memory, and the encoding of various data types. Most general-purpose computers have the same basic structure, consisting of the high-speed primary memory, the arithmetic control unit (typically called the central processing unit or CPU), and the peripheral input and output (I/O) devices. One or more buses move data between these components. These units are directly visible to the machine-level programmer and are part of the user architecture. The CPU is the brain of the computer. The CPU is capable of fetching data from and storing it in memory. Internal to the CPU are a number of registers that provide local, high-speed storage for the processor. These registers can hold program data and memory addresses.

The Structure of a VAX Operating System

This chapter describes the use of architectural features by the VAX/Virtual Memory System (VMS) operating system that support an operating system and the creation of a logical programming environment. The chapter discusses the strategies used by the VMS operating system kernel in its resource-management activities and discusses the implementation of the VMS operating system. VMS was designed in parallel with the VAX architecture and takes advantage of the features of VAX architecture. The chapter examines the operating systems use of the architectural support for managing the processor, memory, and I/O. VMS uses the hardware process as the basis for program execution. Processes are scheduled to run by VMS using a pre-emptive priority scheme, where the highest priority process is always run. The VMS scheduler maintains a number of data structures to manage the scheduling procedure, including the process control block.

Physical Input and Output

This chapter describes the process through which the real hardware and the operating system software combine to provide each user with a simple, predictable, logical environment to create and execute programs. The chapter describes some of the characteristics of VAX input and output (I/O) devices. It discusses the functions performed by I/O controllers, which control several devices concurrently and provide for the buffering of data between the device and memory. The differences between programmed I/O, where the central processing unit (CPU) reads and writes data registers, and direct memory access I/O, where the device transfers directly to memory, are discussed in light of the speed of the data transfer. The chapter describes several typical I/O devices, their physical characteristics, their programming, and their operation. The complexity of the devices and the need to share them among various users or processes precludes executing code that manipulates most I/O devices directly.